mixdog 0.9.92 → 0.9.94

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