Chain C — the classifier the plan skipped

Room: work · Disposition: live, maintained and deliberately un-promoted Last observed: 2026-08-29

What

A deterministic labeller of already-derived chronology text — mostly tool-result “B” slices from the Grok and Codex session archives. It sorts a block into five labels: conversational_connective, operational_corroboration, repeated_ledger, structural_junk, and unsure.

It is one file with no local imports, b_structure_classifier.py, plus its contract, its tests, and an optional pair of retrieval flags.

It does not write history, mutate raw archives, or replace conversation-core. unsure is never silently dropped.

Why

PLAN-004 sequenced the chronology work as review → readers → reconcile. Chain C sat before readers in the previous Archivist’s handoff, and the plan jumped over it. What ran instead was the keyword B-signal: score blocks by terms and IDs, then test whether readers do better on the filtered text.

They did not. REQ-132 reconciled six old blocks and found that term-scored B added ledger echo, not new reader claims. FIND-137 closed the chain on 2026-08-14 and set temperature: keyword B shelved, every byte preserved, and — explicitly — this null is not standing law for newer archives.

The same day, the Human said the classifier project could not die; it was the Archivist’s main thing to complete. FIND-138 records the correction in its first line: FIND-137 “was wrong if read as ‘the chronology classifier is finished’.”

Chain C is not v0.3 of the keyword filter. It is the different thing that was skipped: structure, not another keyword contest on the same six packets.

Where

Standing, three readings

Disposition — live. REQ-178 made Chain C a maintained chronology-local component. Nothing since disposes it: no later FIND shelves, supersedes, or closes it. Its absence from tools/ is the contract being kept, not delivery that stalled.

Delivery — two REQs fulfilled, both CHANGEs complete. REQ-178 (the component is maintained; the toolbox names it live) and REQ-197 (retrieval may optionally prefer or drop Chain C labels), with CHANGE-178 and CHANGE-197 both complete.

Evidence — sound on Grok, host-narrow elsewhere, and still unconsumed. v0 was hardened on 2026-08-15 against real session shape: Grok read_file dumps are not ledger, bookend documents are structural_junk, ledger JSON needs both a board ID and a body, host-truncated dumps are junk. FIND-264 named the honest gap — the classifier exists so later search can prefer operational events, and nothing consumes the labels yet. That leftover is what earns keep, and it is still the leftover.

The host-narrowness, measured

The 2026-08-15 harden fixed a real miss: file reads were being read as ledger echo. The guard it added matches Grok’s read_file prefix, N→, and a leading exit: N shell wrapper. Claude Code’s Read emits cat -n — spaces, digits, a tab. Codex emits neither.

Across eight sessions per family from historical/imports/:

Six of fifty Claude cat -n file reads land in repeated_ledger — the exact label the guard exists to prevent. Codex comes out 95% unsure, with zero structural_junk and zero operational_corroboration; the classifier is very nearly inert there.

Nothing is silently lost — unsure is never dropped on any host — and the 21 tests still pass. What is narrower than it reads is the claim, not the code’s correctness in the corpus it was taught on. FIND-1047 has the numbers and the method; it is mailed to Architect as a boundary question rather than taken as a bounded write, because Chain C is live under REQ-178.

The bookend detector is the counter-example worth copying: it matches document headings and enter fields rather than a line prefix, and it fires on Claude too. That is the shape of any repair here — match on what the house writes, not on how a host wraps it.

The shape of the sessions, which is the real finding

The contract carries an observation worth more than the labeller: a standing-office chat is not a uniform blob. Both ends grow schema.

The head is host and enter ceremony — system instruction, git snapshot, injected AGENTS.md, Rise <office>, the enter packet, the card, news. The tail is retirement ceremony — honor stamp, unread mail, sign-out. The middle is the actual day.

An early teaching pass labelled file-reads of the card and LANDING as repeated_ledger. They are not ledger; they are the agent loading its office. Treat regular bookends as envelope, not history. FIND-222 records that an import starts exactly this way.

That is why newer Corpus imports are a fairer teacher than the six old blocks: the bookends are becoming stable while the old blocks predate the schema.

One qualification the contract does not carry: head and tail ceremony is real on every host — the enter packet and the honor stamp do not change with the provider — but only Grok’s transport is currently recognised, so the schema is observed unevenly. See above.

Movement

What survives, and what does not

Surviving: the labeller, its contract, its tests, the session-shape observation, and the Human’s bound that the old-block null is not law for newer intake.

Not surviving: the claim that targeted B improves readers at equal load on those six units, that term retention equals semantic validation, and the product promotion. Those were rejected as claims, not as files — the bytes are all in the archive bundle.

Frontier

Two edges, not one.

Detection is host-narrow. The file-read guard reads Grok’s transport rather than what the house writes (FIND-1047). With Architect for the boundary call.

And the gap FIND-264 named is still open: nothing consumes the labels at scale. The retrieval flags exist and are the only consumer, and that tool went cold with its corpus on 2026-08-29.

Reopening is not “continue the old plan.” It would want a newer archive with stable bookends, a named question the labels actually answer, and a measurement that separates fewer errors from better error descriptions. Promotion into tools/ or ai/ stays behind a later gate that has not been argued.

The seam a reader will hit

episode_retrieval.py and classify_import.py sit in the cold bundle and import b_structure_classifier from the live habitat. They do not run standalone from the archive. Their own dependency chain — historian_payload_measurement, block_size_measurement, historian_workbench, root_turn_index, session_manifest — is the closed measurement arc and stayed cold with the corpus it reads. The classifier was not duplicated into both rooms to hide this.