mixdog 0.9.38 → 0.9.39

package/src/runtime/agent/orchestrator/session/context-utils.mjs

@@ -99,6 +99,212 @@ export function estimateMessagesTokens(messages) {
     return messages.reduce((sum, m) => sum + estimateMessageTokens(m), 0);
 }
 
+// Context status is polled while the agent loop mutates and replaces message
+// arrays. Keep the accumulated summary on that array, but cheaply validate
+// every entry before reusing its contribution. The fingerprint deliberately
+// avoids serializing content/blocks on the warm path; it compares the
+// references of every estimator-visible string instead.
+// Producer invariant: compaction copies message/call objects, transcript repair
+// replaces array entries, stored-tool-args replaces `arguments`, and MCP reload
+// replaces tool descriptors; settled nested non-string payloads are not mutated
+// in place without replacing their containing reference.
+const contextMessageMemo = new WeakMap();
+const contextTranscriptMemo = new WeakMap();
+
+function contextValueFingerprint(value) {
+    if (typeof value === 'string') return { value, entries: null };
+    if (Array.isArray(value)) return {
+        value,
+        entries: value.map(contextBlockFingerprint),
+    };
+    return value && typeof value === 'object'
+        ? { value, entries: [contextBlockFingerprint(value)] }
+        : { value, entries: null };
+}
+
+function contextBlockFingerprint(block) {
+    if (!block || typeof block !== 'object') return { value: block };
+    const fn = block.function;
+    return {
+        value: block,
+        text: typeof block.text === 'string' ? block.text : null,
+        content: typeof block.content === 'string' ? block.content : null,
+        args: typeof block.args === 'string' ? block.args : null,
+        arguments: block.arguments,
+        input: typeof block.input === 'string' ? block.input : null,
+        function: fn,
+        functionArguments: typeof fn?.arguments === 'string' ? fn.arguments : null,
+    };
+}
+
+function contextMessageFingerprint(message) {
+    if (!message || typeof message !== 'object') {
+        return {
+            role: undefined,
+            content: contextValueFingerprint(''),
+            toolCalls: contextValueFingerprint(null),
+            thinkingBlocks: contextValueFingerprint(null),
+            assistantBlocks: contextValueFingerprint(null),
+            toolCallId: null,
+        };
+    }
+    return {
+        role: message.role,
+        content: contextValueFingerprint(message.content),
+        toolCalls: contextValueFingerprint(message.toolCalls),
+        thinkingBlocks: contextValueFingerprint(message.thinkingBlocks),
+        assistantBlocks: contextValueFingerprint(message.assistantBlocks),
+        toolCallId: message?.toolCallId || null,
+    };
+}
+
+function sameContextValueFingerprint(a, b) {
+    if (!a || !b || a.value !== b.value) return false;
+    if (a.entries === null || b.entries === null) return a.entries === b.entries;
+    if (a.entries.length !== b.entries.length) return false;
+    for (let index = 0; index < a.entries.length; index += 1) {
+        if (!sameContextBlockFingerprint(a.entries[index], b.entries[index])) return false;
+    }
+    return true;
+}
+
+function sameContextBlockFingerprint(a, b) {
+    return !!a && !!b
+        && a.value === b.value
+        && a.text === b.text
+        && a.content === b.content
+        && a.args === b.args
+        && Object.is(a.arguments, b.arguments)
+        && a.input === b.input
+        && a.function === b.function
+        && a.functionArguments === b.functionArguments;
+}
+
+function sameContextMessageFingerprint(a, b) {
+    return !!a && a.role === b.role
+        && sameContextValueFingerprint(a.content, b.content)
+        && sameContextValueFingerprint(a.toolCalls, b.toolCalls)
+        && sameContextValueFingerprint(a.thinkingBlocks, b.thinkingBlocks)
+        && sameContextValueFingerprint(a.assistantBlocks, b.assistantBlocks)
+        && a.toolCallId === b.toolCallId;
+}
+
+function contextMessageContribution(message) {
+    const fingerprint = contextMessageFingerprint(message);
+    if (message && typeof message === 'object') {
+        const cached = contextMessageMemo.get(message);
+        if (cached && sameContextMessageFingerprint(cached.fingerprint, fingerprint)) return cached.contribution;
+    }
+    const role = ['system', 'user', 'assistant', 'tool'].includes(fingerprint.role) ? fingerprint.role : 'other';
+    const text = messageEstimateText(message);
+    const tokens = estimateTokens(text) + 4;
+    const contribution = {
+        role,
+        tokens,
+        reminderBuckets: null,
+        toolCallCount: 0,
+        toolCallTokens: 0,
+        toolResultCount: role === 'tool' ? 1 : 0,
+        toolResultTokens: role === 'tool' ? tokens : 0,
+    };
+    if (role === 'user' && String(text || '').trim().startsWith('<system-reminder>')) {
+        const buckets = { tokens: contribution.tokens, otherTokens: contribution.tokens };
+        let sectionTokens = 0;
+        for (const section of splitMarkdownSections(stripSystemReminder(text))) {
+            const bucket = reminderSectionBucket(section);
+            const sectionTokenCount = estimateTokens(section);
+            buckets[bucket] = (buckets[bucket] || 0) + sectionTokenCount;
+            sectionTokens += sectionTokenCount;
+        }
+        buckets.otherTokens = Math.max(0, contribution.tokens - sectionTokens);
+        contribution.reminderBuckets = buckets;
+    }
+    if (fingerprint.role === 'assistant' && Array.isArray(message?.toolCalls) && message.toolCalls.length) {
+        contribution.toolCallCount = message.toolCalls.length;
+        try { contribution.toolCallTokens = estimateTokens(JSON.stringify(message.toolCalls)); }
+        catch { contribution.toolCallTokens = estimateTokens(`[${message.toolCalls.length} tool calls]`); }
+    }
+    if (message && typeof message === 'object') {
+        contextMessageMemo.set(message, { fingerprint, contribution });
+    }
+    return contribution;
+}
+
+function emptyContextSummaryState() {
+    return {
+        rows: {
+            system: { count: 0, tokens: 0 },
+            user: { count: 0, tokens: 0 },
+            assistant: { count: 0, tokens: 0 },
+            tool: { count: 0, tokens: 0 },
+            other: { count: 0, tokens: 0 },
+        },
+        semantic: {
+            system: { count: 0, tokens: 0 },
+            chat: { count: 0, tokens: 0 },
+            assistant: { count: 0, tokens: 0 },
+            toolResults: { count: 0, tokens: 0 },
+            reminders: { count: 0, tokens: 0, otherTokens: 0 },
+            workflow: { tokens: 0 },
+            memory: { tokens: 0 },
+            workspace: { tokens: 0 },
+            environment: { tokens: 0 },
+            other: { tokens: 0 },
+        },
+        estimatedTokens: 0,
+        toolCallCount: 0,
+        toolCallTokens: 0,
+        toolResultCount: 0,
+        toolResultTokens: 0,
+    };
+}
+
+function applyContextMessageContribution(state, contribution, direction) {
+    const { role, tokens } = contribution;
+    state.estimatedTokens += direction * tokens;
+    state.rows[role].count += direction;
+    state.rows[role].tokens += direction * tokens;
+    if (role === 'system') {
+        state.semantic.system.count += direction;
+        state.semantic.system.tokens += direction * tokens;
+    } else if (role === 'user') {
+        if (contribution.reminderBuckets) {
+            state.semantic.reminders.count += direction;
+            state.semantic.reminders.tokens += direction * contribution.reminderBuckets.tokens;
+            state.semantic.reminders.otherTokens += direction * contribution.reminderBuckets.otherTokens;
+            for (const bucket of ['workflow', 'memory', 'workspace', 'environment', 'other']) {
+                state.semantic[bucket].tokens += direction * (contribution.reminderBuckets[bucket] || 0);
+            }
+        } else {
+            state.semantic.chat.count += direction;
+            state.semantic.chat.tokens += direction * tokens;
+        }
+    } else if (role === 'assistant') {
+        state.semantic.assistant.count += direction;
+        state.semantic.assistant.tokens += direction * tokens;
+    } else if (role === 'tool') {
+        state.semantic.toolResults.count += direction;
+        state.semantic.toolResults.tokens += direction * tokens;
+    }
+    state.toolCallCount += direction * contribution.toolCallCount;
+    state.toolCallTokens += direction * contribution.toolCallTokens;
+    state.toolResultCount += direction * contribution.toolResultCount;
+    state.toolResultTokens += direction * contribution.toolResultTokens;
+}
+
+function contextSummaryResult(state, count) {
+    return {
+        count,
+        estimatedTokens: state.estimatedTokens,
+        roles: Object.fromEntries(Object.entries(state.rows).map(([role, row]) => [role, { ...row }])),
+        semantic: Object.fromEntries(Object.entries(state.semantic).map(([name, row]) => [name, { ...row }])),
+        toolCallCount: state.toolCallCount,
+        toolCallTokens: state.toolCallTokens,
+        toolResultCount: state.toolResultCount,
+        toolResultTokens: state.toolResultTokens,
+    };
+}
+
 export const DEFAULT_COMPACTION_BUFFER_TOKENS = 0;
 export const DEFAULT_COMPACTION_BUFFER_RATIO = 0.1;
 export const MAX_COMPACTION_BUFFER_RATIO = 0.25;
