@te-river/opencode-team-mode 1.8.3 → 1.8.5

package/dist/tm/dispatch.js

@@ -40,6 +40,22 @@
  * already calls.  What the host does NOT give is tool-level cancellation — the
  * only thing stoppable is the whole active execution (`interrupt`) — so nothing
  * here pretends that granularity exists.
+ *
+ * Waking (2026-10-23, measured in another project): steering a session that has
+ * already settled is not an interjection, it is a RESURRECTION — the host's own
+ * sentence is "Steering wakes session execution", so the line starts a second run
+ * that overlaps whatever the lead dispatched meanwhile (two processes on one
+ * device, in the incident that produced this).  A steer therefore refuses unless
+ * the registry says `running`, and the explicit `wake:true` opt-in is the only way
+ * to deliver into a settled/unknown child.  The same incident showed the mirror
+ * bug on the stop path: a settled row made `cancel:true` answer "没有运行中的
+ * 子代理可停" WITHOUT asking the host, while the woken child was in fact running.
+ * An explicitly named id is always asked of the host now.
+ *
+ * The body fallback has one more source: a settled host sub-agent's report also
+ * lives in the PARENT transcript as `<subagent sessionID="…">…</subagent>`; when
+ * the child session's context yields no assistant text, that envelope is read
+ * (exact id match, last one wins) instead of reporting `child_body_missing`.
  */
 import { sameAgent } from "../identity.js";
 import { tmError, toToolResult } from "./result.js";
@@ -225,6 +241,79 @@ export function lastAssistantMessage(messages) {
 export function lastAssistantText(messages) {
     return lastAssistantMessage(messages).text;
 }
+/** Every non-empty text body a transcript carries, in message order.
+ *  Deliberately NOT filtered by role: the host's completion envelope arrives as an
+ *  ordinary (user-role) message, and dropping it here would make the fallback below
+ *  structurally dead. */
+function transcriptTexts(messages) {
+    const list = Array.isArray(messages) ? messages : [];
+    const out = [];
+    for (const entry of list) {
+        const e = entry;
+        if (Array.isArray(e?.parts)) {
+            const t = e.parts
+                .filter((p) => {
+                const pp = p;
+                return pp && pp.type === "text" && typeof pp.text === "string";
+            })
+                .map((p) => String(p.text))
+                .join("\n");
+            if (t.trim())
+                out.push(t);
+            continue;
+        }
+        if (e?.type === "text" && typeof e.text === "string" && e.text.trim())
+            out.push(e.text);
+    }
+    return out;
+}
+/** The body of the LAST `<subagent sessionID="<sid>" …>…</subagent>` envelope in one
+ *  text, or null.  The id must match EXACTLY — an envelope naming another child is
+ *  never adopted, because the lead naming a session must not receive someone else's
+ *  report (the same rule `parentageOf` applies to steering). */
+function lastEnvelopeFor(text, sessionID) {
+    let from = 0;
+    let found = null;
+    for (;;) {
+        const open = text.indexOf("<subagent", from);
+        if (open < 0)
+            break;
+        const gt = text.indexOf(">", open);
+        if (gt < 0)
+            break;
+        const tag = text.slice(open, gt + 1);
+        const close = text.indexOf("</subagent>", gt + 1);
+        if (close < 0)
+            break;
+        const id = /\bsessionID\s*=\s*(?:"([^"]*)"|'([^']*)')/.exec(tag);
+        if (id && (id[1] ?? id[2] ?? "").trim() === sessionID) {
+            const body = text.slice(gt + 1, close).trim();
+            if (body)
+                found = body;
+        }
+        from = close + "</subagent>".length;
+    }
+    return found;
+}
+/** The body the host injected into the PARENT transcript for this child, if any.
+ *  The v2 plugin can read a child's own context, but a host sub-agent's report also
+ *  arrives in the parent as a completion envelope — and on a host whose child context
+ *  answers with no assistant text (the measured `child_body_missing`), that envelope
+ *  is the only readable copy.  Null when nothing matches, so the caller keeps its
+ *  exact `child_body_missing` wording rather than inventing a third outcome. */
+export function hostEnvelopeBody(messages, sessionID) {
+    const sid = String(sessionID ?? "").trim();
+    if (!sid)
+        return null;
+    const texts = transcriptTexts(messages);
+    // newest-first: a child re-run after a wake may have been injected more than once
+    for (let i = texts.length - 1; i >= 0; i--) {
+        const hit = lastEnvelopeFor(texts[i], sid);
+        if (hit)
+            return hit;
+    }
+    return null;
+}
 /**
  * Turn whatever the host puts in an error slot into ONE readable line.
  *
@@ -267,6 +356,15 @@ export function describeHostError(err, max = 220) {
         .join(" ");
     return shorten(flat || "session.error", max);
 }
+/**
+ * The line a PRESUMED settle must print when the body it collected carries no
+ * `time.completed`.  Both halves of that condition matter: the settle was an inference
+ * (the parent went idle, no event named this child) AND the text has no completion marker,
+ * so it may be what the child had written before its last tool call.  A live lead read
+ * exactly that fragment as the delivery, concluded "修复没落地", and re-dispatched work
+ * that had already landed — the fix is to say it, not to withhold the text.
+ */
+export const INCOMPLETE_PRESUMED_BODY_WARNING = "⚠ 推定结算且正文未带完成时间：这可能是最后一次工具调用前的半截话，不要据此判定交付；稍后再次 tm_join 可复核（或让子代理续跑）。";
 /** One child's status line — the lead reads these, so keep them terse. */
 export function renderChildLine(c, elapsedMs) {
     const secs = Math.round(elapsedMs / 1000);
@@ -275,7 +373,7 @@ export function renderChildLine(c, elapsedMs) {
     // needs to see that the child was never running, not a bare 已完成.
     const stop = c.state === "idle" && c.cancelNote ? ` ·${c.cancelNote}` : "";
     return `${c.sessionID} · ${c.agent} · "${c.label}" · ${tag}${stop}${c.adopted ? " ·（本进程重启后由宿主会话树接管）" : ""}${c.via === "host-injection" && c.settleSource === "parent-idle"
-        ? " ·（宿主子代理：随父会话空闲推定已结算，宿主没给过这个子会话的 idle 事件）"
+        ? " ·（宿主子代理：随父会话空闲推定已结算；宿主未给该子会话 idle 事件）"
         : c.via === "host-injection"
             ? " ·（宿主 subagent 派发）"
             : ""}`;
@@ -632,15 +730,36 @@ export function buildDispatchTools(deps) {
             }
         }
     }
