Answer prose round 1: 0 🔴, 7 🟡 (0 misread); rename Record to Annotation, and reword the decision, the help and the changelog
CI / tests (pull_request) Successful in 2m37s

This commit was merged in pull request #504.
This commit is contained in:
2026-11-12 10:25:30 +01:00
parent 72d9a9f652
commit fa54ed46b1
8 changed files with 47 additions and 47 deletions
+1 -1
View File
@@ -2,7 +2,7 @@
## Unreleased
- loop-claude records beside each verdict, interrupt and quoted answer the claude-config release and commit that ran it, the tokens each thread spent by model and kind with the list prices in force, and any typed answer of yours the judge quotes as reversing a choice the worker took itself; `score-outcomes` counts those reversals per finished chunk.
- loop-claude records beside each verdict, interrupt and quoted answer the claude-config release and commit that ran it, the tokens the worker, each subagent and the judge spent, by model and kind, with the list prices in force, and any typed answer of yours the judge quotes as reversing a choice the worker took on its own recommendation; `score-outcomes` counts those reversals per finished chunk.
- `larv-review prepare-scoring` makes a scoring run's worktree and writes each seat's prompt; `record-scoring` removes both once it has recorded the run.
- `deploy-release` moves a checkout whose `settings.json` differs from the release only by a `/model` pick or the key order Claude Code writes, and then says to pick the model again.
- `chunk-pr merge` waits for the pull request's checks itself, allowing a minute for them to report, and no longer takes `--gate-passed`. `wait-for <file> [<pattern>]` waits for a line in a background job's log or report.
+1 -1
View File
@@ -114,7 +114,7 @@ Install puts only `loop-claude` and `loop-inbox` on `PATH`; call the others by t
- `rule-hook [overrides]` blocks a tool call that breaks a rule a program can check, unless the call overrides the rule; `settings.json` → `hooks` runs it before each Agent, Bash, Edit, MultiEdit, Read, Skill and Write call, and `rule-hook --help` states the rules and the override.
- `run-heavy <command>` runs a heavy command once it holds one of the machine's heavy slots, one per 4 CPUs, which every session shares; `run-heavy --help` states the slots, and the memory cap it gives a container that sets no limit.
- `run-tests [<pytest args>...]` runs this repo's test suite, as Test says.
- `score-outcomes [L E I S]` shows what each finished item's chunk measured beside the scores the item was guessed at, to score a new item by, code health's two counter-signals per chunk, misread findings and later fixes, and the answers that reversed a worker's choice; `score-outcomes --help` states the report.
- `score-outcomes [L E I S]` shows what each finished item's chunk measured beside the scores the item was guessed at, to score a new item by. Per chunk it also shows code health's two counter-signals, misread findings and later fixes, and how many of the human's answers reversed a worker's choice; `score-outcomes --help` states the report.
- `settings_filter.py` is git's clean filter for `settings.json`: it drops `"model"` and sorts the keys. `.gitattributes` sets the filter `settings` on `settings.json`, and Install's `git config` line makes this script that filter.
- `statusline.py` renders Claude Code's status line; `settings.json` → `statusLine` runs it.
- `subagent-rung [--plan] <model> <L>` prints the Agent tool's model and effort for a subagent's task, picked by its L from the project's model, and with `--plan` never below the project's rung; `subagent-rung --help` states the rule.
+13 -13
View File
@@ -163,16 +163,16 @@ def rule(cycle: Cycle, transcript_path: str, quoted_answers: int) -> Ruled | Sto
verdict = dataclasses.replace(verdict, taken_in=chunk_items.taken_in(entries, cycle.todo))
if not isinstance(verdict, Interrupt | QuotedAnswer):
return Ruled(verdict)
record = record_of(cycle, transcript_path, entries, verdict.judged)
if isinstance(record, Failure):
return Stop(1, record.reason)
annotation = annotation_of(cycle, transcript_path, entries, verdict.judged)
if isinstance(annotation, Failure):
return Stop(1, annotation.reason)
stepped = ruling_step_up(cycle, verdict)
if failure := archive_stepped(cycle, transcript_path, ruling_outcome(cycle, verdict, quoted_answers, record), stepped):
if failure := archive_stepped(cycle, transcript_path, ruling_outcome(cycle, verdict, quoted_answers, annotation), stepped):
return Stop(1, failure.reason)
return Ruled(verdict, stepped.after if stepped else None)
def record_of(cycle: Cycle, transcript_path: str, entries: list[Entry], judged: Judged) -> outcomes.Record | Failure:
def annotation_of(cycle: Cycle, transcript_path: str, entries: list[Entry], judged: Judged) -> outcomes.Annotation | Failure:
"""What a verdict, an interrupt or a quoted answer records beside its judge lines: the setup, the stretch's spend as spend.py counts it, and the reversal the judge found."""
since = last_spent(cycle.project_archive, transcript_path)
if isinstance(since, Failure):
@@ -181,14 +181,14 @@ def record_of(cycle: Cycle, transcript_path: str, entries: list[Entry], judged:
if isinstance(subagents, Failure):
return subagents
spent = spend.spent(since, entries, subagents, judge_of(cycle).model, judged.tokens)
return outcomes.Record(cycle.config, spend.spent_block(since, spent), judged.reversed)
return outcomes.Annotation(cycle.config, spend.spent_block(since, spent), judged.reversed)
def ruling_outcome(cycle: Cycle, ruling: Interrupt | QuotedAnswer, quoted_answers: int, record: outcomes.Record) -> str:
def ruling_outcome(cycle: Cycle, ruling: Interrupt | QuotedAnswer, quoted_answers: int, annotation: outcomes.Annotation) -> str:
"""The archive's outcome for a ruling: interrupted where it goes to the human, with the question put to them, and else answered from README.md or the records."""
if isinstance(ruling, QuotedAnswer) and not to_the_human(ruling, quoted_answers):
return outcomes.answered(question=ruling.question, sources=prompts.QUOTE_SOURCES, answer=ruling.answer, evidence=ruling.evidence, escalation=ruling.escalation, judge=str(judge_of(cycle)), worker=cycle.route.worker_line(), judge_cost=ruling.judged.cost, record=record)
return outcomes.interrupted(question_for(ruling), ruling.evidence, str(judge_of(cycle)), ruling.escalation, cycle.route.worker_line(), ruling.judged.cost, record)
return outcomes.answered(question=ruling.question, sources=prompts.QUOTE_SOURCES, answer=ruling.answer, evidence=ruling.evidence, escalation=ruling.escalation, judge=str(judge_of(cycle)), worker=cycle.route.worker_line(), judge_cost=ruling.judged.cost, annotation=annotation)
return outcomes.interrupted(question_for(ruling), ruling.evidence, str(judge_of(cycle)), ruling.escalation, cycle.route.worker_line(), ruling.judged.cost, annotation)
def keep_rejection(cycle: Cycle, transcript_path: str, rejected: Rejected) -> Stop | None:
@@ -233,10 +233,10 @@ def question_for(ruling: Interrupt | QuotedAnswer) -> str:
def close(cycle: Cycle, transcript_path: str, verdict: Finished | Unfinished) -> Archived | Stop:
entries = read_transcript(transcript_path)
record = entries if isinstance(entries, Failure) else record_of(cycle, transcript_path, entries, verdict.judged)
if isinstance(record, Failure):
return Stop(1, record.reason)
outcome = outcomes.finished(cycle.route.worker_line(), verdict.evidence, str(judge_of(cycle)), verdict.judged.cost, record) if isinstance(verdict, Finished) else outcomes.unfinished(cycle.route.worker_line(), verdict.evidence, str(judge_of(cycle)), verdict.escalation, verdict.judged.cost, record)
annotation = entries if isinstance(entries, Failure) else annotation_of(cycle, transcript_path, entries, verdict.judged)
if isinstance(annotation, Failure):
return Stop(1, annotation.reason)
outcome = outcomes.finished(cycle.route.worker_line(), verdict.evidence, str(judge_of(cycle)), verdict.judged.cost, annotation) if isinstance(verdict, Finished) else outcomes.unfinished(cycle.route.worker_line(), verdict.evidence, str(judge_of(cycle)), verdict.escalation, verdict.judged.cost, annotation)
if failure := archived(cycle.project_archive, transcript_path, cycle.task, outcome, cycle.effects):
return Stop(1, failure.reason)
if isinstance(verdict, Finished) and (failure := delete_session(cycle.session)):
+1 -1
View File
@@ -22,7 +22,7 @@ class Judged:
cost: float = 0.0
# Its reply's usage, on the judge's model.
tokens: Tokens = Tokens()
# A typed answer of the human's that reversed a choice the worker took itself, as the judge quoted it; empty for none, and where the quote isn't in the transcript.
# The human's whole typed answer that holds the judge's quote of a reversal of a choice the worker took on its own recommendation; empty for none, and where no typed answer holds the quote.
reversed: str = ""
+1 -1
View File
@@ -13,7 +13,7 @@
transcript is kept once.
- <sha256>.outcomes.md sits beside the copy and holds the task, then each outcome opened by its UTC time (outcomes.py).
A verdict, an interrupt or a quoted answer also records the setup that ran it, what was spent since the
previous record and any reversal the judge quoted (outcomes.Record).
previous outcome that recorded a spend, and any reversal the judge quoted (outcomes.Annotation).
- session/ holds every other file of the session, such as the subagents' transcripts, which Claude
Code keeps in a folder named after the session, beside the transcript. A file there is replaced only by a version that
grew from it. A file Claude Code rewrote whole lands beside its copy as <name>.<hash of its content>
+18 -18
View File
@@ -31,26 +31,26 @@ JUDGE_COST_AT = re.compile(rf"^{re.escape(JUDGE)}(.+)\n{re.escape(JUDGE_COST)}([
# The claude-config release and commit that ran the cycle, on the line before JUDGE, such as `Config: v0.8.0 (<sha>)`.
CONFIG = "Config: "
# Opens the block of what the stretch of work since the previous record spent; a record that spent nothing has none.
# Opens the block of what the work since the previous outcome that recorded a spend spent; an outcome that spent nothing has none.
SPENT = "Spent since "
# Opens the quote of a typed answer of the human's that reversed a choice the worker took itself.
# Opens the quote of a typed answer of the human's that reversed a choice the worker took on its own recommendation.
REVERSED = "Reversed:"
REVERSED_AT = re.compile(rf"^{re.escape(REVERSED)}\n((?:> .*\n)*> .*)", re.MULTILINE)
class Record(typing.NamedTuple):
"""What a verdict, an interrupt or a quoted answer records beside its judge lines, so a change to the setup can be judged before and after: docs/decisions.md → `loop-claude: each verdict records the setup, the spend and the reversals…`. Each part is left out where empty; the cycle always gives config."""
class Annotation(typing.NamedTuple):
"""What a verdict, an interrupt or a quoted answer records beside its judge lines, so a change to the setup can be judged before and after: docs/decisions.md → `loop-claude: each verdict records the claude-config release and commit that ran it…`. Each part is left out where empty; the cycle always gives config."""
config: str = ""
# The block spend.spent_block renders.
spent: str = ""
# The judge's quote of the human's reversing answer, as the judge checked it.
# The human's whole typed answer that holds the judge's quote of the reversal, as loop-claude checked it.
reversed: str = ""
def record_lines(record: Record) -> str:
reversed_block = f"{REVERSED}\n{quoted(record.reversed)}\n\n" if record.reversed else ""
spent_block = f"{record.spent}\n\n" if record.spent else ""
config_line = f"{CONFIG}{record.config}\n" if record.config else ""
def annotation_lines(annotation: Annotation) -> str:
reversed_block = f"{REVERSED}\n{quoted(annotation.reversed)}\n\n" if annotation.reversed else ""
spent_block = f"{annotation.spent}\n\n" if annotation.spent else ""
config_line = f"{CONFIG}{annotation.config}\n" if annotation.config else ""
return f"{reversed_block}{spent_block}{config_line}"
@@ -74,7 +74,7 @@ def judge_lines(judge: str, judge_cost: float) -> str:
def judge_costs(outcomes: str) -> list[tuple[str, float]]:
"""The rung and cost of each judge run the outcomes record a cost for."""
"""The rung and cost of each judge run the outcomes annotation a cost for."""
return [(found[1], float(found[2])) for found in JUDGE_COST_AT.finditer(outcomes)]
@@ -82,26 +82,26 @@ def escalation_block(escalation: str) -> str:
return f"Escalation:\n{quoted(escalation)}\n\n" if escalation else ""
def finished(worker: WorkerLine, evidence: str, judge: str, judge_cost: float = 0.0, record: Record = Record()) -> str:
return f"{FINISHED}\n\nEvidence:\n{quoted(evidence)}\n\n{record_lines(record)}{judge_lines(judge, judge_cost)}\n{WORKER}{worker}"
def finished(worker: WorkerLine, evidence: str, judge: str, judge_cost: float = 0.0, annotation: Annotation = Annotation()) -> str:
return f"{FINISHED}\n\nEvidence:\n{quoted(evidence)}\n\n{annotation_lines(annotation)}{judge_lines(judge, judge_cost)}\n{WORKER}{worker}"
def unfinished(worker: WorkerLine, evidence: str, judge: str, escalation: str, judge_cost: float = 0.0, record: Record = Record()) -> str:
def unfinished(worker: WorkerLine, evidence: str, judge: str, escalation: str, judge_cost: float = 0.0, annotation: Annotation = Annotation()) -> str:
"""escalation is the judge's quote showing that the worker's cited escalation trigger fired; empty for none."""
escalated = escalation_block(escalation)
return f"{UNFINISHED}\n\nEvidence:\n{quoted(evidence)}\n\n{escalated}{record_lines(record)}{judge_lines(judge, judge_cost)}\n{WORKER}{worker}"
return f"{UNFINISHED}\n\nEvidence:\n{quoted(evidence)}\n\n{escalated}{annotation_lines(annotation)}{judge_lines(judge, judge_cost)}\n{WORKER}{worker}"
def interrupted(question: str, evidence: str, judge: str, escalation: str, worker: WorkerLine, judge_cost: float = 0.0, record: Record = Record()) -> str:
def interrupted(question: str, evidence: str, judge: str, escalation: str, worker: WorkerLine, judge_cost: float = 0.0, annotation: Annotation = Annotation()) -> str:
"""escalation is the judge's quote showing that the worker's cited escalation trigger fired; empty for none. worker is the line naming the route the worker ran on until the interrupt."""
escalated = escalation_block(escalation)
return f"{INTERRUPTED}\n\n{question}\n\nEvidence:\n{quoted(evidence)}\n\n{escalated}{record_lines(record)}{judge_lines(judge, judge_cost)}\n{WORKER}{worker}"
return f"{INTERRUPTED}\n\n{question}\n\nEvidence:\n{quoted(evidence)}\n\n{escalated}{annotation_lines(annotation)}{judge_lines(judge, judge_cost)}\n{WORKER}{worker}"
def answered(*, question: str, sources: str, answer: str, evidence: str, escalation: str, judge: str, worker: WorkerLine, judge_cost: float = 0.0, record: Record = Record()) -> str:
def answered(*, question: str, sources: str, answer: str, evidence: str, escalation: str, judge: str, worker: WorkerLine, judge_cost: float = 0.0, annotation: Annotation = Annotation()) -> str:
"""escalation and worker are as on interrupted. Every parameter is keyword-only, since a swap of two str ones would still type-check."""
escalated = escalation_block(escalation)
return f"{ANSWERED}\n\n{question}\n\n{sources} says:\n{quoted(answer)}\n\nEvidence:\n{quoted(evidence)}\n\n{escalated}{record_lines(record)}{judge_lines(judge, judge_cost)}\n{WORKER}{worker}"
return f"{ANSWERED}\n\n{question}\n\n{sources} says:\n{quoted(answer)}\n\nEvidence:\n{quoted(evidence)}\n\n{escalated}{annotation_lines(annotation)}{judge_lines(judge, judge_cost)}\n{WORKER}{worker}"
def rejected(why: str, reply: str, judge: str, judge_cost: float = 0.0) -> str:
@@ -106,16 +106,16 @@ class Outcomes(unittest.TestCase):
self.assertIsInstance(read.latest_worker(kept, str(pathlib.Path(root, "gone.jsonl"))), Failure)
def test_a_record_quotes_the_reversal_then_the_spend_then_the_config_before_the_judge(self):
record = outcomes.Record("v0.8.0 (abc)", "Spent since the chunk began, in tokens of x:\n- worker, m: 1", "No, keep it.\nUse X.")
self.assertEqual(outcomes.finished("w", "e", "j", record=record), "Verdict: finished\n\nEvidence:\n> e\n\nReversed:\n> No, keep it.\n> Use X.\n\nSpent since the chunk began, in tokens of x:\n- worker, m: 1\n\nConfig: v0.8.0 (abc)\nJudge: j\nWorker: w")
self.assertEqual(outcomes.finished("w", "e", "j", record=outcomes.Record("v0.8.0 (abc)")), "Verdict: finished\n\nEvidence:\n> e\n\nConfig: v0.8.0 (abc)\nJudge: j\nWorker: w")
record = outcomes.Annotation("v0.8.0 (abc)", "Spent since the chunk began, in tokens of x:\n- worker, m: 1", "No, keep it.\nUse X.")
self.assertEqual(outcomes.finished("w", "e", "j", annotation=record), "Verdict: finished\n\nEvidence:\n> e\n\nReversed:\n> No, keep it.\n> Use X.\n\nSpent since the chunk began, in tokens of x:\n- worker, m: 1\n\nConfig: v0.8.0 (abc)\nJudge: j\nWorker: w")
self.assertEqual(outcomes.finished("w", "e", "j", annotation=outcomes.Annotation("v0.8.0 (abc)")), "Verdict: finished\n\nEvidence:\n> e\n\nConfig: v0.8.0 (abc)\nJudge: j\nWorker: w")
def test_reads_back_each_reversal_and_the_stamps_of_the_outcomes_that_record_a_spend(self):
spent = outcomes.Record("c", "Spent since the chunk began, in tokens of x:\n- worker, m: 1", "No, keep it.\nUse X.")
spent = outcomes.Annotation("c", "Spent since the chunk began, in tokens of x:\n- worker, m: 1", "No, keep it.\nUse X.")
kept = "Task: Do it.\n\n" + "\n".join(f"{utc(NOW + offset)} {outcome}\n" for offset, outcome in enumerate([
outcomes.unfinished("w", "e", "j", "", record=spent),
outcomes.unfinished("w", "e", "j", "", annotation=spent),
outcomes.stopped("w", "Ctrl-C"),
outcomes.finished("w", "e", "j", record=outcomes.Record("c", "Spent since x, in tokens of x:\n- judge, m: 1")),
outcomes.finished("w", "e", "j", annotation=outcomes.Annotation("c", "Spent since x, in tokens of x:\n- judge, m: 1")),
]))
self.assertEqual(outcomes.reversals(kept), ["No, keep it.\nUse X."])
self.assertEqual(outcomes.spent_stamps(kept), [utc(NOW), utc(NOW + 2)])
@@ -128,7 +128,7 @@ class Outcomes(unittest.TestCase):
transcript.write_text('{"timestamp": "2026-10-03T00:00:00Z"}\n')
self.assertEqual(read.last_spent(kept, str(transcript)), "")
with contextlib.redirect_stderr(io.StringIO()):
self.assertIsNone(write.archive(kept, str(transcript), "Do it.", outcomes.unfinished("w", "e", "j", "", record=outcomes.Record("c", "Spent since the chunk began, in tokens of x:\n- worker, m: 1")), NOW))
self.assertIsNone(write.archive(kept, str(transcript), "Do it.", outcomes.unfinished("w", "e", "j", "", annotation=outcomes.Annotation("c", "Spent since the chunk began, in tokens of x:\n- worker, m: 1")), NOW))
self.assertIsNone(write.archive(kept, str(transcript), "Do it.", outcomes.stopped("w", "Ctrl-C"), NOW + 1))
self.assertEqual(read.last_spent(kept, str(transcript)), utc(NOW))
gone = read.last_spent(kept, str(pathlib.Path(root, "gone.jsonl")))
+5 -5
View File
@@ -15,7 +15,7 @@ Each project principle states one rule that the decisions below apply; their ent
- bin/: the tools run on the host's Python, with no container, and so do their tests outside CI
- bin/: the tools support only the latest stable Python, and the tests, written in plain unittest, run on it in four pytest-xdist workers
- deploy: this repo keeps no `AGENTS.md`, since `~/.claude` is its checkout; its principles and decision titles head `docs/decisions.md`, its working rules follow them there, and its `.claude/settings.json` excludes every `.claude/CLAUDE.md`, so a session in the clone loads only the clone's `CLAUDE.md`
- loop-claude: each verdict records the setup, the spend and the reversals: the claude-config release and commit that ran it, the raw tokens each thread spent by model and kind since the previous record, and the human's typed answer the judge quotes as reversing a choice the worker took itself
- loop-claude: each verdict records the claude-config release and commit that ran it, the raw tokens each thread spent by model and kind since the previous outcome that recorded a spend, and the human's typed answer the judge quotes as reversing a choice the worker took on its own recommendation
- loop-claude: one session per project, its id derived from the checkout's path relative to `~/code`, or to `/` outside it
- loop-inbox: a loop-claude lists itself while it runs, and its waiting question, as files per session under `~/.local/state/loop-claude/`, and takes the first answer, from its terminal or from loop-inbox, that names that question
- machine load: a heavy command waits for one of the machine's heavy slots, one for every 4 CPUs, which every session shares, and loop-claude starts a worker only while at least a quarter of the machine's memory is available
@@ -139,15 +139,15 @@ Valid while `~/.claude` is a checkout of this repo.
2026-09-28, lilleman. Serves goals 1 and 3: saving each transcript locally is the first step of backing it up, and it shows afterwards what an unattended run did. A copy of the `.jsonl`, deduplicated by content hash, with its outcomes beside it; a rendering drops tool results, and a second-resolution stamp names two states within one second as one file. A failed archive exits 1, since a loop that loses its record silently fails the backup goal. Valid while transcripts stay small enough to copy whole.
## loop-claude: each verdict records the setup, the spend and the reversals: the claude-config release and commit that ran it, the raw tokens each thread spent by model and kind since the previous record, and the human's typed answer the judge quotes as reversing a choice the worker took itself
## loop-claude: each verdict records the claude-config release and commit that ran it, the raw tokens each thread spent by model and kind since the previous outcome that recorded a spend, and the human's typed answer the judge quotes as reversing a choice the worker took on its own recommendation
2026-11-12, lilleman, todo item 305. Serves goals 1, 1.2 and 1.4. A change to the setup can be judged only by comparing chunks run before it with chunks run after, so each verdict, interrupt and quoted answer in loop-claude's archive records three things beside its judge lines.
- `Config: <release> (<commit>)`: `git describe` and the commit of `~/.claude`, so outcomes group by the setup that produced them. Where git can't tell, it records `unknown` and why, on one line.
- A `Spent since` block: the raw tokens each thread spent, by model and by kind (input, cache write 5m, cache write 1h, cache read, output), then the list prices of `bin/routing_figures/prices.py` in force. The threads are the worker's main thread, each subagent by its agent type and description, and the judge run that ruled. Each message counts once, by its id. The stretch runs from the previous outcome that recorded a spend, so a `/talk` or a stop between rulings neither counts twice nor drops a stretch. Tokens, not dollars, are kept, since prices change and a past chunk's cost can be derived again from them. Claude Code doesn't report thinking apart from output, so it is left in output. The judge's tokens come from its json reply's `usage`, until item 303 archives the judge's own transcript.
- A `Reversed:` quote: the latest `[human]` line the judge finds overriding a choice the worker took on its own recommendation and recorded. The quote must appear verbatim in the transcript, or it is dropped. `score-outcomes` counts the distinct quotes per finished chunk, which is the counter-signal of goal 1.2 the 2026-11-08 entry of `loop-claude: a judge decides each interrupt…` is valid under. It counts only chunks that record a Config line, since earlier judges didn't look for reversals.
- A `Spent since` block: the raw tokens each thread spent, by model and by kind (input, cache write 5m, cache write 1h, cache read, output), then the list prices in force, from `bin/routing_figures/prices.py`. The threads are the worker's main thread, each subagent by its agent type and description, and the judge run that ruled. Each message counts once, by its id. The stretch runs from the previous outcome that recorded a spend, so what a `/talk` or a stopped run spent between rulings is counted once. It keeps tokens, since prices change. The prices recorded beside them give what the stretch cost when it ran. Claude Code doesn't report thinking apart from output, so it is left in output. The judge's tokens come from its json reply's `usage`, until item 303 archives the judge's own transcript.
- A `Reversed:` quote: the human's typed answer that overrides a choice the worker took on its own recommendation and recorded. The judge quotes the latest such `[human]` line; loop-claude keeps the whole typed answer that holds the quote verbatim, and drops a quote no typed answer holds. `score-outcomes` counts the distinct answers per finished chunk. That count is goal 1.2's counter-signal, and the 2026-11-08 entry of `loop-claude: a judge decides each interrupt…` is valid only while it stays low. It counts only chunks that record a Config line, since earlier judges didn't look for reversals.
Valid while the archive stays the record score-outcomes and routing-figures read.
Valid while score-outcomes reads the reversals from the archive.
## loop-claude: the worker's claude compacts its context before it fills a 200k window, at about 170k tokens, and `CLAUDE.md` → "Compact instructions" says what the summary keeps