@te-river/opencode-team-mode 1.8.6 → 1.8.8

package/dist/tm/dispatch.js

@@ -342,6 +342,177 @@ export function hostEnvelopeBody(messages, sessionID) {
     }
     return null;
 }
+const HISTORY_ACK_RE = /The subagent is working in the background \(sessionID: (ses_[A-Za-z0-9]+)\)/gi;
+const SESSION_ID_RE = /^ses_[A-Za-z0-9]+$/;
+const SHELL_ID_RE = /^sh_[A-Za-z0-9]+$/;
+/**
+ * The text bodies a transcript carries, for the HISTORY scanners only.
+ *
+ * Deliberately wider than `transcriptTexts` above, which keeps the body-collection policy
+ * (`type:"text"`): a background dispatch's ACK reaches the parent as a TOOL RESULT part, and
+ * the v2 seam hands tool parts through untouched (`normaliseContextMessages` moves
+ * `content[]` to `parts[]` and keeps their kind).  Reading only `type:"text"` would make
+ * this whole recovery path structurally dead — the exact shape of the task-offload bug,
+ * where a matcher that never fired was mistaken for "nothing to match".  `textsOf` in
+ * `src/host/v2-subagent.ts` reads `{text}` off every part for the same reason.
+ */
+function historyTexts(messages) {
+    const list = Array.isArray(messages) ? messages : [];
+    const out = [];
+    for (const entry of list) {
+        const e = entry;
+        if (typeof e?.text === "string" && e.text.trim())
+            out.push(e.text);
+        if (!Array.isArray(e?.parts))
+            continue;
+        const joined = e.parts
+            .map((p) => {
+            const t = p?.text;
+            return typeof t === "string" ? t : "";
+        })
+            .filter((s) => s.trim())
+            .join("\n");
+        if (joined.trim())
+            out.push(joined);
+    }
+    return out;
+}
+/** End index of the tag that starts at `from`, honouring quotes: a shell `command` may
+ *  contain `>` (a redirect), and cutting the tag there would lose the `state` after it. */
+function historyTagEnd(text, from) {
+    let quote = "";
+    for (let i = from; i < text.length; i++) {
+        const ch = text[i];
+        if (quote) {
+            if (ch === "\\")
+                i++;
+            else if (ch === quote)
+                quote = "";
+            continue;
+        }
+        if (ch === '"' || ch === "'")
+            quote = ch;
+        else if (ch === ">")
+            return i;
+    }
+    return -1;
+}
+function historyTagAttr(tag, name) {
+    const m = new RegExp(`\\b${name}\\s*=\\s*(?:"([^"]*)"|'([^']*)')`).exec(tag);
+    return (m?.[1] ?? m?.[2] ?? "").trim();
+}
+/** A label for a candidate whose evidence carried none: the nearest line above the ACK (the
+ *  dispatch description usually rides there), else the line below it, else `"host child"`. */
+function historyLabelNear(text, index) {
+    const before = text
+        .slice(0, index)
+        .split(/\r?\n/)
+        .map((s) => s.trim())
+        .filter(Boolean);
+    const after = text
+        .slice(index)
+        .split(/\r?\n/)
+        .map((s) => s.trim())
+        .filter(Boolean);
+    const cand = before[before.length - 1] ?? after[1] ?? "";
+    return cand.replace(/^[-*·\s]+/, "").slice(0, 40) || "host child";
+}
+function historyStateOf(raw) {
+    const s = raw.toLowerCase();
+    if (s === "running" || s === "started" || s === "busy")
+        return "running";
+    if (s === "completed" || s === "succeeded" || s === "done")
+        return "completed";
+    return "error";
+}
+/** Sub-agent candidates named by a parent transcript, in transcript order (a later
+ *  envelope overwrites the earlier ACK for the same id — that is what "last one wins"
+ *  means for a child that was woken and re-ran). */
+export function childrenFromParentHistory(messages) {
+    const found = new Map();
+    for (const text of historyTexts(messages)) {
+        for (const m of text.matchAll(HISTORY_ACK_RE)) {
+            const sid = m[1];
+            const prior = found.get(sid);
+            // An envelope already read for this id carries a stronger state; an ACK after it is a
+            // re-dispatch, so it wins — both cases reduce to "the later evidence wins".
+            found.set(sid, { sessionID: sid, state: "running", label: prior?.label ?? historyLabelNear(text, m.index ?? 0) });
+        }
+        let from = 0;
+        for (;;) {
+            const open = text.indexOf("<subagent", from);
+            if (open < 0)
+                break;
+            if (!/\s/.test(text[open + "<subagent".length] ?? "")) {
+                from = open + 9;
+                continue;
+            }
+            const gt = historyTagEnd(text, open);
+            if (gt < 0)
+                break;
+            const tag = text.slice(open, gt + 1);
+            const sid = historyTagAttr(tag, "sessionID");
+            const stateRaw = historyTagAttr(tag, "state");
+            const close = text.indexOf("</subagent>", gt + 1);
+            if (SESSION_ID_RE.test(sid) && stateRaw) {
+                const state = historyStateOf(stateRaw);
+                const body = close >= 0 && state === "completed" ? text.slice(gt + 1, close).trim() : "";
+                const described = historyTagAttr(tag, "description").slice(0, 40);
+                found.set(sid, {
+                    sessionID: sid,
+                    state,
+                    ...(body ? { body } : {}),
+                    label: described || found.get(sid)?.label || "host child",
+                });
+            }
+            from = close >= 0 ? close + "</subagent>".length : gt + 1;
+        }
+    }
+    return [...found.values()];
+}
+/** Background shells the host announced in a parent transcript, last state per id. */
+export function backgroundShellsFromParentHistory(messages) {
+    const found = new Map();
+    for (const text of historyTexts(messages)) {
+        let from = 0;
+        for (;;) {
+            const open = text.indexOf("<shell", from);
+            if (open < 0)
+                break;
+            if (!/\s/.test(text[open + "<shell".length] ?? "")) {
+                from = open + 6;
+                continue;
+            }
+            const gt = historyTagEnd(text, open);
+            if (gt < 0)
+                break;
+            const tag = text.slice(open, gt + 1);
+            const id = historyTagAttr(tag, "id");
+            if (SHELL_ID_RE.test(id)) {
+                const state = (historyTagAttr(tag, "state") || "running").toLowerCase();
+                const command = historyTagAttr(tag, "command");
+                found.set(id, { id, state, ...(command ? { command: command.slice(0, 80) } : {}) });
+            }
+            from = gt + 1;
+        }
+    }
+    return [...found.values()];
+}
+/** The `后台 shell` section tm_join appends.  A running shell is named as RUNNING and told
+ *  not to be re-dispatched: the user can see those processes, and a lead that cannot see
+ *  them dispatches the same work twice.  Nothing is killed here — the host owns the shell. */
+export function renderBackgroundShells(shells) {
+    if (!shells.length)
+        return null;
+    const verdict = (s) => s.state === "running" ? "运行中" : s.state === "completed" ? "已完成" : `失败(${s.state})`;
+    const parts = shells.map((s) => `${s.id} ${verdict(s)}${s.command ? ` · ${shorten(s.command, 60)}` : ""}`);
+    const running = shells.filter((s) => s.state === "running");
+    const lines = [`后台 shell：${shells.length} 个（${parts.join(" / ")}）`];
+    if (running.length) {
+        lines.push(`⏳ ${running.map((s) => s.id).join("、")} 还在跑 —— 别重复派同类活（宿主的 shell 自己收输出，这里只报告，不 kill）。`);
+    }
+    return lines.join("\n");
+}
 /**
  * Turn whatever the host puts in an error slot into ONE readable line.
  *
@@ -393,31 +564,49 @@ export function describeHostError(err, max = 220) {
  * that had already landed — the fix is to say it, not to withhold the text.
  */
 export const INCOMPLETE_PRESUMED_BODY_WARNING = "⚠ 推定结算且正文未带完成时间：这可能是最后一次工具调用前的半截话，不要据此判定交付；稍后再次 tm_join 可复核（或让子代理续跑）。";
