Silent success: failed tool chain still ends with reason.kind = completed and headless exit 0

[JohnXu22786]

After a ToolNotFoundError loop gives up, the turn still ends with reason.kind = "completed" and headless exits 0 — a failed agent run presented as success.

This is independent of the wire-level tool-call bug (thread #4370): the wire fix stops the loop, but does not stop the masking. A tool chain that errored to exhaustion should surface as error (or at least a non-zero headless exit), not completed.

Worth its own fix rather than riding along.

[argszero]

Verified against rc.2 (HEAD b150a55) — your framing is right, and it's a distinct layer from #4370. The mechanism is fully traceable, and the root gap is in the turn-end taxonomy itself: a "completed" reason is emitted whenever the model stops calling tools, with no distinction between a genuine answer and a surrender after an error chain.

1. The verified chain (rc.2)

1. A tool failure is a result, never a throw. ToolNotFoundError from resolveExecution is caught inside dispatch and converted to toolErrorResult(error) (packages/core/tools/src/index.ts ~:1547-1550). It lands in the session as a normal tool/result with isError: true.
2. Errors never conclude a step. executeToolCalls computes concluded only from results carrying concludesTurn === true (packages/core/agent-loop/src/tool-calls.ts:157). An error result returns concluded: false.
3. step() maps that to "keep going", not "failed". concluded ? { kind: 'completed' } : null (packages/core/agent-loop/src/agent.ts:418) — null means "run another step", and the loop has no step cap (while (true) at agent.ts:263 and :339; the [BUG] ReactLoopAgent.turn() step loop has no upper bound — a stalled model can burn ~1M tokens in a single turn #2821 maxSteps blueprint is not in rc.2). The chain terminates only when the model itself stops calling tools or a step hits max-tokens.
4. The model's surrender is "completed". When the model finally answers with text, if (toolCalls.length === 0) return { kind: 'completed' } (agent.ts:413) → turn/end records { kind: 'completed' } (agent.ts:319).
5. Headless exit is a pure function of that reason. io.exit(outcome.reason?.kind === 'completed' ? 0 : 1) (packages/bundle/headless/src/index.ts:133) → exit 0. Genuine error reasons do exit 1 (:130-131) — the fix half exists; tool-error chains just never reach that state.

2. The taxonomy gap (the layer worth its own fix)

TurnEndReasonMap (packages/core/session/src/types.ts:155-174) is completed | aborted | blocked | error | max-tokens | interrupted — and it's merge-extensible by design (declaration merging, :176-177). Two facts follow:

• There is deliberately no structured signal for "the model stopped calling tools because the last tool chain errored". agent/request-error (agent.ts:374-389) gives LLM request failures a retry/error path; there is no equivalent for repeated tool failures — they are invisible to the reason, and therefore to every downstream consumer (exit codes, session titles, UIs, subagent settlement summaries).
• Because the map is extensible, a new variant (e.g. { kind: 'tool-error' } or 'exhausted') needs no core type surgery — but the loop has no hook that fires on tool-chain exhaustion: agent/turn-stopping (agent.ts:296) runs only after turnEnds is already decided. So the fix has to teach step() to observe the chain, not just add a consumer.

3. Bounding the fix — don't key on "any isError"

A blunt rule ("any failed tool call in the turn → error reason") would false-positive on legitimate recovery turns: a model retries a failed call and succeeds, or routes around a flaky tool — those are successful turns with failed calls. The discriminating signal is the terminal character of the chain: the final step before turn-end produced only isError results, and the model's next (final) step contained no tool calls. Consecutive error-only steps also give you an exhaustion threshold to mirror the sticky turn-end family (#3685 max-tokens sticky at agent.ts:285-290, #4048 sticky error replay — same "replayed poison" shape as the #4370 loop). Headless then maps the new reason to non-zero exit with one more branch.

Good call separating it from the wire fix — this one is about observability of outcome, not recovery from poison.