process-gap(story-writer+orchestrator): a burst that self-flags "residual references left for a follow-on sweep" creates no tracked obligation — the sweep rotted across two later revisions until a manual pre-delivery check forced it

## Summary

During a scoped edit to a spec (a story), the authoring agent correctly limited its edits to an authorized touch-list and explicitly noted in its changelog: *"N residual references found OUTSIDE this burst's authorized touch-list … are deliberately left unedited — flagged for a follow-on sweep, not silently expanded into."* This is good discipline (don't sprawl an edit beyond its mandate). **But "flagged for a follow-on sweep" produced no tracked obligation anywhere** — no drift row, no task, no machine-checkable marker, nothing a later agent would encounter and act on. It was prose in a changelog entry.

Consequence: the promised follow-on sweep **rotted across two subsequent revisions** of the same document (each of which amended the doc for other reasons and did not do the flagged sweep), leaving the document internally inconsistent (stale status markers pointing at a now-resolved dependency) the whole time. It was only completed when a downstream reviewer/orchestrator, doing a pre-delivery consistency pass, happened to notice the stale markers and dispatched the sweep explicitly. Had that manual check not happened, the stale markers would have reached delivery.

## Why it matters

- "Deliberately deferred, flagged for later" is the *right* call for scope hygiene, but a flag that lives only as changelog prose is invisible to every subsequent agent. Later revisions read the current document state, not the buried "I promised to sweep this" sentence three changelog entries down.
- The result is a silent internal-consistency debt with a decay half-life measured in revisions: each revision that touches the doc for another reason is an opportunity to notice-and-skip, compounding the staleness.
- This is distinct from a normal "TODO left in code" because it's in a *governance artifact* whose whole value is being an accurate current-state record; a stale status marker there actively misleads downstream agents (e.g. a gate marker still saying GATED after the gate cleared).

## Root cause

There is no mechanism that converts a "deferred sub-scope / follow-on sweep needed" declaration into a **tracked, surfaced obligation**. The options an agent has are: (a) do it now (violates scope discipline), or (b) write prose about it (invisible later). There is no (c) "emit a drift row / open a task / drop a machine-checkable marker that a later gate will surface."

## Suggested mitigation

- When an authoring agent defers in-scope-but-out-of-touch-list follow-up work, require it to record the deferral as a **tracked obligation** in a surfaced location: a drift-items row in the pipeline state, a task, or a structured marker the next relevant gate scans for — not only as changelog prose.
- A cheap phase/pre-delivery check: before a story goes to delivery, scan its live body (excluding its own changelog history) for status markers that contradict the current dependency/gate state (e.g. "GATED" pins whose named dependency is now satisfied). This is the check that caught it here manually; automating it closes the class.
- Orchestrator dispatch practice: when dispatching a scoped edit that self-flags a deferral, immediately open the tracked follow-up rather than trusting the changelog prose to resurface it.

## Severity

MED — no shipped escape (a manual pre-delivery consistency pass caught it), but it survived two intervening revisions and would have reached delivery absent that manual catch; the fix (tracked obligation instead of changelog prose) is cheap and closes a recurring silent-decay class in governance artifacts.

The issue describes a process gap in a story-writer/orchestrator system. The codebase is in Rust. To start, look for the agent authoring logic, changelog generation, and pipeline state management. The goal is to add a mechanism to convert a deferral declaration into a tracked obligation (like a drift row or task). Examine how status markers and dependencies are currently represented and validated. A 'done' state would be a new automated check that scans a story's live body for stale status markers before delivery.

Written by the indexing model from the issue text.