Artifact Truth Is Not Lifecycle Truth

When an audit artifact says accepted but durable lifecycle state does not advance, the defect is usually a missing state write—not a routing failure. Treat artifact contents and durable lifecycle records as separate sources of truth, and prove the boundary writes the correct machine-readable state.

Definition

Artifact truth is what a review or audit document records at a point in time—for example, that a specification audit returned an accepted verdict.

Lifecycle truth is what the durable controller state says about what stage the work may enter next—for example, whether spec hardening is complete and planning may begin.

These are related but not interchangeable. Automation must write lifecycle truth explicitly at the boundary where verdicts become durable state.

Why it matters

Teams often diagnose controller loops as routing or classifier problems when the parser already worked. The workflow keeps re-entering the same stage because durable state still says the prior step never completed.

That creates expensive false fixes: broader route-graph changes, new classifiers, or extra normalization gates—when the real gap was a single missing write to durable state.

Common failure mode

An audit artifact records an accepted verdict with risks. The controller parses the verdict correctly. But the durable state file still shows the prior subsection as not_started, or uses prose like complete — ACCEPT instead of an exact machine token.

Downstream dispatch reads durable state, not the audit artifact, and sends the item back through the same path. The system looks stuck in a loop even though the audit clearly passed.

Better pattern

Trace lifecycle transitions through three layers:

1. Artifact truth — what the audit or review document says.
2. Parsed token — the normalized machine-readable verdict extracted at the boundary.
3. Durable truth — the exact value written into lifecycle state that dispatch will read next.

At the accepted-verdict boundary:

• Write the correct durable subsection value using exact allowed tokens.
• Advance the current stage to the next authorized stage directly when the design calls for it.
• Add tests that assert durable state after the transition—not only that a handler returned a success code.
• Add negative tests proving obsolete paths no longer run.

Prefer the smallest boundary-local fix before changing route graphs or classifiers.

Example

A governed workflow runs a specification audit. The audit file says the spec is accepted with risks. The parser returns ACCEPT_WITH_RISKS. But durable lifecycle state still lists spec hardening as not_started.

Weak pattern: change the route graph because the item "will not advance to plan."

Better pattern: add or fix the seam writer that maps the parsed verdict into the durable spec-hardening field, use exact tokens the validator accepts, advance to plan when the design requires it, and test the durable file contents after the controller action.

The lesson is not that audits are unreliable. The lesson is that accepted artifact truth does not advance lifecycle truth unless something writes durable state at the boundary.

Related concepts

• State and Lifecycle Management
• Human Gates and Approval
• Audit and Review
• Workflow Design
• Error Handling and Fail-Closed Behaviour
• Testing and Verification