+/** Wall-clock elapsed for a row, or `null` when NOBODY measured a start.  `startedAt` is only
+ *  set when it is a real measurement (the host's own `time.created` for an adopted history row,
+ *  our dispatch moment otherwise); the host's run window (`hostCreatedAt` → `hostIdleAt`) is the
+ *  fallback.  A history row is discovered long after its run began, so our discovery moment is
+ *  not a start — printing `0s` from it is the fake duration this split exists to remove. */
+export function elapsedOf(c, at = Date.now()) {
+    if (!c.startedAtUnknown)
+        return (c.finishedAt ?? at) - c.startedAt;
+    if (typeof c.hostCreatedAt === "number")
+        return (c.hostIdleAt ?? c.finishedAt ?? at) - c.hostCreatedAt;
+    return null;
+}
 /** One child's status line — the lead reads these, so keep them terse.  The tag is chosen by
  *  the settle SOURCE, because the same word would otherwise cover a host-confirmed finish, an
  *  unreachable seam and a guess: only `session-get` may print the host's outcome, and nothing
  *  but a real settlement may print 完成. */
 export function renderChildLine(c, elapsedMs) {
-    const secs = Math.round(elapsedMs / 1000);
+    const secs = elapsedMs === null ? null : Math.round(elapsedMs / 1000);
+    /** Seconds, or the truth when nobody measured a start — never `0s`. */
+    const dur = (n) => (n === null ? "时长未知" : `${n}s`);
     const hostRunSecs = c.hostIdleAt !== undefined && c.hostCreatedAt !== undefined && c.hostIdleAt > c.hostCreatedAt
         ? Math.round((c.hostIdleAt - c.hostCreatedAt) / 1000)
         : secs;
     const tag = c.state === "running"
-        ? `运行中 ${secs}s`
+        ? secs === null
+            ? "运行中（时长未知）"
+            : `运行中 ${secs}s`
         : c.state === "error"
             ? `失败：${shorten(c.error ?? "", 80)}`
             : c.settleSource === "session-get"
                 ? // The host's own record answered with a finished run: the only form allowed to
                     // print its outcome word, and it never says 推定.
-                    `已结算（${c.outcome ?? "宿主未给 outcome"}）· 运行 ${hostRunSecs}s`
+                    `已结算（${c.outcome ?? "宿主未给 outcome"}）· 运行 ${dur(hostRunSecs)}`
                 : c.settleSource === "parent-idle"
                     ? // An inference.  完成 is exactly the word this may not borrow.
-                        `推定已结算（未确认完成）· 派发后 ${secs}s`
-                    : `已完成 ${secs}s`;
+                        `推定已结算（未确认完成）· 派发后 ${dur(secs)}`
+                    : `已完成 ${dur(secs)}`;
     // #33: a row the host reported IDLE for a stop attempt is not a delivery — the lead
     // 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"
+    // A state read off the transcript envelope is not the host's verdict, and the row says so.
+    const inferred = c.historyInferred ? " ·（按历史信封推断）" : "";
+    return `${c.sessionID} · ${c.agent} · "${c.label}" · ${tag}${inferred}${stop}${c.adopted ? " ·（本进程重启后由宿主会话树接管）" : ""}${c.via === "host-injection" && c.settleSource === "parent-idle"
         ? " ·（宿主子代理：随父会话空闲推定已结算；宿主未给该子会话 idle 事件）"
         : c.via === "host-injection"
             ? " ·（宿主 subagent 派发）"
@@ -991,6 +1180,171 @@ export function buildDispatchTools(deps) {
         }
         return { adopted, looked: true, why: adopted ? "" : "会话树里没有被认领标题的子会话" };
     }
+    /** Read the CALLING session's own transcript.  On a host with no `session.children`
+     *  (2.1.4) this is the only recovery source left, and it is also where the host announces
+     *  its background shells.  Never throws: a failure is a reported `why`, because
+     *  "we could not look" and "there was nothing" must not print the same. */
+    async function readParentMessages(parent, directory) {
+        if (!parent)
+            return { ok: false, why: "调用方会话 id 缺失，读不到父会话历史" };
+        if (typeof api?.messages !== "function") {
+            return { ok: false, why: "这个宿主客户端没有给出读取会话正文的缝（v2 上是 ctx.session.context），父会话历史读不到" };
+        }
+        try {
+            const un = unwrapClientResult(await api.messages({ path: { id: parent }, ...(directory ? { query: { directory } } : {}) }));
+            if (!un.ok)
+                return { ok: false, why: `读取父会话历史失败：${shorten(un.message ?? "", 90)}` };
+            return { ok: true, data: un.data, why: "" };
+        }
+        catch (err) {
+            return {
+                ok: false,
+                why: `读取父会话历史失败：${describeHostError(err?.message ?? err, 90)}`,
+            };
+        }
+    }
+    /**
+     * Adopt the children the PARENT TRANSCRIPT still names — the second recovery path, for a
+     * host whose `session.children` does not exist.  Measured live (2.1.4 + 1.8.6): a service
+     * restart empties this in-process registry, `session.children` is gone, so tm_join
+     * answered `没有待收集的派发` while the user could still see the sub-agents running — and
+     * the lead re-dispatched work that was already in flight.
+     *
+     * The transcript is not trusted as ownership: every candidate is verified through the
+     * host's own `session.get` (`parentID === the caller`) before a row is opened, because an
+     * envelope names a session, it does not prove the session is OURS.  A candidate the host
+     * will not confirm is counted as skipped and never shown as a child.
+     *
+     * The row's state comes from the HOST, for every candidate: `time.idle` → settled with the
+     * host's own `outcome` word; answered WITHOUT `time.idle` → RUNNING, whatever the transcript's
+     * envelope says (1.8.7 took three `state="error"` envelopes as conclusions and answered
+     * `0 运行中 / 3 失败` while the host's own UI still showed two of those children running).
+     * The envelope's state is the fallback ONLY when the per-session read cannot answer, and the
+     * row then prints `按历史信封推断` instead of borrowing the host's verdict.
+     *
+     * A candidate that is already FINISHED does not enter the live table: it becomes one count
+     * (`另有 N 条已结算的历史子代理`) and is returned, body and all, when named with `ids`.
+     */
+    async function adoptFromParentHistory(parent, parentMessages, directory, only) {
+        const candidates = childrenFromParentHistory(parentMessages);
+        let adopted = 0;
+        let skipped = 0;
+        let settled = 0;
+        let running = 0;
+        // The split is counted per candidate, so the trajectory says how many of the leftovers were
+        // still work and how many were already history.  An already-registered row is tallied from
+        // its own record — it is still part of what this transcript names.
+        const tally = (r) => {
+            if (r.state === "running")
+                running++;
+            else
+                settled++;
+        };
+        for (const cand of candidates) {
+            const sid = cand.sessionID;
+            if (!sid || sid === parent) {
+                skipped++;
+                continue;
+            }
+            const known = children.get(sid);
+            if (known) {
+                skipped++;
+                if (!only || only.has(sid))
+                    tally(known);
+                continue;
+            }
+            if (only && !only.has(sid)) {
+                skipped++;
+                continue;
+            }
+            const gate = await parentageOf(sid, parent, directory);
+            if (!gate.ok) {
+                skipped++;
+                log({ step_id: "join", event: "adopt_history_refused", child: sid, reason: "parentage" });
+                continue;
+            }
+            const hostAgent = gate.agent.trim().toLowerCase();
+            // T3: this registry never carries a lead, whatever a stale transcript says.
+            const agent = hostAgent && !sameAgent(hostAgent, leadAgent) ? hostAgent : "subagent";
+            const rec = {
+                sessionID: sid,
+                agent,
+                label: cand.label || "host child",
+                parentSessionID: parent,
+                // Our discovery moment — never the run's start.  Replaced below by the host's own
+                // `time.created` when it answers with one; until then the row reports 时长未知.
+                startedAt: now(),
+                startedAtUnknown: true,
+                state: "running",
+                via: "host-injection",
+            };
+            // ASK THE HOST FIRST, for every candidate.  The transcript proves a dispatch existed; it
+            // does not decide whether the run is over — the host's `time.idle` does.  A 1.8.7 live
+            // session read three `state="error"` envelopes as verdicts and reported 0 运行中 / 3 失败
+            // while the host's UI still showed two children running.
+            const st = await readHostSessionState(api, sid);
+            if (st.createdAt !== undefined) {
+                // The host's own start: the only clock a duration may be derived from.
+                rec.hostCreatedAt = st.createdAt;
+                rec.startedAt = st.createdAt;
+                rec.startedAtUnknown = false;
+            }
+            if (st.idleAt) {
+                rec.state = "idle";
+                rec.finishedAt = st.idleAt;
+                rec.hostIdleAt = st.idleAt;
+                rec.settleSource = "session-get";
+                if (st.outcome)
+                    rec.outcome = st.outcome;
+            }
+            else if (st.answered) {
+                // Answered, and no finished run on record → still running.  No `time.created` means no
+                // duration; the row says so rather than counting from our discovery moment.
+            }
+            else if (cand.state === "completed" || cand.state === "error") {
+                // The per-session read could not answer: the envelope is the only evidence left, and
+                // the row is marked so the lead can see whose word this is.
+                rec.historyInferred = true;
+                rec.settleSource = "injection";
+                if (cand.state === "completed") {
+                    rec.state = "idle";
+                }
+                else {
+                    rec.state = "error";
+                    rec.error = "宿主注入信封报告 state=error（正文随注入消息送达）";
+                }
+            }
+            // A candidate that is already finished leaves the LIVE table (it cannot be running) and
+            // becomes a count.  `owned` still returns it when the lead names it with `ids`.
+            if (rec.state !== "running")
+                rec.historySettled = true;
+            tally(rec);
+            children.set(sid, rec);
+            deps.onChildSession?.(sid, agent);
+            adopted++;
+            log({ step_id: "join", event: "adopt", child: sid, agent, state: rec.state, source: "parent-history" });
+        }
+        // One summary row per call: the counters are what makes "I looked and there was
+        // nothing" distinguishable from "I never looked" in the trajectory — and `settled` /
+        // `running` are what makes "the transcript named them" distinguishable from "they are
+        // live work".
+        log({
+            step_id: "join",
+            event: "adopt_history",
+            candidates: candidates.length,
+            adopted,
+            skipped,
+            settled,
+            running,
+            source: "parent-history",
+        });
+        const why = !candidates.length
+            ? "父会话历史里没有子代理派发记录（既没有后台 ack，也没有 <subagent> 信封；历史若被压缩过，这条也不算数）"
+            : adopted
+                ? ""
+                : `父会话历史里 ${candidates.length} 个候选都没能认领（${skipped} 个已登记或宿主未确认归属）`;
+        return { adopted, looked: true, candidates: candidates.length, skipped, settled, running, why };
+    }
     /** Claim ONE explicitly named child of the calling session — the host's own
      *  `task` child included, which `adoptFromHost` must never pick up on its
      *  own.  The lock is the host's parentage (`parentID === the caller`), read
@@ -1085,7 +1439,8 @@ export function buildDispatchTools(deps) {
 - { 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.  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.  已受理 means the host took the line into that inbox — NOT that the child read or obeyed it.  After a successful steer the tool re-reads that inbox ONCE: an item gone from the pending list is reported 已送达, still pending is 已受理（未送达，宿主在步边界投递）, and an inbox it cannot read is 已受理（未验证送达）— delivery is never inferred from the write alone, and none of the three means the child followed it.  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.
+- 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 on a host with no \`session.children\` the children your own transcript still names — the background ACK \`(sessionID: ses_…)\` and the \`<subagent sessionID="…" state="…">\` envelope — are claimed after the host confirms their parentage.  Their STATE is the host's \`session.get\`: no \`time.idle\` means still RUNNING, whatever an old envelope in the transcript says.  One that answered while nobody was listening is not lost — it stops being a table row (only children that can still be running are listed) and is counted as \`另有 N 条已结算的历史子代理\`; name it with \`ids\` to get that row and its body back.
+- Background SHELLS the host announced in this session are reported at the end of every reply (\`后台 shell：N 个\`), with the running ones named as still running.  Nothing is killed by this tool: re-run a shell only if a completed one failed, and never dispatch the same work again while one is still running.
 - 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)" },
@@ -1135,9 +1490,43 @@ export function buildDispatchTools(deps) {
                 if (settling.size)
                     await Promise.allSettled([...settling]);
                 const directory = typeof c.directory === "string" && c.directory ? c.directory : undefined;
+                // Read the CALLER's own transcript ONCE per call: it is the floor recovery source
+                // when the host has no `session.children`, and the only place a background shell is
+                // ever announced.  In-process on v2 (`ctx.session.context`), one hop on v1.
+                const parentHistory = await readParentMessages(parent, directory);
+                // Shells are REPORTED, never claimed: they are the host's processes, and this tool
+                // only exists to keep the lead from re-dispatching what is already running.
+                const shellSection = parentHistory.ok
+                    ? renderBackgroundShells(backgroundShellsFromParentHistory(parentHistory.data))
+                    : null;
                 const idList = parseIdList(args.ids);
                 const idFilter = idList && idList.length ? new Set(idList) : null;
-                const owned = () => [...children.values()].filter((r) => (!parent || r.parentSessionID === parent) && (!idFilter || idFilter.has(r.sessionID)));
+                const owned = () => [...children.values()].filter((r) => (!parent || r.parentSessionID === parent) &&
+                    (!idFilter || idFilter.has(r.sessionID)) &&
+                    // A settled HISTORY row is a count, not a table row — the table answers "what can
+                    // still be running".  Naming it with `ids` is the documented way to re-read it,
+                    // so an explicit filter always includes it.
+                    (!r.historySettled || Boolean(idFilter)));
+                /** Settled history rows this session knows about, minus the ones the lead NAMED (those
+                 *  are rendered as rows instead).  Reported as ONE line, never as N rows: 26 finished
+                 *  history children used to bury the single live one. */
+                const historySettledCount = () => {
+                    let n = 0;
+                    for (const r of children.values()) {
+                        if (!r.historySettled)
+                            continue;
+                        if (parent && r.parentSessionID !== parent)
+                            continue;
+                        if (idFilter?.has(r.sessionID))
+                            continue;
+                        n++;
+                    }
+                    return n;
+                };
+                const historyLine = () => {
+                    const n = historySettledCount();
+                    return n ? `另有 ${n} 条已结算的历史子代理（正文可用 ids 取回）。` : "";
+                };
                 let mine = owned();
                 // Whether we got to LOOK at the host's tree, and what it said — the empty
                 // answer must not claim "there is nothing to adopt" on a host we cannot
@@ -1153,6 +1542,24 @@ export function buildDispatchTools(deps) {
                     adoption = await adoptFromHost(parent, directory, idFilter);
                     if (adoption.adopted)
                         mine = owned();
+                    // Second recovery source, for the host that has no `session.children` at all
+                    // (measured 2.1.4): the parent transcript still names its children.  Only asked
+                    // when the tree walk did not settle the question — never instead of it.
+                    if (mine.length < (idFilter ? idFilter.size : 1)) {
+                        const hist = parentHistory.ok
+                            ? await adoptFromParentHistory(parent, parentHistory.data, directory, idFilter)
+                            : { adopted: 0, looked: false, candidates: 0, skipped: 0, settled: 0, running: 0, why: parentHistory.why };
+                        if (hist.adopted)
+                            mine = owned();
+                        // The `why` has to keep the three states apart: a children API that looked, no
+                        // children API but the history claimed something, and neither source yielding a
+                        // child.  Fusing them is the overstatement this path was built to stop.
+                        adoption = {
+                            adopted: adoption.adopted + hist.adopted,
+                            looked: adoption.looked,
+                            why: [adoption.why, hist.why].filter(Boolean).join("；"),
+                        };
+                    }
                     // Plan B: a NAMED id may be the host's own `task` child (no ·tm
                     // marker, so the tree walk above never claims it).  Collecting it is
                     // how the lead reads back a result we replaced with a pointer — the
@@ -1216,7 +1623,7 @@ export function buildDispatchTools(deps) {
                     }
                     const row = children.get(target);
                     const rowLine = row
-                        ? renderChildLine(row, (row.finishedAt ?? now()) - row.startedAt)
+                        ? renderChildLine(row, elapsedOf(row, now()))
                         : `${target} · ${gate.agent} ·（本进程没有它的登记行，归属由宿主确认）`;
                     if (steerText) {
                         // A steer into a session that is not running is a WAKE, not an interjection:
@@ -1409,7 +1816,15 @@ export function buildDispatchTools(deps) {
                         // the transcript, and the honest reason is that a synchronous host
                         // task never enters this registry at all.
                         `如果你用的是同步 \`task\`：宿主自己就把结果收回来了，它从不登记在这里，这不是派发失败。` +
-                        `只有后台 \`task {background:true}\`（或显式带 ids）需要 tm_join 来取。`);
+                        `只有后台 \`task {background:true}\`（或显式带 ids）需要 tm_join 来取。` +
+                        // A round whose leftovers are ALL settled is still not empty: they are history,
+                        // and the lead must know they exist (and how to read them) without the whole
+                        // table being dumped again.
+                        (historyLine() ? `\n\n${historyLine()}` : "") +
+                        // A round with no collectable CHILD is still not an empty round when the host
+                        // has shell commands in flight: the user can see them and the lead cannot, so
+                        // silence here is what produced a duplicate dispatch.
+                        (shellSection ? `\n\n${shellSection}` : ""));
                 }
                 await settleAdopted(mine, directory);
                 const waitMs = Math.max(0, Math.min(maxWaitMs, Number(args.waitMs) || 0));
