Refuse a Touches: list touch-predictions cannot read in todo-item add and edit, and in rank_todo.py --check #607

Merged
lilleman merged 10 commits from item-424 into main 2026-11-18 16:43:42 +01:00
18 changed files with 275 additions and 177 deletions
+1
View File
@@ -2,6 +2,7 @@
## Unreleased
- `todo-item add` and `todo-item edit --detail` refuse a detail whose `Touches:` list touch-predictions cannot read, and `rank_todo.py --check` fails on each item holding one, so rule-hook refuses a commit of such a plan: after updating, run `~/.claude/bin/rank_todo.py --check` in each project and fix each list it names.
- loop-claude hands each worker's claude a Bash output ceiling of 6,000 characters that saves a longer result to a file, rule-hook refuses a Read of a session transcript under ~/.claude/projects, and review-replay takes --bash-ceiling and --read-limit to test such a limit against archived review rounds.
- do-epic picks each epic item's repo, or that it is Claude's work or a human task, by repo-rule.md and a headless claude call, records the pick as a label on the issue and reads it back without a new call; where the rule leaves it unclear it returns a question for the human. The epic backends gain a label write.
- judge-replay <model> --offline replays every archived verdict through a "?" rule, a decision table and a classifier trained on the archive, with no judge call, and counts the interrupts each misses.
+1 -1
View File
@@ -223,7 +223,7 @@ Install puts only `loop-claude` on `PATH`; call the others by their path, such a
- `machine_load/` takes the machine's heavy slots, its shared lock files, for `run_heavy` and `adf_codec`, and reads the memory share that loop-claude waits for. It also gives `mutate_changes` a slot's CPU count.
- `model_routing/` holds the shipped routing ladder (`routing-ladder.json`) and its steps (`ladder.py`), and reads a ladder from that file or a project's own (`ladder_file.py`), for loop-claude, `rule_hook`, `do_epic`, both replay tools and `subagent-rung`. It finds a project's config folder through `project_config`. It also holds the list prices, which `routing_figures` and `transcript_archive` read.
- `notifier/` sends the human a DM through the notifier a project's config names, for `notify` and for loop-claude through `loop_effects`. Its backends are `mattermost.py` and `slack.py`.
- `plan/` is the plan's core, and imports neither `plan_store` nor `release_plan`. It holds an item and the items table's format (`todo_table.py`), releases (`release.py`), the ranking (`ranking.py`, with its score formula in `formula.py` and its blocker order in `blockers.py`), the paths an item's text names (`named_paths.py`) and `citations.py`, which holds `todo.md` and `docs/decisions.md` to each other. `goals_file.py` reads the goals file's sections, goals and goal weights, for the ranking and for `loop_claude`'s premises.
- `plan/` is the plan's core, and imports neither `plan_store` nor `release_plan`. It holds an item and the items table's format (`todo_table.py`), releases (`release.py`), the ranking (`ranking.py`, with its score formula in `formula.py` and its blocker order in `blockers.py`), the paths an item's text names (`named_paths.py`), an item's `Touches:` prediction and where two overlap (`touches.py`), and `citations.py`, which holds `todo.md` and `docs/decisions.md` to each other. `goals_file.py` reads the goals file's sections, goals and goal weights, for the ranking and for `loop_claude`'s premises.
- `plan_store/` reads and writes a project's plan through the store the project's config names (`stores.py`). Every backend meets `plans.py`'s `PlanStore`: a markdown file (`todo_md.py`, which also ranks and checks the file in place, with its text edits in `markdown_edits.py`) or a Jira epic (`jira_epic.py`). `scoring.py` reads the goal weights that both backends rank by. `contract.py` holds the tests every backend that writes must pass; `jira_epic.py` doesn't yet, and its own tests stand in for Jira. `fakes.py` holds a plan in memory.
- `rank_todo.py`, `settings_filter.py` and `statusline.py` are tools of one file each, tested beside them.
- `record_store/` reads and writes a project's records, each through the store the project's config names (`stores.py`): a markdown file, a Confluence Cloud page (`confluence_page.py`), or, for the goals, a Jira epic's description (`jira_description.py`). `contract.py` holds the tests every backend must pass, and `fakes.py` a store in memory that the tests of other tools use.
+1 -1
View File
@@ -14,7 +14,7 @@ from failure import Failure
from project_config.main import located
from loop_claude.loop.reload import LoopRun
from release_plan.next_chunk import NextChunk, NoItem, planned
from touch_predictions.prediction import overlaps, predicted, Touches
from plan.touches import overlaps, predicted, Touches
from loop_state.paths import Paths
from transcript_archive.project_key import project_key
from release_plan.release_standing import project_plan
+167
View File
@@ -0,0 +1,167 @@
import pathlib
import shutil
import subprocess
import sys
import unittest
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
from adf_codec import convert
from failure import Failure
from plan.touches import overlaps, Part, predicted, rendered, together
DETAIL = """A planning call.
Touches:
- `bin/a.py`: `main`, `Plan.branch` (small)
- `README.md`: `## Goals, and (more): things`
- `bin/run.sh`: lines 10-20
- `docs/new.md`
More prose, with `bin/b.py` named.
"""
needs_docker = unittest.skipIf(shutil.which("docker") is None or subprocess.run(["docker", "info"], capture_output=True, timeout=20).returncode != 0, "adf_codec runs in a container, which needs a docker daemon")
def text(words: str, code: bool = False) -> dict:
return {"type": "text", "text": words, **({"marks": [{"type": "code"}]} if code else {})}
def bullet_of(*spans: dict) -> dict:
return {"type": "listItem", "attrs": {"localId": "i"}, "content": [{"type": "paragraph", "attrs": {"localId": "p"}, "content": list(spans)}]}
# A Touches list as someone types it in Jira's editor: a paragraph, then a bulleted list whose paths and names carry the code mark.
JIRA_TOUCHES = {"type": "doc", "version": 1, "content": [
{"type": "paragraph", "attrs": {"localId": "a"}, "content": [text("A planning call.")]},
{"type": "paragraph", "attrs": {"localId": "b"}, "content": [text("Touches:")]},
{"type": "bulletList", "attrs": {"localId": "c"}, "content": [
bullet_of(text("bin/a.py", True), text(": "), text("main", True), text(", "), text("Plan.branch", True), text(" (small)")),
bullet_of(text("a`b.md", True), text(": "), text("## The `foo` tool", True), text(" (small)"), text(", "), text("`x`", True)),
bullet_of(text("bin/run.sh", True), text(": lines 10-20")),
bullet_of(text("docs/new.md", True)),
]},
{"type": "paragraph", "attrs": {"localId": "d"}, "content": [text("More prose.")]},
]}
class PredictedTest(unittest.TestCase):
def test_reads_each_bullet_of_the_touches_list(self) -> None:
self.assertEqual(predicted(DETAIL), {
"bin/a.py": (Part("main"), Part("Plan.branch", small=True)),
"README.md": (Part("## Goals, and (more): things"),),
"bin/run.sh": (Part("lines 10-20"),),
"docs/new.md": (),
})
def test_a_detail_without_the_list_predicts_nothing(self) -> None:
self.assertIsNone(predicted("Only prose, with `bin/a.py` named."))
def test_a_bullet_it_cannot_read_is_a_failure_that_quotes_it(self) -> None:
for bullet in ("- bin/a.py: main", "- `bin/a.py`: main", "- `bin/a.py`: lines 20-10", "- `bin/a.py`: `main` `other`"):
with self.subTest(bullet):
found = predicted(f"Touches:\n\n{bullet}\n")
assert isinstance(found, Failure)
self.assertIn(bullet, found.reason)
def test_an_empty_list_is_a_failure(self) -> None:
self.assertIsInstance(predicted("Touches:\n\nProse.\n"), Failure)
found = predicted("Touches:\n")
assert isinstance(found, Failure)
self.assertEqual(found.reason, "no bullet follows `Touches:`")
def test_reads_a_list_right_under_its_label_a_one_line_range_and_a_name_of_any_letters(self) -> None:
self.assertEqual(predicted("Touches:\n- `a.py`: `Xray`, lines 5-5\n"), {"a.py": (Part("Xray"), Part("lines 5-5"))})
def test_rendered_reads_back(self) -> None:
touches = predicted(DETAIL)
assert isinstance(touches, dict)
self.assertEqual(predicted(f"Touches:\n\n{rendered(touches)}\n"), touches)
def test_a_name_that_holds_backticks_takes_a_longer_run_with_a_space_inside_each_end(self) -> None:
self.assertEqual(predicted("Touches:\n- `a.md`: `` ## The `foo` tool `` (small), ``` `` ```, `` `x` ``\n"), {"a.md": (Part("## The `foo` tool", small=True), Part("``"), Part("`x`"))})
self.assertEqual(rendered({"a.md": (Part("## The `foo` tool", small=True), Part("``"))}), "- `a.md`: `` ## The `foo` tool `` (small), ``` `` ```")
def test_a_longer_run_without_padding_spaces_is_the_text_between_its_runs(self) -> None:
self.assertEqual(predicted("Touches:\n- ``a`b.md``: ``## The `foo` tool`` (small), ``` `` ```, `` `x` ``\n"), {"a`b.md": (Part("## The `foo` tool", small=True), Part("``"), Part("`x`"))})
def test_a_longer_run_with_a_space_at_one_end_only_keeps_it(self) -> None:
self.assertEqual(predicted("Touches:\n- `a.md`: `` x``, ``y ``, `` a ``\n"), {"a.md": (Part(" x"), Part("y "), Part("a"))})
@needs_docker
def test_a_list_written_in_markdown_and_read_back_from_a_jira_description_reads_as_written(self) -> None:
description = convert.markdown_to_adf(DETAIL)
assert isinstance(description, dict)
self.assertEqual(predicted(convert.adf_to_markdown(description)), predicted(DETAIL))
@needs_docker
def test_a_list_typed_in_jiras_editor_reads_as_its_files_and_parts(self) -> None:
read = convert.adf_to_markdown(JIRA_TOUCHES)
self.assertEqual(predicted(read), {
"bin/a.py": (Part("main"), Part("Plan.branch", small=True)),
"a`b.md": (Part("## The `foo` tool", small=True), Part("`x`")),
"bin/run.sh": (Part("lines 10-20"),),
"docs/new.md": (),
})
def test_a_name_ends_only_at_a_run_as_long_as_the_one_that_opens_it(self) -> None:
self.assertEqual(predicted("Touches:\n- `a.md`: `` a ``` b ``, `c``d`\n"), {"a.md": (Part("a ``` b"), Part("c``d"))})
def test_a_path_holds_any_character_and_a_single_backtick_keeps_a_names_spaces(self) -> None:
self.assertEqual(predicted("Touches:\n- `my file.md`: ` x `\n- `` a`b.md ``\n"), {"my file.md": (Part(" x "),), "a`b.md": ()})
def test_rendered_reads_back_whatever_a_path_or_a_name_holds(self) -> None:
touches = {"my file.md": (Part("## todo.md: under `Touches:` in its detail"), Part("## ``a`` and `b`", small=True), Part("`"), Part("## ends in `x`"), Part(" x "), Part("lines 2-3")), "a`b.md": (), "c, d: e.md": (Part("# T"),)}
self.assertEqual(predicted(f"Touches:\n\n{rendered(touches)}\n"), touches)
def test_a_bullet_with_an_unclosed_run_a_blank_name_or_a_stray_separator_is_a_failure(self) -> None:
for bullet in ("- `a.md`: `` ## A", "- `a.md`: `` ## A `", "- `a.md`: `` ``", "- `a.md`: ", "- `a.md`:", "- `a.md`: `f`, ", "- `a.md`: `f`,`g`", "- ``", "- `a.md` (small)", "- `a.md`: `f` (small) (small)"):
with self.subTest(bullet):
self.assertIsInstance(predicted(f"Touches:\n\n{bullet}\n"), Failure)
def test_a_range_that_runs_backwards_is_a_failure_that_says_so(self) -> None:
found = predicted("Touches:\n\n- `bin/a.py`: `f`, lines 20-10\n")
assert isinstance(found, Failure)
self.assertEqual(found.reason, "the bullet '- `bin/a.py`: `f`, lines 20-10' under `Touches:` holds a line range whose first line comes after its last")
def test_together_joins_items_and_keeps_small_only_where_each_says_so(self) -> None:
joined = together([{"a.py": (Part("f", small=True), Part("g", small=True))}, {"a.py": (Part("f"),), "b.md": ()}, {"b.md": (Part("# T"),)}])
self.assertEqual(joined, {"a.py": (Part("f"), Part("g", small=True)), "b.md": ()})
def test_together_keeps_a_part_not_small_once_one_says_so_and_reads_on_past_a_whole_file(self) -> None:
joined = together([{"a.py": (Part("f"),), "b.md": ()}, {"b.md": (Part("# T"),), "a.py": (Part("f", small=True),), "c.py": (Part("h"),)}])
self.assertEqual(joined, {"a.py": (Part("f"),), "b.md": (), "c.py": (Part("h"),)})
class OverlapsTest(unittest.TestCase):
def test_other_files_and_other_parts_do_not_overlap(self) -> None:
self.assertEqual(overlaps({"a.py": (Part("f"),)}, {"a.py": (Part("g"),), "b.py": ()}), [])
def test_the_same_part_overlaps(self) -> None:
self.assertEqual(overlaps({"a.py": (Part("f"), Part("g"))}, {"a.py": (Part("g"),)}), ["`a.py` `g`"])
def test_a_class_overlaps_its_method_but_not_a_name_it_only_starts(self) -> None:
self.assertEqual(overlaps({"a.py": (Part("Plan"),)}, {"a.py": (Part("Plan.branch"), Part("Planned"))}), ["`a.py` `Plan`"])
def test_a_whole_file_overlaps_any_part_of_it(self) -> None:
self.assertEqual(overlaps({"a.py": ()}, {"a.py": (Part("g", small=True),)}), ["`a.py`"])
def test_reads_on_past_a_file_only_one_touches_and_past_a_whole_file(self) -> None:
theirs = {"a.py": (), "b.py": (Part("g"),)}
self.assertEqual(overlaps({"z.py": (Part("f"),), "a.py": (), "b.py": (Part("g"),)}, theirs), ["`a.py`", "`b.py` `g`"])
def test_line_ranges_overlap_where_they_share_a_line(self) -> None:
self.assertEqual(overlaps({"x.sh": (Part("lines 1-10"),)}, {"x.sh": (Part("lines 10-12"),)}), ["`x.sh` lines 1-10"])
self.assertEqual(overlaps({"x.sh": (Part("lines 1-9"),)}, {"x.sh": (Part("lines 10-12"),)}), [])
self.assertEqual(overlaps({"x.sh": (Part("lines 10-12"),)}, {"x.sh": (Part("lines 1-10"),)}), ["`x.sh` lines 10-12"])
self.assertEqual(overlaps({"x.sh": (Part("lines 11-12"),)}, {"x.sh": (Part("lines 1-10"),)}), [])
def test_a_line_range_overlaps_a_named_part_since_nothing_tells_them_apart(self) -> None:
self.assertEqual(overlaps({"a.py": (Part("lines 1-9"),)}, {"a.py": (Part("f"),)}), ["`a.py` lines 1-9"])
self.assertEqual(overlaps({"a.py": (Part("f"),)}, {"a.py": (Part("lines 1-9"),)}), ["`a.py` `f`"])
def test_a_small_change_on_either_side_is_taken(self) -> None:
self.assertEqual(overlaps({"a.py": (Part("f", small=True),)}, {"a.py": (Part("f"),)}), [])
self.assertEqual(overlaps({"a.py": (Part("f"),)}, {"a.py": (Part("f", small=True),)}), [])
@@ -1,5 +1,7 @@
"""An item's prediction of the files and parts it will touch, as its detail spells it, and where two predictions overlap.
It sits in plan so that plan_store's `FilePlan.check` and todo-item can call `predicted`: touch_predictions imports plan_store, and importing touch_predictions from plan_store would make the two packages import each other.
The spelling, which the decision `todo.md: an item of the next release predicts the files and parts it will touch …` gives the reasons for:
Touches:
@@ -46,7 +48,7 @@ def predicted(detail: str) -> Touches | None | Failure:
break
read = bullet(line)
if read is None:
return Failure(f"the bullet {line!r} under `{LABEL}` is not a path in backticks, then optionally a colon and its parts, each a name in backticks or `lines <first>-<last>`, and optionally `{SMALL}`")
return Failure(f"the bullet {line!r} under `{LABEL}` is not a path in backticks, then optionally a colon and its parts, each a name in backticks or `lines <first>-<last>` that `{SMALL.strip()}` may follow; `{SMALL.strip()}` follows a part, never a bare path")
if any(span and span[0] > span[1] for span in map(line_range, read[1])):
return Failure(f"the bullet {line!r} under `{LABEL}` holds a line range whose first line comes after its last")
touches = together([touches, {read[0]: read[1]}])
+11 -2
View File
@@ -7,6 +7,7 @@ from plan_store.plans import cells, Plan, Written
from failure import Failure
from plan.todo_table import item_details, items, NoItemsTable, renames
from plan_store import markdown_edits
from plan.touches import predicted
from plan import ranking
from record_store.stores import RecordStore
from text_files.file_writes import replace_file
@@ -84,7 +85,7 @@ class FilePlan:
return ranked
def check(self) -> list[str]:
"""Why `rank_todo.py --check` fails on the file, empty when it passes: the file is not ranked, or an item scores under the bar."""
"""Why `rank_todo.py --check` fails on the file, empty when it passes: the file is not ranked, an item scores under the bar, or touch-predictions cannot read an item's `Touches:` list."""
texts = self.texts()
if isinstance(texts, Failure):
return [texts.reason]
@@ -92,7 +93,7 @@ class FilePlan:
if isinstance(ranked, Failure):
return [ranked.reason]
unranked = [] if ranked.text == texts[0] else [f"{self.path}: not ranked; run rank_todo.py on it"]
return unranked + [f"{self.path}: {line}" for line in ranked.under_bar]
return unranked + [f"{self.path}: {line}" for line in ranked.under_bar + unreadable_touches(texts[0])]
def reported(self, ranked: ranking.Ranked) -> list[str]:
"""Ranking's notes and under-bar lines, each prefixed with the file's path, as a tool prints them on stderr."""
@@ -115,6 +116,14 @@ class FilePlan:
return weighing if isinstance(weighing, Failure) else (plan, *weighing)
def unreadable_touches(todo: str) -> list[str]:
"""One line per item whose `Touches:` list touch-predictions cannot read, saying why. Every item is read, not only the next release's: a later item moves into the next release with its detail, and the list is fixed most cheaply where it was written."""
details = item_details(todo)
if isinstance(details, Failure):
return [details.reason]
return [f"item {id_}: {read.reason}" for id_, detail in details.items() if isinstance(read := predicted(detail), Failure)]
def plan_of(todo: str) -> Plan | Failure:
"""The plan a todo.md's text holds."""
found = items(todo)
+3 -2
View File
@@ -11,7 +11,8 @@ question rows come first, then security rows, then the rest, each group by score
then by ID. Then it moves each blocker, an item another's Blocked by cell names, that ranks below
an item it blocks to just above the first such item. Orders the details to match. Writes each
item's R, and adds the Blocked by and R columns to a table without them. --check doesn't write
anything and fails when the file is not ranked as it would be.
anything and fails when the file is not ranked as it would be, or when an item's detail holds a
`Touches:` list not spelt as `touch-predictions --help` shows.
A valid todo.md; ## Details and each item's detail are optional:
@@ -87,7 +88,7 @@ Exit 1, saying why, on bad arguments, a checkout no config names or a config tha
file given that is not the config's plan, a file that cannot be read or written, a todo.md, goals file or docs/decisions.md that breaks the
rules above, a scoring run on docs/comprehension-history.md's newest scored commit with no Mean row
ending in its overall, an item that is not exempt scoring under the bar, or --check finding the file
unranked.
unranked, or an item's `Touches:` list unreadable.
"""
import pathlib
import sys
+20
View File
@@ -12,6 +12,7 @@ from plan.test_ranking import DECISIONS, OLD_SHAPE, README, TODO
from project_config.settings import DEFAULT_FLOOR
from plan import goals_file, ranking
import rank_todo
from todo_item.test_todo_item import READABLE_TOUCHES, UNREADABLE_BULLETS
class Main(unittest.TestCase):
@@ -102,6 +103,25 @@ class Main(unittest.TestCase):
self.assertEqual(self.run_main(str(todo)), (1, f"{todo}: {under}\n"))
self.assertEqual(self.run_main("--check", str(todo)), (1, f"{todo}: {under}\n"))
def test_check_fails_on_each_item_whose_touches_list_it_cannot_read(self):
with tempfile.TemporaryDirectory() as temp:
todo = pathlib.Path(temp, "todo.md")
configured(self, pathlib.Path(temp))
self.enterContext(contextlib.chdir(temp))
pathlib.Path(temp, "README.md").write_text(README)
pathlib.Path(temp, "docs").mkdir()
pathlib.Path(temp, "docs", "decisions.md").write_text(DECISIONS)
for bullet in UNREADABLE_BULLETS:
with self.subTest(bullet):
# Item 1 sits in a later release than item 3: the check reads every item's list, not only the next release's.
todo.write_text(TODO.replace("Fast detail.", READABLE_TOUCHES).replace("Later detail.", f"Touches:\n\n{bullet}"))
self.assertEqual(self.run_main(str(todo))[0], 0)
code, said = self.run_main("--check", str(todo))
self.assertEqual(code, 1)
self.assertTrue(said.startswith(f"{todo}: item 1: "), said)
self.assertIn(repr(bullet), said)
self.assertEqual(said.count("\n"), 1)
def test_says_to_reshape_an_old_shape_table_but_passes_the_check(self):
with tempfile.TemporaryDirectory() as temp:
todo = pathlib.Path(temp, "todo.md")
+14 -4
View File
@@ -27,7 +27,8 @@ list and show read only the plan, and print no Score: an item's place in list's
add files the item under the next free ID, with the tagline in bold, and the detail it reads from
stdin, if any. The detail may hold no ## or ### heading.
It prints `Filed item <ID> in <plan>.` It doesn't write anything where ranking fails or scores the item under the bar.
It prints `Filed item <ID> in <plan>.` It doesn't write anything where ranking fails or scores the item under the bar,
or where the detail holds a `Touches:` list not spelt as `touch-predictions --help` shows.
In a Jira epic, add files a Task under the epic, and <ID> is the new issue's number. The release
must be one of the Jira project's Fix Versions, named as 1.2.0 or v1.2.0 there, and --exempt
security also labels the issue `security`. The item scores by the config's `jira-score-formula`, and
@@ -41,7 +42,8 @@ edit sets the cells whose flag is given and leaves the rest; an empty value, as
empties the cell. --detail replaces the detail with the text on stdin, and --clear-detail removes it.
Text on stdin without --detail, and --detail without text on stdin, are refused, so no detail is
dropped or wiped by mistake. It prints `Edited item <ID> in <plan>.` It doesn't write anything where
ranking fails or scores the item under the bar.
ranking fails or scores the item under the bar, or where a new detail holds a `Touches:` list not
spelt as `touch-predictions --help` shows.
In a Jira epic, edit changes an issue the loop filed: its summary, description and scores, the label
`security` with --exempt, and its "is blocked by" links with --blocked-by: it makes a link for each
blocker added and deletes the link of each blocker dropped. Each blocker must be an open child of the
@@ -89,6 +91,7 @@ from project_config.main import located
from plan_store.plans import no_item, PlanStore, TAGLINE, Written
from plan.release import parsed, Release, version as release_version
from plan_store.stores import store as plan_store
from plan.touches import predicted
from record_store.stores import RecordStore, store
from todo_item.table import shown, table
from todo_item.edits import with_bullet
@@ -115,7 +118,8 @@ def main(argv: list[str], folder: pathlib.Path = pathlib.Path(), stdin: typing.T
case "show":
done = show(args, plan)
case "add":
done = reported(plan.add(fields(args), piped(stdin)), "not filed", lambda written: f"Filed item {written.id} in {plan.label}.")
detail = piped(stdin)
done = unreadable(detail, "not filed") or reported(plan.add(fields(args), detail), "not filed", lambda written: f"Filed item {written.id} in {plan.label}.")
case "edit":
done = edit(args, plan, piped(stdin))
case "move":
@@ -194,6 +198,12 @@ def reported(written: Written | Failure, refusal: str, done: typing.Callable[[Wr
return done(written)
def unreadable(detail: str | None, refusal: str) -> Failure | None:
"""A Failure opened with refusal where detail holds a `Touches:` list touch-predictions cannot read; checked here, before the plan's backend gets the detail, so a plan in Jira is held to it too."""
read = None if detail is None else predicted(detail)
return Failure(f"{refusal}: {read.reason}") if isinstance(read, Failure) else None
def list_(args: argparse.Namespace, plan: PlanStore) -> str | Failure:
read = plan.read()
if isinstance(read, Failure):
@@ -220,7 +230,7 @@ def edit(args: argparse.Namespace, plan: PlanStore, text: str) -> str | Failure:
detail = text if args.detail else "" if args.clear_detail else None
if not fields(args) and detail is None:
return Failure("not edited: no flag names a change; todo-item --help lists them")
return reported(plan.edit(args.id, fields(args), detail, args.comment), "not edited", lambda written: f"Edited item {written.id} in {plan.label}.")
return unreadable(detail, f"not edited: item {args.id}'s detail") or reported(plan.edit(args.id, fields(args), detail, args.comment), "not edited", lambda written: f"Edited item {written.id} in {plan.label}.")
def finish(args: argparse.Namespace, plan: PlanStore, changelog: RecordStore | None) -> str | Failure:
+41
View File
@@ -25,6 +25,16 @@ CHANGELOG = "# Changelog\n\n## Unreleased\n\n- Older news.\n\n## 0.1.0\n\n- Firs
# ## Details of the ranked fixture, without the trailing ## Notes.
HEADER = "| ID | Release | Blocked by | Exempt | Item | L | E | I | R | S | Moves |\n|---|---|---|---|---|---|---|---|---|---|---|\n"
DETAILS = "## Details\n\n### 3. Make it fast, `a | b`.\n\nFast detail.\n\n### 1. Ship the later thing.\n\nLater detail.\n\n"
# The bullets six items held on 2026-11-18, which touch-predictions cannot read: `(small)` after a bare path, and a part not in backticks.
UNREADABLE_BULLETS = (
"- `bin/judge_replay/main.py` (small)",
"- `bin/do_epic/main.py` (small)",
"- `principles/technical-principles.md`: the tests bullet group, `A valuable test checks behaviour` (small)",
"- `README.md`: loop-claude's section (small)",
"- `bin/rule_hook/rules.py`: the rule table (small)",
"- `settings.json`: the PreToolUse matcher (small)",
)
READABLE_TOUCHES = "Why.\n\nTouches:\n\n- `bin/a.py`: `main`, `Plan.branch` (small)\n- `bin/run.sh`: lines 10-20\n- `docs/new.md`\n"
class Terminal(io.StringIO):
@@ -488,6 +498,37 @@ class Edit(TodoItem):
self.assertEqual(self.todo.read_text(), before)
class UnreadableTouches(TodoItem):
"""A `Touches:` list touch-predictions cannot read is refused when written, since loop-claude doesn't start any chunk beside an item whose list it cannot read."""
def test_add_and_edit_refuse_each_bullet_that_stalled_the_loop(self):
for bullet in UNREADABLE_BULLETS:
for argv, refusal in ((ADD, "not filed: "), (["edit", "3", "--detail"], "not edited: item 3's detail: ")):
with self.subTest(bullet=bullet, command=argv[0]):
before = self.todo.read_text()
code, out, err = self.run_main(*argv, stdin=f"Why.\n\nTouches:\n\n- `bin/a.py`: `main`\n{bullet}\n")
self.assertEqual((code, out), (1, ""))
self.assertTrue(err.startswith(refusal), err)
self.assertIn(repr(bullet), err)
self.assertEqual(self.todo.read_text(), before)
def test_add_and_edit_take_a_readable_list_and_a_detail_without_one(self):
for detail in (READABLE_TOUCHES, "Why, without a list.\n"):
with self.subTest(detail):
self.assertEqual(self.run_main(*ADD, stdin=detail)[0], 0)
self.assertEqual(self.run_main("edit", "3", "--detail", stdin=detail)[0], 0)
self.assertIn(detail, self.todo.read_text())
def test_a_plan_in_jira_gets_no_unreadable_list_either(self):
self.config.write_text(self.config.read_text().replace('"checkout:todo.md"', f'"{JIRA_PLAN}"') + 'env-file = "~/acme.env"\n' + JIRA_SCORING)
plan = MemoryPlan({3: {"Release": "0.1.0", "Item": "**Count the runs.**", "L": "1", "E": "2", "I": "3", "S": "1"}})
self.enterContext(unittest.mock.patch.object(main, "plan_store", return_value=plan))
detail = f"Touches:\n\n{UNREADABLE_BULLETS[0]}\n"
self.assertEqual(self.run_main(*ADD, stdin=detail)[:2], (1, ""))
self.assertEqual(self.run_main("edit", "3", "--detail", stdin=detail)[:2], (1, ""))
self.assertEqual((list(plan.rows), plan.details), ([3], {}))
class Move(TodoItem):
def test_sets_the_items_release_and_keeps_the_rest(self):
self.assertEqual(self.run_main("move", "3", "--release", "0.2.0"), (0, f"Moved item 3 to release 0.2.0 in {self.todo}.\n", ""))
+1 -1
View File
@@ -3,7 +3,7 @@ import dataclasses
from failure import Failure
from plan.todo_table import Item, waiting
from touch_predictions.prediction import LABEL, overlaps, predicted, Touches
from plan.touches import LABEL, overlaps, predicted, Touches
@dataclasses.dataclass(frozen=True)
+1 -1
View File
@@ -3,7 +3,7 @@ import re
from failure import Failure
from git_cli.git_repo import git, Git
from touch_predictions.prediction import Part, Touches
from plan.touches import Part, Touches
from touch_predictions.file_parts import part_names
HUNK = re.compile(r"^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@", re.M)
+1 -1
View File
@@ -49,7 +49,7 @@ import typing
from git_cli.git_repo import default_ref, git, Git
from failure import Failure
from plan_store.stores import store as plan_store
from touch_predictions.prediction import predicted, together, Touches
from plan.touches import predicted, together, Touches
from project_config.main import project
from project_config.settings import ProjectConfig, TOUCH_PREDICTIONS
from touch_predictions import record
+1 -1
View File
@@ -3,7 +3,7 @@ import re
from failure import Failure
from record_store.stores import RecordStore
from touch_predictions.prediction import rendered, Touches
from plan.touches import rendered, Touches
from text_files.utc_stamp import STAMPED
TITLE = "# Touch predictions"
+1 -159
View File
@@ -1,7 +1,6 @@
import os
import pathlib
import re
import shutil
import subprocess
import sys
import tempfile
@@ -10,53 +9,16 @@ import unittest
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
from touch_predictions.beside import Beside, chunks_beside
from adf_codec import convert
from touch_predictions import diff_parts, file_parts, main, record
from failure import Failure
from test_env import isolated_env
from project_config.main import located
from record_store.fakes import MemoryStore
from touch_predictions.prediction import overlaps, Part, predicted, rendered, together
from plan.touches import Part
from plan_store.todo_md import plan_of
from project_config.settings import ProjectConfig
from project_config.test_project_config import write_config
DETAIL = """A planning call.
Touches:
- `bin/a.py`: `main`, `Plan.branch` (small)
- `README.md`: `## Goals, and (more): things`
- `bin/run.sh`: lines 10-20
- `docs/new.md`
More prose, with `bin/b.py` named.
"""
needs_docker = unittest.skipIf(shutil.which("docker") is None or subprocess.run(["docker", "info"], capture_output=True, timeout=20).returncode != 0, "adf_codec runs in a container, which needs a docker daemon")
def text(words: str, code: bool = False) -> dict:
return {"type": "text", "text": words, **({"marks": [{"type": "code"}]} if code else {})}
def bullet_of(*spans: dict) -> dict:
return {"type": "listItem", "attrs": {"localId": "i"}, "content": [{"type": "paragraph", "attrs": {"localId": "p"}, "content": list(spans)}]}
# A Touches list as someone types it in Jira's editor: a paragraph, then a bulleted list whose paths and names carry the code mark.
JIRA_TOUCHES = {"type": "doc", "version": 1, "content": [
{"type": "paragraph", "attrs": {"localId": "a"}, "content": [text("A planning call.")]},
{"type": "paragraph", "attrs": {"localId": "b"}, "content": [text("Touches:")]},
{"type": "bulletList", "attrs": {"localId": "c"}, "content": [
bullet_of(text("bin/a.py", True), text(": "), text("main", True), text(", "), text("Plan.branch", True), text(" (small)")),
bullet_of(text("a`b.md", True), text(": "), text("## The `foo` tool", True), text(" (small)"), text(", "), text("`x`", True)),
bullet_of(text("bin/run.sh", True), text(": lines 10-20")),
bullet_of(text("docs/new.md", True)),
]},
{"type": "paragraph", "attrs": {"localId": "d"}, "content": [text("More prose.")]},
]}
PYTHON = """\"\"\"Docstring.\"\"\"
import os
@@ -98,126 +60,6 @@ Text.
"""
class PredictedTest(unittest.TestCase):
def test_reads_each_bullet_of_the_touches_list(self) -> None:
self.assertEqual(predicted(DETAIL), {
"bin/a.py": (Part("main"), Part("Plan.branch", small=True)),
"README.md": (Part("## Goals, and (more): things"),),
"bin/run.sh": (Part("lines 10-20"),),
"docs/new.md": (),
})
def test_a_detail_without_the_list_predicts_nothing(self) -> None:
self.assertIsNone(predicted("Only prose, with `bin/a.py` named."))
def test_a_bullet_it_cannot_read_is_a_failure_that_quotes_it(self) -> None:
for bullet in ("- bin/a.py: main", "- `bin/a.py`: main", "- `bin/a.py`: lines 20-10", "- `bin/a.py`: `main` `other`"):
with self.subTest(bullet):
found = predicted(f"Touches:\n\n{bullet}\n")
assert isinstance(found, Failure)
self.assertIn(bullet, found.reason)
def test_an_empty_list_is_a_failure(self) -> None:
self.assertIsInstance(predicted("Touches:\n\nProse.\n"), Failure)
found = predicted("Touches:\n")
assert isinstance(found, Failure)
self.assertEqual(found.reason, "no bullet follows `Touches:`")
def test_reads_a_list_right_under_its_label_a_one_line_range_and_a_name_of_any_letters(self) -> None:
self.assertEqual(predicted("Touches:\n- `a.py`: `Xray`, lines 5-5\n"), {"a.py": (Part("Xray"), Part("lines 5-5"))})
def test_rendered_reads_back(self) -> None:
touches = predicted(DETAIL)
assert isinstance(touches, dict)
self.assertEqual(predicted(f"Touches:\n\n{rendered(touches)}\n"), touches)
def test_a_name_that_holds_backticks_takes_a_longer_run_with_a_space_inside_each_end(self) -> None:
self.assertEqual(predicted("Touches:\n- `a.md`: `` ## The `foo` tool `` (small), ``` `` ```, `` `x` ``\n"), {"a.md": (Part("## The `foo` tool", small=True), Part("``"), Part("`x`"))})
self.assertEqual(rendered({"a.md": (Part("## The `foo` tool", small=True), Part("``"))}), "- `a.md`: `` ## The `foo` tool `` (small), ``` `` ```")
def test_a_longer_run_without_padding_spaces_is_the_text_between_its_runs(self) -> None:
self.assertEqual(predicted("Touches:\n- ``a`b.md``: ``## The `foo` tool`` (small), ``` `` ```, `` `x` ``\n"), {"a`b.md": (Part("## The `foo` tool", small=True), Part("``"), Part("`x`"))})
def test_a_longer_run_with_a_space_at_one_end_only_keeps_it(self) -> None:
self.assertEqual(predicted("Touches:\n- `a.md`: `` x``, ``y ``, `` a ``\n"), {"a.md": (Part(" x"), Part("y "), Part("a"))})
@needs_docker
def test_a_list_written_in_markdown_and_read_back_from_a_jira_description_reads_as_written(self) -> None:
description = convert.markdown_to_adf(DETAIL)
assert isinstance(description, dict)
self.assertEqual(predicted(convert.adf_to_markdown(description)), predicted(DETAIL))
@needs_docker
def test_a_list_typed_in_jiras_editor_reads_as_its_files_and_parts(self) -> None:
read = convert.adf_to_markdown(JIRA_TOUCHES)
self.assertEqual(predicted(read), {
"bin/a.py": (Part("main"), Part("Plan.branch", small=True)),
"a`b.md": (Part("## The `foo` tool", small=True), Part("`x`")),
"bin/run.sh": (Part("lines 10-20"),),
"docs/new.md": (),
})
def test_a_name_ends_only_at_a_run_as_long_as_the_one_that_opens_it(self) -> None:
self.assertEqual(predicted("Touches:\n- `a.md`: `` a ``` b ``, `c``d`\n"), {"a.md": (Part("a ``` b"), Part("c``d"))})
def test_a_path_holds_any_character_and_a_single_backtick_keeps_a_names_spaces(self) -> None:
self.assertEqual(predicted("Touches:\n- `my file.md`: ` x `\n- `` a`b.md ``\n"), {"my file.md": (Part(" x "),), "a`b.md": ()})
def test_rendered_reads_back_whatever_a_path_or_a_name_holds(self) -> None:
touches = {"my file.md": (Part("## todo.md: under `Touches:` in its detail"), Part("## ``a`` and `b`", small=True), Part("`"), Part("## ends in `x`"), Part(" x "), Part("lines 2-3")), "a`b.md": (), "c, d: e.md": (Part("# T"),)}
self.assertEqual(predicted(f"Touches:\n\n{rendered(touches)}\n"), touches)
def test_a_bullet_with_an_unclosed_run_a_blank_name_or_a_stray_separator_is_a_failure(self) -> None:
for bullet in ("- `a.md`: `` ## A", "- `a.md`: `` ## A `", "- `a.md`: `` ``", "- `a.md`: ", "- `a.md`:", "- `a.md`: `f`, ", "- `a.md`: `f`,`g`", "- ``", "- `a.md` (small)", "- `a.md`: `f` (small) (small)"):
with self.subTest(bullet):
self.assertIsInstance(predicted(f"Touches:\n\n{bullet}\n"), Failure)
def test_a_range_that_runs_backwards_is_a_failure_that_says_so(self) -> None:
found = predicted("Touches:\n\n- `bin/a.py`: `f`, lines 20-10\n")
assert isinstance(found, Failure)
self.assertEqual(found.reason, "the bullet '- `bin/a.py`: `f`, lines 20-10' under `Touches:` holds a line range whose first line comes after its last")
def test_together_joins_items_and_keeps_small_only_where_each_says_so(self) -> None:
joined = together([{"a.py": (Part("f", small=True), Part("g", small=True))}, {"a.py": (Part("f"),), "b.md": ()}, {"b.md": (Part("# T"),)}])
self.assertEqual(joined, {"a.py": (Part("f"), Part("g", small=True)), "b.md": ()})
def test_together_keeps_a_part_not_small_once_one_says_so_and_reads_on_past_a_whole_file(self) -> None:
joined = together([{"a.py": (Part("f"),), "b.md": ()}, {"b.md": (Part("# T"),), "a.py": (Part("f", small=True),), "c.py": (Part("h"),)}])
self.assertEqual(joined, {"a.py": (Part("f"),), "b.md": (), "c.py": (Part("h"),)})
class OverlapsTest(unittest.TestCase):
def test_other_files_and_other_parts_do_not_overlap(self) -> None:
self.assertEqual(overlaps({"a.py": (Part("f"),)}, {"a.py": (Part("g"),), "b.py": ()}), [])
def test_the_same_part_overlaps(self) -> None:
self.assertEqual(overlaps({"a.py": (Part("f"), Part("g"))}, {"a.py": (Part("g"),)}), ["`a.py` `g`"])
def test_a_class_overlaps_its_method_but_not_a_name_it_only_starts(self) -> None:
self.assertEqual(overlaps({"a.py": (Part("Plan"),)}, {"a.py": (Part("Plan.branch"), Part("Planned"))}), ["`a.py` `Plan`"])
def test_a_whole_file_overlaps_any_part_of_it(self) -> None:
self.assertEqual(overlaps({"a.py": ()}, {"a.py": (Part("g", small=True),)}), ["`a.py`"])
def test_reads_on_past_a_file_only_one_touches_and_past_a_whole_file(self) -> None:
theirs = {"a.py": (), "b.py": (Part("g"),)}
self.assertEqual(overlaps({"z.py": (Part("f"),), "a.py": (), "b.py": (Part("g"),)}, theirs), ["`a.py`", "`b.py` `g`"])
def test_line_ranges_overlap_where_they_share_a_line(self) -> None:
self.assertEqual(overlaps({"x.sh": (Part("lines 1-10"),)}, {"x.sh": (Part("lines 10-12"),)}), ["`x.sh` lines 1-10"])
self.assertEqual(overlaps({"x.sh": (Part("lines 1-9"),)}, {"x.sh": (Part("lines 10-12"),)}), [])
self.assertEqual(overlaps({"x.sh": (Part("lines 10-12"),)}, {"x.sh": (Part("lines 1-10"),)}), ["`x.sh` lines 10-12"])
self.assertEqual(overlaps({"x.sh": (Part("lines 11-12"),)}, {"x.sh": (Part("lines 1-10"),)}), [])
def test_a_line_range_overlaps_a_named_part_since_nothing_tells_them_apart(self) -> None:
self.assertEqual(overlaps({"a.py": (Part("lines 1-9"),)}, {"a.py": (Part("f"),)}), ["`a.py` lines 1-9"])
self.assertEqual(overlaps({"a.py": (Part("f"),)}, {"a.py": (Part("lines 1-9"),)}), ["`a.py` `f`"])
def test_a_small_change_on_either_side_is_taken(self) -> None:
self.assertEqual(overlaps({"a.py": (Part("f", small=True),)}, {"a.py": (Part("f"),)}), [])
self.assertEqual(overlaps({"a.py": (Part("f"),)}, {"a.py": (Part("f", small=True),)}), [])
class FilePartsTest(unittest.TestCase):
def names(self, path: str, text: str, *lines: int) -> set[str] | None:
return file_parts.part_names(path, text, lines)
+1 -1
View File
@@ -806,7 +806,7 @@ Valid while the worker writes the tests that larv-review's reviewers hold to the
## todo.md: an item of the next release predicts the files and parts it will touch under `Touches:` in its detail; chunk-preflight takes, in the plan's order, the items that overlap none taken before them as the chunks that may run at once, and the optional `touch-predictions` record keeps each chunk's prediction beside what it touched
2026-11-15, lilleman's call of 2026-11-13 in item 373, which split item 361. Serves goal 1.5, held to goal 1.4: several chunks of one project run at once only where they are unlikely to touch the same lines, since a conflict costs a rebase, a gate rerun and often a review round. A session on the project's rung or above writes each prediction, as `rules/todo-items.md` says, and `bin/touch_predictions/` reads it. The choices the call left open:
2026-11-15, lilleman's call of 2026-11-13 in item 373, which split item 361. Serves goal 1.5, held to goal 1.4: several chunks of one project run at once only where they are unlikely to touch the same lines, since a conflict costs a rebase, a gate rerun and often a review round. A session on the project's rung or above writes each prediction, as `rules/todo-items.md` says, and `bin/plan/touches.py` reads it. The choices the call left open:
- **The spelling.** A `Touches:` line, then one bullet per file: the path in backticks, then its parts, each a name in backticks or `lines <first>-<last>`, with `(small)` after a part the item changes only a little; a path or a name that holds a backtick takes a longer run of backticks with a space inside each end, as a Markdown code span does. A path alone is the whole file. Three readers seated as the README's audience picked the bulleted list over one line and over a table, since backticks hold a heading's commas, colons and parentheses. Two of the three put `(small)` after the part and outside the backticks, and two left line ranges unquoted. Each picked a different config key: `touch-predictions` was one reader's first choice and the second choice of the other two.
- **A part's boundaries.** Python's `ast` module names the innermost function or class, a top-level assignment by the name it sets, and `(module)` for the rest. A Markdown file's parts are its headings outside fenced code. Any other file, and Python that doesn't parse, falls back to line ranges. A table row is no part of its own: the item named one, but the tables chunks collide on are the plan's and the changelog's, which don't count.
+1 -1
View File
@@ -30,4 +30,4 @@ paths:
- **The Exempt cell keeps an item whatever its score:** `security` for a security finding, `defect` for a 🔴 finding or an item that restores a maintain goal the project breaks today, `question` for a question only the human can answer, which ranks first in its release, `decision` for an item `docs/decisions.md` cites, `owner` for an item the human told you to keep, and, where no other reason fits, `principle` for a 🟡 finding against a file in the config's principles folder, whose item's detail names that principle. Every item `docs/decisions.md` cites carries one of these reasons.
- **A maintain goal vetoes an item that breaks it,** whatever the item scores: redesign the item so it holds the goal, or drop it.
- **When you remove an item that no chunk built, title the commit `Drop item <ID>: <why>`,** or `Drop items 12, 14 and 15: <why>` for several. Such an item was deleted under the bar, vetoed, superseded or moot; a finished item is not one. Without the title, `score-outcomes` credits the item with the work of the chunk that removed it, where that chunk changed more than `todo.md`.
- **Predict, in the detail of each item of the next release, what the item will touch.** When you plan the next release, or file or move an item into it, give the item's detail a `Touches:` line, then one bullet per file the item will change. Each bullet names the file, then the parts of it the item will change: a function, a class or a section heading, or line ranges where the file has none of these. A path alone means the whole file. Read the code first; a prediction from the item's text alone misses. `~/.claude/bin/touch-predictions --help` shows the spelling and how a part is named; a name that holds a backtick takes a longer run of backticks with a space inside each end, as a Markdown code span does. Mark a part `(small)` where the item changes only a few lines of it. Leave out the plan and the project's records, which every chunk writes. `chunk-preflight` reads the predictions to name the items that may start chunks at once, and `touch-predictions record` keeps each beside what its chunk touched.
- **Predict, in the detail of each item of the next release, what the item will touch.** When you plan the next release, or file or move an item into it, give the item's detail a `Touches:` line, then one bullet per file the item will change. Each bullet names the file, then the parts of it the item will change: a function, a class or a section heading, or line ranges where the file has none of these. A path alone means the whole file. Read the code first; a prediction from the item's text alone misses. `~/.claude/bin/touch-predictions --help` shows the spelling and how a part is named; a name that holds a backtick takes a longer run of backticks with a space inside each end, as a Markdown code span does. Mark a part `(small)` where the item changes only a few lines of it. `(small)` follows a part, never a bare path. A part is a name in backticks, or `lines <first>-<last>`. BANNED: ``- `bin/a.py` (small)``, ``- `README.md`: loop-claude's section (small)``. GOOD: ``- `bin/a.py`: `main` (small)``, ``- `README.md`: `## Tools` (small)``. Leave out the plan and the project's records, which every chunk writes. `chunk-preflight` reads the predictions to name the items that may start chunks at once, and `touch-predictions record` keeps each beside what its chunk touched. `todo-item add`, `todo-item edit` and `rank_todo.py --check` refuse a list touch-predictions cannot read.
+6 -1
View File
@@ -6,7 +6,7 @@
`Bar = 0.1`
`Next ID = 424`
`Next ID = 426`
## Items
@@ -39,6 +39,7 @@
| 341 | 0.13.0 | | | **Hand each worker's claude a lower Read limit through `CLAUDE_CODE_FILE_READ_MAX_OUTPUT_TOKENS`, kept only where replays of the archived review rounds find what two unchanged replays find.** | 2 | 2 | 3 | 5 | 3 | 1.4 by 3 | 1.0 |
| 298 | 0.13.0 | | | **Send the judge only the decision entries and the transcript tail a verdict needs, and keep the cut only where `judge-replay` changes no verdict kind.** | 3 | 3 | 3 | 7 | 4 | 1.4 by 2, 1.5 by 1 | 0.9 |
| 395 | 0.13.0 | | decision | **Keep each block a save didn't change, with its localId, and the spacing paragraphs beside it as Jira or Confluence holds them.** | 3 | 2 | 2 | 5 | 5 | 1.6 by 4 | 0.8 |
| 425 | 0.13.0 | | | **Show on loop-claude's terminal why it doesn't start a chunk beside the next item, as chunk-preflight prints it.** | 1 | 1 | 2 | 2 | 2 | 1.5 by 2 | 0.7 |
| 367 | 0.13.0 | | | **Check that every write to a Jira plan leaves it ranked, as rule-hook's `todo-rank-check` checks `todo.md` today.** | 2 | 2 | 3 | 5 | 3 | 1.6 by 2 | 0.7 |
| 423 | 0.13.0 | | | **Skip the judge's model call on a worker's final message that the offline classifier decides is finished.** | 3 | 3 | 3 | 7 | 5 | 1.4 by 2 | 0.4 |
| 77 | 0.14.0 | | | **Teach `bin/metric-bench` Go and TypeScript, rerun it once two projects' comprehension histories name places, and bring into review only a metric that tracks the panel.** | 4 | 2 | 1 | 5 | 6 | 1.1 by 7, 1.4 by 7 | 2.1 |
@@ -407,6 +408,10 @@ Touches:
Today a Jira detail edited in one line, or a Confluence record with one entry appended, is written back whole by adf-codec's portable pair, which drops each block's localId and the empty paragraphs Jira uses for spacing. A save whose text is the text a read showed already sends nothing (`docs/decisions.md` → `project config: the loop shows a Jira description and a Confluence page as adf-codec's portable markdown, …`). Match the saved markdown's top-level blocks against the held document's, each as the portable pair reads it, and send the held block where they match. The decision's limit on partial saves ends with this item.
### 425. Show on loop-claude's terminal why it doesn't start a chunk beside the next item, as chunk-preflight prints it.
`chunks_beside` names each item it refuses and why, such as an unreadable `Touches:` list, and chunk-preflight prints those lines, but loop-claude's `chunk_windows.may_start` keeps only `picked` and drops them, so idle slots show no reason. Found by item 424's product-owner review; a list a person edits in Jira's UI, or one filed before item 424, still reaches loop-claude unchecked.
### 367. Check that every write to a Jira plan leaves it ranked, as rule-hook's `todo-rank-check` checks `todo.md` today.
One of 0.13.0's history ports, per lilleman's call of 2026-11-12.