@@ -301,81 +507,23 @@ function reminderSectionBucket(section) {
 }
 
 export function summarizeContextMessages(messages) {
-    const rows = {
-        system: { count: 0, tokens: 0 },
-        user: { count: 0, tokens: 0 },
-        assistant: { count: 0, tokens: 0 },
-        tool: { count: 0, tokens: 0 },
-        other: { count: 0, tokens: 0 },
-    };
-    const semantic = {
-        system: { count: 0, tokens: 0 },
-        chat: { count: 0, tokens: 0 },
-        assistant: { count: 0, tokens: 0 },
-        toolResults: { count: 0, tokens: 0 },
-        reminders: { count: 0, tokens: 0, otherTokens: 0 },
-        workflow: { tokens: 0 },
-        memory: { tokens: 0 },
-        workspace: { tokens: 0 },
-        environment: { tokens: 0 },
-        other: { tokens: 0 },
-    };
-    let toolCallCount = 0;
-    let toolCallTokens = 0;
-    let toolResultCount = 0;
-    let toolResultTokens = 0;
-    for (const message of messages || []) {
-        const role = rows[message?.role] ? message.role : 'other';
-        const text = messageEstimateText(message);
-        const tokens = estimateMessageTokens(message);
-        rows[role].count += 1;
-        rows[role].tokens += tokens;
-        if (role === 'system') {
-            semantic.system.count += 1;
-            semantic.system.tokens += tokens;
-        } else if (role === 'user') {
-            if (String(text || '').trim().startsWith('<system-reminder>')) {
-                semantic.reminders.count += 1;
-                semantic.reminders.tokens += tokens;
-                let sectionTokens = 0;
-                for (const section of splitMarkdownSections(stripSystemReminder(text))) {
-                    const bucket = reminderSectionBucket(section);
-                    const sectionTokenCount = estimateTokens(section);
-                    semantic[bucket].tokens += sectionTokenCount;
-                    sectionTokens += sectionTokenCount;
-                }
-                semantic.reminders.otherTokens += Math.max(0, tokens - sectionTokens);
-            } else {
-                semantic.chat.count += 1;
-                semantic.chat.tokens += tokens;
-            }
-        } else if (role === 'assistant') {
-            semantic.assistant.count += 1;
-            semantic.assistant.tokens += tokens;
-        } else if (role === 'tool') {
-            semantic.toolResults.count += 1;
-            semantic.toolResults.tokens += tokens;
-        }
-        if (message?.role === 'assistant' && Array.isArray(message.toolCalls) && message.toolCalls.length) {
-            toolCallCount += message.toolCalls.length;
-            try { toolCallTokens += estimateTokens(JSON.stringify(message.toolCalls)); }
-            catch { toolCallTokens += estimateTokens(`[${message.toolCalls.length} tool calls]`); }
-        }
-        if (message?.role === 'tool') {
-            toolResultCount += 1;
-            toolResultTokens += tokens;
-        }
+    if (!Array.isArray(messages)) return contextSummaryResult(emptyContextSummaryState(), 0);
+    let cached = contextTranscriptMemo.get(messages);
+    if (!cached || messages.length < cached.count) {
+        cached = { count: 0, contributions: [], state: emptyContextSummaryState() };
+        contextTranscriptMemo.set(messages, cached);
     }
-    return {
-        count: Array.isArray(messages) ? messages.length : 0,
-        estimatedTokens: Array.isArray(messages) ? estimateMessagesTokens(messages) : 0,
-        roles: rows,
-        semantic,
-        toolCallCount,
-        toolCallTokens,
-        toolResultCount,
-        toolResultTokens,
-    };
+    for (let index = 0; index < messages.length; index += 1) {
+        const previous = cached.contributions[index];
+        const contribution = contextMessageContribution(messages[index]);
+        if (previous === contribution) continue;
+        if (previous) applyContextMessageContribution(cached.state, previous, -1);
+        cached.contributions[index] = contribution;
+        applyContextMessageContribution(cached.state, contribution, 1);
+    }
+    cached.contributions.length = messages.length;
+    cached.count = messages.length;
+    return contextSummaryResult(cached.state, messages.length);
 }
 
 // Per-request overhead the provider injects that never appears in the
@@ -383,6 +531,39 @@ export function summarizeContextMessages(messages) {
 // provider wraps around the request. The chars/4 message estimate misses all
 // of it, so a "fits" verdict computed from messages alone is optimistic.
 const REQUEST_OVERHEAD_TOKENS = 512;
+const toolSchemaTokenMemo = new WeakMap();
+const requestReserveTokenMemo = new WeakMap();
+
+function sameToolArrayEntries(cached, tools) {
+    if (!cached || cached.entries.length !== tools.length) return false;
+    for (let index = 0; index < tools.length; index += 1) {
+        const entry = cached.entries[index];
+        const tool = tools[index];
+        if (entry.tool !== tool
+            || entry.name !== tool?.name
+            || entry.description !== tool?.description
+            || entry.inputSchema !== tool?.inputSchema
+            || entry.input_schema !== tool?.input_schema
+            || entry.parameters !== tool?.parameters
+            || entry.schema !== tool?.schema) return false;
+    }
+    return true;
+}
+
+function cacheToolArrayValue(tools, value) {
+    return {
+        entries: tools.map((tool) => ({
+            tool,
+            name: tool?.name,
+            description: tool?.description,
+            inputSchema: tool?.inputSchema,
+            input_schema: tool?.input_schema,
+            parameters: tool?.parameters,
+            schema: tool?.schema,
+        })),
+        value,
+    };
+}
 
 /**
  * Estimate the token cost of the tool/function schemas a provider appends to
@@ -394,10 +575,14 @@ const REQUEST_OVERHEAD_TOKENS = 512;
  */
 export function estimateToolSchemaTokens(tools) {
     if (!Array.isArray(tools) || tools.length === 0) return 0;
+    const cached = toolSchemaTokenMemo.get(tools);
+    if (sameToolArrayEntries(cached, tools)) return cached.value;
     let text = '';
     try { text = JSON.stringify(tools); }
     catch { text = tools.map(t => String(t?.name ?? '')).join(''); }
-    return estimateTokens(text);
+    const tokens = estimateTokens(text);
+    toolSchemaTokenMemo.set(tools, cacheToolArrayValue(tools, tokens));
+    return tokens;
 }
 
 /**
@@ -407,7 +592,12 @@ export function estimateToolSchemaTokens(tools) {
  * request-side bytes the message estimate cannot see.
  */
 export function estimateRequestReserveTokens(tools) {
-    return estimateToolSchemaTokens(tools) + REQUEST_OVERHEAD_TOKENS;
+    if (!Array.isArray(tools)) return estimateToolSchemaTokens(tools) + REQUEST_OVERHEAD_TOKENS;
+    const cached = requestReserveTokenMemo.get(tools);
+    if (sameToolArrayEntries(cached, tools)) return cached.value;
+    const reserve = estimateToolSchemaTokens(tools) + REQUEST_OVERHEAD_TOKENS;
+    requestReserveTokenMemo.set(tools, cacheToolArrayValue(tools, reserve));
+    return reserve;
 }
 
 /**
@@ -418,13 +608,15 @@ export function estimateRequestReserveTokens(tools) {
  *
  * @param {unknown[]} messages
  * @param {unknown[]|number} toolsOrReserve tool list or precomputed reserve tokens
- * @param {{ messageCount?: number }} [opts]
+ * @param {{ messageCount?: number, estimatedMessageTokens?: number }} [opts]
  */
 export function estimateTranscriptContextUsage(messages, toolsOrReserve, opts = {}) {
     const list = Array.isArray(messages) ? messages : [];
     const count = Number.isFinite(Number(opts.messageCount)) ? Number(opts.messageCount) : list.length;
     if (count <= 0 || list.length === 0) return 0;
-    const messageTokens = estimateMessagesTokens(list);
+    const messageTokens = Number.isFinite(Number(opts.estimatedMessageTokens))
+        ? Number(opts.estimatedMessageTokens)
+        : summarizeContextMessages(list).estimatedTokens;
     const reserve = typeof toolsOrReserve === 'number' && Number.isFinite(toolsOrReserve)
         ? Math.max(0, toolsOrReserve)
         : estimateRequestReserveTokens(toolsOrReserve);

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

@@ -15,7 +15,8 @@ import { isAgentOwner } from '../../agent-owner.mjs';
 
 // Eager-dispatch: tools with readOnlyHint:true in their declaration are safe
 // to execute during SSE parsing so tool work overlaps with the rest of the
-// stream. Writes, bash, MCP and skills stay serial after send() returns.
+// stream. MCP follows that annotation; writes, bash, and skills stay serial
+// after send() returns.
 // Memoized: the read-only name Set is built once per distinct `tools` array
 // (keyed by identity via a module-level WeakMap) so repeated per-call lookups
 // are O(1) instead of O(N) tools.find scans.

package/src/runtime/agent/orchestrator/session/manager/delivered-completions.mjs

@@ -0,0 +1,123 @@
+// Process-local delivered-completion registry.
+//
+// Purpose: a task-completion body that was already injected into the active TUI
+// loop and ACKed (modelVisibleDelivered) must never ALSO be enqueued into — or
+// drained from — the session pending queue one turn later. The TUI ack and the
+// racing background/fallback enqueue run on different code paths within the SAME
+// process, so this in-memory registry lets an enqueue/drain site recognize "this
+// completion was already delivered" and skip it.
+//
+// Recorded keys (either one matching = already delivered):
+//   - meta.execution_id (when present)
+//   - a hash of the model-visible completion text
+//
+// Bounded + TTL'd so a long-lived process never accumulates unbounded entries.
+// Both record and a matching lookup REFRESH the entry (sliding TTL), so an
+// ACKed completion survives across long-idle turns as long as it keeps being
+// checked. Headless/API sessions never ack, so the registry stays empty for
+// them and marked in-memory completions drain exactly once (behavior unchanged).
+//
+// Residual risk: with a 6h sliding TTL the only remaining eviction path is the
+// bounded-size cap — if MORE than DELIVERED_MAX_ENTRIES distinct completions are
+// delivered before an older ACKed key is next checked, that oldest key is
+// evicted and its (now un-refreshed) completion could enqueue/drain a second
+// time. This requires >512 live completions between a delivery and its drain,
+// which is far outside normal single-process interactive use.
+import { createHash } from 'node:crypto';
+
+const DELIVERED_TTL_MS = 6 * 60 * 60 * 1000; // 6h, sliding (refreshed on record + hit)
+const DELIVERED_MAX_ENTRIES = 512;
+// key -> expiresAt (ms). Insertion order = age order (Map guarantee), so the
+// oldest key is always the first — used for bounded-size eviction.
+const _delivered = new Map();
+
+export function hashCompletionText(text) {
+    const value = String(text ?? '').trim();
+    if (!value) return null;
+    return createHash('sha1').update(value).digest('hex');
+}
+
+function execKey(executionId) {
+    const id = executionId == null ? '' : String(executionId).trim();
+    return id ? `id:${id}` : null;
+}
+
+function textKey(text) {
+    const h = hashCompletionText(text);
+    return h ? `tx:${h}` : null;
+}
+
+function pruneExpired(now) {
+    for (const [key, expiresAt] of _delivered) {
+        if (expiresAt <= now) _delivered.delete(key);
+    }
+}
+
+function enforceBound() {
+    while (_delivered.size > DELIVERED_MAX_ENTRIES) {
+        const oldest = _delivered.keys().next().value;
+        if (oldest === undefined) break;
+        _delivered.delete(oldest);
+    }
+}
+
+// Record a delivered completion under its execution_id (when present) and its
+// model-visible text hash. Both keys point at the same expiry so a later
+// enqueue/drain matching EITHER is recognized as already delivered. Re-recording
+// an existing key refreshes its expiry (sliding TTL).
+export function recordDeliveredCompletion({ executionId, text } = {}) {
+    const now = Date.now();
+    pruneExpired(now);
+    const expiresAt = now + DELIVERED_TTL_MS;
+    let recorded = false;
+    for (const key of [execKey(executionId), textKey(text)]) {
+        if (!key) continue;
+        _delivered.delete(key); // re-insert to refresh age order
+        _delivered.set(key, expiresAt);
+        recorded = true;
+    }
+    if (recorded) enforceBound();
+    return recorded;
+}
+
+export function isDeliveredCompletion({ executionId, text } = {}) {
+    const now = Date.now();
+    const keys = [execKey(executionId), textKey(text)].filter(Boolean);
+    let hit = false;
+    for (const key of keys) {
+        const expiresAt = _delivered.get(key);
+        if (expiresAt === undefined) continue;
+        if (expiresAt <= now) { _delivered.delete(key); continue; }
+        hit = true;
+    }
+    if (!hit) return false;
+    // Sliding refresh: extend every present key (and move it to the age tail) so
+    // a long-idle drain that checks it later still recognizes it as delivered.
+    const expiresAt = now + DELIVERED_TTL_MS;
+    for (const key of keys) {
+        if (!_delivered.has(key)) continue;
+        _delivered.delete(key);
+        _delivered.set(key, expiresAt);
+    }
+    return true;
+}
+
+// One diagnostic stderr line per dedup skip, naming the site
+// (mirror/fallback/notify-enqueue/drain) so the actual racing edge is
+// empirically confirmable in logs.
+export function logDuplicateSkip(site, { executionId, text } = {}) {
+    try {
+        const id = executionId == null ? '' : String(executionId).trim();
+        const h = hashCompletionText(text);
+        process.stderr.write(
+            `[completion-dedup] skip site=${site}`
+            + `${id ? ` execution_id=${id}` : ''}`
+            + `${h ? ` hash=${h.slice(0, 12)}` : ''}\n`,
+        );
+    } catch { /* ignore */ }
+}
+
+// Test-only reset hook.
+export function _clearDeliveredCompletions() {
+    _delivered.clear();
+}

package/src/runtime/agent/orchestrator/session/manager/idle-cleanup.mjs

@@ -13,10 +13,22 @@ import { nonNegativeIntEnv } from './env-utils.mjs';
 const CLEANUP_INTERVAL_MS = nonNegativeIntEnv('MIXDOG_SESSION_CLEANUP_INTERVAL_MS', 5 * 60 * 1000); // check every 5 minutes
 const CLEANUP_INITIAL_DELAY_MS = nonNegativeIntEnv('MIXDOG_SESSION_CLEANUP_INITIAL_DELAY_MS', CLEANUP_INTERVAL_MS > 0 ? CLEANUP_INTERVAL_MS : 0);
 const CLEANUP_SLOW_LOG_MS = nonNegativeIntEnv('MIXDOG_SESSION_CLEANUP_SLOW_LOG_MS', 250);
-const TOMBSTONE_MAX_AGE_MS = 24 * 60 * 60 * 1000; // 24h — far longer than any realistic ask race window
+// Tombstone unlink TTL. The guarded resurrection race (temp-write→rename inside
+// _doSave) resolves in microseconds, so 1h is still vastly longer than any
+// realistic in-flight ask race — while short enough that matured tombstones are
+// reclaimed promptly instead of accumulating for a full day.
+const TOMBSTONE_MAX_AGE_MS = 60 * 60 * 1000; // 1h
 let _cleanupTimer = null;
 let _cleanupInitialTimer = null;
 
+// A session is "live" when it still owns a non-closed runtime entry. Passed to
+// the retention cap so the active/current and any in-flight session is never
+// pruned by the open-session max-age/max-count bounds.
+function _isSessionLive(id) {
+    const entry = _getRuntimeEntry(id);
+    return !!(entry && entry.closed !== true);
+}
+
 function _previewIds(items, limit = 5) {
     const ids = (items || []).slice(0, limit).map((item) => item.id).filter(Boolean);
     if (ids.length === 0) return '';
@@ -29,6 +41,7 @@ function sweepIdleSessions({ includeTombstones = true } = {}) {
     try {
         const result = sweepStaleSessions({
             tombstoneMaxAgeMs: includeTombstones ? TOMBSTONE_MAX_AGE_MS : 0,
+            isSessionLive: _isSessionLive,
         });
         const {
             cleaned,
@@ -81,7 +94,7 @@ function sweepIdleSessions({ includeTombstones = true } = {}) {
  * Rationale: closeSession() leaves the tombstone on disk as the authoritative
  * resurrection-blocker for racing saveSession() calls. That race resolves in
  * microseconds (the window inside _doSave between temp write and rename), so
- * 24h is vastly safe. After the TTL expires we reclaim the disk slot.
+ * 1h is vastly safe. After the TTL expires we reclaim the disk slot.
  *
  * Uses `getStoredSessionsRaw()` rather than `listStoredSessions()` because the
  * latter's inline 30-min idle cleanup would race-unlink tombstones before we

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

@@ -5,6 +5,7 @@ import { resolvePluginData } from '../../../../shared/plugin-paths.mjs';
 import { updateJsonAtomicSync, updateJsonAtomic } from '../../../../shared/atomic-file.mjs';
 import { promptContentText, isInternalRuntimeNotificationText } from './prompt-utils.mjs';
 import { loadSession } from '../store.mjs';
+import { isDeliveredCompletion, logDuplicateSkip } from './delivered-completions.mjs';
 
 const _sessionPendingMessages = new Map();
 const PENDING_MESSAGES_FILE = 'session-pending-messages.json';
@@ -24,6 +25,31 @@ function isCompletionNotificationEntry(entry) {
         && entry.notificationKind === COMPLETION_NOTIFICATION_KIND;
 }
 
+// Pre-marker completion notifications were persisted as plain strings,
+// indistinguishable from genuine user/steering messages except by their
+// model-visible wrapper shape. Such stale strings must never replay into a
+// resumed session, but they carry no notificationKind marker, so the marker
+// check alone leaves them behind. Because this is a SILENT-drop path, the
+// shared lenient wrapper detector is too broad (a user message quoting a
+// completion card could be dropped), so this uses its OWN strict recognizer:
+// the string must be a verbatim full-card paste and nothing else —
+//   (1) start with the exact instruction preamble + "\n\nResult:\n",
+//   (2) have EVERY non-empty body line quoted with "> " (100%),
+//   (3) carry no extra leading/trailing prose (whitespace-trim only).
+// Conservative by design: a false negative just keeps a legacy string, but a
+// false positive on genuine user text would silently drop a real message.
+const LEGACY_COMPLETION_CARD_PREAMBLE_RE = /^The async \S+ task \S+ has finished \([^)]*\) - review this result in your next step\.\n\nResult:\n/;
+function isLegacyUnmarkedCompletionNotification(entry) {
+    if (typeof entry !== 'string') return false;
+    const value = entry.trim();
+    const match = LEGACY_COMPLETION_CARD_PREAMBLE_RE.exec(value);
+    if (!match) return false;
+    const body = value.slice(match[0].length);
+    const lines = body.split(/\r?\n/).filter((line) => line.length > 0);
+    if (lines.length === 0) return false;
+    return lines.every((line) => line.startsWith('> '));
+}
+
 // Canonical completion-enqueue tagger. Every deferred tool/agent completion
 // notification MUST be enqueued through this so drain can discard it on resume
 // (never replay out-of-order). Pass the model-visible completion text (or an
@@ -393,8 +419,21 @@ export function drainPendingMessages(sessionId) {
     // in-memory queue is empty, so keeping it only ever delivers live entries.
     // Genuine user/steering messages carry no marker and are kept in order in
     // both paths.
-    const memoryKept = memory;
-    const persistedKept = persisted.filter((m) => !isCompletionNotificationEntry(m));
+    // Drain-time belt: drop MARKED in-memory completion entries whose text hash
+    // was already delivered+ACKed (TUI execution-ui) this process — those would
+    // double-inject next turn. Only marked completion entries are eligible;
+    // genuine user/steering entries carry no marker and are always kept.
+    const memoryKept = memory.filter((m) => {
+        if (!isCompletionNotificationEntry(m)) return true;
+        const text = pendingMessageText(m);
+        if (text && isDeliveredCompletion({ text })) {
+            logDuplicateSkip('drain', { text });
+            return false;
+        }
+        return true;
+    });
+    const persistedKept = persisted.filter((m) => !isCompletionNotificationEntry(m)
+        && !isLegacyUnmarkedCompletionNotification(m));
     const memoryVisible = modelVisiblePendingMessages(memoryKept);
     const persistedVisible = modelVisiblePendingMessages(persistedKept);
     if (memoryVisible.length === 0) return persistedVisible;

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

@@ -24,7 +24,7 @@ import { _closeBashSessionLazy } from './runtime-loaders.mjs';
  * and recreates the session in its pre-close state.
  *
  * Long-term cleanup: `sweepTombstones()` below unlinks tombstones older than
- * TOMBSTONE_MAX_AGE_MS (24h — vastly longer than any realistic in-flight race).
+ * TOMBSTONE_MAX_AGE_MS (1h — vastly longer than the microsecond in-flight race).
  */
 export function closeSession(id, reason = 'manual', opts = {}) {
     // tombstone=false: detach runtime resources (heartbeat, bash shells,