Readable Stop Cards

The live `StopReason` struct still exposes message, position frames, task identity, report reference, and resumable state as separate fields. Pattern and history code still moves those fields through stopped events rather than requiring readers to parse nested message strings. The current mechanical renderer leads with the stored explanation and renders position as detail.

Generic pattern termination still builds a `StopReason` from the recorded termination message, report reference, and collected position frames. Parent frames add context without overwriting the child reason. The behavior is now part of the general pattern interpreter path, so its contribution is folded into the broader stop contract rather than isolated as a separate surface.

The pattern language and bundled gated-task behavior still support declared prose for stopped values, and the executor and fixer prompts still tell agents where to write the reason. Pattern docs still describe the declaration field and the compatibility boundary for frozen patterns. Some original pattern config touched by this run has since moved, but the declared-prose path remains in the interpreter and tests.

The current pattern interpreter still reads declared prose artifacts for the stopping position and rejects stale or unrelated material. Note-channel prose keeps precedence, while recovered comment prose remains a fallback. The behavior is covered in pattern interpreter tests, and later generated cards receive this prose through the stop bundle rather than through a separate filesystem hunt.

`StopReason::mechanical_body` and its report and trailer variants still render the explanation first and attach position, report, and footer detail below it. Headless output, TUI state, command status output, and engine support prompts still call that shared rendering rather than assembling separate messages. Generated cards now wrap this text, but they still keep it as mechanical detail.

History decoding and encoding still round-trip stopped events with structured position data, report paths, resumability, operator pause state, and generated-card fields. Projection, replay, tape, attach, headless, and TUI paths still tolerate both old mechanical stops and records with generated fields. The durable stop record is therefore a current cold-read contract, not just a live display detail.

The prompt catalog still includes `stop-summary.md` and `reader-preamble.md`, and the reference docs list both placeholders and contracts. The parser for stop summaries still accepts only the compact title-and-body shape and rejects malformed output so callers can fall back. Existing reader-facing prompt paths still receive the shared vocabulary primer without changing their own result shapes.

`src/engine/run/stop_card.rs` still decorates eligible stops by building a bounded bundle, resolving the reader preamble and stop-summary prompt, invoking a utility one-shot, and storing accepted title and body fields. Missing utility configuration, empty prompts, launch failures, malformed output, and operator pauses all leave the original mechanical stop unchanged. Surface code reads the fields from the stop rather than calling the model itself.

Live stop surfaces still prefer the generated card when both fields are present and append the mechanical detail underneath. Headless output, status-style command output, TUI stop state, recorded-stop investigation actions, and merge-conflict prompts all use the same generated-or-mechanical decision. If a stop lacks a complete card, those paths fall back to the mechanical body instead of displaying a partial result.

Status output still renders a generated stop card from the durable record when one is present and otherwise prints the mechanical stop. The registry stores a cold stop alongside run metadata, and maintenance, repair, replay, and projection paths still decode generated and mechanical stop records. Histories without durable stop cards continue to load through the compatibility path.