mixdog 0.9.136 → 0.9.138

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixdog",
-  "version": "0.9.136",
+  "version": "0.9.138",
   "private": false,
   "type": "module",
   "description": "Standalone mixdog coding-agent CLI/TUI workspace.",

package/src/runtime/agent/orchestrator/agent-runtime/cache-strategy.mjs

@@ -311,7 +311,6 @@ export function buildStableProviderPromptCacheKey(provider, opts, prefix = {}) {
         effort: cleanString(prefix.effort ?? opts?.effort),
         fast: prefix.fast === true || opts?.fast === true,
         serviceTier: cleanString(prefix.serviceTier),
-        toolChoice: cleanString(prefix.toolChoice),
         parallelToolCalls: prefix.parallelToolCalls === false ? false : true,
         cacheLaneSlot: laneEnabled ? shardSlot : null,
         cacheLaneShards: autoLane ? 'auto' : shardCount > 1 ? shardCount : null,

package/src/runtime/agent/orchestrator/context/collect.mjs

@@ -828,7 +828,7 @@ export function loadScopedRoleInstructions(agent, provider = null) {
 }
 
 // --- Compose system prompt — 4-BP cache layout ---
-// Returns { baseRules, stableSystemContext, sessionMarker, volatileTail } mapping
+// Returns the three stable system blocks and the BP3 core used for refreshes.
 // directly to the breakpoint plan:
 //   BP1 (1h, system block #1) = baseRules — shared tool policy
 //   BP2 (1h, system block #2) = stableSystemContext — profile, skills, deferred/MCP
@@ -894,20 +894,7 @@ export function composeSystemPrompt(opts) {
         ? sessionMarkerParts.join('\n\n---\n\n')
         : '';
 
-    // ── BP4: live message tail ─────────────────────────────────────────
-    // Raw role, permission, and task labels are intentionally omitted: role
-    // selection already shapes the session/rules/tools, permissions are
-    // enforced structurally, and the task body is sent as the actual user turn
-    // by askSession().
-    const volatileParts = [];
-    // workspaceContext's discovered-project list is intentionally not injected:
-    // BP3 already carries the scoped session/project environment, while the
-    // full layout would add redundant cache fragmentation.
-    const volatileTail = volatileParts.length > 0
-        ? volatileParts.join('\n\n')
-        : '';
-
-    return { baseRules, stableSystemContext, sessionMarkerCore, sessionMarker, volatileTail };
+    return { baseRules, stableSystemContext, sessionMarkerCore, sessionMarker };
 }
 // --- Helpers ---
 function readSafe(path) {

package/src/runtime/agent/orchestrator/providers/anthropic-messages.mjs

@@ -325,9 +325,9 @@ export function _toAnthropicMessagesForTest(messages) {
 // sees, so the cache breakpoint is stable across turns.
 //   message-anchor: prefer a safe tool_result tail, then a previous real user
 //                   text turn if another slot remains. Synthetic
-//                   <system-reminder> messages and current pure-text prompts
-//                   are excluded so per-call volatileTail/current prompt
-//                   content never becomes a 1h prefix key.
+//                   synthetic reminder messages and current pure-text prompts
+//                   are excluded so per-call prompt content never becomes a
+//                   1h prefix key.
 // messageTtl === null disables the tail. BP3 (tier3) now rides a system block,
 // so it is no longer marked here.
 // ANTHROPIC_MSG_SLOTS=0 is honoured upstream by passing messageTtl = null.

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

@@ -15,7 +15,6 @@ import {
     DEFAULT_COMPACT_TYPE,
 } from './compact.mjs';
 import { isContextOverflowError } from '../providers/retry-classifier.mjs';
-import { stripSoftWarns } from '../tool-loop-guard.mjs';
 import { tryReadCached, setReadCached, invalidatePathForSession, clearReadDedupSession, extractTouchedPathsFromPatch, tryScopedToolCached, setScopedToolCached, clearScopedToolsForSession, clearScopedToolsForSessionPaths, invalidatePrefetchCache } from './read-dedup.mjs';
 import { isInvalidToolArgsMarker, formatInvalidToolArgsResult } from '../providers/openai-compat-stream.mjs';
 
@@ -34,6 +33,7 @@ import { executeTool, _scopedCacheOutcomeForCall, resolveLiveToolCwd } from './l
 // this file; import it from there directly rather than via this module.
 import { recordToolBatch } from '../tools/tool-batch-trace.mjs';
 import { projectProviderEvidence } from './evidence-union.mjs';
+import { prepareProviderPrefixGuard } from './provider-prefix-guard.mjs';
 
 
 import { resolve as resolvePath, isAbsolute } from 'path';
@@ -185,9 +185,6 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
     const signal = opts.signal || null;
     const sessionAgent = opts.session?.agent;
     const forcedFirstTool = opts.forcedFirstTool ?? null;
-    const forcedFirstToolDef = forcedFirstTool
-        ? tools.find(tool => tool?.name === forcedFirstTool)
-        : null;
     // Opaque providerState passthrough. The loop never inspects provider-native
     // payloads; the originating provider owns them. Stateful Responses
     // providers may use it for continuation anchors.
@@ -205,6 +202,8 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
         }
     };
     const sessionRef = opts.session || null;
+    let _providerPrefixGuardState = sessionRef?._providerPrefixGuardState || null;
+    let _fixedProviderToolSurface = sessionRef?._providerToolSurfaceSnapshot || null;
     const loopUsageMetricsEpoch = () => Number(sessionRef?.usageMetricsEpoch) || 0;
     const loopUsageMetricsTurnId = () => Number(sessionRef?.usageMetricsTurnId) || 0;
     // Sub-agent (worker/heavy-worker/reviewer/…) sessions
@@ -427,25 +426,8 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
     // sessionRef.cwd is the live SSOT. The legacy positional cwd is only the
     // turn-start snapshot and becomes stale after an in-turn cwd tool call.
     cwd = resolveLiveToolCwd(cwd, sessionRef);
-    // Staged pre-cap warnings + one true hard stop. The ONLY count-based
-    // forced termination is the hard cap at maxLoopIterations (default 200):
-    // a genuine runaway guard. Before it, staged warnings fire at 50%/75%/90%
-    // of the cap steering the model to converge — warnings only, nothing is
-    // cut off early. Other runaway protection is behavior-based (steering
-    // ladder hints, REPEAT_FAIL_LIMIT), never a lower iteration count.
-    let _iterWarnStage = 0;
-    // Tiny-cap loops can't afford staged 50/75/90%
-    // steers — the 50% stage lands on iteration 1 in every session, spamming
-    // the normal batch→answer path. For caps < 10 emit ONE wrap-up warning at
-    // the penultimate iteration instead; caps >= 10 keep staged behavior.
-    const _singleWarn = maxLoopIterations < 10;
-    const _iterWarnAt = _singleWarn
-        ? [Math.max(1, maxLoopIterations - 1)]
-        : [
-            Math.floor(maxLoopIterations * 0.5),
-            Math.floor(maxLoopIterations * 0.75),
-            Math.floor(maxLoopIterations * 0.9),
-        ];
+    // The hard cap is the sole count-based steering injection. Behavioral
+    // guards below handle repeated failures/dedup without periodic reminders.
     while (true) {
         // A cwd tool call updates sessionRef in place. Refresh before building
         // this iteration's eager dispatcher and cache keys so every following
@@ -478,26 +460,6 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
             messages.push({ role: 'user', content: `<system-reminder>\n${finalTurnReminder}\n</system-reminder>`, meta: 'hook' });
             process.stderr.write(`[loop] hard iteration cap ${maxLoopIterations} reached (sess=${sessionId || 'unknown'}); forcing final text turn.\n`);
         }
-        if (_iterWarnStage < _iterWarnAt.length && iterations >= _iterWarnAt[_iterWarnStage]) {
-            _iterWarnStage += 1;
-            const warnAt = _iterWarnAt[_iterWarnStage - 1];
-            const stageMsg = _singleWarn
-                ? `Iteration budget nearly spent: ${warnAt} of ${maxLoopIterations} iterations used — answer NOW with the best anchors you already hold.`
-                : _iterWarnStage === 1
-                    ? `Iteration budget notice: ${warnAt} of ${maxLoopIterations} iterations used. Converge on a conclusion: prefer finishing the current objective over opening new exploration.`
-                    : `Iteration budget warning (stage ${_iterWarnStage}): ${warnAt} of ${maxLoopIterations} iterations used — the loop hard-stops at ${maxLoopIterations}. Wrap up now: summarize progress, state what remains, and finish with your best current result.`;
-            messages.push({ role: 'user', content: `<system-reminder>\n${stageMsg}\n</system-reminder>`, meta: 'hook' });
-            process.stderr.write(`[loop] iteration warning stage ${_iterWarnStage} at ${iterations} (sess=${sessionId || 'unknown'}); continuing with steer.\n`);
-            try {
-                appendAgentTrace({
-                    sessionId,
-                    iteration: iterations,
-                    kind: 'steer',
-                    payload: { tag: 'iteration_warning', stage: _iterWarnStage, at: iterations, unit: maxLoopIterations },
-                    agent: sessionAgent || null,
-                });
-            } catch { /* best-effort */ }
-        }
         // Drain queued steering/prompts BEFORE the pre-send compact check, but
         // only immediately after a tool batch has completed: queued entries
         // are attached after tool results are appended and before the recursive
@@ -510,9 +472,7 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
             _toolBatchJustCompleted = false;
             _lastToolBatchHadSleep = false;
         }
