Humanize

Humanize (the laundering chain)

One generative pass over a draft: semantic cleanup, a seeded diction rewrite, word recovery, optional accent, then the deterministic terminal stage. The chain is a pure function — structurally diverged draft in, laundered draft plus a measurement report out. It runs once per invocation. Structure, review, author edits, and the decision to run the chain again belong to the caller (GH-208): a workflow command invokes match-outline before this chain when the form needs changing, runs the read-only instruments after it, and reads this chain's seed-reach report to decide whether another cycle would pay.

The verified effect on a fresh AI draft (2026-07-29, working gate) is 100% AI -> Mixed: 23.8% AI / 76.2% AI-assisted, mean window 0.993 -> 0.576. On well-edited prose the gain is real but small — see the calibration data at the end.

The chain

Input contract: structurally diverged prose

The chain does not restructure. match-voice gate-rejects everything (distance 0.0) when the input's sentence structure is still the drafting model's — the ablation rows in the calibration data (unverified, but consistent with every measured run). Divergence is the caller's job, before the chain runs:

• match-outline is the structural tool — section-level rewriting against a blueprint. It is a document rewriter, not a prose stage, and it carries its own risk class: verify content preservation after it, including figure blocks (a 2026-08-31 run dropped an entire figure while reporting "all citations and numbers preserved" — see match-outline's SKILL.md).
• A venue profile's structural_step field is consumed by the caller, not by this chain: it names the structural tool the caller should run (or skip) before invoking humanize.
• Well-edited human prose is acceptable input without a structural pass — expect low seed reach and a small gated gain (strategy-theatre: 19 of 125 paragraphs changed, and that was enough).

A run on undiverged input is not an error; it reports itself through the gate stats (kept-original dominating, distance near 0.0) and the caller reads that as "run the structural step first."

What the caller owns

The chain reports; the caller decides. After the terminal stage, the caller's review phase runs the read-only instruments — reverse-outline (annotate + rank), critic-panel and its rule-based application (critic-apply, GH-206), cold review (GH-207), voice-critic — and the author picks and edits. None of that is this skill's procedure. Critic picks and author edits are new prose that has never been laundered, so a caller that applies them re-enters the chain in a new cycle; re-entering is the 're-running from a pre-terminal checkpoint' the terminal contract allows.

Seed reach is the cycle signal, and this chain must report it: the count of paragraphs the seed pass changed, out of total. Measured indicators from the strategy-theatre runs, for the caller's decision:

When the seed cannot move the text, the article has converged and further chain runs only shuffle between detector buckets.

The terminal invariant (GH-57)

inject-vernacular is terminal for its cycle. Within a cycle nothing writes after it. After the terminal stage, models may read but never write. The evidence is the Strategy Theatre provenance logs: every generative pass regresses text toward the model's distribution center — match-voice injected bold lead-ins despite instructions, tighten-style invented a sentence, and a rerun rewrote hand-cleaned prose 8/8 times until the entailment gate rejected all of it. A defect found after the terminal stage is fixed by the author's hand, or by re-running from a pre-terminal checkpoint — never by an additional model repair on the final text.

Three rules the order encodes:

1. Locks travel the whole chain. Spans marked <!-- lock --> … <!-- /lock --> at drafting are excised by the shared drivers before any model call and spliced back byte-identical after, in every stage — protection is mechanical, enforced in prose_document.py / md_paragraphs.py, never by prompts.
2. inject-vernacular is terminal because it is deterministic. It applies the idiolect.yaml operator bank by substitution and restoration only; nothing samples, so it cannot regress the text toward a model's center — which qualifies it to run after every stage that can.
3. Snark and disproportion are born at drafting and locked. No stage in this chain inserts them: mechanical joke insertion is prohibited by design. voice-critic audits them in the caller's review phase (L0–L5 scale, receipt-first, density caps) and flags to the author gate; it never edits.

Why anchors on the seed and none on the iterator

The GH-194 measurement (see Model pins below) made the anchored Cohere seed the mechanism: the anchored pass does the work, and iteration adds little. The --no-anchors iterator remains for payloads that keep falling: anchors constrain an iterator into register patterns Pangram catches, so the iterator runs free while the seed carries the register.

Prerequisites

• A Cohere key (COHERE_API_KEY / COHERE_SECRETS_FILE) — every stage's default model is cohere:command-a-03-2025 since GH-176–190, except accent-dial (deliberate gemma4:31b-cloud, see Phase 4)
• Ollama endpoint reachable — required by the keyless fallbacks and the recorded July recipe
• A writing-voice/ directory with exemplars
• For Pangram measurement: an API key configured per the match-voice credential contract (.secrets/keys.json with "pangram" entry)

Model pins vs stage defaults (GH-193, re-pinned GH-194)

Stage defaults are Cohere; the recorded July recipe pinned other models, and those pins are the experiment — do not "fix" a pinned command to the default. Whether Cohere arms beat the pins was GH-194 (2026-08-31, two published payloads, seed+iterator isolated on raw articles, prose-only Pangram):

(Dated 2026-08-31; superseded by the 2026-09-02 drift event — see the Calibration data note. The authorship findings stand; the numbers do not.)

The recommended strategy is a single Krugman-anchored Cohere seed pass (--model cohere:command-a-03-2025 --author Krugman), with further no-anchor passes only if the score still falls: it tied the pinned recipe's 3-pass endpoint on one payload in ONE pass, was the only arm to move the other payload at all, and needs no Ollama. The pinned recipe is iterator-driven, the Cohere strategy seed-driven. The multi-family "foreign fingerprint" thesis did not replicate: both mixed arms were worse than either pure arm, and a gpt-oss pass after a Cohere seed actively destroys the seed's gain (0.896 -> 0.996) — never mix them in that order.

Limits: n=2 payloads, arms isolated on raw articles, stop-on-upturn sampled once per pass.

Contract-field protection (GH-362)

YAML spec files carry contract fields (section_goal, goals, acceptance criteria, metadata) whose values are terse, lowercase phrases the repo's audit tools grep for. The chain protects them in two layers:

Exclude keys. Both tighten.py and drive.py accept --exclude-keys with dot-separated key-path globs. For YAML files, the default exclusion list is section_goal, goals.*.goal, acceptance.*, meta.*, metrics.* (GH-227: a rewrite pass once replaced a metrics.*.computed value with a pasted model refusal that shipped unnoticed). These paragraphs get status excluded-key and never reach the rewriter. Pass --exclude-keys with no arguments to disable the default.

Guard phrases. verify.py accepts --must-preserve with exact phrases that must survive rewriting unchanged. A candidate that loses a guard phrase is rejected (fatal finding) and the original text is kept. Use this for claims-integrity markers like "recorded as planned", "no number is cited", "submission-status care" that the repo's claims audit greps for.

ASCII normalization. verify.py normalizes typographic unicode (curly quotes, non-breaking hyphens and spaces, en-dashes) to ASCII before running any check. A rewrite that reintroduces them is caught by the gate rather than silently passing.

When running the chain on spec YAML, the exclude-keys defaults apply automatically. For guard phrases, pass them explicitly on the drive.py or tighten.py command line, or configure them in the venue profile.

Procedure

Phase 0: Discover, resolve the venue, measure the baseline

1. Discover writing-voice/ by walking up from the article path. Error if not found.

2. Venue mode (GH-336). If the user named a venue (--venue <name>, or "humanize this for the book/newsletter/..."), resolve the profile:

   $RUN <match-structure>/scripts/venue_profile.py show \
     --venue <name> --for <article.md>
   

   A profile that fails validation is refused — report the errors and stop; never fall back to guessing. From the resolved profile:

   profile field	governs
   structural_step	the caller's pre-chain step, not this chain — report it so the caller can confirm it ran (or was skipped)
   anchor_query	the seed's anchor selection (Phase 2)
   targets, hedge_policy	tighten-style's floor: pass --venue <name> to tighten.py in Phase 3
   tell_lexicon	the lexical catalog: pass --lexicon=<value> in Phase 1
   gates	which measurements run: no pangram gate → skip every Pangram scan in every phase, standing grant or not (when the gate IS present, uploads run under the consent rule — per document, or the operator's standing grant, GH-210)
   citations	which citation markers to spot-check after each stage ([1] numbered vs pandoc [@citekey] — both must survive every rewrite verbatim)

   List venues with venue_profile.py list --for <article.md> when the user asks what is available. No venue named, or no venues/ directory → ask for the anchor selection interactively; everything else takes its default.

3. Capture baseline measurements:

   # Pangram baseline (one-shot scan; uploads the prose, costs a scan)
   $RUN <agent-dir>/scripts/pangram_report.py scan --article <article.md>
   
   # Style baseline
   $RUN <match-structure>/scripts/style.py profile <article.md>
   
   # Burstiness baseline (one line; the full numbers are in the profile)
   $RUN <match-structure>/scripts/style.py burstiness <article.md> --text
   

   Record the baseline Pangram scores (human %, mean window score, verdict), the full text_metrics() output, and the burstiness line. These are the "baseline" column in the final report. Print the CV next to the Pangram score at every measurement point below, not only in the final table — sentence-length dispersion and AI-phrase density are the two features a plain stylometric model uses, and a step that moves the score without moving CV moved something else (GH-129: a diction-only control arm held CV at 0.621 and Pangram at 0.436, while the same model reshaping rhythm took CV to 0.690 and Pangram to 0.259). In venue mode, capture the Pangram baseline only when the profile's gates include pangram. Under a standing consent grant (GH-210) the drivers score every stage by default — which is what the stop-at-the-upturn rule needs — and --no-pangram opts a run out. Hold the Pangram framing constant across every measurement in a run — slice, whole, and prose-only payload scores of the same article are not comparable (measured spread on one article: 0.225 / 0.913 / 1.000).

Phase 1: filter-tells semantic cleanup

Run the lexical and structural scans on the input. Block-locked regions never enter the scans' prose view, and semantic edits are applied through the lock-respecting drivers — a locked antithesis or authored snark span is not filter-tells' to collapse. With writing-voice/idiolect.yaml discoverable, the structural scan calibrates to the author baseline: native constructions flag only above the author ceiling, and calibrated flags say reduce toward the target, not to zero.

bash <filter-tells>/scripts/detect-lexical.sh <article.md>
$RUN <filter-tells>/scripts/detect-structural.py <article.md>

In venue mode pass --lexicon=<tell_lexicon> to detect-lexical.sh — the newsletter banned-word list must not drive edits on an academic methods section, and the academic lexicon adds paper-template tells the default list does not carry.

Apply the semantic edits following the filter-tells Step 3 procedure. The edits that matter most for this chain:

1. Antithesis pairs — collapse every negation-flip pair into a single sentence. These are the dominant AI rhetorical pattern. Target: 0 pairs.
2. CoT leakage — delete bridge sentences that add no information. Apply the removal test: delete the sentence, re-read the paragraph. If nothing is lost, it was scaffolding.
3. Recap ballast — compress paragraphs that restate earlier points without adding new information.
4. Banned words — swap any remaining banned words (check the lexical scan output).
5. Author-stance narration — sentences written from the author's chair: scope negotiation ("here we deal with", "this article covers"), and system facts stated as author experience ("waiting for my approval"). Rewrite as claims about the system ("a human approves it before it exists"). The bridge sentence and the learning-objectives paragraph are the sanctioned exceptions; everything else in this register goes.

After editing, re-run both scans to confirm:

• Structural verdict: MINOR-ISSUES or better (was LIKELY-AI)
• Antithesis pairs: 0
• No banned words

Measure after filter-tells (Pangram + profile + burstiness against the baseline). Record as the "after-tells" column, Pangram and CV together.

Phase 2: seeded match-voice

Run the seed. It is the mechanism, not an enhancement. A single unseeded match-voice pass has only its own distribution to push against, so it substitutes diction instead of stripping it.

2.1 Seed — Cohere, anchored (the GH-194 default)

$RUN <match-voice>/scripts/drive.py \
  --article <cleaned.md> \
  --model cohere:command-a-03-2025 \
  --author <the author whose register fits> \
  --voice-dir <repo>/writing-voice \
  --pangram \
  --out <seed.md>

--author works by filename inference where the manifest carries no author field — the anchor pool line reports (inferred from filenames) — so the old anchor-by-tags-only guidance (GH-98 era) is superseded; tags remain the tool when no single author fits. Verify the pool either way:

$RUN <match-structure>/scripts/voice_anchors.py tags --voice-dir <repo>/writing-voice

With a Cohere seed, the seed is usually the result (GH-194: every Cohere arm's floor was the seed itself). Measure it; that score is the baseline for 2.2. Record seed reach — paragraphs changed out of total, from the driver's accepted/kept table — it is the caller's cycle signal and a required line in the report.

A flat or slightly worse seed score does not discard the seed when its reach is healthy (GH-224). The seed's contribution is divergence that Phase 3 exploits, and its own Pangram reading measures that poorly. Measured on the-qwerty-endpoint, same payload, one day apart:

Discarding the flat seed cost 0.13 mean window at the end of the chain. So: a seed with healthy reach (the measured healthy runs sat near 9–11 of 19) stays in the lineage through Phase 3, and the floor decision compares post-tighten measurements when both lineages were run — or simply accepts the seeded composition when only one was. A seed with collapsed reach (the converged-article signal, strategy-theatre's 16/125 with mass gate rejection) is still set aside on its score.

2.2 Iterate — only while the score still falls

PREV=<seed.md>
for i in 01 02 03 04; do
  $RUN <match-voice>/scripts/drive.py --article $PREV \
    --model cohere:command-a-03-2025 --no-anchors --pangram \
    --canonical-blocks <repo>/writing-voice/canonical-blocks.txt \
    --out pass$i.md
  PREV=pass$i.md   # read the score; STOP at the first upturn
done

Expect this loop to stop at pass 1 — iteration earned nothing in any GH-194 Cohere arm. It stays in the recipe because stop-on-upturn makes a zero-gain loop cost exactly one pass, and a payload that does respond gets its passes.

Three rules, all load-bearing:

1. Score every pass and stop at the first upturn. Never run a fixed count. Past the floor each pass concentrates the iterator's own signature and the score climbs back (the U-curve: 0.992 -> 0.579 -> 0.432 -> 0.489 -> … -> 0.700 by pass 10, stay-on-track 2026-07-29).
2. The publish candidate is the floor pass, not the last pass — with the GH-224 amendment above: between the seed and its input, the floor is judged after Phase 3, not on the seed's own reading. Keep every pass on disk with its provenance.
3. The floor pass's score is raw until the caller's cold review gates it. Every stage measured this way lost most of its gain at review — the raw floor and the gated floor are different numbers, and only the gated one counts. Cold review belongs to the caller's review phase (GH-207).

Pass --canonical-blocks explicitly when the article is staged anywhere but its repo: discovery walks up from the article path, so a run staged in a scratch directory silently has no registry and will rewrite the disclosure and subscribe lines.

Recorded July configuration (alternative). The pre-GH-194 pinned recipe — anchored gemma4:31b-cloud seed, then a gpt-oss:120b-cloud no-anchors iterator — is the arm the calibration tables below measured through July. It is iterator-driven where the Cohere strategy is seed-driven, lost the GH-194 head-to-head (mean 0.867 vs 0.768), and a gpt-oss pass after a Cohere seed actively undoes the seed (0.896 -> 0.996) — never mix them in that order. Reach for it when an iterator-grind on an already-clean draft is specifically wanted; substitute the model names into the commands above. Pangram retrains on new model families, so re-measure before reusing any recipe.

2.3 Ablation: the unseeded single pass

Retained as a named ablation; choosing it is a deviation a run has to state and justify (measured 0.609 gated against 0.370 seeded on the same article). Inline locks reach the rewriter as opaque [[LOCK-n]] anchor tokens; a rewrite that drops one is refused by the drivers and the original paragraph is kept.

$RUN <match-voice>/scripts/drive.py \
  --article <cleaned.md> \
  --model cohere:command-a-03-2025 \
  --no-anchors \
  --pangram \
  --out <output.md>

In venue mode, include --pangram only when the profile's gates carry pangram; a venue without that gate (academic) is never uploaded to the external detector.

Check the output for:

• accepted-mechanical count (should be most paragraphs, not kept-original)
• Distance > 0 (confirms the gate accepted rewrites)
• Pangram verdict and mean window score (when the gate ran)

2.4 Burstiness (optional, same slot)

The burstiness pass (GH-129) runs in the match-voice slot: match-voice's burstiness.py raises sentence-length variance through the rewrite transport, behind the same gate. It earns its position the same way the seed does — measured only on documents already through the chain. On pipeline-state prose it moved Pangram 38.1% -> 29.1% (and, at an earlier state of the same article, 0.445 -> 0.259) with a rhythm-held control within noise both times; run on a raw draft it can do nothing (a saturated 100% baseline has no room to fall). The CV printed at each measurement point is how you see whether it has anything left to do: match-voice's SKILL.md carries the invocation and the gate details.

Measure after Phase 2 (profile at minimum; Pangram per the venue gates). Record as the "after-voice" column.

Phase 3: tighten-style (word recovery)

Run tighten-style after the rewrite. The rewrite buys the score and costs words; this pass gives the words back without giving back the score.

$RUN <tighten-style>/scripts/tighten.py --article <floor-pass.md> \
  --out <tightened.md>

(In venue mode add --venue <name> — the profile's targets become the sentence floor and its hedge policy sets the TS-08 threshold. Pass --out explicitly: tighten.py's default output name is <stem>.tightmd, which the rest of this chain does not expect.)

Measured (2026-07-26 worktrees run):

The pass must run through the rewrite transport, never by hand. The same tightening applied by Claude against the rule catalog took a 0.0% draft to 77.9% — same article, same rules, opposite result, because Claude tightens toward Claude's own register. Read the findings; let the tool rewrite.

A second placement exists, and it is the caller's. A caller may run tighten-style before the chain when the paragraphs are too dense for the rewriter to clear the mechanical gate (the venue profile's structural_step can name it for exactly that reason). This phase answers a different question — "the rewrite left the prose leisurely" — and a run states which placement was used; both is defensible only when the first was for the gate reason and this one for the word count.

Record as the "after-tighten" column.

Phase 4: accent-dial (optional)

When the author wants the accent — or the venue profile calls for it — run accent-dial on the tightened text. It is a generative candidate source with deterministic application, so it sits after every other sampling stage and before the terminal stage.

python3 <accent-dial>/scripts/accent_dial.py --article <tightened.md> --dial 0.4

Three things this chain holds accent-dial to (its SKILL.md carries the full contract, grain choice, and dial calibration):

• It composes after structural repair, never instead of it — the round-trip launders diction, not discourse structure, and gemma manufactures antithesis, so its output gets a structural recheck.
• Its model exception stands: default gemma4:31b-cloud (ACCENT_DIAL_MODEL), deliberately not the pipeline-wide Cohere default — the 2026-08-21 A/B showed stronger return-leg translators polish the accent away (L2 composite -0.009 vs +0.726) and score worse on Pangram (0.247 vs 0.150).
• Its entailment review gate is mandatory before the output moves on: applied paragraphs are reviewed against their originals and rejected by reverting in place — never by a model repair.

Record as the "after-accent" column. Skipped → say so in the run-completeness check; the chain is complete without it.

Phase 4b: scoped filter-tells recheck (pre-terminal)

Every sampling stage after Phase 1 can inject phrasing the early scan never saw — match-voice injected bold lead-ins despite instructions, tighten-style can raise nominalization, applied critic picks moved Pangram 0.332 -> 0.421. A full re-scan would re-litigate author text and invite the over-correction loop filter-tells warns about, so the recheck is scoped to the paragraphs the drivers actually changed, and it runs here — after the last sampling stage, before the terminal stage — because the terminal contract forbids repairs after inject-vernacular.

$RUN <filter-tells>/scripts/scoped_scan.py <current.md> \
  --from-manifest <seed>.generation.yaml \
  --from-manifest <passNN>.generation.yaml \
  --from-tighten <tightened.md>.tighten.json \
  --from-accent-log <dialed.md>.log.json \
  --lexicon <tell_lexicon>       # venue mode

The drivers emit the scope themselves: drive.py writes changed_paragraphs into its generation.yaml, tighten.py writes a <out>.tighten.json sidecar, and accent-dial's edit log carries applied flags (its indices are mapped onto prose paragraph numbers). Findings are repaired editorially per the filter-tells procedure, through the rewrite transport — never by hand — and idiolect calibration keeps the scan from fighting accent-dial's deliberate injections: constructions below the author ceiling never flag. An empty scope is a stated no-op, not an error. A paragraph the chain never touched is out of scope by construction; a tell in author text stays the author's to keep.

Phase 5: inject-vernacular (terminal)

When the repository carries writing-voice/idiolect.yaml, run the terminal vernacular stage on the Phase 3 (or Phase 4) output:

$RUN <inject-vernacular>/scripts/inject_vernacular.py <output.md>

Deterministic operators only — it restores the author's markers toward the bank's essay targets and writes an edit log for the survival analysis; nothing samples. This is the last stage that writes. Everything after this line — the Phase 7 report, any final Pangram scan, and the whole of the caller's review phase — reads the text and never modifies it. A defect found from here on means the author's hand or a re-run from a pre-terminal checkpoint. No idiolect.yaml → skip this phase; the invariant then attaches to the end of the last stage that ran.

Phase 6: run-completeness check

Before the report, state what actually ran. A partial run must report itself as partial — the failure this prevents is a run that stops at an unseeded Phase 2, looks complete, and quietly omits the step that does the work.

Phase 7: Consolidated report

Print a single report. Each metric shows the stage columns — baseline, after-tells, after-voice, after-tighten, after-accent (when it ran) — and the total delta (final minus baseline).

In venue mode, head the report with the venue name and add a target column to categories 2–5 wherever the profile's targets block carries the metric — the question the report answers becomes "did the chain land on the venue's measured register", not only "did the numbers move". Run each gate from the profile's gates list in order and state pass/fail per gate; omit the Pangram category entirely when that gate is absent.

1. AI/Human detection (Pangram) — one row per stage measured: human %, mean score, verdict, CV.

2. Readability — Flesch Reading Ease, Flesch-Kincaid Grade, Gunning Fog, SMOG Index.

3. Lexical diversity — Type-Token Ratio, Corrected TTR, Hapax Ratio, Yule's K.

4. Syntactic and structural — sentence length mean / stdev / CV / min / max / p10 / median / p90, mean clause length, passive per 100 sentences, paragraph cohesion.

5. Stylometrics — function word ratio; hedges, commas, semicolons, em dashes, colons per 1000 words; top sentence openers.

6. Filter-tells results — antithesis pairs, banned words, structural verdict, before and after cleanup.

7. Match-voice gate stats — accepted (mechanical), kept original, skipped (short), mean distance, seed reach.

File naming convention

When it breaks

• Every paragraph kept-original with reason ?: suspect a gate crash before blaming the rewrite model. GH-318 had verify.py crashing on the --no-anchors anchors JSON, and drive.py recorded every crash as an ordinary rejection — runs shipped an untouched copy of the input while reporting success (Pangram before == after is the tell). Check the provenance YAML: accepted: 0 with unchanged scores means the gate never ran, not that the rewrites failed.
• match-voice gate rejects everything (distance 0.0): the input is not structurally diverged. Hand the run back to the caller to run match-outline (or more aggressive Phase 1 semantic edits) — the precondition in the input contract above.
• tighten-style gate rejects everything: the prose is already at or below the density floor — there is nothing to tighten.
• Pangram score does not improve: the semantic cleanup missed rhetorical patterns. Re-run filter-tells Step 3 (the full semantic analysis) and look for surviving antithesis pairs, tricolon patterns, or CoT leakage.
• Meaning drift: rewrites compound; the caller's match-outline pass is the largest source of drift. Compare the final output against the original (not the intermediate) to catch cumulative losses.
• Filler regression: an unanchored iterator can introduce filler. Check the stylometrics section of the report.

Calibration data

Drift event, 2026-09-02. Pangram retrained and the July/August floors below are no longer current: a published-pipeline article that passed at 0.2061 mean window on 2026-08-23 scanned 0.9955 UNTOUCHED on 2026-09-02 (same prose-only framing, payload verified — substack#323). The decay this section always warned about arrived at detector scale; the laundering fingerprints of the July/August model families appear to have entered the mirror set. Every score below is a dated record of a dead detector version. Reuse of any recipe re-measures first, and the newsletter venue retired its pangram gate in response (paper-stash#85) — its posture is the process disclosure, not the race.

The historical runs below were measured under the pre-GH-208 layout, with match-outline as the chain's own first phase; its role is unchanged — it ran before filter-tells then, and runs caller-side now.

Tested on 2026-10-29-how-to-break-an-ais-heresy.md (2,357 words) with hardcoded Evans how-to blueprint and anchor-tags.

Gate-bug caveat (GH-318, fixed 2026-07-29). Through 2026-07-28, verify.py crashed on the list-format anchors JSON that --no-anchors writes, and drive.py recorded every crash as kept-original. Any --no-anchors row from that window may describe an untouched copy of its input, not a rewrite: the on-disk provenance for the 2026-07-28 no-anchors runs shows accepted: 0 with Pangram before == after. Rows marked unverified below predate the fix and could not be reproduced from provenance; the verified row is a post-fix run with all 35 paragraphs accepted (distance 0.533).

The ablation claim (each step necessary) rests on the two unverified rows and needs re-measurement with the working gate before it can be stated as fact.

All calibration above was measured with match-outline as the structural step. tighten-style calibration is pending.

Iteration calibration (2026-07-29, working gate, stay-on-track article, published as pass02). Seed: Kimi match-outline + filter-tells + gemma4 match-voice with Krugman anchors (0.992 — anchored passes still do not move Pangram, but change the fingerprint the iterator erases). Then gpt-oss no-anchors, iterated; full per-pass data in idea-factory:substack/2026/Q4/experiments/2026-07-29-gptoss-iter/stats.csv.

Well-edited-input regime (2026-08-22, strategy-theatre). The table above was measured descending from a fresh AI draft at 0.992, where every pass had something to strip. Against prose already through two critic panels and a socratic pass, the same recipe behaves differently and still works:

Two lessons. The seed does not need to rewrite wholesale to work — 19 paragraphs of foreign fingerprint were enough. And survival at cold review falls as input quality rises (21% single-shot, 51% harness on mid-edit text, 33–35% on well-edited text): the chain's value is front-loaded onto drafts, and on edited prose the gated gain is real but small.

Same-family iteration is a no-op: kimi match-voice on kimi-derived prose moved distance 0.05, Pangram 0.993 -> 0.993. The iterator must be a different family from whatever produced the input.