Turn-end notification excerpt shows the turn's narration, not its completion receipt — select an explicit receipt while keeping every text block (#192 follow-up)

[zerohacker666]

Summary

Since the #192 fix (d1ac134, "stream-json answer keeps every text block of the turn") the turn's answer is the concatenation of every assistant text block, in order. That is right for the ledger, but the turn-end notification excerpt (notify: brief, 500 chars) and the inline result_text are taken from the head of that answer, so an orchestrator sees the worker's narration ("Reading the tests… Starting the gates…") and never the completion receipt the worker wrote last. Please keep every block in the transcript (do not reopen #192) and let the excerpt select an explicit completion receipt.

What happened

Two managed claude sessions (adapter claude-stream-json, project excore), each ending its turn with a deliberately short receipt:

session	turn	answer chars	receipt starts at	blocks before it	500-char brief excerpt shows
s871 (2026-09-05)	1	~3,900	1,020	7	narration only
s871	2	~1,700	516	3	narration, receipt cut
s908 (2026-09-06)	1	1,067	647	5	narration only, ends mid-sentence ("All checks green (selftes")

s908's receipt (420 chars: verdict, card@commit, checks incl. NOT RUN, risks, evidence path) is exactly what the orchestrator needs; the brief notification carried none of it. notify: final (2000) shows it only because the turn happened to be short. The orchestrator then spends an agent_read round trip to learn the verdict (the frugality concern of #194/#195).

Code: crates/ccteam-harness/src/execution/claude_stream_json/translate.rs:222-233 builds final_text from acc_text (all blocks joined); crates/ccteam-im/src/delegation.rs:293 BRIEF_NOTIFICATION_ANSWER_MAX_CHARS = 500 and notification_answer_max_chars(NotifyMode) size the excerpt from that text's head.

Expected

Keep the transcript as is (every block, ordered). For the notification excerpt and result_text, pick a receipt instead of the head, in this order:

1. If the answer contains an explicit receipt marker (e.g. a <report>…</report> block, or a configurable marker), use that block.
2. Otherwise use the last assistant text block of the turn (the block after the final tool call) — that is where a disciplined worker puts its conclusion.
3. Otherwise fall back to today's head excerpt.

The excerpt could say which rule fired (receipt: marker|last-block|head) so the reader knows whether they saw a conclusion or a preview. agent_read and FleetView should keep showing the whole answer.

Impact

• Orchestrators using notify: brief cannot act on completion notifications; they must poll or read transcripts (token cost, latency).
• Workers are pushed to write nothing but the receipt, which loses the narration that Turn ledger keeps only the last assistant text block; mid-turn replies to the human are dropped #192 wanted kept.

Workaround in use

Worker protocol: the final text block is a receipt ≤400 chars (verdict · id@commit · checks incl. NOT RUN · risks · evidence path); the orchestrator reads it with agent_read{sid, n:1, max_chars:600} after every completion notification instead of trusting the excerpt.

Environment

• ccteam 702d9de (2026-09-05), adapter claude-stream-json, Claude Code 2.1.260, project excore, sessions s871 / s908.
• Related: Turn ledger keeps only the last assistant text block; mid-turn replies to the human are dropped #192 (fixed; do not revert), Make token frugality the default for orchestrated sessions (duplicate completions, notify default, agent_read polling cost) #194, Orchestrator still pays twice for an inline answer, and a bare agent_read is 73% pointer #195.

[zerohacker666]

Review against the latest dev (702d9de92cd7c390cda8ba2ffa52f035217a9959), including #192/#194/#195 and the original excore turn/notification records.

The underlying problem belongs in ccteam: completion excerpts need access to the final response separately from the complete conversation text. I recommend retaining this as a P2 issue, with the evidence and proposed implementation corrected below.

Evidence corrections

1. Current excerpts are already head/tail, not head-only. Both notification text and inline result_text use truncate_head_tail_with_marker: subtract the read-pointer length, then allocate 70% to the head and 30% to the tail. For these 500-character samples, only 134 characters of the tail survive. This can omit the verdict at the beginning of a 420-character final receipt, but it does not omit the entire tail.

2. The observed notifications differ from the issue's table. Counts below are Unicode characters, excluding the notification header:

Child turn	Full answer chars	Conclusion starts at	Actual parent notification
s871-1	4,702	1,020	500-character head/tail excerpt; conclusion opening absent
s871-2	2,592	516	500-character head/tail excerpt; conclusion opening absent
s908-1	1,067	647	Full 1,067-character answer, including READY for review and the receipt