-        const baseSendTools = _capFinalToolsDisabled
-            ? tools
-            : (forcedFirstToolDef && toolCallsTotal === 0 ? [forcedFirstToolDef] : tools);
+        const baseSendTools = tools;
         let sendTools;
         let requestToolScope;
         let compactChanged;
@@ -527,23 +487,18 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
                     || messages.some((message, index) => message !== messagesBeforeTranscriptRepair[index]))) {
                 opts.cacheBreakIntent = 'transcript_rebuild';
             }
-            for (let _i = 0; _i < messages.length; _i++) {
-                const _m = messages[_i];
-                if (_m && _m.role === 'tool' && typeof _m.content === 'string' && _m.content.includes('⚠')) {
-                    const _stripped = stripSoftWarns(_m.content);
-                    if (_stripped !== _m.content) {
-                        _m.content = _stripped;
-                        if (!opts.cacheBreakIntent) opts.cacheBreakIntent = 'soft_warn_strip';
-                    }
-                }
-            }
-            sendTools = snapshotProviderRequestTools({
+            const _candidateSendTools = snapshotProviderRequestTools({
                 provider: sessionRef?.provider || provider?.name,
                 tools: baseSendTools,
                 nativeTools: opts.nativeTools,
                 messages,
                 session: sessionRef,
             });
+            if (!_fixedProviderToolSurface) {
+                _fixedProviderToolSurface = _candidateSendTools;
+                if (sessionRef) sessionRef._providerToolSurfaceSnapshot = _fixedProviderToolSurface;
+            }
+            sendTools = _fixedProviderToolSurface;
             requestToolScope = {
                 session: sessionRef,
                 provider: sessionRef?.provider || provider?.name,
@@ -655,8 +610,25 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
         const _evidenceProjection = projectProviderEvidence(_providerMessageSource, {
             enabled: !_evidenceUnionDisabled,
             apply: !_evidenceUnionShadow,
+            // Path aliases are a whole-history projection: a later repeated
+            // path can rewrite already-sent tool results and invalidate every
+            // provider's prefix cache. Row/exact-result references are
+            // append-only, so retain those and disable only the unsafe pass.
+            pathAliases: false,
         });
         const _providerMessages = _evidenceProjection.messages;
+        const _providerPrefixGuardCandidate = prepareProviderPrefixGuard(
+            _providerPrefixGuardState,
+            _providerMessages,
+            {
+                tools: sendTools,
+                nativeTools: Array.isArray(opts.nativeTools) ? opts.nativeTools : [],
+            },
+            {
+                provider: sessionRef?.provider || provider?.name || null,
+                cacheBreakIntent: opts.cacheBreakIntent,
+            },
+        );
         if (_evidenceProjection.stats.reusedRows > 0
             || _evidenceProjection.stats.exactResultRefs > 0
             || _evidenceProjection.stats.pathAliases > 0) {
@@ -723,6 +695,8 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
             continue;
         }
         response = _sendResult.response;
+        _providerPrefixGuardState = _providerPrefixGuardCandidate;
+        if (sessionRef) sessionRef._providerPrefixGuardState = _providerPrefixGuardState;
         if (_imageStripActive && Array.isArray(_pendingImageStripPersistMessages)) {
             messages.splice(0, messages.length, ..._pendingImageStripPersistMessages);
             _imageStripActive = false;

package/src/runtime/agent/orchestrator/session/evidence-union.mjs

@@ -526,7 +526,18 @@ export function projectProviderEvidence(messages, options = {}) {
         }
     }
 
-    const pathProjection = projectProviderPathAliases(projected || messages, { apply });
+    const pathProjection = options.pathAliases === false
+        ? {
+            messages: projected || messages,
+            stats: {
+                pathFacts: 0,
+                pathAliases: 0,
+                reusedPathFacts: 0,
+                pathAliasBytesSaved: 0,
+                changedIndexes: [],
+            },
+        }
+        : projectProviderPathAliases(projected || messages, { apply });
     stats.pathFacts = pathProjection.stats.pathFacts;
     stats.pathAliases = pathProjection.stats.pathAliases;
     stats.reusedPathFacts = pathProjection.stats.reusedPathFacts;

package/src/runtime/agent/orchestrator/session/evidence-union.test.mjs

@@ -209,3 +209,19 @@ test('shadow mode reports savings without changing provider messages', () => {
     assert.equal(projected.stats.reusedRows, 1);
     assert.ok(projected.stats.afterBytes < projected.stats.beforeBytes);
 });
+
+test('provider projection stays append-only when path aliases are disabled', () => {
+    const repeated = `src/${'nested/'.repeat(10)}feature.mjs`;
+    const firstMessages = [
+        call('glob_1', 'glob'),
+        result('glob_1', `${repeated}\nsrc/unique.mjs`),
+    ];
+    const first = projectProviderEvidence(firstMessages, { pathAliases: false });
+    const later = projectProviderEvidence([
+        ...firstMessages,
+        call('read_1', 'read', { file_path: repeated }),
+        result('read_1', `${repeated} [ok]\n1→export const value = 1;`),
+    ], { pathAliases: false });
+    assert.deepEqual(later.messages.slice(0, first.messages.length), first.messages);
+    assert.equal(later.stats.pathAliases, 0);
+});

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

@@ -319,7 +319,7 @@ export function createSession(opts) {
             ? describeShellStartupPolicy()
             : '',
     ].filter(Boolean).join('\n');
-    const { baseRules, stableSystemContext, sessionMarkerCore, sessionMarker, volatileTail } = composeSystemPrompt({
+    const { baseRules, stableSystemContext, sessionMarkerCore, sessionMarker } = composeSystemPrompt({
         userPrompt: opts.systemPrompt,
         agentRules: injectedRules || undefined,
         roleRules: roleRules || undefined,
@@ -357,10 +357,6 @@ export function createSession(opts) {
         // the field and serialize content as a normal system instruction).
         messages.push({ role: 'system', content: sessionMarker, cacheTier: 'tier3' });
     }
-    if (volatileTail) {
-        messages.push({ role: 'user', content: `<system-reminder>\n${volatileTail}\n</system-reminder>` });
-        messages.push({ role: 'assistant', content: '.' });
-    }
     if (opts.files?.length) {
         const fileContext = opts.files
             .map(f => `### ${f.path}\n\`\`\`\n${f.content}\n\`\`\``)

package/src/runtime/agent/orchestrator/session/provider-prefix-guard.mjs

@@ -0,0 +1,63 @@
+import { createHash } from 'crypto';
+
+const COMPACTION_INTENTS = new Set([
+    'automatic_compaction',
+    'deferred_body_compaction',
+    'manual_compaction',
+    'post_turn_compaction',
+]);
+
+function digest(value) {
+    const encoded = JSON.stringify(value);
+    if (typeof encoded !== 'string') {
+        throw new TypeError('provider prefix value is not serializable');
+    }
+    return createHash('sha256').update(encoded).digest('hex');
+}
+
+function snapshot(messages, requestPrefix) {
+    return {
+        messageHashes: messages.map(digest),
+        requestPrefixHash: digest(requestPrefix),
+    };
+}
+
+export class ProviderPrefixMutationError extends Error {
+    constructor(message, details = {}) {
+        super(message);
+        this.name = 'ProviderPrefixMutationError';
+        this.code = 'PROVIDER_PREFIX_MUTATION';
+        this.details = details;
+    }
+}
+
+export function isCompactionPrefixReset(intent) {
+    return COMPACTION_INTENTS.has(String(intent || ''));
+}
+
+export function prepareProviderPrefixGuard(previous, messages, requestPrefix, options = {}) {
+    const next = snapshot(Array.isArray(messages) ? messages : [], requestPrefix);
+    if (!previous || isCompactionPrefixReset(options.cacheBreakIntent)) return next;
+
+    if (previous.requestPrefixHash !== next.requestPrefixHash) {
+        throw new ProviderPrefixMutationError('provider request prefix changed outside compaction', {
+            provider: options.provider || null,
+            kind: 'request_prefix',
+        });
+    }
+    if (next.messageHashes.length < previous.messageHashes.length) {
+        throw new ProviderPrefixMutationError('provider message history shrank outside compaction', {
+            provider: options.provider || null,
+            kind: 'history_shrink',
+        });
+    }
+    for (let index = 0; index < previous.messageHashes.length; index += 1) {
+        if (previous.messageHashes[index] === next.messageHashes[index]) continue;
+        throw new ProviderPrefixMutationError('provider message prefix changed outside compaction', {
+            provider: options.provider || null,
+            kind: 'message_prefix',
+            index,
+        });
+    }
+    return next;
+}

package/src/runtime/agent/orchestrator/session/provider-prefix-guard.test.mjs

@@ -0,0 +1,95 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import {
+    prepareProviderPrefixGuard,
+    ProviderPrefixMutationError,
+} from './provider-prefix-guard.mjs';
+
+const CACHE_PROVIDERS = [
+    'anthropic',
+    'anthropic-oauth',
+    'openai',
+    'openai-oauth',
+    'xai',
+    'grok-oauth',
+    'gemini',
+    'deepseek',
+    'opencode-go',
+    'cursor-oauth',
+    'ollama',
+    'lmstudio',
+];
+
+test('accepts append-only provider history for every provider surface', () => {
+    for (const provider of CACHE_PROVIDERS) {
+        const first = prepareProviderPrefixGuard(
+            null,
+            [{ role: 'user', content: 'one' }],
+            { tools: [{ name: 'read' }], nativeTools: [] },
+            { provider },
+        );
+        assert.doesNotThrow(() => prepareProviderPrefixGuard(
+            first,
+            [
+                { role: 'user', content: 'one' },
+                { role: 'assistant', content: 'two' },
+            ],
+            { tools: [{ name: 'read' }], nativeTools: [] },
+            { provider },
+        ), provider);
+    }
+});
+
+test('rejects prior-message and tool-prefix rewrites outside compaction', () => {
+    const first = prepareProviderPrefixGuard(
+        null,
+        [{ role: 'user', content: 'one' }],
+        { tools: [{ name: 'read' }], nativeTools: [] },
+    );
+    assert.throws(
+        () => prepareProviderPrefixGuard(
+            first,
+            [{ role: 'user', content: 'rewritten' }],
+            { tools: [{ name: 'read' }], nativeTools: [] },
+        ),
+        ProviderPrefixMutationError,
+    );
+    assert.throws(
+        () => prepareProviderPrefixGuard(
+            first,
+            [{ role: 'user', content: 'one' }],
+            { tools: [{ name: 'read' }, { name: 'shell' }], nativeTools: [] },
+        ),
+        ProviderPrefixMutationError,
+    );
+});
+
+test('allows only compaction intents to establish a new prefix', () => {
+    const first = prepareProviderPrefixGuard(
+        null,
+        [{ role: 'user', content: 'one' }],
+        { tools: [{ name: 'read' }], nativeTools: [] },
+    );
+    for (const cacheBreakIntent of [
+        'automatic_compaction',
+        'deferred_body_compaction',
+        'manual_compaction',
+        'post_turn_compaction',
+    ]) {
+        assert.doesNotThrow(() => prepareProviderPrefixGuard(
+            first,
+            [{ role: 'user', content: 'compacted' }],
+            { tools: [{ name: 'read' }], nativeTools: [] },
+            { cacheBreakIntent },
+        ));
+    }
+    assert.throws(
+        () => prepareProviderPrefixGuard(
+            first,
+            [{ role: 'user', content: 'repaired' }],
+            { tools: [{ name: 'read' }], nativeTools: [] },
+            { cacheBreakIntent: 'transcript_rebuild' },
+        ),
+        ProviderPrefixMutationError,
+    );
+});

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

@@ -67,7 +67,7 @@ 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;
+    if (markerAt < 0 || !/Async agent task .* finished\./.test(text.slice(0, markerAt))) return null;
     const lines = text.slice(markerAt + marker.length)
         .split(/\r?\n/)
         .map((line) => line.replace(/^>\s?/, ''));

package/src/runtime/agent/orchestrator/tools/builtin/bash-tool.mjs

@@ -684,7 +684,6 @@ export async function executeBashTool(args, workDir, options = {}) {
                 task ? renderBackgroundTask(task) : (result.jobId ? `[task_id: ${result.jobId}]` : null),
                 '',
                 result.backgroundMessage || 'auto-backgrounded; still running — judge from the partial output whether waiting can finish in budget, or diagnose and pursue an alternative.',
-                result.jobId ? 'You will be notified when it completes; do not poll.' : null,
                 partialOutput ? `\n${partialOutput}` : '',
             ].filter((l) => l !== null && l !== '');
             return _prependDestructiveWarning(command, lines.join('\n'));

package/src/runtime/agent/orchestrator/tools/builtin/task-tool.mjs

@@ -135,12 +135,7 @@ export async function executeTaskTool(args, options = {}) {
         if (isShellTask) refreshShellTask(taskId, { includeRunning: true });
         const latest = getBackgroundTask(taskId, { context: options }) || task;
         const rendered = renderBackgroundTask(latest, { includeResult: true });
-        if (latest.status !== 'running') return rendered;
-        return [
-            rendered,
-            '',
-            'Still running. Completion will be delivered automatically; do not poll or call task again unless the user explicitly asks for another snapshot.',
-        ].join('\n');
+        return rendered;
     }
 
     if (action === 'cancel') {

package/src/runtime/memory/lib/memory-embed.mjs

@@ -104,7 +104,7 @@ const RAW_EMBED_EXCLUDE_CONTENT_RES = [
   /^\s*\[tool_call\b/i,
   /^\s*\[tool_result\b/i,
   /^\s*\[mixdog-runtime\]/i,
-  /^\s*The async (?:shell task|agent task|\S+ execution|\S+) .*has finished\b.*review this result in your next step/i,
+  /^\s*Async .+ finished\./i,
   /^\s*background task\b/i,
 ]
 const RAW_EMBED_EXCLUDE_NON_CONVERSATION_CONTENT_RES = [
@@ -126,7 +126,7 @@ function isRawEmbeddable(role, content) {
 
 const RAW_EMBED_SQL_EXCLUDE_ROLE_VALUES = [...RAW_EMBED_EXCLUDE_ROLES]
 const RAW_EMBED_SQL_ALWAYS_EXCLUDE_CONTENT_RE =
-  '^\\s*(\\[tool_call(?:\\s|\\]|$)|\\[tool_result(?:\\s|\\]|$)|\\[mixdog-runtime\\]|The async (shell task|agent task|\\S+ execution|\\S+) .*has finished(\\s|$).*review this result in your next step|background task(\\s|$))'
+  '^\\s*(\\[tool_call(?:\\s|\\]|$)|\\[tool_result(?:\\s|\\]|$)|\\[mixdog-runtime\\]|Async .+ finished\\.|background task(\\s|$))'
 const RAW_EMBED_SQL_NON_CONVERSATION_EXCLUDE_CONTENT_RE =
   '^\\s*\\[(system|log|offload|debug|trace|info|warn|warning|error|fatal)\\]'
 

package/src/runtime/memory/lib/memory.mjs

@@ -447,9 +447,8 @@ export async function ensureCurrentSchemaExtensions(db, dims) {
   } catch (err) {
     __mixdogMemoryLog(`[memory] attachment-placeholder cleanup failed: ${err?.message || err}\n`)
   }
-  // One-time cleanup: runtime tool-completion notification rows ("The async
-  // shell/agent task ... has finished ... - review this result in your next
-  // step." followed by an unquoted or `> `-quoted Result body, and
+  // One-time cleanup: runtime tool-completion notification rows ("Async ...
+  // finished." followed by an unquoted or `> `-quoted Result body, and
   // "[mixdog-runtime] ..." nudges) that were persisted by the transcript
   // watcher before it gained the shouldExcludeIngestMessage exclusion
   // (transcript-ingest.mjs). Gated by a meta flag so this DELETE runs at
@@ -467,7 +466,7 @@ export async function ensureCurrentSchemaExtensions(db, dims) {
       const candidates = await db.query(
         `SELECT id, content FROM entries
          WHERE role = 'user' AND (
-           content LIKE 'The async % task % has finished%'
+           content LIKE 'Async % finished.%'
            OR content LIKE '[mixdog-runtime]%'
            OR content LIKE 'background task%'
          )`,

package/src/runtime/memory/lib/session-ingest.mjs

@@ -274,16 +274,13 @@ export function sessionMessageContentForIngest(m) {
   return base
 }
 
-// Head-line shape of toolCompletionInstruction() (tool-execution-contract.mjs)
-// as it is ACTUALLY persisted by mgr.enqueuePendingMessage — UNQUOTED, no
-// `> ` prefix on the Result body (real DB rows look like:
-// "The async shell task <id> has finished (completed, exit 0) - review this
-// result in your next step.\nResult:\nbackground task\ntask_id: ...").
+// Head-line shape of toolCompletionInstruction() as persisted by
+// mgr.enqueuePendingMessage — unquoted, with no `> ` prefix on Result.
 // isModelVisibleToolCompletionWrapper only matches the QUOTED (`> `) shape
 // mirrored via the notify-wrapper's own quoting, so it misses this unquoted
 // persisted form. The instruction head alone is a sufficient, unambiguous
 // fingerprint (only the runtime ever emits this exact phrase).
-const UNQUOTED_TOOL_COMPLETION_HEAD_RE = /^The async (?:shell task|agent task|\S+ execution|\S+) .*has finished\b.*review this result in your next step/i
+const UNQUOTED_TOOL_COMPLETION_HEAD_RE = /^Async .+ finished\./i
 
 // Exported so memory.mjs's one-time cleanup (ensureCurrentSchemaExtensions)
 // can confirm SQL-prefiltered candidate rows with the SAME predicate the live
@@ -328,9 +325,8 @@ export function shouldExcludeIngestMessage(m) {
     const text = typeof raw === 'string' ? raw : ''
     if (/^\[mixdog-runtime\]/.test(text.trimStart())) return true
     if (isInternalRuntimeNotificationText(text)) return true
-    // Model-visible tool-completion mirror rows (mgr.enqueuePendingMessage of
-    // modelVisibleToolCompletionMessage — "The async shell/agent task ... has
-    // finished ... - review this result in your next step.\n\nResult:\n> ...").
+    // Model-visible tool-completion mirror rows from
+    // modelVisibleToolCompletionMessage ("Async ... finished.\n\nResult:\n> ...").
     // These are runtime notifications, not conversation, on both ingest paths.
     if (isModelVisibleToolCompletionWrapper(text)) return true
     // Unquoted persisted form of the same wrapper (see comment above).

package/src/runtime/shared/background-tasks.mjs

@@ -466,6 +466,8 @@ export function renderBackgroundTask(taskOrId, { includeResult = false } = {}) {
   const lines = [
     'background task',
     `task_id: ${task.taskId}`,
+    `surface: ${task.surface}`,
+    `operation: ${task.operation}`,
     task.label ? `label: ${task.label}` : null,
     `status: ${task.status}`,
     `started: ${task.startedAt}`,
@@ -479,7 +481,7 @@ export function renderBackgroundTask(taskOrId, { includeResult = false } = {}) {
     && _so.slice(0, -11) === _se.slice(0, -11)
     ? _so.slice(0, -11) : null;
   for (const [key, value] of Object.entries(visibleMeta)) {
-    if (key === 'task_id') continue; // already in the envelope header
+    if (key === 'task_id' || key === 'surface' || key === 'operation') continue;
     if (logsBase && (key === 'stdout' || key === 'stderr')) continue;
     lines.push(`${key}: ${value}`);
   }

package/src/runtime/shared/task-notification-envelope.mjs

@@ -70,7 +70,7 @@ export function renderShellCompletionEnvelope({
 }
 
 // Build the shell completion instruction via the shared wording so all async
-// surfaces read identically ("The async shell task … has finished …"). The
+// surfaces read identically ("Async shell task … finished."). The
 // exit detail is folded into the shared detail slot.
 export function shellCompletionInstruction({ jobId, status, exitCode = null } = {}) {
   return toolCompletionInstruction({

package/src/runtime/shared/tool-card-model.mjs

@@ -260,10 +260,11 @@ function joinActionAgent(action, agent) {
 export function agentResponseTitle(args, count = 1) {
   const total = Math.max(1, Number(count) || 1);
   if (total > 1) return `Responses ${total} agents`;
-  const name = titleizeAgentName(args?.agent || args?.subagent_type || args?.name || '');
+  const name = titleizeAgentName(args?.agent || args?.subagent_type || args?.name || '') || 'Agent';
   // The agent + model identify the responder; the response summary itself
   // is hidden in the collapsed card (expanding still shows the full body).
-  // No generic "Agent" fallback — render just "Response" when the agent is empty.
+  // Keep the surface identifiable even when a failed/legacy completion has no
+  // concrete agent identity.
   return withModelAndTag(joinActionAgent('Response', name), args);
 }
 
@@ -322,7 +323,7 @@ export function hasAgentResponseResult(value) {
     }
     if (/^agent result\b/i.test(trimmed)) continue;
     if (/^(?:undefined|null)$/i.test(trimmed)) continue;
-    if (/^<\/?(?:final-answer|task-notification|task-id|tool-use-id|output-file|result|status|summary|usage|total_tokens|tool_uses|duration_ms|worktree|worktreePath|worktreeBranch)[^>]*>$/i.test(trimmed)) continue;
+    if (/^<\/?(?:final-answer|task-id|tool-use-id|output-file|result|status|summary|usage|total_tokens|tool_uses|duration_ms|worktree|worktreePath|worktreeBranch)[^>]*>$/i.test(trimmed)) continue;
     if (!sawBlank && /^(?:agent task|background task|agent message queued\b|agent close:|task_id|surface|operation|label|status|type|target|agent|preset|model|effort|fast|limits|started|finished|error|notification|queueDepth):?\s*/i.test(trimmed)) continue;
     if (!sawBlank && /^(?:agents|tasks):\s*/i.test(trimmed)) continue;
     if (/^\(no agents or tasks\)$/i.test(trimmed)) continue;

package/src/runtime/shared/tool-execution-contract.mjs

@@ -38,26 +38,9 @@ export function backgroundTaskHeaderStatus(text) {
   return clean(match?.[1]).toLowerCase();
 }
 
-function notificationHead(text) {
-  const value = String(text || '').trim();
-  const match = /\n\s*\n/.exec(value);
-  if (!match) return value;
-  return value.slice(0, match.index).trim();
-}
-
-function isInternalTaskNotificationEnvelope(text) {
-  const value = String(text || '').trim();
-  if (!value) return false;
-  if (/^background task\b/i.test(value)) return false;
-  if (/^<task-notification\b/i.test(value)) return true;
-  const head = notificationHead(value);
-  return /^<task-notification\b/i.test(head);
-}
-
 export function shouldPersistModelVisibleToolCompletion(text, meta = {}) {
   const message = String(text || '').trim();
   if (!message) return false;
-  if (isInternalTaskNotificationEnvelope(message)) return false;
 
   const metaStatus = clean(meta?.status).toLowerCase();
   if (NON_PERSISTENT_TOOL_STATUSES.has(metaStatus)) return false;
@@ -96,7 +79,6 @@ export function isBracketedShellNotificationEnvelope(text) {
 export function isInternalRuntimeNotificationText(text) {
   const value = String(text ?? '').trim();
   if (!value) return false;
-  if (isInternalTaskNotificationEnvelope(value)) return true;
   if (isBracketedShellNotificationEnvelope(value)) return true;
   if (/^background task\b/i.test(value)
     && /^task_id:\s*\S+/mi.test(value)
@@ -132,7 +114,7 @@ export function toolCompletionInstruction({ surface = 'tool', id, status, detail
       ? 'agent task'
       : `${surface} execution`;
   const statusText = status ? ` (${status}${detail ? `, ${detail}` : ''})` : '';
-  return `The async ${label} ${id || ''} has finished${statusText} - review this result in your next step. Final result follows; do not recheck.`;
+  return `Async ${label} ${id || ''}${statusText} finished.`;
 }
 
 function toolCompletionMeta({
@@ -156,8 +138,6 @@ function toolCompletionMeta({
   };
 }
 
-const MODEL_VISIBLE_COMPLETION_INSTRUCTION_RE = /\b(async (?:agent task|shell task|\w+ execution)|Async \S+)/i;
-const MODEL_VISIBLE_COMPLETION_REVIEW_RE = /has finished\b[\s\S]*review this result in your next step/i;
 const MODEL_VISIBLE_COMPLETION_ASYNC_HEADER_RE = /^Async .+ finished\./i;
 
 export function isModelVisibleToolCompletionWrapper(text) {
@@ -167,9 +147,7 @@ export function isModelVisibleToolCompletionWrapper(text) {
   if (!resultSplit) return false;
   const preamble = value.slice(0, resultSplit.index).trim();
   if (!preamble) return false;
-  const instructionLike = MODEL_VISIBLE_COMPLETION_INSTRUCTION_RE.test(preamble)
-    || MODEL_VISIBLE_COMPLETION_REVIEW_RE.test(preamble)
-    || MODEL_VISIBLE_COMPLETION_ASYNC_HEADER_RE.test(preamble);
+  const instructionLike = MODEL_VISIBLE_COMPLETION_ASYNC_HEADER_RE.test(preamble);
   if (!instructionLike) return false;
   const quotedSection = value.slice(resultSplit.index + resultSplit[0].length);
   const quotedLines = quotedSection.split(/\r?\n/).filter((line) => line.length > 0);
@@ -193,9 +171,7 @@ export function isLikelyToolCompletionWrapper(text) {
   if (!resultSplit) return false;
   const preamble = value.slice(0, resultSplit.index).trim();
   if (!preamble) return false;
-  const instructionLike = MODEL_VISIBLE_COMPLETION_INSTRUCTION_RE.test(preamble)
-    || MODEL_VISIBLE_COMPLETION_REVIEW_RE.test(preamble)
-    || MODEL_VISIBLE_COMPLETION_ASYNC_HEADER_RE.test(preamble);
+  const instructionLike = MODEL_VISIBLE_COMPLETION_ASYNC_HEADER_RE.test(preamble);
   if (!instructionLike) return false;
   const quotedSection = value.slice(resultSplit.index + resultSplit[0].length);
   const quotedLines = quotedSection.split(/\r?\n/).filter((line) => line.length > 0);
@@ -205,11 +181,10 @@ export function isLikelyToolCompletionWrapper(text) {
 }
 
 const INTERNAL_TRANSCRIPT_CONTEXT_RE =
-  /^<(?:system-reminder|task-notification|skill|memory-context|mcp-instructions|available-deferred-tools|event)\b/i;
+  /^<(?:system-reminder|skill|memory-context|mcp-instructions|available-deferred-tools|event)\b/i;
 const INTERNAL_TRANSCRIPT_SYNTHETIC_RE =
   /^(?:\[mixdog-runtime\]|A previous model worked on this task and produced the compacted handoff summary below\b|Re-attached after compaction\b|Reference files:\s)/i;
-const INTERNAL_TRANSCRIPT_ASYNC_HEAD_RE =
-  /^The async (?:agent task|shell task|\w+ execution) \S+ has (?:finished|completed)\b/i;
+const INTERNAL_TRANSCRIPT_ASYNC_HEAD_RE = /^Async .+ finished\./i;
 // Persisted USER cancellation control rows ("[Request interrupted by user]"
 // and its tool-use variant) exist for the next model step, not for humans:
 // the human already saw the cancel they typed. The live engine path already
@@ -222,6 +197,16 @@ const INTERNAL_TRANSCRIPT_ASYNC_HEAD_RE =
 // (scripts/turn-checkpoint-crash-test.mjs).
 const INTERNAL_TRANSCRIPT_INTERRUPT_RE =
   /^\[request interrupted by user(?: for tool use)?\]$/i;
+const TRANSCRIPT_CANCELLED_STATUS_RE =
+  /^\[request interrupted(?: by process restart)?\]$/i;
+
+// Crash/implicit interruption markers remain in model-visible history for
+// recovery, but every human transcript renders them as a Cancelled status row.
+// Explicit user-cancel markers stay on the hidden-control-row path above
+// because the live surface already emitted its cancellation status.
+export function isTranscriptCancelledStatusText(text) {
+  return TRANSCRIPT_CANCELLED_STATUS_RE.test(String(text ?? '').trim());
+}
 
 // One display-only policy for every transcript surface. Runtime control rows
 // may be persisted as ordinary role:user messages so the next model step can
@@ -245,9 +230,7 @@ export function isInternalTranscriptDisplayText(text) {
   const resultSplit = /\r?\n(?:[ \t]*\r?\n)?Result:[ \t]*\r?\n/i.exec(value);
   if (!resultSplit) return false;
   const preamble = value.slice(0, resultSplit.index).trim();
-  const instructionLike = MODEL_VISIBLE_COMPLETION_INSTRUCTION_RE.test(preamble)
-    || MODEL_VISIBLE_COMPLETION_REVIEW_RE.test(preamble)
-    || MODEL_VISIBLE_COMPLETION_ASYNC_HEADER_RE.test(preamble);
+  const instructionLike = MODEL_VISIBLE_COMPLETION_ASYNC_HEADER_RE.test(preamble);
   if (!instructionLike) return false;
   const normalizedBody = value.slice(resultSplit.index + resultSplit[0].length)
     .split(/\r?\n/)

package/src/runtime/shared/tool-result-summary.mjs

@@ -169,7 +169,7 @@ function firstAgentResultLine(text) {
     const trimmed = line.trim();
     if (!trimmed) continue;
     if (/^agent result\b/i.test(trimmed)) continue;
-    if (/^<\/?(?:final-answer|task-notification|task-id|tool-use-id|output-file|result|status|summary|usage|total_tokens|tool_uses|duration_ms|worktree|worktreePath|worktreeBranch)[^>]*>$/i.test(trimmed)) continue;
+    if (/^<\/?(?:final-answer|task-id|tool-use-id|output-file|result|status|summary|usage|total_tokens|tool_uses|duration_ms|worktree|worktreePath|worktreeBranch)[^>]*>$/i.test(trimmed)) continue;
         if (/^(?:agent task|status|type|target|role|agent|preset|model|effort|fast|limits|session|task-id|task_id|notification|queueDepth|worker|worker_stage|last_progress|silent_for|watchdog|queued_followups|diagnostic|started|finished|elapsed|reused):\s*/i.test(trimmed)) continue;
     if (/^\[[a-z-]+:\s*[^\]]*\]$/i.test(trimmed)) continue;
     return truncateSingleLine(trimmed, AGENT_SURFACE_BRIEF_MAX);

package/src/session-runtime/notification-bus.test.mjs

@@ -18,7 +18,7 @@ const completionMeta = {
   execution_surface: 'agent',
   execution_id: 'task-agent-1',
   status: 'completed',
-  instruction: 'The async agent task task-agent-1 has finished (completed) - review this result in your next step. Final result follows; do not recheck.',
+  instruction: 'Async agent task task-agent-1 (completed) finished.',
 };
 
 test('session-id authority delivers to only the requested Lead among simultaneous listeners', () => {

package/src/session-runtime/provider-request-snapshot.mjs

@@ -306,30 +306,23 @@ export function snapshotProviderRequestTools(options = {}) {
     || names.size === 0) {
     return finish();
   }
-  const discovered = new Set(parseToolSelection(session?.deferredDiscoveredTools));
-  for (const message of Array.isArray(messages) ? messages : []) {
-    const native = message?.nativeToolSearch;
-    const source = clean(native?.provider).toLowerCase();
-    if (source && source !== normalizedProvider
-      && !(ANTHROPIC_NATIVE_PROVIDERS.has(source)
-        && ANTHROPIC_NATIVE_PROVIDERS.has(normalizedProvider))) continue;
-    for (const name of parseToolSelection(native?.toolReferences)) discovered.add(name);
-  }
-  if (discovered.size === 0) return finish();
-
-  // Catalog arrays have no separate key map, so `name` is their explicit
-  // selection key contract: capture it once, skip undiscovered/duplicate
-  // entries without touching schemas, and seed selected normalization with the
-  // captured value to avoid a second getter evaluation.
+  // Anthropic tools precede every cache_control breakpoint. Adding a schema
+  // after tool_search therefore invalidates the whole provider cache prefix.
+  // Send the complete defer_loading catalog from the first request instead;
+  // tool_search controls callability, not provider-visible schema membership.
   const seenCatalogRefs = new WeakSet();
-  for (const tool of Array.isArray(session?.deferredToolCatalog) ? session.deferredToolCatalog : []) {
+  const catalog = [
+    ...(Array.isArray(session?.deferredToolCatalog) ? session.deferredToolCatalog : []),
+    ...(Array.isArray(session?.deferredLateToolCatalog) ? session.deferredLateToolCatalog : []),
+  ];
+  for (const tool of catalog) {
     if (tool && typeof tool === 'object') {
       if (activeCandidateRefs.has(tool) || seenCatalogRefs.has(tool)) continue;
       seenCatalogRefs.add(tool);
     }
     const capturedName = tool?.name;
     const selectionName = typeof capturedName === 'string' ? clean(capturedName) : '';
-    if (!selectionName || !discovered.has(selectionName) || names.has(selectionName)) continue;
+    if (!selectionName || names.has(selectionName)) continue;
     appendSnapshot(tool, capturedName, true);
   }
   return finish();

package/src/session-runtime/provider-request-snapshot.test.mjs

@@ -0,0 +1,37 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { snapshotProviderRequestTools } from './provider-request-snapshot.mjs';
+
+test('Anthropic deferred tool surface is complete and byte-stable from the first send', () => {
+    const session = {
+        provider: 'anthropic-oauth',
+        deferredNativeTools: true,
+        deferredToolCatalog: [
+            { name: 'shell', inputSchema: { type: 'object', properties: {} } },
+            { name: 'recall', inputSchema: { type: 'object', properties: {} } },
+        ],
+    };
+    const tools = [{ name: 'load_tool', inputSchema: { type: 'object', properties: {} } }];
+    const first = snapshotProviderRequestTools({
+        provider: session.provider,
+        tools,
+        messages: [],
+        session,
+    });
+    const later = snapshotProviderRequestTools({
+        provider: session.provider,
+        tools,
+        messages: [{
+            role: 'tool',
+            nativeToolSearch: {
+                provider: 'anthropic-oauth',
+                toolReferences: ['shell'],
+            },
+        }],
+        session,
+    });
+    assert.deepEqual(JSON.parse(JSON.stringify(later)), JSON.parse(JSON.stringify(first)));
+    assert.deepEqual(first.map((tool) => tool.name), ['load_tool', 'shell', 'recall']);
+    assert.equal(first[1].deferLoading, true);
+    assert.equal(first[2].deferLoading, true);
+});

package/src/standalone/hook-bus/handlers.mjs

@@ -519,7 +519,6 @@ export function parseHandlerOutput(run, eventName) {
     updatedToolName: null,
     updatedToolOutput: null,
     additionalContext: null,
-    systemMessage: null,
     suppressOutput: false,
     continueFlag: undefined,
     askReason: null,
@@ -552,7 +551,6 @@ export function parseHandlerOutput(run, eventName) {
       out.reason = limitText(json.reason || out.reason || `blocked by ${eventName} hook`);
     }
     if (json.suppressOutput) out.suppressOutput = true;
-    if (typeof json.systemMessage === 'string') out.systemMessage = limitText(json.systemMessage);
     if (typeof json.additionalContext === 'string') out.additionalContext = limitText(json.additionalContext);
 
     const hso = json.hookSpecificOutput;

package/src/standalone/hook-bus.mjs

@@ -271,7 +271,6 @@ export function createStandaloneHookBus({ maxEvents = 80, dataDir = null, prompt
       updatedToolName: null,
       updatedToolOutput: null,
       additionalContext: [],
-      systemMessage: null,
       ask: false,
       askReason: null,
       handlersRun: handlers.length,
@@ -303,7 +302,6 @@ export function createStandaloneHookBus({ maxEvents = 80, dataDir = null, prompt
       }
       const parsed = parseHandlerOutput(run, eventName);
       if (parsed.additionalContext) agg.additionalContext.push(parsed.additionalContext);
-      if (parsed.systemMessage && !agg.systemMessage) agg.systemMessage = parsed.systemMessage;
       if (parsed.updatedInput && !agg.updatedInput) agg.updatedInput = parsed.updatedInput;
       if (parsed.updatedToolName && !agg.updatedToolName) agg.updatedToolName = parsed.updatedToolName;
       if (parsed.updatedToolOutput != null && agg.updatedToolOutput == null) agg.updatedToolOutput = parsed.updatedToolOutput;
@@ -509,7 +507,6 @@ export function createStandaloneHookBus({ maxEvents = 80, dataDir = null, prompt
         blocked: agg.blocked || undefined,
         reason: agg.reason || undefined,
         additionalContext: agg.additionalContext.length ? agg.additionalContext : undefined,
-        systemMessage: agg.systemMessage || undefined,
         updatedInput: agg.updatedInput || undefined,
         updatedToolName: agg.updatedToolName || undefined,
         handlersRun: agg.handlersRun || undefined,

package/src/tui/dist/index.mjs

@@ -3505,7 +3505,7 @@ function firstAgentResultLine(text) {
     const trimmed = line.trim();
     if (!trimmed) continue;
     if (/^agent result\b/i.test(trimmed)) continue;
-    if (/^<\/?(?:final-answer|task-notification|task-id|tool-use-id|output-file|result|status|summary|usage|total_tokens|tool_uses|duration_ms|worktree|worktreePath|worktreeBranch)[^>]*>$/i.test(trimmed)) continue;
+    if (/^<\/?(?:final-answer|task-id|tool-use-id|output-file|result|status|summary|usage|total_tokens|tool_uses|duration_ms|worktree|worktreePath|worktreeBranch)[^>]*>$/i.test(trimmed)) continue;
     if (/^(?:agent task|status|type|target|role|agent|preset|model|effort|fast|limits|session|task-id|task_id|notification|queueDepth|worker|worker_stage|last_progress|silent_for|watchdog|queued_followups|diagnostic|started|finished|elapsed|reused):\s*/i.test(trimmed)) continue;
     if (/^\[[a-z-]+:\s*[^\]]*\]$/i.test(trimmed)) continue;
     return truncateSingleLine(trimmed, AGENT_SURFACE_BRIEF_MAX);
@@ -11641,7 +11641,7 @@ function joinActionAgent(action, agent) {
 function agentResponseTitle(args, count = 1) {
   const total = Math.max(1, Number(count) || 1);
   if (total > 1) return `Responses ${total} agents`;
-  const name = titleizeAgentName(args?.agent || args?.subagent_type || args?.name || "");
+  const name = titleizeAgentName(args?.agent || args?.subagent_type || args?.name || "") || "Agent";
   return withModelAndTag(joinActionAgent("Response", name), args);
 }
 function agentActionTitle(args) {
@@ -11684,7 +11684,7 @@ function hasAgentResponseResult(value) {
     }
     if (/^agent result\b/i.test(trimmed)) continue;
     if (/^(?:undefined|null)$/i.test(trimmed)) continue;
-    if (/^<\/?(?:final-answer|task-notification|task-id|tool-use-id|output-file|result|status|summary|usage|total_tokens|tool_uses|duration_ms|worktree|worktreePath|worktreeBranch)[^>]*>$/i.test(trimmed)) continue;
+    if (/^<\/?(?:final-answer|task-id|tool-use-id|output-file|result|status|summary|usage|total_tokens|tool_uses|duration_ms|worktree|worktreePath|worktreeBranch)[^>]*>$/i.test(trimmed)) continue;
     if (!sawBlank && /^(?:agent task|background task|agent message queued\b|agent close:|task_id|surface|operation|label|status|type|target|agent|preset|model|effort|fast|limits|started|finished|error|notification|queueDepth):?\s*/i.test(trimmed)) continue;
     if (!sawBlank && /^(?:agents|tasks):\s*/i.test(trimmed)) continue;
     if (/^\(no agents or tasks\)$/i.test(trimmed)) continue;

package/src/tui/session/agent-envelope.mjs

@@ -20,7 +20,7 @@ function stripSyntheticAgentTags(text) {
   if (taskResult) return taskResult;
   return value
     .replace(/^agent result[^\n]*(?:\n|$)/i, '')
-    .replace(/<\/?(?:final-answer|task-notification|task-id|tool-use-id|output-file|result|status|summary|usage|total_tokens|tool_uses|duration_ms|worktree|worktreePath|worktreeBranch)[^>]*>/gi, '')
+    .replace(/<\/?(?:final-answer|task-id|tool-use-id|output-file|result|status|summary|usage|total_tokens|tool_uses|duration_ms|worktree|worktreePath|worktreeBranch)[^>]*>/gi, '')
     .trim();
 }
 
@@ -153,8 +153,7 @@ export function parseModelVisibleCompletionWrapper(text) {
   const split = /\n\nResult:\n/.exec(value);
   if (!split) return null;
   const preamble = value.slice(0, split.index).trim();
-  if (!/^The async \S+ task \S+ has finished\b[\s\S]*review this result in your next step\.?(?: Final result follows; do not recheck\.)?$/i.test(preamble)
-      && !/^Async \S+.* finished\.$/i.test(preamble)) {
+  if (!/^Async \S+.* finished\.$/i.test(preamble)) {
     return null;
   }
   const quotedLines = value.slice(split.index + split[0].length).split(/\r?\n/);
@@ -243,37 +242,43 @@ export function parseSyntheticAgentMessage(text) {
       isError: /^(failed|error|timeout|cancelled|canceled|killed|denied)$/i.test(label),
     };
   }
-  if (/<task-notification\b/i.test(value)) {
-    const status = textBetweenTag(value, 'status') || 'completed';
-    const summary = textBetweenTag(value, 'summary') || `Agent ${status}`;
-    const taskId = textBetweenTag(value, 'task-id');
-    const result = stripSyntheticAgentTags(value);
-    return {
-      name: 'agent',
-      label: status,
-      taskId,
-      summary,
-      result: result || summary,
-    };
-  }
   return null;
 }
 
 export function buildExecutionResponseToolItem(text, {
   id,
   responseKey = '',
+  executionSurface = '',
+  executionStatus = '',
   now = Date.now(),
 } = {}) {
-  const synthetic = parseSyntheticAgentMessage(text);
+  const surface = String(executionSurface || '').trim().toLowerCase();
+  const status = String(executionStatus || '').trim().toLowerCase();
+  const explicitName = /^(agent|shell|search)$/.test(surface) ? surface : '';
+  const parsed = parseSyntheticAgentMessage(text);
+  const synthetic = parsed || (explicitName ? {
+    name: explicitName,
+    label: status || 'completed',
+    args: {
+      type: 'result',
+      status: status || undefined,
+      task_id: responseKey || undefined,
+      surface: explicitName,
+    },
+    result: String(text ?? '').trim(),
+  } : null);
   if (!synthetic) return null;
   const label = synthetic.label || 'notification';
-  const isAgent = synthetic.name === 'agent';
+  const name = explicitName || synthetic.name || 'task';
+  const isAgent = name === 'agent';
   const args = {
     ...(synthetic.args && typeof synthetic.args === 'object' ? synthetic.args : {
       type: label,
       task_id: synthetic.taskId || undefined,
       description: synthetic.summary || 'execution notification',
     }),
+    ...(surface ? { surface } : {}),
+    ...(status ? { status } : {}),
     ...(isAgent ? { type: 'result' } : {}),
   };
   const rawResult = synthetic.rawResult ?? text;
@@ -282,7 +287,7 @@ export function buildExecutionResponseToolItem(text, {
   return {
     kind: 'tool',
     id,
-    name: synthetic.name || 'task',
+    name,
     args,
     result: synthetic.result,
     rawResult,

package/src/tui/session/agent-job-feed.mjs

@@ -326,11 +326,12 @@ export function createAgentJobFeed({
         if (firstDelivery && !successfulPreview && !bodyAlreadyDisplayed) {
           if (cardKey) rememberDisplayedExecutionNotificationKey(cardKey, terminal, executionId);
           if (executionId) rememberDisplayedExecutionResponseState(executionId, hasBody ? 'body' : 'preview', terminal);
-          // Execution completions are inbound agent responses. The session runtime keeps
-          // their aggregation tail-safe (only an immediately-adjacent inbound
-          // response of the same preview/body phase can merge); the fallback
-          // preserves the standalone path for minimal/test harnesses.
-          (pushAsyncAgentResponse || pushUserOrSyntheticItem)(delivery.displayText, nextId(), 'injected', { responseKey: executionId });
+          // Preserve the canonical execution surface through card construction;
+          // text parsing remains a fallback for restored/legacy envelopes.
+          (pushAsyncAgentResponse || pushUserOrSyntheticItem)(delivery.displayText, nextId(), 'injected', {
+            responseKey: executionId,
+            ...(delivery.executionMeta || {}),
+          });
         }
         refreshAgentStatus(parsed);
         const resumeBody = String(delivery.modelContent || '').trim();

package/src/tui/session/completion-card-restore.test.mjs

@@ -9,7 +9,7 @@ import assert from 'node:assert/strict';
 import { restoreTranscriptItems } from './session-api-ext.mjs';
 
 const wrapper = (taskId, body) => [
-  `The async shell task ${taskId} has finished (completed, exit 0) - review this result in your next step. Final result follows; do not recheck.`,
+  `Async shell task ${taskId} (completed, exit 0) finished.`,
   '',
   'Result:',
   ...body.split('\n').map((line) => `> ${line}`),
@@ -45,7 +45,7 @@ test('completion wrapper user rows restore as tool cards, not dropped rows', ()
   assert.equal(card.isError, false);
   assert.match(String(card.result || ''), /8\/8 Mean: 1\.000/);
   // The raw wrapper must never surface as a plain user bubble.
-  assert.ok(!items.some((it) => it?.kind === 'user' && /The async shell task/.test(it.text || '')));
+  assert.ok(!items.some((it) => it?.kind === 'user' && /Async shell task/.test(it.text || '')));
 });
 
 test('non-wrapper internal rows stay suppressed on restore', () => {

package/src/tui/session/notification-plan.mjs

@@ -97,5 +97,9 @@ export function resolveTuiRuntimeNotificationDelivery(event, text) {
     action: 'execution-ui',
     displayText: trimmed,
     modelContent,
+    executionMeta: {
+      executionSurface: String(meta.execution_surface || '').trim(),
+      executionStatus: String(meta.status || parsed?.status || '').trim(),
+    },
   };
 }

package/src/tui/session/session-api-ext.mjs

@@ -10,7 +10,10 @@ import { getVoiceStatus, toggleVoice } from '../lib/voice-setup.mjs';
 import { createSessionOAuthFlowRegistry } from './oauth-flows.mjs';
 import { aggregateToolCategoryEntries, aggregateDoneCategories, classifyToolCategory, formatAggregateDetail, summarizeToolResult, toolLoadingTargets } from '../../runtime/shared/tool-surface.mjs';
 import { aggregateBucketForCategory, aggregateRawResult, failureDetailText, toolCallOutcome } from './tool-result-status.mjs';
-import { isInternalTranscriptDisplayText } from '../../runtime/shared/tool-execution-contract.mjs';
+import {
+  isInternalTranscriptDisplayText,
+  isTranscriptCancelledStatusText,
+} from '../../runtime/shared/tool-execution-contract.mjs';
 import { toolResultTerminalStatus } from '../../runtime/shared/tool-status.mjs';
 
 export function restoredTranscriptMetadata(message) {
@@ -253,7 +256,7 @@ function restoredUserTranscriptItems(message, nextId) {
   const text = (typeof message?.content === 'string'
     ? message.content
     : toolResultText(message?.content)).trim();
-  // Persisted async-completion wrappers ("The async shell task ... Result:
+  // Persisted async-completion wrappers ("Async shell task ... finished. Result:
   // > ...") are the only durable record of a background completion — the live
   // Response card is an event-time push that does not survive a transcript
   // rebuild. Restore them as tool cards instead of dropping them with the
@@ -288,10 +291,7 @@ function restoredUserTranscriptItems(message, nextId) {
   // Crash-recovery control row: keep the persisted marker for the next model
   // step, but render it like a live cancel tail (◈ Cancelled) instead of a
   // raw user bubble with bracketed internals.
-  if (/^\[request interrupted by process restart\]$/i.test(text)) {
-    return [{ kind: 'turndone', id: nextId(), status: 'cancelled', elapsedMs: 0 }];
-  }
-  if (/^\[request interrupted\]$/i.test(text)) {
+  if (isTranscriptCancelledStatusText(text)) {
     return [{ kind: 'turndone', id: nextId(), status: 'cancelled', elapsedMs: 0 }];
   }
   const synthetic = parseSyntheticAgentMessage(text);

package/src/tui/session-local.mjs

@@ -741,6 +741,8 @@ export async function createLocalSessionRuntime({
     const responseItem = buildExecutionResponseToolItem(text, {
       id,
       responseKey: metadata.responseKey || metadata.executionId,
+      executionSurface: metadata.executionSurface,
+      executionStatus: metadata.executionStatus,
     });
     if (!responseItem) return pushUserOrSyntheticItem(text, id, origin);
     if (responseItem.name !== 'agent') {