mixdog 0.9.92 → 0.9.93

package/src/runtime/agent/orchestrator/session/loop/stored-tool-args.mjs

@@ -59,6 +59,9 @@ function compactStoredToolArgString(value, key = '', opts = {}) {
     const isLong = isBody || STORED_TOOL_ARG_LONG_KEY_RE.test(key);
     const limit = isLong ? STORED_TOOL_ARG_LIMIT : Infinity;
     if (value.length <= limit) return value;
+    // A marker is about to replace verbatim text — report the mutation so
+    // sweep callers can tag the resulting prefix-cache break.
+    try { opts.onCompacted?.(); } catch { /* observability only */ }
     const hash = createHash('sha256').update(value).digest('hex').slice(0, 16);
     // Body markers carry the recovery instruction inline: the compaction
     // detectors only require the `[mixdog compacted ...]` shape (no ']' or
@@ -115,14 +118,19 @@ export function compactToolCallsForHistory(calls, opts = {}) {
 //     contract as restoreToolCallBodyForId);
 //   - a call with no result row yet (current batch / interrupted turn) is
 //     left untouched.
+// Returns true when at least one body was actually collapsed to a marker
+// (i.e. the transcript prefix changed), so callers can tag the intentional
+// cache break instead of logging an unexplained input_prefix_mismatch.
 export function compactSettledToolCallBodies(messages) {
-    if (!Array.isArray(messages)) return;
+    if (!Array.isArray(messages)) return false;
     const resultKinds = new Map();
     for (const message of messages) {
         if (message?.role === 'tool' && message.toolCallId) {
             resultKinds.set(message.toolCallId, message.toolKind || 'normal');
         }
     }
+    let changed = false;
+    const sweepOpts = { onCompacted: () => { changed = true; } };
     for (const message of messages) {
         if (message?.role !== 'assistant' || !Array.isArray(message.toolCalls)) continue;
         for (const call of message.toolCalls) {
@@ -130,9 +138,10 @@ export function compactSettledToolCallBodies(messages) {
             if (!call.arguments || typeof call.arguments !== 'object') continue;
             const kind = call.id ? resultKinds.get(call.id) : undefined;
             if (kind === undefined || kind === 'error') continue;
-            call.arguments = compactStoredToolArgValue(call.arguments);
+            call.arguments = compactStoredToolArgValue(call.arguments, '', 0, sweepOpts);
         }
     }
+    return changed;
 }
 
 // Restore retry-safe long command/script text for ONE failed tool call inside a

package/src/runtime/agent/orchestrator/session/loop/tool-classify.mjs

@@ -15,12 +15,11 @@ export function _isMutationTool(name) {
     const n = _stripMcpPrefix(name);
     return n === 'apply_patch';
 }
-// Side-effect-free read-only tools that stay parallel even after an earlier
-// ordered mutation failed in the same batch. Everything NOT in this set is
-// treated as ordered-gate-skippable (see _isOrderedGateSkippable): apply_patch,
-// shell/bash_session, write/edit-style tools, and any (non-mixdog) MCP tool
-// whose effects are unknown. Kept separate from _isMutationTool, which stays
-// apply_patch-only for epoch-mutation counting and eager-dispatch gating.
+// Side-effect-free read-only tools that may eager-start across an upcoming
+// apply_patch barrier and may keep running after an earlier patch fails.
+// Everything NOT in this set waits for its side-effect segment and is skipped
+// after a failed patch. Kept separate from _isMutationTool, which stays
+// apply_patch-only for epoch counting.
 const ORDERED_GATE_SAFE_READONLY_TOOLS = new Set([
     'read',
     'find',

package/src/runtime/agent/orchestrator/session/loop/tool-exec.mjs

@@ -226,8 +226,37 @@ export async function executeTool(name, args, cwd, callerSessionId, sessionRef,
         return result;
     }
     if (name === 'apply_patch') {
-        const patchArgs = typeof args === 'string' ? { patch: args } : args;
-        return executePatchTool(name, patchArgs, cwd, { sessionId: callerSessionId, toolCallId: executeOpts.toolCallId || null });
+        const patchArgs = typeof args === 'string' ? { patch: args } : { ...(args || {}) };
+        // post_shell: optional verification command executed through the normal
+        // one-shot shell path ONLY after the patch applies cleanly; a failed
+        // patch skips it. Patch text and shell output return as ONE tool
+        // result, so patch+verify costs a single call. Runtime-only knob:
+        // stripped before executePatchTool sees the args.
+        const postShell = typeof patchArgs.post_shell === 'string' && patchArgs.post_shell.trim()
+            ? patchArgs.post_shell.trim()
+            : null;
+        delete patchArgs.post_shell;
+        const patchResult = await executePatchTool(name, patchArgs, cwd, {
+            sessionId: callerSessionId,
+            toolCallId: executeOpts.toolCallId || null,
+        });
+        if (!postShell) return patchResult;
+        const patchNorm = normalizeToolEnvelope(patchResult);
+        const patchText = typeof patchNorm.result === 'string' ? patchNorm.result : String(patchNorm.result ?? '');
+        // Text-based failure detection only: legacy string returns normalize
+        // to explicitSuccess:false even on success, so that flag is unusable here.
+        const patchFailed = /^Error[\s:[]/.test(patchText.trimStart());
+        if (patchFailed) {
+            return `${patchText}\n--- post_shell skipped: patch failed ---`;
+        }
+        const shellRes = await executeBuiltinTool('shell', { command: postShell }, cwd, completionToolOpts);
+        const shellNorm = normalizeToolEnvelope(shellRes);
+        const shellText = typeof shellNorm.result === 'string' ? shellNorm.result : String(shellNorm.result ?? '');
+        const shellFailed = /^Error[\s:[]/.test(shellText.trimStart());
+        const header = shellFailed
+            ? '--- post_shell FAILED (patch is applied; fix and re-verify) ---'
+            : '--- post_shell ---';
+        return `${patchText}\n\n${header}\n${shellText}`;
     }
     if (isBuiltinTool(name)) {
         // clientHostPid threaded for the same per-terminal job-scope reason as

package/src/runtime/agent/orchestrator/session/manager/compaction-runner.mjs

@@ -25,6 +25,7 @@ import {
     compactTypeForSession,
 } from './context-meta.mjs';
 import { resolveSemanticSummaryModel } from '../loop/compact-policy.mjs';
+import { traceAgentCompact, messagePrefixHash } from '../../agent-trace.mjs';
 import { uncachedInputTokensForProvider } from './usage-metrics.mjs';
 import { pruneOffloadSession } from '../tool-result-offload.mjs';
 import { _getPendingMessagesForSession } from './pending-messages.mjs';
@@ -302,6 +303,7 @@ export async function runSessionCompaction(session, opts = {}) {
         semanticCompact: false,
     };
     const budget = targetBudgetTokens;
+    const compactStartedAt = Date.now();
     try { await opts.onStageChange?.('compacting'); } catch { /* best-effort */ }
     const provider = opts.provider || getProvider(session.provider) || null;
     let compacted;
@@ -486,6 +488,31 @@ export async function runSessionCompaction(session, opts = {}) {
             lastRecallFastTrackError: recallFastTrackError?.message || null,
             lastError: compactError?.message || semanticCompactError?.message || recallFastTrackError?.message || String(compactError || semanticCompactError || recallFastTrackError || 'compact failed'),
         };
+        // compact_meta parity with the loop's pre-send pass: the out-of-loop
+        // (post-turn/manual) compaction failure was previously invisible to
+        // trace analytics.
+        traceAgentCompact({
+            sessionId: opts.sessionId || session.id || null,
+            stage: mode === 'auto' ? 'post_turn' : 'manual',
+            trigger: mode,
+            compact_type: compactType,
+            compact_changed: false,
+            before_count: messages.length,
+            after_count: messages.length,
+            context_window: positiveContextWindow(session.contextWindow) || null,
+            budget_tokens: boundary,
+            boundary_tokens: boundary,
+            target_budget_tokens: budget,
+            reserve_tokens: reserveTokens,
+            pressure_tokens: pressureTokens,
+            trigger_tokens: triggerTokens,
+            message_tokens_est: beforeMessageTokens,
+            duration_ms: Date.now() - compactStartedAt,
+            provider: session.provider || null,
+            model: session.model || null,
+            error: session.compaction.lastError,
+            error_code: 'compact_failed',
+        });
         return {
             changed: false,
             error: session.compaction.lastError,
@@ -574,6 +601,39 @@ export async function runSessionCompaction(session, opts = {}) {
         compactCount: (session.compaction?.compactCount || 0) + (changed ? 1 : 0),
     };
     if (changed) invalidateProviderContextBaseline(session);
+    // Observability parity with the loop's pre-send pass: record the
+    // out-of-loop mutation as compact_meta and park a one-shot intent so the
+    // next turn's first send tags its cache break instead of logging an
+    // unexplained input_prefix_mismatch (observed live: a 403k→10k post-turn
+    // compact traced as intentional_transition: null with no compact_meta).
+    let beforePrefixHash = null;
+    try { beforePrefixHash = messagePrefixHash(messages); } catch { /* best-effort */ }
+    traceAgentCompact({
+        sessionId: pruneSessionId || null,
+        stage: mode === 'auto' ? 'post_turn' : 'manual',
+        trigger: mode,
+        compact_type: compactType,
+        compact_changed: changed,
+        input_prefix_hash: beforePrefixHash,
+        before_count: messages.length,
+        after_count: compacted.length,
+        before_bytes: beforeEncoded ? Buffer.byteLength(beforeEncoded, 'utf8') : null,
+        after_bytes: afterEncoded ? Buffer.byteLength(afterEncoded, 'utf8') : null,
+        context_window: positiveContextWindow(session.contextWindow) || null,
+        budget_tokens: boundary,
+        boundary_tokens: boundary,
+        target_budget_tokens: budget,
+        reserve_tokens: reserveTokens,
+        pressure_tokens: pressureTokens,
+        trigger_tokens: triggerTokens,
+        message_tokens_est: beforeMessageTokens,
+        duration_ms: Date.now() - compactStartedAt,
+        provider: session.provider || null,
+        model: session.model || null,
+    });
+    if (changed) {
+        session.pendingCacheBreakIntent = mode === 'auto' ? 'post_turn_compaction' : 'manual_compaction';
+    }
     return {
         changed,
         reason: unchangedReason,

package/src/runtime/agent/orchestrator/session/manager/pending-messages.mjs

@@ -19,16 +19,41 @@ const PENDING_MESSAGES_MODE = 0o600;
 const PENDING_ORPHAN_TTL_MS = 7 * 24 * 60 * 60 * 1000;
 const PENDING_ORPHAN_GRACE_MS = 60 * 60 * 1000;
 // Replay window for genuine user/steering entries. A cross-surface submit is
-// meant for a LIVE owner; if nothing picked it up within this window, firing
-// it into a session resumed hours or days later reads as a surprise
-// self-injection (user report: stale spool messages replayed on re-entry).
-// Crash+restart recovery within the window still replays normally.
+// meant for a LIVE owner; entries that predate this process and exceeded the
+// window are still DELIVERED (CC parity, reference messageQueueManager.ts:
+// queued user input is never silently discarded), but annotated with an
+// explicit late-delivery header so a session resumed hours later reads them
+// as clearly-late input instead of a surprise self-injection.
 const STALE_USER_INJECTION_TTL_MS = 30 * 60 * 1000;
 
+// Ownership epoch for the staleness gate below: entries enqueued while THIS
+// process was already alive were aimed at a live owner that still exists.
+const _PENDING_PROCESS_START_MS = Date.now();
+
 function isStaleUserInjection(entry, now = Date.now()) {
     if (isCompletionNotificationEntry(entry)) return false;
     const enqueuedAt = Number(entry?.enqueuedAt) || 0;
-    return enqueuedAt > 0 && (now - enqueuedAt) > STALE_USER_INJECTION_TTL_MS;
+    if (enqueuedAt <= 0) return false;
+    // A submit that arrived AFTER this owner process booted is CURRENT input
+    // the owner was merely too busy to take yet (observed: remote sends
+    // silently discarded after 30m while the owner ground through long
+    // turns). It must deliver regardless of age. The stale window only
+    // guards entries that PREDATE this process — the resumed-session replay
+    // case the TTL was built for (surprise self-injection on re-entry).
+    if (enqueuedAt >= _PENDING_PROCESS_START_MS) return false;
+    return (now - enqueuedAt) > STALE_USER_INJECTION_TTL_MS;
+}
+
+// CC parity: never silently discard queued user input. A stale entry is
+// delivered with this explicit age-annotated header so neither the user nor
+// the model mistakes it for fresh input.
+function lateDeliveryText(text, entry, now = Date.now()) {
+    const value = String(text ?? '');
+    if (!value.trim()) return value;
+    const enqueuedAt = Number(entry?.enqueuedAt) || 0;
+    const ageMinutes = Math.max(1, Math.round((now - enqueuedAt) / 60000));
+    const age = ageMinutes >= 120 ? `~${Math.round(ageMinutes / 60)}h` : `~${ageMinutes}m`;
+    return `[late delivery: queued ${age} ago, before the current session owner started]\n${value}`;
 }
 // Marker for deferred agent/tool *completion* notifications. Such entries must
 // never be replayed into a later turn on session resume (out-of-order delivery
@@ -765,7 +790,6 @@ export function hydratePendingMessages(sessionId, options = {}) {
       let hydrated = [];
       let alreadyDelivered = [];
       let staleLedgerEntries = [];
-      const staleUserEntries = [];
       const ledgerSession = loadSession(sessionId);
       // Durable lifecycle epoch this hydration started under. Publishing claims the
       // durable entries into THIS process's memory, so it must be revalidated
@@ -797,16 +821,19 @@ export function hydratePendingMessages(sessionId, options = {}) {
                     return false;
                 }
                 if (!id || inDelivery.has(id) || acked.has(id)) return false;
-                // Stale genuine user/steering entries must not surprise-inject
-                // into a session resumed long after they were queued (user:
-                // "re-entering the session suddenly injected old messages").
-                // Completion entries keep their own resume-drop policy.
-                if (isStaleUserInjection(entry)) {
-                    staleUserEntries.push(entry);
-                    return false;
-                }
                 return true;
             });
+            // CC parity: stale genuine user/steering entries DELIVER with a
+            // late-delivery header instead of being silently dropped (the old
+            // behavior discarded them; user report: remote/steering sends
+            // silently ignored around owner restarts). Completion entries
+            // keep their own resume-drop policy (drain discards them).
+            for (const entry of hydrated) {
+                if (!isStaleUserInjection(entry)) continue;
+                if (typeof entry.message === 'string') {
+                    entry.message = lateDeliveryText(entry.message, entry);
+                }
+            }
             // Read-only claim: durable data remains until successful delivery
             // acknowledges these exact ids. A crash here therefore redelivers.
             return undefined;
@@ -828,13 +855,6 @@ export function hydratePendingMessages(sessionId, options = {}) {
         runPendingTestHook('hydrate:betweenCleanups', { sessionId });
         if (pendingLifecycleInvalidated(sessionId, startToken)) return 0;
       }
-      if (staleUserEntries.length > 0) {
-        try { process.stderr.write(`[session] dropped ${staleUserEntries.length} stale queued message(s) (older than ${Math.round(STALE_USER_INJECTION_TTL_MS / 60000)}m) sessionId=${sessionId}\n`); } catch {}
-        const cleaned = await acknowledgePendingMessages(sessionId, staleUserEntries, { expectedToken: startToken });
-        if (cleaned) cleanupConfirmed.push(...staleUserEntries);
-        runPendingTestHook('hydrate:betweenCleanups', { sessionId });
-        if (pendingLifecycleInvalidated(sessionId, startToken)) return 0;
-      }
       if (cleanupConfirmed.length > 0) {
         try {
             // One session save prunes both IDs whose replay spool was removed
@@ -968,7 +988,19 @@ function modelVisiblePendingMessages(messages) {
 }
 
 export function _mergePendingMessageEntries(entries) {
-    const normalized = (Array.isArray(entries) ? entries : [])
+    // CC-parity delivery priority (reference messageQueueManager.ts: user
+    // input enqueues at 'next', task notifications at 'later', and dequeue
+    // always serves 'next' first). Our single merged turn message is the
+    // analogue of that dequeue order: genuine user/steering entries are
+    // merged BEFORE deferred completion notifications so queued user input
+    // is never buried under system notification text. FIFO is preserved
+    // within each group (stable partition).
+    const source = Array.isArray(entries) ? entries : [];
+    const ordered = [
+        ...source.filter((entry) => !isCompletionNotificationEntry(entry)),
+        ...source.filter(isCompletionNotificationEntry),
+    ];
+    const normalized = ordered
         .map(normalizePendingMessageEntry)
         .filter(Boolean);
     if (normalized.length === 0) return null;
@@ -1106,7 +1138,6 @@ export function drainForeignUserInjections(sessionId) {
         }
     } catch { /* ledger unavailable — in-memory sets still guard */ }
     const taken = [];
-    let droppedStale = 0;
     // The mtime memo may ONLY be armed by a scan that actually reached a
     // lifecycle-valid decision under the spool lock. Arming it upfront meant a
     // drain refused in-lock (a close/detach/reopen landing in the window) still
@@ -1137,14 +1168,15 @@ export function drainForeignUserInjections(sessionId) {
                     && !isCompletionNotificationEntry(entry)
                     && !isLegacyUnmarkedCompletionNotification(text)
                     && text && !isInternalRuntimeNotificationText(text);
-                // Stale foreign submits are removed WITHOUT injecting: they
-                // were aimed at a live owner that no longer exists (user:
-                // stale spool messages fired on session re-entry days later).
-                if (foreignUser && isStaleUserInjection(entry)) droppedStale += 1;
+                // CC parity: stale foreign submits still deliver, carrying a
+                // late-delivery header instead of being silently removed
+                // (user report: remote sends silently discarded around owner
+                // restarts).
+                if (foreignUser && isStaleUserInjection(entry)) taken.push(lateDeliveryText(text, entry));
                 else if (foreignUser) taken.push(text);
                 else kept.push(entry);
             }
-            if (taken.length === 0 && droppedStale === 0) return undefined;
+            if (taken.length === 0) return undefined;
             if (kept.length > 0) next.sessions[sessionId] = kept;
             else {
                 delete next.sessions[sessionId];
@@ -1158,9 +1190,6 @@ export function drainForeignUserInjections(sessionId) {
         return [];
     }
     if (lifecycleDecided) _rememberForeignSpoolScan(sessionId, mtime);
-    if (droppedStale > 0) {
-        try { process.stderr.write(`[session] dropped ${droppedStale} stale foreign submit(s) (older than ${Math.round(STALE_USER_INJECTION_TTL_MS / 60000)}m) sessionId=${sessionId}\n`); } catch {}
-    }
     return taken;
 }
 

package/src/runtime/agent/orchestrator/session/manager.mjs

@@ -126,7 +126,7 @@ export {
     updateSessionManualTitle,
     flushSessionMetrics,
 } from './manager/session-crud.mjs';
-export { deleteSession } from './store.mjs';
+export { deleteSession, listOwnedAgentSessionIds } from './store.mjs';
 // Read-only parsed-session access (desktop pane peek): no resume, no
 // ownership, no liveness side effects.
 export { loadSession } from './store.mjs';

package/src/runtime/agent/orchestrator/session/send-with-recovery.mjs

@@ -211,9 +211,13 @@ export async function sendWithRecovery(ctx) {
                 // acknowledgement replays on a fresh request instead of
                 // failing the turn. Non-acked (or tool-bearing) shapes keep
                 // the explicit-failure contract below unchanged.
+                // NOTE: no classifyError gate here — an exposed stall is
+                // stamped unsafeToRetry, which the general classifier reads as
+                // terminal, but that unsafety is exactly what the retraction
+                // removes (observed live: make-mips-interpreter failed twice
+                // because this guard demanded 'transient' and never fired).
                 if (
                     transportRetriesUsed < TRANSPORT_RETRY_MAX
-                    && classifyError(sendErr) === 'transient'
                     && await retractExposedTextForReplay()
                 ) {
                     const waitMs = TRANSPORT_RETRY_BACKOFF_MS[transportRetriesUsed];
@@ -325,8 +329,13 @@ export async function sendWithRecovery(ctx) {
             // send after a bounded wait instead of failing the turn.
             if (
                 transportRetriesUsed < TRANSPORT_RETRY_MAX
-                && classifyError(sendErr) === 'transient'
-                && (outcome.replaySafe === true || await retractExposedTextForReplay())
+                && (
+                    (outcome.replaySafe === true && classifyError(sendErr) === 'transient')
+                    || (
+                        (classifyError(sendErr) === 'transient' || outcome.stallObserved === true)
+                        && await retractExposedTextForReplay()
+                    )
+                )
             ) {
                 const waitMs = TRANSPORT_RETRY_BACKOFF_MS[transportRetriesUsed];
                 try {

package/src/runtime/agent/orchestrator/session/store/listing.mjs

@@ -64,6 +64,16 @@ const RESUMABLE_OPEN_MAX_COUNT = 300;
 // idle this long — see the blank-scratch branch in sweepStaleSessions.
 const BLANK_SCRATCH_MAX_AGE_MS = 60 * 60 * 1000; // 1h
 
+/** Child-agent transcripts share their visible parent's retention boundary.
+ * Presence (including a tombstone or unreadable file) preserves the child;
+ * only proven parent absence releases it to ordinary cleanup. */
+function retainedLinkedAgent(session) {
+    if (!session || !isAgentOwner(session)) return false;
+    const parentId = String(session.ownerSessionId || session.parentSessionId || '').trim();
+    if (!/^[A-Za-z0-9_-]+$/.test(parentId) || parentId === session.id) return false;
+    return probePath(sessionPath(parentId)).state !== PROBE_ABSENT;
+}
+
 
 export function listStoredSessions(options = {}) {
     const dir = getStoreDir();
@@ -423,6 +433,13 @@ function* sweepStaleSessionSteps(ttlMs, options = {}) {
             // messages), so there is no second, divergent parse of this file.
             const actual = record.doc;
             const diskClosed = record.closed === true || actual.status === 'closed';
+            if (retainedLinkedAgent(actual)) {
+                // Parent-owned agent transcripts are task history, not
+                // ephemeral worker cache. This covers both new open sessions
+                // and tombstones created by older Mixdog versions.
+                remaining++;
+                continue;
+            }
             if (diskClosed) {
                 // A shared store can be tombstoned by another process while
                 // this process still owns an in-flight controller for the same

package/src/runtime/agent/orchestrator/session/store-summary-reader.mjs

@@ -59,6 +59,106 @@ function cleanValue(value) {
     return String(value || '').trim();
 }
 
+function archivedAgentNotification(content, sessionId) {
+    const text = typeof content === 'string' ? content : '';
+    const marker = '\n\nResult:\n';
+    const markerAt = text.indexOf(marker);
+    if (markerAt < 0 || !/The async agent task .* has finished \(/.test(text.slice(0, markerAt))) return null;
+    const lines = text.slice(markerAt + marker.length)
+        .split(/\r?\n/)
+        .map((line) => line.replace(/^>\s?/, ''));
+    const divider = lines.findIndex((line) => line.trim() === '');
+    if (divider < 0) return null;
+    const headers = new Map();
+    for (const line of lines.slice(0, divider)) {
+        const match = /^([A-Za-z][A-Za-z0-9_]*):\s*(.*?)\s*$/.exec(line);
+        if (match) headers.set(match[1], match[2]);
+    }
+    if (headers.get('surface') !== 'agent' || headers.get('sessionId') !== sessionId) return null;
+    const status = cleanValue(headers.get('status')).toLowerCase();
+    if (!/^(?:completed|failed|cancelled)$/.test(status)) return null;
+    const body = lines.slice(divider + 1).join('\n').trim();
+    if (!body) return null;
+    return {
+        body,
+        status,
+        tag: cleanValue(headers.get('tag') || headers.get('label')),
+        agent: cleanValue(headers.get('agent')),
+        provider: cleanValue(headers.get('provider')),
+        model: cleanValue(headers.get('model')),
+        effort: cleanValue(headers.get('effort')),
+        fast: cleanValue(headers.get('fast')).toLowerCase() === 'true',
+        finishedAt: Date.parse(cleanValue(headers.get('finished'))) || 0,
+    };
+}
+
+/** Legacy recovery for child transcripts already unlinked by terminal reaping.
+ * The parent owns one canonical body-carrying completion notification, so scan
+ * only files containing the exact child id and project the newest valid body. */
+function readArchivedAgentResult(sessionId) {
+    const dir = join(dataDir(), 'sessions');
+    if (probePath(dir).state !== PROBE_PRESENT) return null;
+    let files;
+    try { files = readdirSync(dir).filter((file) => file.endsWith('.json')); }
+    catch { return null; }
+    let best = null;
+    for (const file of files) {
+        let raw;
+        try { raw = readFileSync(join(dir, file), 'utf8'); } catch { continue; }
+        if (!raw.includes(sessionId)) continue;
+        const record = readTopLevelLifecycleRecord(raw);
+        if (isLifecycleUnreadable(record) || record.id === sessionId) continue;
+        const parent = record.doc;
+        const messages = Array.isArray(parent.messages) ? parent.messages : [];
+        for (let index = messages.length - 1; index >= 0; index--) {
+            const message = messages[index];
+            if (message?.role !== 'user') continue;
+            const archived = archivedAgentNotification(message.content, sessionId);
+            if (!archived) continue;
+            const at = positiveNumber(
+                message?.meta?.transcript?.at,
+                archived.finishedAt || positiveNumber(parent.updatedAt),
+            );
+            if (best && best.at > at) continue;
+            best = { ...archived, at, parent };
+            break;
+        }
+    }
+    if (!best) return null;
+    const text = `# Archived agent result\n\n${best.body}`;
+    return {
+        sessionId,
+        items: [{
+            id: `archived-agent-result:${sessionId}`,
+            kind: 'assistant',
+            text,
+            status: best.status,
+            ...(best.at ? { at: best.at } : {}),
+            ...(best.model ? { model: best.model } : {}),
+            ...(best.provider ? { provider: best.provider } : {}),
+            ...(best.agent ? { agent: best.agent } : {}),
+        }],
+        provider: best.provider,
+        model: best.model,
+        effort: best.effort,
+        fast: best.fast,
+        cwd: cleanValue(best.parent.cwd),
+        desktopSession: desktopSession(best.parent.desktopSession, best.parent.cwd),
+        workflow: null,
+        stats: {
+            currentContextTokens: 0,
+            currentEstimatedContextTokens: 0,
+            currentContextSource: null,
+        },
+        contextWindow: null,
+        rawContextWindow: null,
+        displayContextWindow: null,
+        autoCompactTokenLimit: null,
+        archivedAgentResult: true,
+        readOnlyDetachedAgent: false,
+    };
+}
+
 function activeAgentWorker(row) {
     const statuses = [row?.stage, row?.status]
         .map(cleanValue)
@@ -421,6 +521,7 @@ export async function readStoredSessionTranscript(id, options = {}) {
     // Same strict authority as the store, and the same fail-closed rule: an
     // absent, unreadable, ambiguous or foreign record yields no transcript.
     const read = readTextFile(join(dataDir(), 'sessions', `${sessionId}.json`));
+    if (read.state === PROBE_ABSENT) return readArchivedAgentResult(sessionId);
     if (read.state !== PROBE_PRESENT) return null;
     const record = readTopLevelLifecycleRecord(read.text);
     if (isLifecycleUnreadable(record) || record.id !== sessionId) return null;

package/src/runtime/agent/orchestrator/session/store.mjs

@@ -1188,6 +1188,36 @@ export function loadSession(id) {
     return stored ? _ensureLifecycleFields(stored) : null;
 }
 
+/** Strictly enumerate child-agent session files linked to one visible parent.
+ * Used only by explicit parent deletion; ordinary close/context switches keep
+ * the relationship intact. */
+export function listOwnedAgentSessionIds(ownerSessionId) {
+    const ownerId = String(ownerSessionId || '').trim();
+    if (!/^[A-Za-z0-9_-]+$/.test(ownerId)) return [];
+    const dir = getStoreDir();
+    if (probePath(dir).state !== PROBE_PRESENT) return [];
+    let files;
+    try {
+        files = readdirSync(dir).filter((file) => file.endsWith('.json'));
+    } catch {
+        return [];
+    }
+    const ids = [];
+    for (const file of files) {
+        const candidateId = file.slice(0, -5);
+        if (!candidateId || candidateId === ownerId || !/^[A-Za-z0-9_-]+$/.test(candidateId)) continue;
+        try {
+            const record = readTopLevelLifecycleRecord(readFileSync(join(dir, file), 'utf8'));
+            if (isLifecycleUnreadable(record) || record.id !== candidateId) continue;
+            const session = record.doc;
+            if (!isAgentOwner(session)) continue;
+            const linkedOwner = String(session.ownerSessionId || session.parentSessionId || '').trim();
+            if (linkedOwner === ownerId) ids.push(candidateId);
+        } catch { /* unreadable/vanished records are never deletion targets */ }
+    }
+    return ids;
+}
+
 
 export function deleteSession(id, options = {}) {
     // Keep caller probes and all vetoes ahead of the non-reentrant lock and