Evidence in excore: .ccteam/chat/s871/turns.jsonl and .ccteam/chat/s908/turns.jsonl; received notifications in .ccteam/chat/s869/turns.jsonl lines 3 and 7, and .ccteam/chat/s896/turns.jsonl line 21. The s908-1 notification was recorded at 2026-09-06T10:40:39.891367269Z. Recalculating a 500-character brief for s908-1 does omit its verdict, but that is a simulated brief, not the notification actually received.

3. The stated workaround is not sufficient. agent_read{sid,n:1,max_chars:600} also uses head/tail truncation. Recalculating that budget for all three answers still omits their conclusion openings. Use the excerpt's full-read budget while that turn is still newest, or page to the specific older turn if the child has since answered again. result_text has a 2,000-character cap; all three samples retain the conclusion opening at that cap, so they do not demonstrate the claimed inline-result failure.

Responsibility and proposed scope

The #192 fix must stay: all top-level text survives in stream order. However, translate.rs folds those blocks and Claude's result.result into one AgentMessage(String). Downstream completion rendering only sees that combined string. The distinction between complete turn text and final response is lost during normalization.

Suggested implementation:

• Preserve the full transcript text and retain final-response text or explicit message/block boundaries alongside it. Prefer vendor-provided final output (result.result for Claude), with a clearly defined fallback for missing final output.
• Have pushed notifications and inline results use the same final-response selection, then apply their existing budgets. Fall back to the existing head/tail preview when no final response can be identified, and expose which source was selected. agent_read and FleetView must retain access to the full conversation.
• Carry the information through the durable turn record, live notification, inline wait, transcript recovery and restart reconciliation. An in-memory-only adapter change would make live and recovered notifications disagree.

I would defer <report> or configurable receipt-marker parsing. Receipt format, verdict semantics and acceptance rules belong to the calling workflow; ccteam can first preserve the structure the vendor already supplies. In particular, do not infer a vendor text block by splitting the flattened answer on blank lines: paragraphs inside one block use the same separator.

Acceptance should cover long narration followed by a short final response, multi-paragraph final responses, missing/empty final output, exclusion of nested subagent text, failures, and identical live/inline/recovered selection, while preserving #192's full-text assertions.

This was a review and read-only evidence check; no fix has been implemented. cargo fmt --all -- --check passed; the workspace is clean.

[zerohacker666]

Fixed on dev in 35b1ad4 (ships with the next release). Thanks @zerohacker666 for the evidence check — it stands, and it changed the scope: the excerpt was already head/tail (70% head, agent_read pointer, 30% tail); s908's parent actually received the whole 1,067-char answer under final; only s871's two brief notifications showed the failure mode (narration head + ~135 chars of the receipt's tail, verdict line lost). The root cause is in the bridge: normalisation folded the turn into one string and lost the final-response boundary, while the excerpt policy kept assuming the head carries the gist.

What changed

• TurnCompleted now carries conclusion: the text after the turn's last tool call — Claude's result.result (measured: the last text block), falling back to the last stream block; omitted when it is the whole answer. It rides into turns.jsonl as TurnRecord.conclusion, into the delegation signal, and through the restart-recovery and reconcile paths, so live, inline and recovered notifications select the same text.
• One excerpt rule for completion notifications, inline result_text and agent_read rows:
  1. the answer fits the cap → the whole answer (unchanged);
  2. otherwise → the conclusion, whole, behind one …[+N chars: agent_read{sid,n:1,max_chars:<total>}]… marker standing in for the narration it skips (N = omitted chars; the recipe reads the whole turn). If the conclusion itself cannot fit beside the marker it is head/tail-cut, still carrying the recipe;
  3. no conclusion (single-block turn, or a vendor without that boundary) → the head/tail preview as before.
• Transcript unchanged: every block stays (Turn ledger keeps only the last assistant text block; mid-turn replies to the human are dropped #192 is not reopened). agent_read and FleetView still show the whole answer; conclusion steers a row's own cut and never appears on the wire.

For s908-1 under brief this yields the header line, then …[+647 chars: agent_read{sid:s908,n:1,max_chars:1067}]…, then the 420-char receipt whole.

Not adopted: the <report> / configurable receipt marker and a receipt: marker|last-block|head label. Receipt format belongs to the calling workflow; the bridge keeps the structure the vendor already supplies, and the marker's omitted count already tells the reader that narration was skipped.

Other vendors: codex mirrors each agent_message as its own row, so its boundary text was already the last message; ACP (grok/opencode/kimi/dsh) and pi turns arrive as one block and keep the head/tail preview.

docs/orchestration*.md now describe the rule. Closing; reopen if a brief notification on the next release still shows narration instead of the receipt.