@jini-ai/chat 0.6.6 → 0.6.7

package/dist/react/message-blocks.js

@@ -1,4 +1,84 @@
 import { assistantContentFromEvents, isReplyBoundary, legacyAssistantContentFromEvents } from '../core/index.js';
+/** Whether there is anything besides plain text to place: a tool row, an ext event, or (when asked
+ * for) non-blank thinking. With none of these the flat path is identical. */
+function hasSomethingToInterleave({ events, rows }, { includeThinking }) {
+    if (rows.length > 0)
+        return true;
+    return events.some((ev) => ev.kind === 'ext' || (includeThinking && ev.kind === 'thinking' && ev.text.trim() !== ''));
+}
+/** Whether `content` is demonstrably built from the text events. */
+function contentMatchesEvents({ events, content }) {
+    // Both producers' shapes count: today's (a paragraph break between steps, see
+    // `assistantContentFromEvents`) and the old plain concatenation older saved rows carry.
+    return content === assistantContentFromEvents({ events }) || content === legacyAssistantContentFromEvents({ events });
+}
+function flushText({ state }) {
+    if (state.buffer.length === 0)
+        return;
+    state.blocks.push({ kind: 'text', text: state.buffer, key: `text-${state.blocks.length}` });
+    state.buffer = '';
+}
+function placeThinking({ state, text }) {
+    flushText({ state });
+    const { blocks } = state;
+    const last = blocks[blocks.length - 1];
+    if (last && last.kind === 'thinking')
+        blocks[blocks.length - 1] = { kind: 'thinking', text: last.text + text, key: last.key };
+    else
+        blocks.push({ kind: 'thinking', text, key: `thinking-${blocks.length}` });
+}
+function placeReplyEnd({ state }) {
+    flushText({ state });
+    state.blocks.push({ kind: 'reply-end', index: state.replies, key: `reply-end-${state.replies}` });
+    state.replies += 1;
+}
+function placeExt({ state, ev }, { slotOf }) {
+    // One block per SLOT, at its first occurrence — later events in the same slot fold into it
+    // (`useExtEventGroups`'s job in `MessageRow.tsx`), not a second block. A slot is the `name`
+    // unless its renderer keys events into separate surfaces (see `ExtEventSlotKey`).
+    const slot = slotOf(ev);
+    if (state.emittedExtSlots.has(slot))
+        return;
+    state.emittedExtSlots.add(slot);
+    flushText({ state });
+    state.blocks.push({ kind: 'ext', name: ev.name, slot, key: `ext-${slot}` });
+}
+function placeToolUse({ state, id }) {
+    const row = state.rowById.get(id);
+    // A `tool_use` the timeline did not surface (deduped away as a repeat of one already seen).
+    // Skipping it keeps this function's output consistent with `rows`, which is the authority on
+    // what gets a card.
+    if (!row || state.emitted.has(id))
+        return;
+    state.emitted.add(id);
+    flushText({ state });
+    const { blocks } = state;
+    const last = blocks[blocks.length - 1];
+    if (last && last.kind === 'tools') {
+        blocks[blocks.length - 1] = { kind: 'tools', rows: [...last.rows, row], key: last.key };
+    }
+    else {
+        blocks.push({ kind: 'tools', rows: [row], key: `tools-${blocks.length}` });
+    }
+}
+function placeEvent({ state, ev }, { slotOf, includeThinking }) {
+    if (ev.kind === 'text') {
+        state.buffer += ev.text;
+        return;
+    }
+    if (ev.kind === 'thinking') {
+        if (includeThinking)
+            placeThinking({ state, text: ev.text });
+        return;
+    }
+    // Emitted per boundary, before any slot dedupe below, so every reply gets its own end marker.
+    if (isReplyBoundary({ event: ev }))
+        placeReplyEnd({ state });
+    if (ev.kind === 'ext')
+        placeExt({ state, ev }, { slotOf });
+    else if (ev.kind === 'tool_use')
+        placeToolUse({ state, id: ev.id });
+}
 /**
  * Rebuilds an assistant message as ordered blocks, or returns `null` if that cannot be done
  * losslessly.
@@ -17,85 +97,27 @@ import { assistantContentFromEvents, isReplyBoundary, legacyAssistantContentFrom
 export function interleaveMessageBlocks({ events, content, rows }, { slotOf = (ev) => ev.name, includeThinking = false } = {}) {
     if (!events || events.length === 0)
         return null;
-    const hasExtEvent = events.some((ev) => ev.kind === 'ext');
-    const hasThinking = includeThinking && events.some((ev) => ev.kind === 'thinking' && ev.text.trim() !== '');
-    if (rows.length === 0 && !hasExtEvent && !hasThinking)
+    if (!hasSomethingToInterleave({ events, rows }, { includeThinking }))
         return null;
     // The reconstruction is only trustworthy if the text events are demonstrably the source `content`
     // was built from. Anything else and the offsets below are fiction.
-    // Both producers' shapes count: today's (a paragraph break between steps, see
-    // `assistantContentFromEvents`) and the old plain concatenation older saved rows carry.
-    if (content !== assistantContentFromEvents({ events }) && content !== legacyAssistantContentFromEvents({ events: events }))
+    if (!contentMatchesEvents({ events, content }))
         return null;
-    const rowById = new Map(rows.map((row) => [row.id, row]));
-    const blocks = [];
-    const emitted = new Set();
-    const emittedExtSlots = new Set();
-    let buffer = '';
-    let replies = 0;
-    const flushText = () => {
-        if (buffer.length === 0)
-            return;
-        blocks.push({ kind: 'text', text: buffer, key: `text-${blocks.length}` });
-        buffer = '';
+    const state = {
+        rowById: new Map(rows.map((row) => [row.id, row])),
+        blocks: [],
+        emitted: new Set(),
+        emittedExtSlots: new Set(),
+        buffer: '',
+        replies: 0,
     };
-    for (const ev of events) {
-        if (ev.kind === 'text') {
-            buffer += ev.text;
-            continue;
-        }
-        if (ev.kind === 'thinking') {
-            if (!includeThinking)
-                continue;
-            flushText();
-            const last = blocks[blocks.length - 1];
-            if (last && last.kind === 'thinking')
-                blocks[blocks.length - 1] = { kind: 'thinking', text: last.text + ev.text, key: last.key };
-            else
-                blocks.push({ kind: 'thinking', text: ev.text, key: `thinking-${blocks.length}` });
-            continue;
-        }
-        if (isReplyBoundary({ event: ev })) {
-            // Emitted per boundary, before any slot dedupe below, so every reply gets its own end marker.
-            flushText();
-            blocks.push({ kind: 'reply-end', index: replies, key: `reply-end-${replies}` });
-            replies += 1;
-        }
-        if (ev.kind === 'ext') {
-            // One block per SLOT, at its first occurrence — later events in the same slot fold into it
-            // (`useExtEventGroups`'s job in `MessageRow.tsx`), not a second block. A slot is the `name`
-            // unless its renderer keys events into separate surfaces (see `ExtEventSlotKey`).
-            const slot = slotOf(ev);
-            if (emittedExtSlots.has(slot))
-                continue;
-            emittedExtSlots.add(slot);
-            flushText();
-            blocks.push({ kind: 'ext', name: ev.name, slot, key: `ext-${slot}` });
-            continue;
-        }
-        if (ev.kind !== 'tool_use')
-            continue;
-        const row = rowById.get(ev.id);
-        // A `tool_use` the timeline did not surface (deduped away as a repeat of one already seen).
-        // Skipping it keeps this function's output consistent with `rows`, which is the authority on
-        // what gets a card.
-        if (!row || emitted.has(ev.id))
-            continue;
-        emitted.add(ev.id);
-        flushText();
-        const last = blocks[blocks.length - 1];
-        if (last && last.kind === 'tools') {
-            blocks[blocks.length - 1] = { kind: 'tools', rows: [...last.rows, row], key: last.key };
-        }
-        else {
-            blocks.push({ kind: 'tools', rows: [row], key: `tools-${blocks.length}` });
-        }
-    }
-    flushText();
+    for (const ev of events)
+        placeEvent({ state, ev }, { slotOf, includeThinking });
+    flushText({ state });
     // Every row must have found its place. If one did not, the message would render with a tool card
     // missing entirely — strictly worse than the flat layout it would have had.
-    if (emitted.size !== rows.length)
+    if (state.emitted.size !== rows.length)
         return null;
-    return blocks;
+    return state.blocks;
 }
 //# sourceMappingURL=message-blocks.js.map

package/dist/react/slots.d.ts

@@ -179,8 +179,8 @@ export interface ComposerSlots {
      * Host controls rendered at the START of the footer row, immediately after the attach/discovery
      * "+" trigger — for a control that belongs with the composer's other action-row buttons (e.g. a
      * push-to-talk mic button) rather than in {@link leadingAccessories}'s pinned-context zone above
-     * the input, or in {@link footerAccessories}'s trailing slot (reserved for an agent/model picker
-     * and pushed to the row's far end via `margin-left: auto`).
+     * the input, or in {@link footerAccessories}'s slot (reserved for an agent/model picker, which
+     * follows this one; only the send group is pushed to the row's far end).
      */
     footerLeadingAccessory?: ReactNode;
     onAttach?: (a: ChatAttachment) => void;