-    function fetchReply(sid, directory) {
+    /** Read the completion envelope the host injected into the PARENT transcript for
+     *  this child.  Absent seam / failed call / no matching envelope all return null —
+     *  the fallback may not turn "I could not look" into a body. */
+    async function envelopeFromParent(parent, sid, directory) {
+        if (!parent || !sid || parent === sid)
+            return null;
+        if (typeof api?.messages !== "function")
+            return null;
+        try {
+            const raw = await api.messages({ path: { id: parent }, ...(directory ? { query: { directory } } : {}) });
+            const un = unwrapClientResult(raw);
+            if (!un.ok)
+                return null;
+            return hostEnvelopeBody(un.data, sid);
+        }
+        catch {
+            return null;
+        }
+    }
+    function fetchReply(sid, directory, parentSessionID) {
         return (async () => {
             if (typeof api?.messages !== "function") {
-                return { text: "", error: "这个宿主客户端没有给出读取子会话正文的缝（v2 上它是 ctx.session.context 的兼容层）" };
+                return { text: "", error: "这个宿主客户端没有给出读取子会话正文的缝（v2 上它是 ctx.session.context 的兼容层）", bodyComplete: false };
             }
             try {
                 const raw = await api.messages({ path: { id: sid }, ...(directory ? { query: { directory } } : {}) });
                 const un = unwrapClientResult(raw);
-                const got = un.ok ? lastAssistantMessage(un.data) : { text: "", error: un.message };
+                const got = un.ok
+                    ? lastAssistantMessage(un.data)
+                    : { text: "", error: un.message };
                 // The seam that ANSWERED, named by the seam itself. On v1 that is the host's
                 // `session.messages`; on v2 the same call is served by `ctx.session.context`, and
                 // printing "session.messages" there would credit an endpoint this host does not
@@ -651,12 +770,28 @@ export function buildDispatchTools(deps) {
                 // and the last item carried no text part" is a different fact from "no seam".
                 const reported = raw?.shape;
                 const shape = typeof reported === "string" && reported ? reported : undefined;
-                return got.text
-                    ? { ...got, via, ...(shape ? { shape } : {}) }
-                    : { text: "", error: got.error, via, ...(shape ? { shape } : {}) };
+                // `bodyComplete` is derived from the SAME parse that produced the text, so a caller
+                // can never read a body and a completeness verdict from two different messages.
+                const completeness = {
+                    bodyComplete: typeof got.completedAt === "number",
+                    ...(typeof got.completedAt === "number" ? { bodyCompletedAt: got.completedAt } : {}),
+                };
+                return got.text.trim()
+                    ? { ...got, via, ...(shape ? { shape } : {}), ...completeness }
+                    : await (async () => {
+                        // C: the child's own context answered with no assistant text.  Before
+                        // reporting `child_body_missing`, look for the host's completion envelope
+                        // in the parent — for a host sub-agent that IS the delivered report, and a
+                        // lead that cannot read it has to re-dispatch work that already landed.
+                        const envelope = await envelopeFromParent(parentSessionID ?? "", sid, directory);
+                        if (envelope) {
+                            return { text: envelope, via: "host-envelope", shape: "parent-envelope", bodyComplete: true };
+                        }
+                        return { text: "", error: got.error, via, ...(shape ? { shape } : {}), ...completeness };
+                    })();
             }
             catch (err) {
-                return { text: "", error: describeHostError(err?.message ?? err, 140) };
+                return { text: "", error: describeHostError(err?.message ?? err, 140), bodyComplete: false };
             }
         })();
     }
@@ -817,10 +952,10 @@ export function buildDispatchTools(deps) {
         description: `Collect the sub-agent work attached to THIS session — the read-back side of delegation. You reach for it in two situations: the host's background \`task\` finished and TeamMode replaced its injected reply with a preview (pull the whole thing back with \`{ ids: ["<child session>"] }\`), or a dispatched child from before this build is still open and needs collecting or cancelling.
 - No args: status snapshot of every open child of THIS session — running / idle(done) / error, with elapsed seconds.  Cheap and non-blocking: use it to decide whether to keep working or start merging.
 - { waitMs: 30000 }: bounded wait (capped at ${waitLabel(maxWaitMs)}) until every child settles.  A wait BLOCKS YOU — your turn is parked in this tool call, so it is the synchronous \`task\` experience with none of its visibility.  Wait once, briefly, and only when the very next step needs the answer; a second consecutive wait after nothing settled is cut to 10s and answered with what to do instead.  Never wait for a child whose result you do not need — abort it instead ({ cancel: true }).
-- { ids: [...] }: restrict to those child sessions — a host \`task\` child is collectable when you NAME it (its parentage is verified against the host's own session tree, never assumed); { cancel: true }: abort still-running ones.
-- Steer a child while it runs — the same call, no separate tool: { steer: "先停手，验收改成 X", ids: ["<child>"] } admits the line into that child's inbox with delivery "steer" (or "queue") and the host wakes execution at the step boundary.  已受理 is the whole claim: it is NOT proof the child read it, and the reply never says 已送达.  { unread: true, ids: ["<child>"] } lists that child's undelivered inbox items (ids + shape only, never the body); { unsend: {"sessionID":"ses_…","inboxID":"msg_…"} } withdraws one that has not been delivered — an already-delivered item is the documented no-op and is reported as one.  All three ask the host for parentage FIRST and refuse a session that is not yours; a host without the seam answers no-seam instead of pretending.
+- { ids: [...] }: restrict to those child sessions — a host \`task\` child is collectable when you NAME it (its parentage is verified against the host's own session tree, never assumed); { cancel: true }: abort still-running ones.  With explicit ids the host is ALWAYS asked, even for a row this process believes settled — a settled-looking row can have been woken and be running for real.
+- Steer a child while it runs — the same call, no separate tool: { steer: "先停手，验收改成 X", ids: ["<child>"] } admits the line into that child's inbox with delivery "steer" (or "queue") and the host wakes execution at the step boundary.  已受理 is the whole claim: it is NOT proof the child read it, and the reply never says 已送达.  Steer REFUSES a child whose registered state is not running (idle / error / unknown), because the host's doc sentence "Steering wakes session execution" means the line starts a second run that overlaps new dispatches — pass { wake: true } to do that deliberately.  { unread: true, ids: ["<child>"] } lists that child's undelivered inbox items (ids + shape only, never the body); { unsend: {"sessionID":"ses_…","inboxID":"msg_…"} } withdraws one that has not been delivered — an already-delivered item is the documented no-op and is reported as one.  All three ask the host for parentage FIRST and refuse a session that is not yours; a host without the seam answers no-seam instead of pretending.
 - A plugin/host restart does NOT orphan a child: those the host still lists under your session are re-adopted automatically (their rows are marked 接管), and one that answered while nobody was listening is reported 已完成, not lost.
-- Replies come back through the offload pipeline: a long sub-agent report arrives as a handle + ≤80-token preview (page it with tm_fetch), so a batch of parallel work does not multiply your context.  STATUS: blocked/failed children are surfaced first, always.`,
+- Replies come back through the offload pipeline: a long sub-agent report arrives as a handle + ≤80-token preview (page it with tm_fetch), so a batch of parallel work does not multiply your context.  STATUS: blocked/failed children are surfaced first, always.  When a child's own session yields no assistant text, the host's injected \`<subagent sessionID="…">…</subagent>\` envelope in THIS session is read as the body and labelled 正文来源=宿主注入信封 (an id must match exactly).`,
         args: {
             ids: { descriptor: "ids: string[] (optional — only these child sessions)" },
             waitMs: { descriptor: `waitMs: number (optional 0..${maxWaitMs} — bounded wait; a SECOND consecutive wait is cut to 10s, because waiting is not parallel work)` },
@@ -840,6 +975,9 @@ export function buildDispatchTools(deps) {
             delivery: {
                 descriptor: "delivery: steer|queue (optional, default steer — applies to steer only. Any other value is refused rather than silently defaulted.)",
             },
+            wake: {
+                descriptor: "wake: boolean (optional, default false — steer only. A steer into a settled/idle child is REFUSED unless this is true, because the host wakes execution and the child then overlaps new dispatches. Accepts true/false or the strings \"true\"/\"false\".)",
+            },
             unread: {
                 descriptor: "unread: true (optional — list the undelivered inbox items of the child named by ids: ids and shape only, never the body)",
             },
@@ -946,6 +1084,45 @@ export function buildDispatchTools(deps) {
                         ? renderChildLine(row, (row.finishedAt ?? now()) - row.startedAt)
                         : `${target} · ${gate.agent} ·（本进程没有它的登记行，归属由宿主确认）`;
                     if (steerText) {
+                        // A steer into a session that is not running is a WAKE, not an interjection:
+                        // the host's own doc says "Steering wakes session execution", so it starts a
+                        // second run that overlaps whatever the lead dispatched meanwhile.  Measured
+                        // cost: a settled child was woken this way and ran concurrently with a fresh
+                        // worker, two processes on one device.  Default = refuse; `wake:true` is the
+                        // explicit opt-in, and the value is coerced the way the rest of this tool's
+                        // boolean args are (`cancel`/`unread` above): boolean or "true"/"false".
+                        const wakeRaw = args.wake;
+                        let wakeRequested = false;
+                        if (wakeRaw !== undefined && wakeRaw !== null) {
+                            if (wakeRaw === true || wakeRaw === false)
+                                wakeRequested = wakeRaw;
+                            else if (typeof wakeRaw === "string" && /^(true|false)$/i.test(wakeRaw.trim())) {
+                                wakeRequested = /^true$/i.test(wakeRaw.trim());
+                            }
+                            else {
+                                return toToolResult(tmError(tool, "args", `wake 只接受 true/false（布尔或 "true"/"false" 字符串），收到 ${shorten(String(wakeRaw), 24)}，未发送。`));
+                            }
+                        }
+                        // The registry can be stale in the dangerous direction too (an event we
+                        // missed would leave a settled child looking running); ask the host before
+                        // trusting "running" when it offers a status map.
+                        if (row && row.state === "running" && typeof api?.status === "function") {
+                            await refreshFromStatus(directory);
+                        }
+                        const rowState = row?.state;
+                        if (rowState !== "running" && !wakeRequested) {
+                            log({
+                                step_id: "join",
+                                event: "steer_refused",
+                                child: target,
+                                agent: gate.agent,
+                                reason: "not-running",
+                                state: rowState ?? "unregistered",
+                                // the LENGTH, never the text — R6 binds the audit trail as much as the reply
+                                chars: steerText.length,
+                            });
+                            return toToolResult(`没有发送：该子代理已结算（或状态未知）；插话会唤醒它并与新派发并发——要停止用 cancel:true，要复活请显式 wake:true。\n目标：${rowLine}`);
+                        }
                         let outcome = "no-seam";
                         let inboxID;
                         let note;
@@ -971,6 +1148,7 @@ export function buildDispatchTools(deps) {
                             delivery,
                             outcome,
                             ok: outcome === "steered",
+                            wake: wakeRequested,
                             ...(inboxID ? { inboxID } : {}),
                             ...(seam ? { seam } : {}),
                             // the LENGTH, never the text — R6 binds the audit trail as much as the reply
@@ -979,8 +1157,8 @@ export function buildDispatchTools(deps) {
                         const tally = {};
                         tally[outcome] = 1;
                         log({ step_id: "join", event: "steer_summary", count: 1, outcomes: steerOutcomeParts(tally).join(" / ") });
-                        const wake = row && row.state !== "running"
-                            ? `\n它现在不是运行中（${row.state === "error" ? "失败" : "已结算"}）；按文档 steer 会唤醒它的执行，但唤醒之后它做什么，要等它结算才看得到。`
+                        const wake = outcome === "steered" && wakeRequested && row && row.state !== "running"
+                            ? `\n已按 wake:true 唤醒：它当时不是运行中（${row.state === "error" ? "失败" : "已结算"}），宿主把这条插话当成新的执行输入——它会和新派发的 worker 并发，留意这一点。`
                             : "";
                         return toToolResult(`插话目标：${rowLine}\n插话结果：${steerVerdictLine(outcome, { inboxID, note, seam })}\n插话计数：${steerOutcomeParts(tally).join(" · ")}${wake}`);
                     }
@@ -1102,41 +1280,84 @@ export function buildDispatchTools(deps) {
                 let cancelTally = null;
                 if (args.cancel === true || args.cancel === "true") {
                     cancelTally = {};
-                    for (const r of stillRunning) {
+                    // B: an EXPLICITLY named id is always asked of the host.  The registry is this
+                    // process's memory, not the host's truth — the live failure was a row settled
+                    // HERE while the host had just been made to run it by a steer, and the old loop
+                    // over `stillRunning` answered "没有运行中的子代理可停" without ever calling the
+                    // host.  With no ids the shipped behaviour stays ("only those we still believe
+                    // are running"), because "cancel everything" must not interrogate every settled
+                    // child of the session.
+                    const cancelTargets = idFilter ? mine.filter((r) => idFilter.has(r.sessionID)) : stillRunning;
+                    for (const r of cancelTargets) {
+                        const wasRunning = r.state === "running";
                         let outcome;
                         let note;
                         if (typeof api?.abort === "function") {
-                            // v1's path, byte-exact and FIRST: the personality is frozen and a shipped
-                            // test pins "aborted on request".
+                            // v1's path, byte-exact and FIRST for a RUNNING row: the personality is
+                            // frozen and a shipped test pins "aborted on request".
                             const un = unwrapClientResult(await api.abort({ path: { id: r.sessionID } }));
-                            outcome = un.ok ? "stopped" : "threw";
-                            r.error = un.ok ? "aborted on request" : `abort failed: ${shorten(un.message ?? "", 60)}`;
-                            r.state = "error";
+                            if (wasRunning) {
+                                outcome = un.ok ? "stopped" : "threw";
+                                r.error = un.ok ? "aborted on request" : `abort failed: ${shorten(un.message ?? "", 60)}`;
+                                r.state = "error";
+                            }
+                            else {
+                                // v1's abort returns no `interrupted` boolean, so an already-settled row
+                                // cannot honestly be called stopped OR failed from this answer.
+                                outcome = un.ok ? "unknown" : "threw";
+                                note = un.ok ? "v1 的 abort 不返回 interrupted 布尔" : un.message;
+                                r.cancelNote = cancelVerdictLine(outcome, note);
+                            }
                         }
                         else if (typeof api?.interrupt === "function") {
                             const got = cancelOutcomeOf(await api.interrupt({ path: { id: r.sessionID } }));
                             outcome = got.outcome;
                             note = got.note;
-                            // `idle` is the host saying there was no active execution: the registry row
-                            // was stale, not a failed stop. Anything else closes as undelivered.
-                            r.state = outcome === "idle" ? "idle" : "error";
                             r.cancelNote = cancelVerdictLine(outcome, note);
-                            if (r.state === "error")
+                            if (wasRunning) {
+                                // `idle` is the host saying there was no active execution: the registry row
+                                // was stale, not a failed stop. Anything else closes as undelivered.
+                                r.state = outcome === "idle" ? "idle" : "error";
+                                if (r.state === "error")
+                                    r.error = r.cancelNote;
+                            }
+                            else if (outcome === "stopped") {
+                                // A row we believed settled was in fact executing (a woken session is the
+                                // measured case): the host just stopped it, and the row must say so.
+                                r.state = "error";
                                 r.error = r.cancelNote;
+                            }
+                            // idle / unknown / no-seam / threw on an already-settled row leave its settle
+                            // verdict alone — the stop attempt is extra evidence, not a re-settlement.
                         }
                         else {
                             outcome = "no-seam";
-                            r.error = "宿主无 abort 接口，未取消";
-                            r.state = "error";
+                            if (wasRunning) {
+                                r.error = "宿主无 abort 接口，未取消";
+                                r.state = "error";
+                            }
+                            else {
+                                r.cancelNote = cancelVerdictLine("no-seam");
+                            }
                         }
-                        r.finishedAt = now();
+                        if (wasRunning || r.finishedAt === undefined)
+                            r.finishedAt = now();
                         cancelTally[outcome] = (cancelTally[outcome] ?? 0) + 1;
-                        log({ step_id: "join", event: "cancel", child: r.sessionID, agent: r.agent, outcome, ok: outcome === "stopped" });
+                        log({
+                            step_id: "join",
+                            event: "cancel",
+                            child: r.sessionID,
+                            agent: r.agent,
+                            outcome,
+                            explicit: Boolean(idFilter),
+                            was_running: wasRunning,
+                            ok: outcome === "stopped",
+                        });
                     }
                     log({
                         step_id: "join",
                         event: "cancel_summary",
-                        count: stillRunning.length,
+                        count: cancelTargets.length,
                         outcomes: cancelOutcomeParts(cancelTally).join(" / "),
                     });
                 }
@@ -1145,9 +1366,17 @@ export function buildDispatchTools(deps) {
                     `派发汇总：${sums.idle} 完成 / ${sums.running} 运行中 / ${sums.error} 失败${settled ? "（全部已结算）" : `（未等到全部结算 · 本次已等 ${Math.round((now() - waitStart) / 1000)}s）`}`,
                     ...mine.map((r) => renderChildLine(r, (r.finishedAt ?? now()) - r.startedAt)),
                 ];
+                // The `正文：` line belongs directly under the child rows it describes, but the
+                // body's completeness is only knowable once the bodies have been read — remember
+                // where the rows end and splice it back in there.
+                const childRowsEnd = header.length;
                 if (cancelTally) {
                     const parts = cancelOutcomeParts(cancelTally);
-                    header.push(`取消尝试：${parts.join(" · ") || "没有运行中的子代理可停"} —— ` +
+                    header.push(`取消尝试：${parts.join(" · ") ||
+                        // Never leave "没有运行中的子代理可停" as the ONLY answer: with no ids the
+                        // default restricted the attempt to rows we believed running, and the lead
+                        // must know that a settled-looking row was therefore not asked about.
+                        "没有运行中的子代理可停（未显式给 ids 时只对登记为运行中的子代理发起取消；若你怀疑某个已结算的子会话其实在跑，用 ids 点名——我会先去问宿主）"} —— ` +
                         `只有「已由宿主中断」是宿主确认过的停止；「空闲未中断」说明它当时没在活动执行里` +
                         `（登记行过时了，不是失败）；「未确认」说明中断调用成功但宿主没回 interrupted 布尔。` +
                         `这三种结论不要混成一句"已取消"转述给用户。`);
@@ -1241,11 +1470,27 @@ export function buildDispatchTools(deps) {
                 const wantText = !(args.includeText === false || args.includeText === "false");
                 const collectible = mine.filter((r) => r.state !== "running");
                 const blocks = [];
+                /** One token per collected child for the `正文：` line — each token is a MEASUREMENT
+                 *  (`time.completed` was on the message, or it was not), never a guess. */
+                const bodyStatus = [];
                 if (wantText) {
                     for (const r of collectible) {
-                        const reply = await fetchReply(r.sessionID, directory);
+                        const reply = await fetchReply(r.sessionID, directory, parent);
                         const text = reply.text;
-                        const src = text && reply.via ? ` ·正文来源=${reply.via}` : "";
+                        r.bodyComplete = reply.bodyComplete === true;
+                        r.bodyCompletedAt = reply.bodyCompletedAt;
+                        const hasBody = Boolean(text.trim());
+                        // The combination that produced a wrong verdict live: a PRESUMED settle (no
+                        // event ever named this child) plus a body with no completion marker.  Only
+                        // then is "半截" a fair reading — an event/injection-settled child on a seam
+                        // that simply does not carry `time` (2.0.20's ctx) must not be labelled a
+                        // fragment, which would be the same overstatement facing the other way.
+                        const half = hasBody && r.bodyComplete === false && r.settleSource === "parent-idle";
+                        bodyStatus.push(`正文：${!hasBody ? "缺失" : r.bodyComplete ? "完整" : half ? "半截（推定）" : "未带完成时间"} · ${r.agent} "${r.label}"`);
+                        // C labels the fallback in the lead's words: the body above came from the
+                        // host's own completion injection, not from the child's session context.
+                        const viaLabel = reply.via === "host-envelope" ? "宿主注入信封" : reply.via;
+                        const src = text && viaLabel ? ` ·正文来源=${viaLabel}` : "";
                         // Which seam answered, per child — an id, a seam name and the SHAPE it saw, never
                         // a body (R6 binds a diagnostic too). This is the line that makes "正文来源=…"
                         // checkable later, and the only place the three outcomes stay distinguishable:
@@ -1256,12 +1501,19 @@ export function buildDispatchTools(deps) {
                             event: text ? "child_body" : "child_body_missing",
                             child: r.sessionID,
                             via: reply.via ?? "none",
+                            // Completeness rides only the row that claims a BODY was read; a missing body
+                            // has no completion to report (`child_body_missing` stays byte-exact).
+                            ...(text ? { complete: r.bodyComplete === true } : {}),
                             // Only when the SEAM reported one: v1's SDK client gives no shape, and the v1
                             // personality is frozen — its rows stay byte-exact rather than gaining a field
                             // nobody asked for. The v2 bridge reports a shape on every path.
                             ...(text || !reply.shape ? {} : { shape: reply.shape }),
                         });
-                        blocks.push(`--- ${r.agent} "${r.label}" (${r.sessionID})${src} ---\n${text.trim() ||
+                        // Said BEFORE the body and INSIDE this child's own block: the body is what
+                        // gets misread as a delivery, and a warning floating between two blocks would
+                        // not name the child it is about.
+                        const warn = half ? `${INCOMPLETE_PRESUMED_BODY_WARNING}\n` : "";
+                        blocks.push(`--- ${r.agent} "${r.label}" (${r.sessionID})${src} ---\n${warn}${text.trim() ||
                             (r.via === "host-injection"
                                 ? `（这个子会话由宿主的 subagent 工具派发，而这一次我没有读到它的正文${reply.error ? `：${reply.error}` : "：这个宿主没给可读正文的缝"}。完成时宿主仍会把 \`<subagent sessionID=\"${r.sessionID}\" …>\` 注入本会话，我已经把它登记在案、状态如上。` +
                                     `要全文就在那条注入到达后读它，或让子代理把交付写进黑板；不要为了拿正文反复 join。）`
@@ -1269,6 +1521,10 @@ export function buildDispatchTools(deps) {
                                     `——子会话不是文件，tm_read 读不到它：在宿主的会话面板里看这条子会话，或改用内置 task 工具重做这一步。`)}`);
                     }
                 }
+                // One `正文：` line per child, directly under the child rows it describes, and only
+                // when bodies were actually read (`includeText:false` has no body to judge).
+                if (bodyStatus.length)
+                    header.splice(childRowsEnd, 0, ...bodyStatus);
                 const body = [...header, ...(blocks.length ? ["", blocks.join("\n")] : [])].join("\n");
                 const stepId = deps.pipelines.nextStepId();
                 return toToolResult(await deps.pipelines.govern(stepId, tool, body, {