@@ -1530,7 +1945,10 @@ export function buildDispatchTools(deps) {
                 const header = [
                     `派发汇总：${sums.idle} 完成 / ${sums.running} 运行中 / ${sums.error} 失败${settled ? "（全部已结算）" : `（未等到全部结算 · 本次已等 ${Math.round((now() - waitStart) / 1000)}s）`}`,
                     ...(settleLine ? [settleLine] : []),
-                    ...mine.map((r) => renderChildLine(r, (r.finishedAt ?? now()) - r.startedAt)),
+                    // Just under the summary: the settled HISTORY rows, as one count.  Their bodies are
+                    // still reachable with `ids`, which is exactly what the line promises.
+                    ...(historyLine() ? [historyLine()] : []),
+                    ...mine.map((r) => renderChildLine(r, elapsedOf(r, now()))),
                 ];
                 // 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
@@ -1691,7 +2109,7 @@ export function buildDispatchTools(deps) {
                 // 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 body = [...header, ...(blocks.length ? ["", blocks.join("\n")] : []), ...(shellSection ? ["", shellSection] : [])].join("\n");
                 const stepId = deps.pipelines.nextStepId();
                 return toToolResult(await deps.pipelines.govern(stepId, tool, body, {
                     contentType: detectContentType(body),
@@ -1734,7 +2152,10 @@ export function buildDispatchTools(deps) {
                     child: child.sessionID,
                     agent: child.agent,
                     ...(st.outcome ? { outcome: st.outcome } : {}),
-                    ms: st.idleAt - child.startedAt,
+                    ...(() => {
+                        const ms = elapsedOf(child, st.idleAt);
+                        return ms === null ? {} : { ms };
+                    })(),
                 });
                 continue;
             }
@@ -1761,7 +2182,8 @@ export function buildDispatchTools(deps) {
             child.state = "idle";
             child.finishedAt = now();
             child.settleSource = "parent-idle";
-            log({ step_id: "events", event: "idle_presumed", child: child.sessionID, agent: child.agent, ms: child.finishedAt - child.startedAt });
+            const ms = elapsedOf(child);
+            log({ step_id: "events", event: "idle_presumed", child: child.sessionID, agent: child.agent, ...(ms === null ? {} : { ms }) });
         }
     }
     const observeEvent = (event) => {
@@ -1811,7 +2233,8 @@ export function buildDispatchTools(deps) {
                 rec.state = "idle";
                 rec.finishedAt = now();
                 rec.settleSource = "event";
-                log({ step_id: "events", event: "idle", child: sid, agent: rec.agent, ms: (rec.finishedAt ?? 0) - rec.startedAt });
+                const ms = elapsedOf(rec);
+                log({ step_id: "events", event: "idle", child: sid, agent: rec.agent, ...(ms === null ? {} : { ms }) });
             }
             return;
         }
@@ -1870,7 +2293,8 @@ export function buildDispatchTools(deps) {
             rec.state = "idle";
         }
         rec.settleSource = "injection";
-        log({ step_id: "events", event: "idle_injection", child: rec.sessionID, agent: rec.agent, ms: rec.finishedAt - rec.startedAt });
+        const ms = elapsedOf(rec);
+        log({ step_id: "events", event: "idle_injection", child: rec.sessionID, agent: rec.agent, ...(ms === null ? {} : { ms }) });
         return true;
     }
     return {