package/dist/react/tool-call-display.js

@@ -30,34 +30,36 @@ function isRunningToolRow(row) {
 export function applyToolCallDisplay({ blocks, mode }) {
     if (mode === 'show')
         return blocks;
-    if (mode === 'hidden') {
-        const out = [];
-        for (const block of blocks) {
-            if (block.kind !== 'tools') {
-                out.push(block);
-                continue;
-            }
-            const failed = block.rows.filter((row) => isFailedToolRow({ row }));
-            if (failed.length > 0)
-                out.push({ kind: 'tools', rows: failed, key: block.key });
+    return mode === 'hidden' ? hideToolCalls({ blocks }) : collapseToolCalls({ blocks });
+}
+/** `'hidden'`: keeps only failed rows and drops `tools` blocks left empty. */
+function hideToolCalls({ blocks }) {
+    const out = [];
+    for (const block of blocks) {
+        if (block.kind !== 'tools') {
+            out.push(block);
+            continue;
         }
-        return out;
+        const failed = block.rows.filter((row) => isFailedToolRow({ row }));
+        if (failed.length > 0)
+            out.push({ kind: 'tools', rows: failed, key: block.key });
     }
+    return out;
+}
+/** `'collapsed'`: merges every `tools` block of a turn into the turn's first one (see above). */
+function collapseToolCalls({ blocks }) {
     const out = [];
     let turnToolsIndex = -1;
     for (const block of blocks) {
         if (block.kind === 'reply-end')
             turnToolsIndex = -1;
-        if (block.kind !== 'tools') {
-            out.push(block);
-            continue;
-        }
         const first = turnToolsIndex === -1 ? undefined : out[turnToolsIndex];
-        if (first && first.kind === 'tools') {
+        if (block.kind === 'tools' && first?.kind === 'tools') {
             out[turnToolsIndex] = { kind: 'tools', rows: [...first.rows, ...block.rows], key: first.key };
             continue;
         }
-        turnToolsIndex = out.length;
+        if (block.kind === 'tools')
+            turnToolsIndex = out.length;
         out.push(block);
     }
     return out;

package/dist/server/durable-runs/recover.js

@@ -7,6 +7,33 @@ export { RECOVERY_LIMIT, RECOVERY_WINDOW_MS, RUN_STALENESS_MS, SAVED_WORK_NOTICE
 // translateRunFrame saves a run error frame as a status label holding only its message: the
 // daemon's MCP_BRIDGE_UNAVAILABLE code is dropped, so the bridge failure is matched by its text.
 const MCP_BRIDGE_FAILURE = /The assistant's tools did not load \(MCP bridge "jini" status: [^\r\n]*/;
+const STOPPED_NOTICE = "Stopped. Saved work is above.";
+/** Index of the last event matching `match`, or -1.
+ * @complexity O(e) time, O(1) space, no effects. */
+function lastIndexWhere({ events, match }, _optional = {}) {
+    // Reverse scan preserves the last-marker rule on the desktop's ES2022 target.
+    for (let index = events.length - 1; index >= 0; index--)
+        if (match(events[index]))
+            return index;
+    return -1;
+}
+/** One saved event's contribution to the executor diagnostics. */
+function diagnosticLines({ event }, _optional = {}) {
+    if (event.kind === "status")
+        return [event.label, event.detail ?? ""];
+    if (event.kind !== "raw")
+        return [];
+    try {
+        const result = JSON.parse(event.line);
+        // Successful CLI summaries contain usage metadata and answer prose, not failure evidence.
+        if (result?.type === "result" && result.is_error === false)
+            return [];
+    }
+    catch {
+        // Non-JSON stdout can still contain the executor's failure reason.
+    }
+    return [event.line];
+}
 /** Retryability is independent of session resumability. Inspect executor diagnostics, never
  * answer text or tool results: those can quote unrelated failures from completed work. Old
  * attempt diagnostics remain visible but cannot decide the fate of their continuation. */
@@ -14,55 +41,36 @@ function attemptDiagnostics({ run }, _optional = {}) {
     const events = run.message.events ?? [];
     // Checkpoints merge adjacent text, so a base's event count is not a durable offset. The
     // coordinator's recovery marker separates attempts and survives that compaction.
-    let marker = -1;
-    // Reverse scan preserves the last-marker rule on the desktop's ES2022 target.
-    for (let index = run.attemptBase.length ? events.length - 1 : -1; index >= 0; index--) {
-        const event = events[index];
-        if (event.kind === "status" && event.code === "run_recovering") {
-            marker = index;
-            break;
-        }
-    }
-    return events.slice(marker >= 0 ? marker + 1 : run.attemptBase.length).flatMap((event) => {
-        if (event.kind === "status")
-            return [event.label, event.detail ?? ""];
-        if (event.kind !== "raw")
-            return [];
-        try {
-            const result = JSON.parse(event.line);
-            // Successful CLI summaries contain usage metadata and answer prose, not failure evidence.
-            if (result?.type === "result" && result.is_error === false)
-                return [];
-        }
-        catch {
-            // Non-JSON stdout can still contain the executor's failure reason.
-        }
-        return [event.line];
-    }).join("\n");
+    const marker = run.attemptBase.length
+        ? lastIndexWhere({ events, match: (event) => event.kind === "status" && event.code === "run_recovering" })
+        : -1;
+    return events.slice(marker >= 0 ? marker + 1 : run.attemptBase.length).flatMap((event) => diagnosticLines({ event })).join("\n");
 }
-function attemptFailure(run) {
-    const diagnostics = attemptDiagnostics({ run }, {});
+/** Quota/billing and bad requests need human repair. A 429 for rate throttling and a 5xx
+ * overload remain retryable; the provider's coarse RATE_LIMITED class also includes billing. */
+function needsHumanRepair({ diagnostics }, _optional = {}) {
+    const requestStatuses = diagnostics.matchAll(/\b(?:http(?:[ /]?\d(?:\.\d)?)?|(?:status|error|response)(?:[ _-]?code)?|code(?=\s*[:=#]))[\s:=#-]*(4\d\d)\b/gi);
+    if ([...requestStatuses].some((match) => match[1] !== "408" && match[1] !== "429"))
+        return true;
+    return /another answer in this chat is still running|invalid[_ -]?request|context[_ -](length|window)|maximum context|model.*(?:not[_ -]found|does not exist|not supported)|unsupported|does not support|permission denied|forbidden|insufficient[_ -]?(quota|balance|credit|funds)|credit balance is too low|exceeded your current quota|quota[_ -]?exceeded|usage limit|billing|payment required/i.test(diagnostics);
+}
+function attemptFailure({ diagnostics }, _optional = {}) {
     // MCP_BRIDGE_UNAVAILABLE needs bridge repair; another attempt repeats the same failure.
     // Classify it before interpreting the bridge's stderr as an agent auth/watchdog failure.
     if (MCP_BRIDGE_FAILURE.test(diagnostics))
         return "permanent";
     if (/inactivity[_ -]?(timeout|watchdog)|watchdog.*(kill|stop)/i.test(diagnostics))
         return "inactivity-watchdog";
-    const service = classifyAgentServiceFailure({ text: diagnostics });
-    if (service === "AGENT_AUTH_REQUIRED")
+    if (classifyAgentServiceFailure({ text: diagnostics }) === "AGENT_AUTH_REQUIRED")
         return "auth-failure";
-    // Quota/billing and bad requests need human repair. A 429 for rate throttling and a 5xx
-    // overload remain retryable; the provider's coarse RATE_LIMITED class also includes billing.
-    const requestStatuses = diagnostics.matchAll(/\b(?:http(?:[ /]?\d(?:\.\d)?)?|(?:status|error|response)(?:[ _-]?code)?|code(?=\s*[:=#]))[\s:=#-]*(4\d\d)\b/gi);
-    if ([...requestStatuses].some((match) => match[1] !== "408" && match[1] !== "429"))
-        return "permanent";
-    if (/another answer in this chat is still running|invalid[_ -]?request|context[_ -](length|window)|maximum context|model.*(?:not[_ -]found|does not exist|not supported)|unsupported|does not support|permission denied|forbidden|insufficient[_ -]?(quota|balance|credit|funds)|credit balance is too low|exceeded your current quota|quota[_ -]?exceeded|usage limit|billing|payment required/i.test(diagnostics))
-        return "permanent";
-    return "retryable";
+    return needsHumanRepair({ diagnostics }) ? "permanent" : "retryable";
 }
 /** Keep the notice bounded and scoped to the same executor diagnostics as failure classification. */
+function lastDiagnosticLine({ diagnostics }, _optional = {}) {
+    return diagnostics.split(/\r?\n/).map((line) => line.trim()).filter(Boolean).at(-1)?.slice(0, 300);
+}
 function attemptFailureDetail({ run }, _optional = {}) {
-    return attemptDiagnostics({ run }, {}).split(/\r?\n/).map((line) => line.trim()).filter(Boolean).at(-1)?.slice(0, 300);
+    return lastDiagnosticLine({ diagnostics: attemptDiagnostics({ run }) });
 }
 function exclusion(run) {
     if (run.cancelReason)
@@ -71,15 +79,48 @@ function exclusion(run) {
         return "excluded";
     return null;
 }
+/** Preflight cards precede model tools, so the normal open-tool activity scan cannot see them.
+ * Chat saves the bare resource without its wire toolUseId. Saved consent or subsequent model
+ * execution closes this preflight wait, including cards saved before this fix.
+ * A model tool closes the wait and no later card can reopen it, so the wait is pending exactly
+ * when no tool ran and the last card follows the last consent for this conversation.
+ * @complexity O(e) time, O(1) space, no effects.
+ */
+function awaitingAnswer({ run }, _options = {}) {
+    if (isAwaitingAnswer({ events: run.message.events }))
+        return true;
+    const events = run.message.events ?? [];
+    if (events.some((event) => event.kind === "tool_use"))
+        return false;
+    const card = lastIndexWhere({ events, match: (event) => event.kind === "ext" && event.name === "mcp-ui" });
+    const consent = lastIndexWhere({ events, match: (event) => event.kind === "ext" && event.name === "agent_plugins"
+            && event.data?.conversationId === run.conversationId });
+    return card > consent;
+}
 function budgetNotice(run, now) {
     if (now - run.lastProgressAt >= RUN_STALENESS_MS)
-        return isAwaitingAnswer({ events: run.message.events }) ? AWAITING_ANSWER_NOTICE : SAVED_WORK_NOTICE;
+        return awaitingAnswer({ run }) ? AWAITING_ANSWER_NOTICE : SAVED_WORK_NOTICE;
     if (run.recoveryCount >= RECOVERY_LIMIT)
         return EXHAUSTED_NOTICE;
     if (run.recoveryDeadline !== null && now >= run.recoveryDeadline)
         return EXHAUSTED_NOTICE;
     return null;
 }
+/** The exhausted notice's detail: the attempt's last diagnostic, else which budget ended. */
+function exhaustedDetail({ run }, _optional = {}) {
+    return attemptFailureDetail({ run }) ?? (run.recoveryCount >= RECOVERY_LIMIT ? `Tried ${RECOVERY_LIMIT} times` : "Recovery window ended");
+}
+/** Saved work to carry into the next attempt, seeding the saved content when no text event holds it. */
+function savedWork({ run }, _optional = {}) {
+    const saved = [...(run.message.events ?? [])];
+    if (!saved.some((event) => event.kind === "text") && run.message.content)
+        saved.unshift({ kind: "text", text: run.message.content });
+    return saved;
+}
+/** A dead attempt continues now; a fresh queued one waits (see the caller's comment). */
+function continuesNow({ run, probe, trigger, now }, _optional = {}) {
+    return probe === "dead" && (trigger === "attempt-failed" || now - run.attemptStartedAt >= 10_000);
+}
 /** Recovery coordinator behind explicit host ports. One CAS owns both the attempt and its conversation slot.
  * Each recovery decision logs one `logger.info` line (default console) of run metadata. */
 export function createDurableRecovery(ports, { logger = console } = {}) {
@@ -98,6 +139,16 @@ export function createDurableRecovery(ports, { logger = console } = {}) {
             return false;
         return ports.verifyChildDead(run.child, {}).catch(() => false);
     }
+    async function launchNext({ run, next, native }, _optional = {}) {
+        try {
+            await ports.launch({ run: next, request: continuationRequest({ run: { ...run, message: next.message, transcript: next.transcript }, native }, {}) }, {});
+            await ports.store.recoveryClock({ runId: next.runId, now: ports.now(), active: false }, {});
+        }
+        catch {
+            // A rejected/lost start response is uncertain: the daemon may already be executing. The
+            // same idempotent attempt is probed by the attached watcher before another CAS is possible.
+        }
+    }
     async function continueDead(run) {
         await ports.cancelAttempt(run, {}).catch(() => undefined);
         // A locator captured before a hard cancel can outlive its rollout. Reuse reconstruction,
@@ -105,10 +156,7 @@ export function createDurableRecovery(ports, { logger = console } = {}) {
         const missingResume = run.request.agentId === 'codex' && /no rollout found for thread id/.test(attemptDiagnostics({ run }, {}));
         const native = !missingResume && await nativeAllowed(run);
         const nextRunId = ports.mintRunId();
-        const saved = [...(run.message.events ?? [])];
-        if (!saved.some((event) => event.kind === "text") && run.message.content)
-            saved.unshift({ kind: "text", text: run.message.content });
-        const events = recoveredRunEvents({ saved }, { notice: missingResume ? 'silent' : 'visible' });
+        const events = recoveredRunEvents({ saved: savedWork({ run }) }, { notice: missingResume ? 'silent' : 'visible' });
         if (!await ports.store.advance({ run, nextRunId, now: ports.now(), events }, {}))
             return "superseded";
         const next = await ports.store.load({ messageId: run.messageId }, {});
@@ -117,41 +165,46 @@ export function createDurableRecovery(ports, { logger = console } = {}) {
         if (!next || next.runId !== nextRunId)
             return "superseded";
         if (next.cancelReason)
-            return finalize(next, "Stopped. Saved work is above.", { canceled: true });
-        try {
-            await ports.launch({ run: next, request: continuationRequest({ run: { ...run, message: next.message, transcript: next.transcript }, native }, {}) }, {});
-            await ports.store.recoveryClock({ runId: next.runId, now: ports.now(), active: false }, {});
-        }
-        catch {
-            // A rejected/lost start response is uncertain: the daemon may already be executing. The
-            // same idempotent attempt is probed by the attached watcher before another CAS is possible.
-        }
+            return finalize(next, STOPPED_NOTICE, { canceled: true });
+        await launchNext({ run, next, native });
         ports.attach(next, {});
         return "continued";
     }
-    async function decide(run, trigger, liveRunId, seen) {
-        if (exclusion(run))
-            return finalize(run, "Stopped. Saved work is above.", { canceled: true });
+    async function probeAttempt({ run, trigger, liveRunId }, _optional = {}) {
         // A terminal executor end confirms this attempt is dead even when the daemon retains its
         // replayable record (HTTP 200). Other triggers must obtain fresh liveness evidence.
-        const probe = seen.probe = trigger === "attempt-failed" ? "dead" : liveRunId === run.runId ? "live" : await ports.probe(run, {});
-        if (probe === "live") {
-            await ports.store.recoveryClock({ runId: run.runId, now: ports.now(), active: false }, {});
-            ports.attach(run, {});
-            return "reattached";
-        }
+        if (trigger === "attempt-failed")
+            return "dead";
+        return liveRunId === run.runId ? "live" : ports.probe(run, {});
+    }
+    async function reattach(run) {
+        await ports.store.recoveryClock({ runId: run.runId, now: ports.now(), active: false }, {});
+        ports.attach(run, {});
+        return "reattached";
+    }
+    async function finalizeFailure({ run, failure, diagnostics }, _optional = {}) {
+        if (failure !== "permanent")
+            return finalize(run, failure === "auth-failure" ? "Not logged in. Saved work is above." : STOPPED_NOTICE, { canceled: true });
+        // A bridge failure shows its own reason (and stderr): the generic notice hides what needs repair.
+        const bridgeNotice = diagnostics.match(MCP_BRIDGE_FAILURE)?.[0];
+        return finalize(run, bridgeNotice ?? EXHAUSTED_NOTICE, { detail: bridgeNotice ? undefined : lastDiagnosticLine({ diagnostics }) });
+    }
+    async function decide(run, trigger, liveRunId) {
+        if (exclusion(run))
+            return { decision: await finalize(run, STOPPED_NOTICE, { canceled: true }) };
+        const probe = await probeAttempt({ run, trigger, liveRunId });
+        if (probe === "live")
+            return { probe, decision: await reattach(run) };
+        // A pending human answer takes precedence over executor exit diagnostics.
+        if (probe === "dead" && awaitingAnswer({ run }))
+            return { probe, decision: await resolveMissing(run, probe, trigger) };
         // Diagnostics decide only the fate of an attempt that is no longer running. Read before the
         // probe, raw stdout quoting a tool description ("OAuth-authenticated") canceled a live turn
         // as "Not logged in" (luvira, 2026-10-08).
-        const failure = seen.failure = attemptFailure(run);
-        if (failure === "auth-failure" || failure === "inactivity-watchdog")
-            return finalize(run, failure === "auth-failure" ? "Not logged in. Saved work is above." : "Stopped. Saved work is above.", { canceled: true });
-        // A bridge failure shows its own reason (and stderr): the generic notice hides what needs repair.
-        if (failure === "permanent") {
-            const bridgeNotice = attemptDiagnostics({ run }, {}).match(MCP_BRIDGE_FAILURE)?.[0];
-            return finalize(run, bridgeNotice ?? EXHAUSTED_NOTICE, { detail: bridgeNotice ? undefined : attemptFailureDetail({ run }, {}) });
-        }
-        return resolveMissing(run, probe, trigger);
+        const diagnostics = attemptDiagnostics({ run });
+        const failure = attemptFailure({ diagnostics });
+        const decision = failure === "retryable" ? await resolveMissing(run, probe, trigger) : await finalizeFailure({ run, failure, diagnostics });
+        return { probe, failure, decision };
     }
     async function resolveMissing(run, probe, trigger) {
         await ports.store.recoveryClock({ runId: run.runId, now: ports.now(), active: true }, {});
@@ -160,16 +213,16 @@ export function createDurableRecovery(ports, { logger = console } = {}) {
         // a newer attempt committed by another caller while this one was awaiting storage/HTTP.
         if (timed.runId !== run.runId)
             return "superseded";
+        // A dead process cannot resume its question. End this turn with the existing card intact,
+        // rather than minting an attempt that runs preflight and asks the same question again.
+        if (probe === "dead" && awaitingAnswer({ run: timed }))
+            return finalize(timed, AWAITING_ANSWER_NOTICE);
         const notice = budgetNotice(timed, ports.now());
-        if (notice) {
-            const detail = notice === EXHAUSTED_NOTICE
-                ? attemptFailureDetail({ run: timed }, {}) ?? (timed.recoveryCount >= RECOVERY_LIMIT ? `Tried ${RECOVERY_LIMIT} times` : "Recovery window ended")
-                : undefined;
-            return finalize(run, notice, { detail });
-        }
+        if (notice)
+            return finalize(run, notice, { detail: notice === EXHAUSTED_NOTICE ? exhaustedDetail({ run: timed }) : undefined });
         // A queued attempt may be between durable acceptance and the daemon's start transaction.
         // Give that idempotent launch time to appear before a 404 can advance its generation.
-        if (probe === "dead" && (trigger === "attempt-failed" || ports.now() - run.attemptStartedAt >= 10_000))
+        if (continuesNow({ run, probe, trigger, now: ports.now() }))
             return continueDead(timed);
         ports.attach(run, {});
         return "waiting";
@@ -183,12 +236,11 @@ export function createDurableRecovery(ports, { logger = console } = {}) {
                 return "terminal";
             if (expectedRunId && expectedRunId !== run.runId)
                 return "superseded";
-            const seen = {};
-            const decision = await decide(run, trigger, options.liveRunId, seen);
+            const { decision, probe, failure } = await decide(run, trigger, options.liveRunId);
             // The watcher re-confirms its own live run every resolution window; log only real recovery
             // decisions. Metadata only: diagnostics, answers and cancel reasons can hold secrets.
             if (options.liveRunId !== run.runId)
-                logger.info("[durable-recovery] " + JSON.stringify({ runId: run.runId, trigger, probe: seen.probe, decision, failureClass: seen.failure }));
+                logger.info("[durable-recovery] " + JSON.stringify({ runId: run.runId, trigger, probe, decision, failureClass: failure }));
             return decision;
         },
     };

package/dist/server/run-finalizer/entry.js

@@ -1,5 +1,9 @@
 import { isTerminalRunStatus } from '../../core/messages.js';
 import { readSseFrames, runContentFromEvents, runEventsForSave, runInterruptedNotice, translateRunFrame } from '../../core/run-events/entry.js';
+/** An error frame keeps a later successful end from settling as a success. */
+function endStatus({ failed, terminal }, _optional = {}) {
+    return failed && terminal === "succeeded" ? "failed" : terminal;
+}
 /** Follow replayable run streams and save through atomic host ledger operations.
  * The host retains authorization, owner scope, kernel transactions, boot reconciliation, HTTP
  * credentials and excluded run-ID prefixes. Replay starts at zero; error-before-success and
@@ -22,11 +26,14 @@ export function createAssistantRunFinalizer(args, options = {}) {
         catch { /* The host owns reporting failures. */ }
     }
     const active = new Map();
-    async function settle(watch, status, events) {
-        watch.terminal = true;
+    function clearTrailing(watch) {
         if (watch.trailing)
             scheduler.cancel({ handle: watch.trailing.handle });
         watch.trailing = undefined;
+    }
+    async function settle(watch, status, events) {
+        watch.terminal = true;
+        clearTrailing(watch);
         await args.ledger.settle({
             conversationId: watch.conversationId,
             messageId: watch.messageId,
@@ -57,9 +64,7 @@ export function createAssistantRunFinalizer(args, options = {}) {
             }
             return;
         }
-        if (watch.trailing)
-            scheduler.cancel({ handle: watch.trailing.handle });
-        watch.trailing = undefined;
+        clearTrailing(watch);
         watch.checkpointedEvents = watch.events.length;
         watch.checkpointedAt = now();
         watch.checkpointPending = true;
@@ -77,29 +82,36 @@ export function createAssistantRunFinalizer(args, options = {}) {
             void checkpoint(watch);
         });
     }
-    async function readStream(watch) {
+    /** The connection's event body, or why it cannot be followed. Non-success bodies are cancelled. */
+    async function openStream(watch) {
         const response = await daemon.openEvents({ runId: watch.runId, principalId: watch.principalId });
-        if (response.status === 404 || !response.ok || !response.body) {
-            await response.body?.cancel().catch(() => undefined);
-            return response.status === 404 ? { kind: "gone" } : { kind: "dropped" };
-        }
+        if (response.ok && response.body)
+            return { kind: "open", body: response.body };
+        await response.body?.cancel().catch(() => undefined);
+        return response.status === 404 ? { kind: "gone" } : { kind: "dropped" };
+    }
+    async function consumeFrames(watch, body) {
         // Each connection replays the complete history, rather than appending duplicate deltas.
         watch.events = [];
         watch.failed = false;
         const carry = {};
-        for await (const frame of readSseFrames({ body: response.body })) {
+        for await (const frame of readSseFrames({ body })) {
             const outcome = translateRunFrame({ kind: frame.event, raw: frame.data, notices: args.notices }, { carry });
             watch.events.push(...outcome.events);
             if (outcome.error)
                 watch.failed = true;
             if (outcome.terminal) {
                 watch.terminal = true;
-                return { kind: "ended", status: watch.failed && outcome.terminal === "succeeded" ? "failed" : outcome.terminal };
+                return { kind: "ended", status: endStatus({ failed: watch.failed, terminal: outcome.terminal }) };
             }
             void checkpoint(watch);
         }
         return { kind: "dropped" };
     }
+    async function readStream(watch) {
+        const opened = await openStream(watch);
+        return opened.kind === "open" ? consumeFrames(watch, opened.body) : opened;
+    }
     async function follow(watch) {
         for (let attempt = 0; attempt <= maxReconnects; attempt += 1) {
             const result = await readStream(watch).catch(() => ({ kind: "dropped" }));
@@ -140,9 +152,7 @@ export function createAssistantRunFinalizer(args, options = {}) {
             })
                 .finally(() => {
                 watch.terminal = true;
-                if (watch.trailing)
-                    scheduler.cancel({ handle: watch.trailing.handle });
-                watch.trailing = undefined;
+                clearTrailing(watch);
                 active.delete(runId);
             });
             active.set(runId, { watch, done });