mixdog 0.8.0 → 0.9.0

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

@@ -5,35 +5,44 @@ import { join } from 'path';
 import { getProvider, providerInputExcludesCache } from '../providers/registry.mjs';
 import { getModelMetadataSync } from '../providers/model-catalog.mjs';
 import { fetchOAuthUsageSnapshot } from '../providers/oauth-usage.mjs';
-import { agentLoop } from './loop.mjs';
+// Image content is kept in-memory and in the model-visible history so multi-turn
+// recognition matches reference agent behavior (live transcript always retains images). The
+// stored-history placeholder swap now happens only at disk-serialization time
+// inside the session store, so it is no longer imported here.
 import {
-    compactActiveTurn,
-    compactMessages,
+    recallFastTrackCompactMessages,
     semanticCompactMessages,
+    compactTypeIsRecallFastTrack,
+    compactTypeIsSemantic,
+    normalizeCompactType,
+    DEFAULT_COMPACT_TYPE,
+    SUMMARY_PREFIX,
     DEFAULT_COMPACTION_BUFFER_RATIO,
     compactionBufferTokensForBoundary,
     normalizeCompactionBufferRatio,
+    drainSessionCycle1,
 } from './compact.mjs';
-import { estimateMessagesTokens, estimateRequestReserveTokens } from './context-utils.mjs';
+import { estimateMessagesTokens, estimateRequestReserveTokens, estimateTranscriptContextUsage } from './context-utils.mjs';
 import { getMcpTools } from '../mcp/client.mjs';
 import { getInternalTools, executeInternalTool } from '../internal-tools.mjs';
-import { BUILTIN_TOOLS } from '../tools/builtin.mjs';
+import { BUILTIN_TOOLS } from '../tools/builtin/builtin-tools.mjs';
 import { PATCH_TOOL_DEFS } from '../tools/patch-tool-defs.mjs';
 import { CODE_GRAPH_TOOL_DEFS } from '../tools/code-graph-tool-defs.mjs';
-import { executeCodeGraphTool } from '../tools/code-graph.mjs';
-import { closeBashSession } from '../tools/bash-session.mjs';
-import { collectSkillsCached, buildSkillToolDefs, loadAgentTemplate, loadRoleTemplate, composeSystemPrompt, collectMixdogMd } from '../context/collect.mjs';
-import { saveSession, saveSessionAsync, loadSession, listStoredSessions, sweepStaleSessions, markSessionClosed, publishHeartbeat, deleteHeartbeat, setLiveSession } from './store.mjs';
+import { collectSkillsCached, buildSkillManifest, buildSkillToolDefs, composeSystemPrompt } from '../context/collect.mjs';
+import { saveSession, saveSessionAsync, loadSession, listStoredSessionSummaries, sweepStaleSessions, markSessionClosed, publishHeartbeat, deleteHeartbeat, setLiveSession } from './store.mjs';
 import { clearReadDedupSession, tryPrefetchCached, setPrefetchCached } from './read-dedup.mjs';
 import { clearOffloadSession } from './tool-result-offload.mjs';
 import { classifyResultKind } from './result-classification.mjs';
 import { createAbortController } from '../../../shared/abort-controller.mjs';
+import { isInternalRuntimeNotificationText as contractIsInternalRuntimeNotificationText } from '../../../shared/tool-execution-contract.mjs';
 import { logLlmCall } from '../../../shared/llm/usage-log.mjs';
 import { resolvePluginData, mixdogRoot } from '../../../shared/plugin-paths.mjs';
 import { updateJsonAtomicSync } from '../../../shared/atomic-file.mjs';
-import { appendBridgeTrace } from '../bridge-trace.mjs';
-import { maxMtime, maxMtimeRecursive } from '../cache-mtime.mjs';
-import { getRoleInstructionDir } from '../internal-roles.mjs';
+import { appendAgentTrace } from '../agent-trace.mjs';
+import { isAgentOwner } from '../agent-owner.mjs';
+import { maxMtimeRecursive } from '../cache-mtime.mjs';
+import { getHiddenRole, getRoleInstructionDir, listHiddenRoleNames } from '../internal-roles.mjs';
+import { DEFAULT_ACTIVITY_HEARTBEAT_MS } from '../stall-policy.mjs';
 import {
     buildGatewayLimits,
     recordGatewayUsageEvent,
@@ -53,80 +62,134 @@ const _rulesBuilder = (() => {
     try { return _require('../../../../lib/rules-builder.cjs'); } catch { return null; }
 })();
 
-// bridgeRules is the bridge shared prefix (shared rules + bridge common rules +
-// user agent configs). It's rebuilt from disk
-// by rules-builder.cjs on every call; since createSession fires on every
-// Pool B/C bridge turn, that's a lot of redundant readFileSync + concat.
-// BP1/BP3 cache — invalidated by source file mtime, not a timer.
-// Cheap: O(sentinel-count) stat calls on each bridge turn, no I/O otherwise.
-// BP1 cache — single shared entry. buildBridgeInjectionContent is
-// role-agnostic (true cross-role common), so every bridge role reuses the
-// same prefix bytes.
-let _bridgeRulesCache = null;
-let _bridgeRulesMtime = 0;
-function _buildBridgeRules() {
-    if (!_rulesBuilder || typeof _rulesBuilder.buildBridgeInjectionContent !== 'function') return '';
+// BP1/BP2/BP3 prompt-layer caches — invalidated by source file mtime, not a
+// timer. Cheap: O(sentinel-count) stat calls on each session creation, no file
+// I/O when warm.
+let _sharedRulesCache = null;
+let _sharedRulesMtime = 0;
+const _agentRulesCacheByProfile = new Map();
+let _leadRulesCache = null;
+let _leadRulesMtime = 0;
+let _leadMetaCache = null;
+let _leadMetaMtime = 0;
+let _codeGraphRuntimePromise = null;
+let _agentLoopPromise = null;
+let _bashSessionRuntimePromise = null;
+async function _executeCodeGraphToolLazy(name, args, cwd, signal = null, options = {}) {
+    _codeGraphRuntimePromise ??= import('../tools/code-graph.mjs');
+    const mod = await _codeGraphRuntimePromise;
+    if (typeof mod.executeCodeGraphTool !== 'function') throw new Error('code_graph runtime is not available');
+    return mod.executeCodeGraphTool(name, args, cwd, signal, options);
+}
+async function _getAgentLoop() {
+    _agentLoopPromise ??= import('./loop.mjs');
+    const mod = await _agentLoopPromise;
+    if (typeof mod.agentLoop !== 'function') throw new Error('agent loop runtime is not available');
+    return mod.agentLoop;
+}
+function _closeBashSessionLazy(sessionId, reason) {
+    if (!sessionId) return;
+    _bashSessionRuntimePromise ??= import('../tools/bash-session.mjs');
+    _bashSessionRuntimePromise
+        .then((mod) => { if (typeof mod.closeBashSession === 'function') mod.closeBashSession(sessionId, reason); })
+        .catch(() => {});
+}
+function _buildSharedRules() {
+    if (!_rulesBuilder || typeof _rulesBuilder.buildSharedToolContent !== 'function') return '';
     const PLUGIN_ROOT = mixdogRoot();
-    const DATA_DIR = resolvePluginData();
     const RULES_DIR = join(PLUGIN_ROOT, 'rules');
     const mtime = maxMtimeRecursive([
         join(RULES_DIR, 'shared'),
-        join(RULES_DIR, 'bridge'),
-        join(DATA_DIR, 'roles'),
+    ]);
+    if (_sharedRulesCache !== null && mtime <= _sharedRulesMtime) {
+        return _sharedRulesCache;
+    }
+    try {
+        const built = _rulesBuilder.buildSharedToolContent({ PLUGIN_ROOT, DATA_DIR: resolvePluginData() });
+        _sharedRulesCache = built;
+        _sharedRulesMtime = mtime;
+        return built;
+    } catch (e) {
+        throw new Error(`[session] shared tool rules build failed: ${e.message}`);
+    }
+}
+
+function _buildAgentRules(profile = 'full') {
+    if (!_rulesBuilder || typeof _rulesBuilder.buildAgentRoleContent !== 'function') return '';
+    const key = String(profile || 'full');
+    const PLUGIN_ROOT = mixdogRoot();
+    const DATA_DIR = resolvePluginData();
+    const RULES_DIR = join(PLUGIN_ROOT, 'rules');
+    const mtime = maxMtimeRecursive([
+        join(RULES_DIR, 'agent'),
         join(DATA_DIR, 'mixdog-config.json'),
     ]);
-    if (_bridgeRulesCache !== null && mtime <= _bridgeRulesMtime) {
-        return _bridgeRulesCache;
+    const cached = _agentRulesCacheByProfile.get(key);
+    if (cached && mtime <= cached.mtime) {
+        return cached.value;
     }
     try {
-        const built = _rulesBuilder.buildBridgeInjectionContent({ PLUGIN_ROOT, DATA_DIR });
-        _bridgeRulesCache = built;
-        _bridgeRulesMtime = mtime;
+        const built = _rulesBuilder.buildAgentRoleContent({ PLUGIN_ROOT, DATA_DIR, profile: key });
+        _agentRulesCacheByProfile.set(key, { mtime, value: built });
         return built;
     } catch (e) {
-        throw new Error(`[session] bridge common rules build failed: ${e.message}`);
+        throw new Error(`[session] agent role rules build failed: ${e.message}`);
     }
 }
 
-let _leadRulesCache = null;
-let _leadRulesMtime = 0;
 function _buildLeadRules() {
-    if (!_rulesBuilder || typeof _rulesBuilder.buildInjectionContent !== 'function') return '';
+    if (!_rulesBuilder || typeof _rulesBuilder.buildLeadRoleContent !== 'function') return '';
     const PLUGIN_ROOT = mixdogRoot();
     const DATA_DIR = resolvePluginData();
     const RULES_DIR = join(PLUGIN_ROOT, 'rules');
-    const mtime = Math.max(maxMtime([
-        PLUGIN_ROOT,
-        DATA_DIR,
-    ]), maxMtimeRecursive([
-        join(RULES_DIR, 'shared'),
+    const mtime = maxMtimeRecursive([
         join(RULES_DIR, 'lead'),
-        join(DATA_DIR, 'history'),
         join(DATA_DIR, 'mixdog-config.json'),
-        join(DATA_DIR, 'user-workflow.md'),
-        join(DATA_DIR, 'user-workflow.json'),
-        join(PLUGIN_ROOT, 'output-styles'),
-        join(DATA_DIR, 'output-styles'),
-    ]));
+    ]);
     if (_leadRulesCache !== null && mtime <= _leadRulesMtime) {
         return _leadRulesCache;
     }
     try {
-        const built = _rulesBuilder.buildInjectionContent({ PLUGIN_ROOT, DATA_DIR });
+        const built = _rulesBuilder.buildLeadRoleContent({ PLUGIN_ROOT, DATA_DIR });
         _leadRulesCache = built;
         _leadRulesMtime = mtime;
         return built;
     } catch (e) {
-        throw new Error(`[session] lead rules build failed: ${e.message}`);
+        throw new Error(`[session] lead role rules build failed: ${e.message}`);
+    }
+}
+
+function _buildLeadMetaContext() {
+    if (!_rulesBuilder || typeof _rulesBuilder.buildLeadMetaContent !== 'function') return '';
+    const PLUGIN_ROOT = mixdogRoot();
+    const DATA_DIR = resolvePluginData();
+    const RULES_DIR = join(PLUGIN_ROOT, 'rules');
+    const mtime = maxMtimeRecursive([
+        join(RULES_DIR, 'lead'),
+        join(DATA_DIR, 'history'),
+        join(DATA_DIR, 'mixdog-config.json'),
+        join(DATA_DIR, 'user-workflow.md'),
+        join(PLUGIN_ROOT, 'output-styles'),
+        join(DATA_DIR, 'output-styles'),
+    ]);
+    if (_leadMetaCache !== null && mtime <= _leadMetaMtime) {
+        return _leadMetaCache;
+    }
+    try {
+        const built = _rulesBuilder.buildLeadMetaContent({ PLUGIN_ROOT, DATA_DIR });
+        _leadMetaCache = built;
+        _leadMetaMtime = mtime;
+        return built;
+    } catch (e) {
+        throw new Error(`[session] lead meta context build failed: ${e.message}`);
     }
 }
 
-// BP3 role-specific cache — keyed by role. webhook / schedule / hidden
-// retrieval roles each have their own scoped instruction set; other roles
-// return ''.
+// BP4-adjacent role-specific data cache — keyed by role. webhook / schedule
+// roles each have their own scoped instruction set; other roles return ''.
 const _roleSpecificCache = new Map(); // role → { value, mtime }
 function _buildRoleSpecific(currentRole) {
-    if (!_rulesBuilder || typeof _rulesBuilder.buildBridgeRoleSpecificContent !== 'function') return '';
+    if (!_rulesBuilder || typeof _rulesBuilder.buildAgentRoleSpecificContent !== 'function') return '';
     if (!currentRole) return '';
     const PLUGIN_ROOT = mixdogRoot();
     const DATA_DIR = resolvePluginData();
@@ -145,7 +208,7 @@ function _buildRoleSpecific(currentRole) {
         return entry.value;
     }
     try {
-        const built = _rulesBuilder.buildBridgeRoleSpecificContent({ PLUGIN_ROOT, DATA_DIR, currentRole });
+        const built = _rulesBuilder.buildAgentRoleSpecificContent({ PLUGIN_ROOT, DATA_DIR, currentRole });
         _roleSpecificCache.set(currentRole, { mtime, value: built });
         return built;
     } catch (e) {
@@ -153,27 +216,27 @@ function _buildRoleSpecific(currentRole) {
     }
 }
 
-// Smart Bridge is optional — injected via setSmartBridge() during plugin init
+// Agent Runtime is optional — injected via setAgentRuntime() during plugin init
 // so session creation never depends on a circular import. If never injected,
 // createSession simply falls back to classic preset-only behavior.
-let _smartBridgeApi = null;
-let _smartBridgeWarned = false;
+let _agentRuntimeApi = null;
+let _agentRuntimeWarned = false;
 
 /**
- * Inject the Smart Bridge singleton. Called once by agent/index.mjs init()
- * after initSmartBridge(). Safe to call multiple times — later calls
+ * Inject the Agent Runtime singleton. Called once by agent/index.mjs init()
+ * after initAgentRuntime(). Safe to call multiple times — later calls
  * replace the previous reference.
  */
-export function setSmartBridge(api) {
-    _smartBridgeApi = api || null;
+export function setAgentRuntime(api) {
+    _agentRuntimeApi = api || null;
 }
 
-function getSmartBridgeSync() {
-    return _smartBridgeApi;
+function getAgentRuntimeSync() {
+    return _agentRuntimeApi;
 }
 
 /**
- * Thrown when a session is closed while a call is in-flight. Callers (bridge
+ * Thrown when a session is closed while a call is in-flight. Callers (agent
  * handler, CLI) should render this as "cancelled" rather than a hard error.
  */
 export class SessionClosedError extends Error {
@@ -189,9 +252,15 @@ export class SessionClosedError extends Error {
     }
 }
 const HEARTBEAT_THROTTLE_MS = 60_000; // 60s
+// Cap how long the terminal unwind blocks on the post-result session save.
+// The result is already produced (and relayed for agent surfaces) before this
+// save, so a stalled disk write must not hold askSession() open — otherwise the
+// owning background task is stranded in `running` and its completion
+// notification never fires. A slow write finishes in the background.
+const TERMINAL_SAVE_TIMEOUT_MS = nonNegativeIntEnv('MIXDOG_TERMINAL_SAVE_TIMEOUT_MS', 5_000);
 
 // Merge externally-connected MCP tools with the plugin's in-process tools
-// (registered by agent's toolExecutor bridge). Internal tools are exposed
+// (registered by agent's toolExecutor adapter). Internal tools are exposed
 // under their bare names — no mcp__ prefix, since the dispatcher in
 // server.mjs handles them directly without a transport.
 // Sorted deterministically by name — protects BP_1 hash stability from
@@ -208,7 +277,7 @@ function _getMcpTools() {
         inputSchema: t.inputSchema || { type: 'object', properties: {} },
         // Keep annotations so the permission filter / role invariants can
         // tell read-only from write-capable internal tools, and so
-        // bridgeHidden can be read during deny filtering.
+        // agentHidden can be read during deny filtering.
         annotations: t.annotations || {},
     }));
     return [...mcp, ...internal].sort((a, b) => {
@@ -233,7 +302,7 @@ function _getMcpTools() {
 // adding a new toolset id here is a localised change.
 //
 // Unified-shard policy — the session's tool array normally never narrows
-// with permission or role. Bridge sessions share the same schema so BP_1
+// with permission or role. Agent sessions share the same schema so BP_1
 // stays bit-identical and the provider-side cache shard is shared
 // workspace-wide. Rare specialist roles may pass schemaAllowedTools from a
 // declarative hidden-role toolSchemaProfile to keep their first-turn routing
@@ -242,6 +311,7 @@ function _getMcpTools() {
 
 const SESSION_ROUTE_TOOL_ORDER = [
     'code_graph',
+    'find',
     'glob',
     'list',
     'grep',
@@ -251,9 +321,9 @@ const SESSION_ROUTE_TOOL_ORDER = [
     'task',
 ];
 const SESSION_ROUTE_TOOL_RANK = new Map(SESSION_ROUTE_TOOL_ORDER.map((name, index) => [name, index]));
-const MODEL_HIDDEN_FILE_MUTATION_TOOLS = new Set(['edit', 'write']);
 const FILESYSTEM_TOOL_NAMES = new Set([
     'code_graph',
+    'find',
     'glob',
     'list',
     'grep',
@@ -262,12 +332,115 @@ const FILESYSTEM_TOOL_NAMES = new Set([
 ]);
 const READONLY_TOOL_NAMES = new Set([
     'code_graph',
+    'find',
+    'glob',
+    'list',
+    'grep',
+    'read',
+]);
+
+const AGENT_STRING_PERMISSION_READ_ALLOW = Object.freeze([
+    'code_graph',
+    'find',
     'glob',
     'list',
     'grep',
     'read',
+    'explore',
+    'search',
+    'web_fetch',
 ]);
 
+function stringToolPermissionAllowList(toolPermission) {
+    if (toolPermission === 'read') return AGENT_STRING_PERMISSION_READ_ALLOW;
+    if (toolPermission === 'read-write') return AGENT_STRING_PERMISSION_READ_WRITE_ALLOW;
+    if (toolPermission === 'none') return [];
+    return null;
+}
+
+const AGENT_STRING_PERMISSION_READ_WRITE_ALLOW = Object.freeze([
+    'code_graph',
+    'find',
+    'glob',
+    'list',
+    'grep',
+    'read',
+    'apply_patch',
+    'explore',
+    'search',
+    'web_fetch',
+]);
+
+function applyToolPermissionNarrowing(tools, toolPermission, warnRole = null) {
+    if (toolPermission === 'none') return [];
+    const allowList = stringToolPermissionAllowList(toolPermission);
+    if (allowList) {
+        const allowSet = new Set(allowList.map((n) => String(n).toLowerCase()));
+        return tools.filter((t) => allowSet.has(String(t?.name || '').toLowerCase()));
+    }
+    if (toolPermission && typeof toolPermission === 'object') {
+        const allowSet = Array.isArray(toolPermission.allow) && toolPermission.allow.length > 0
+            ? new Set(toolPermission.allow.map(n => String(n).toLowerCase()))
+            : null;
+        const denySet = Array.isArray(toolPermission.deny) && toolPermission.deny.length > 0
+            ? new Set(toolPermission.deny.map(n => String(n).toLowerCase()))
+            : null;
+        if (allowSet || denySet) {
+            const filtered = tools.filter(t => {
+                const name = String(t?.name || '').toLowerCase();
+                if (denySet && denySet.has(name)) return false;
+                if (allowSet && !allowSet.has(name)) return false;
+                return true;
+            });
+            if (filtered.length === 0) {
+                process.stderr.write(`[session] WARN: role permission intersection produced 0 tools — failing closed (role=${warnRole || 'unknown'})\n`);
+            }
+            return filtered;
+        }
+    }
+    return tools;
+}
+
+function recursiveWrapperToolNameForPublicAgentRole(role) {
+    if (!role) return null;
+    const key = String(role).trim();
+    for (const hiddenName of listHiddenRoleNames()) {
+        const def = getHiddenRole(hiddenName);
+        const invokedBy = typeof def?.invokedBy === 'string' ? def.invokedBy.trim() : '';
+        if (invokedBy && invokedBy === key) return invokedBy;
+    }
+    return null;
+}
+
+function finalizeSessionToolList(tools, {
+    schemaAllowedTools = null,
+    disallowedTools = null,
+    ownerIsAgent = false,
+    resolvedRole = null,
+} = {}) {
+    let out = Array.isArray(tools) ? tools : [];
+    const hasCallerAllow = Array.isArray(schemaAllowedTools);
+    if (hasCallerAllow) {
+        const allowSet = new Set(schemaAllowedTools.map(n => String(n).toLowerCase()));
+        out = out.filter(t => allowSet.has(String(t?.name || '').toLowerCase()));
+    }
+    const callerDeny = Array.isArray(disallowedTools) ? disallowedTools.map(n => String(n)) : [];
+    if (callerDeny.length) {
+        const denySet = new Set(callerDeny.map(n => n.toLowerCase()));
+        out = out.filter(t => !denySet.has(String(t?.name || '').toLowerCase()));
+    }
+    const recursiveDeny = ownerIsAgent ? recursiveWrapperToolNameForPublicAgentRole(resolvedRole) : null;
+    if (recursiveDeny) {
+        const deny = recursiveDeny.toLowerCase();
+        out = out.filter(t => String(t?.name || '').toLowerCase() !== deny);
+    }
+    if (ownerIsAgent) {
+        out = out.filter(t => !t?.annotations?.agentHidden);
+        out = orderSessionTools(out);
+    }
+    return out;
+}
+
 function orderSessionTools(tools) {
     return tools.map((tool, index) => ({ tool, index }))
         .sort((a, b) => {
@@ -280,18 +453,18 @@ function orderSessionTools(tools) {
 }
 
 const ALL_BUILTIN_SESSION_TOOLS = orderSessionTools(_dedupByName([
-    ...BUILTIN_TOOLS.filter(t => !MODEL_HIDDEN_FILE_MUTATION_TOOLS.has(t?.name)),
+    ...BUILTIN_TOOLS,
     ...PATCH_TOOL_DEFS,
     ...CODE_GRAPH_TOOL_DEFS,
 ]));
 
-function resolveSessionTools(toolSpec, skills, { ownerIsBridge = false } = {}) {
+function resolveSessionTools(toolSpec, skills, { ownerIsAgentSession = false } = {}) {
     const mcp = _getMcpTools();
-    // Bridge sessions freeze the 3 skill meta-tools into the schema
+    // Agent sessions freeze the skill meta-tool into the schema
     // unconditionally — concrete skill resolution is cwd-scoped at tool-call
     // time (loop.mjs), so the schema bytes stay bit-identical across roles /
     // cwds and the provider cache shard does not fragment.
-    const skillTools = buildSkillToolDefs(skills, { ownerIsBridge });
+    const skillTools = buildSkillToolDefs(skills, { ownerIsAgentSession });
     return _computeBaseTools(toolSpec, mcp, skillTools);
 }
 
@@ -315,8 +488,8 @@ function _dedupByName(tools) {
     return [...seen.values()];
 }
 
-// Bridge visibility is declared per-tool via annotations.bridgeHidden.
-// Tools with bridgeHidden:true are stripped from bridge sessions at schema
+// Agent visibility is declared per-tool via annotations.agentHidden.
+// Tools with agentHidden:true are stripped from agent sessions at schema
 // build time (see deny filtering below). No code-level name list needed.
 
 function _computeBaseTools(toolSpec, mcp, skillTools) {
@@ -357,7 +530,7 @@ function _computeBaseTools(toolSpec, mcp, skillTools) {
                     // Name-pattern match: picks up `search` and any future tool
                     // whose name contains `search`. `recall` and `explore` deliberately do NOT match
                     // — they need `tools:mcp` (full mcp surface) or their own
-                    // toolset id if a role wants targeted retrieval. Public bridge
+                    // toolset id if a role wants targeted retrieval. Public agent
                     // roles never reach the wrapper bodies regardless: see the
                     // isBlockedPublicWrapperCall guard in session/loop.mjs.
                     addMany(mcp.filter(t => /search/i.test(t?.name || '')));
@@ -404,7 +577,7 @@ let nextId = Date.now();
 // this map trimmed to live models; older generations slow down reads
 // without buying anything.
 const CONTEXT_WINDOWS = {
-    // OpenAI GPT-5.x family
+    // OpenAI GPT-5.x family (openai / openai-oauth)
     'gpt-5.5': 272000,
     'gpt-5.4': 272000,
     'gpt-5.4-mini': 272000,
@@ -419,12 +592,33 @@ const CONTEXT_WINDOWS = {
     'gemini-3-pro': 1000000,
     'gemini-3.5-flash': 1000000,
     'gemini-3-flash': 1000000,
+    // xAI Grok (catalog polyfill mirror — model-catalog PRICING_OVERRIDES)
+    'grok-build-0.1': 256000,
+    'grok-4.20': 1000000,
 };
+// Family-pattern fallback used only when both the provider catalog and the
+// exact-id table miss (cold metadata, before the LiteLLM/models.dev catalog
+// warms). Keep these aligned with the catalog so /context, gateway, and the
+// runtime agree on the boundary the first time a model is routed. Local models
+// (llama/mistral/phi/qwen/gemma) stay small so an unknown local id never claims
+// a giant window.
 function guessContextWindow(model) {
     if (CONTEXT_WINDOWS[model])
         return CONTEXT_WINDOWS[model];
-    if (model.includes('llama') || model.includes('mistral') || model.includes('phi'))
+    const m = String(model || '').toLowerCase();
+    // Local/self-hosted families — never inflate an unknown local id.
+    if (m.includes('llama') || m.includes('mistral') || m.includes('mixtral')
+        || m.includes('phi') || m.includes('qwen') || m.includes('gemma')
+        || m.includes('deepseek-r1') || m.includes('codellama'))
         return 8192;
+    // Current hosted families by name pattern.
+    if (m.startsWith('claude-opus') || m.startsWith('claude-sonnet')) return 1000000;
+    if (m.startsWith('claude-haiku') || m.startsWith('claude-')) return 200000;
+    if (m.startsWith('gemini-3') || m.startsWith('gemini-2')) return 1000000;
+    if (m.startsWith('gpt-5')) return 272000;
+    if (m.startsWith('grok-build')) return 256000;
+    if (m.startsWith('grok-')) return 1000000;
+    if (m.startsWith('deepseek-v')) return 1000000;
     return 128000;
 }
 function positiveContextWindow(value) {
@@ -445,26 +639,108 @@ function providerNameOf(provider) {
     if (typeof provider === 'string') return provider.toLowerCase();
     return String(provider?.name || provider?.id || '').toLowerCase();
 }
-function compactBufferRatioForSession(session) {
-    const cfg = session?.compaction || {};
-    return normalizeCompactionBufferRatio(
-        cfg.bufferPercent
-            ?? cfg.bufferPct
-            ?? cfg.bufferRatio
-            ?? cfg.bufferFraction
-            ?? process.env.MIXDOG_BRIDGE_COMPACT_BUFFER_PERCENT
-            ?? process.env.MIXDOG_BRIDGE_COMPACT_BUFFER_RATIO,
-        DEFAULT_COMPACTION_BUFFER_RATIO,
+// Buffer-percent parsing trap: normalizeCompactionBufferRatio treats any value
+// > 1 as a percent (n/100) and any value <= 1 as a literal ratio. That is wrong
+// for percent-NAMED inputs: bufferPercent / bufferPct / *_BUFFER_PERCENT = 1
+// means 1% (0.01), but the shared normalizer would read it as the literal ratio
+// 1.0 (100%). Resolve percent-named and ratio-named inputs with the correct
+// semantics here, before handing a finished ratio to the shared helper:
+//   percent inputs: n  -> n/100   (1 -> 0.01, 10 -> 0.10)
+//   ratio inputs:   n  -> n>1 ? n/100 : n   (0.01 -> 0.01, 10 -> 0.10 legacy)
+function resolveBufferRatioCandidate(percentInputs, ratioInputs) {
+    for (const raw of percentInputs) {
+        const n = Number(raw);
+        if (Number.isFinite(n) && n > 0) return Math.min(1, n / 100);
+    }
+    for (const raw of ratioInputs) {
+        const n = Number(raw);
+        if (Number.isFinite(n) && n > 0) return n > 1 ? n / 100 : n;
+    }
+    return null;
+}
+function compactBufferRatioForConfig(cfg = {}) {
+    const resolved = resolveBufferRatioCandidate(
+        [cfg.bufferPercent, cfg.bufferPct, process.env.MIXDOG_AGENT_COMPACT_BUFFER_PERCENT],
+        [cfg.bufferRatio, cfg.bufferFraction, process.env.MIXDOG_AGENT_COMPACT_BUFFER_RATIO],
     );
+    return normalizeCompactionBufferRatio(resolved, DEFAULT_COMPACTION_BUFFER_RATIO);
+}
+function compactBufferRatioForSession(session) {
+    return compactBufferRatioForConfig(session?.compaction || {});
+}
+// Carry the percent/ratio-named buffer config from a compaction config object
+// onto session.compaction so downstream parsers (compactBufferRatioForSession,
+// loop.resolveCompactBufferRatio, contextStatus) honor a configured buffer
+// percent/ratio. Only finite positive values are copied; absent fields stay
+// undefined so the default-ratio fallback still applies.
+function preserveBufferConfigFields(cfg = {}) {
+    const out = {};
+    for (const key of ['bufferPercent', 'bufferPct', 'bufferRatio', 'bufferFraction']) {
+        const n = Number(cfg?.[key]);
+        if (Number.isFinite(n) && n > 0) out[key] = n;
+    }
+    return out;
+}
+const LEGACY_DEFAULT_COMPACTION_BUFFER_RATIO = 0.1;
+function isPersistedZeroBufferTelemetry(cfg = {}, boundaryTokens = 0) {
+    const boundary = positiveContextWindow(boundaryTokens);
+    if (!boundary) return false;
+    if (positiveContextWindow(process.env.MIXDOG_AGENT_COMPACT_BUFFER_TOKENS)) return false;
+    if (Number.isFinite(Number(process.env.MIXDOG_AGENT_COMPACT_BUFFER_PERCENT)) && Number(process.env.MIXDOG_AGENT_COMPACT_BUFFER_PERCENT) > 0) return false;
+    if (Number.isFinite(Number(process.env.MIXDOG_AGENT_COMPACT_BUFFER_RATIO)) && Number(process.env.MIXDOG_AGENT_COMPACT_BUFFER_RATIO) > 0) return false;
+    for (const key of ['bufferPercent', 'bufferPct', 'bufferFraction']) {
+        const n = Number(cfg?.[key]);
+        if (Number.isFinite(n) && n > 0) return false;
+    }
+    const ratio = Number(cfg?.bufferRatio);
+    if (Number.isFinite(ratio) && ratio > 0) return false;
+    const explicitTokens = Number(cfg?.bufferTokens ?? cfg?.buffer);
+    if (!Number.isFinite(explicitTokens) || explicitTokens !== 0) return false;
+    return true;
+}
+function isLegacyDefaultBufferTelemetry(cfg = {}, boundaryTokens = 0) {
+    const boundary = positiveContextWindow(boundaryTokens);
+    if (!boundary) return false;
+    if (positiveContextWindow(process.env.MIXDOG_AGENT_COMPACT_BUFFER_TOKENS)) return false;
+    if (Number.isFinite(Number(process.env.MIXDOG_AGENT_COMPACT_BUFFER_PERCENT)) && Number(process.env.MIXDOG_AGENT_COMPACT_BUFFER_PERCENT) > 0) return false;
+    if (Number.isFinite(Number(process.env.MIXDOG_AGENT_COMPACT_BUFFER_RATIO)) && Number(process.env.MIXDOG_AGENT_COMPACT_BUFFER_RATIO) > 0) return false;
+    // Percent/fraction-named fields are treated as operator config. The legacy
+    // default telemetry always persisted bufferTokens + bufferRatio after a
+    // check/compact pass, so only that shape is migrated away.
+    for (const key of ['bufferPercent', 'bufferPct', 'bufferFraction']) {
+        const n = Number(cfg?.[key]);
+        if (Number.isFinite(n) && n > 0) return false;
+    }
+    const explicitTokens = positiveContextWindow(cfg?.bufferTokens ?? cfg?.buffer);
+    const ratio = Number(cfg?.bufferRatio);
+    if (!explicitTokens || !Number.isFinite(ratio) || Math.abs(ratio - LEGACY_DEFAULT_COMPACTION_BUFFER_RATIO) > 1e-9) return false;
+    const expectedTokens = Math.floor(boundary * LEGACY_DEFAULT_COMPACTION_BUFFER_RATIO);
+    const cfgBoundary = positiveContextWindow(cfg?.boundaryTokens);
+    const cfgTrigger = positiveContextWindow(cfg?.triggerTokens);
+    return explicitTokens === expectedTokens
+        || (cfgBoundary === boundary && cfgTrigger > 0 && explicitTokens === Math.max(0, boundary - cfgTrigger));
+}
+function compactBufferConfigForBoundary(cfg = {}, boundaryTokens = 0) {
+    const base = cfg || {};
+    if (!isLegacyDefaultBufferTelemetry(base, boundaryTokens)
+        && !isPersistedZeroBufferTelemetry(base, boundaryTokens)) {
+        return base;
+    }
+    return {
+        ...base,
+        bufferTokens: null,
+        buffer: null,
+        bufferRatio: null,
+    };
 }
 function compactBufferTokensForSession(session, boundaryTokens) {
-    const cfg = session?.compaction || {};
+    const cfg = compactBufferConfigForBoundary(session?.compaction || {}, boundaryTokens);
     const explicit = positiveContextWindow(cfg.bufferTokens ?? cfg.buffer)
-        || positiveContextWindow(process.env.MIXDOG_BRIDGE_COMPACT_BUFFER_TOKENS)
+        || positiveContextWindow(process.env.MIXDOG_AGENT_COMPACT_BUFFER_TOKENS)
         || 0;
     return compactionBufferTokensForBoundary(boundaryTokens, {
         explicitTokens: explicit,
-        ratio: compactBufferRatioForSession(session),
+        ratio: compactBufferRatioForConfig(cfg),
         maxRatio: 0.25,
     });
 }
@@ -472,8 +748,8 @@ const COMPACT_TARGET_RATIO = 0.02;
 const COMPACT_TARGET_MIN_TOKENS = 4_000;
 const COMPACT_TARGET_MAX_TOKENS = 16_000;
 function compactTargetRatio() {
-    const raw = process.env.MIXDOG_COMPACT_TARGET_PERCENT
-        ?? process.env.MIXDOG_BRIDGE_COMPACT_TARGET_PERCENT
+    const raw = process.env.MIXDOG_AGENT_COMPACT_TARGET_PERCENT
+        ?? process.env.MIXDOG_COMPACT_TARGET_PERCENT
         ?? COMPACT_TARGET_RATIO;
     const n = Number(raw);
     if (!Number.isFinite(n) || n <= 0) return COMPACT_TARGET_RATIO;
@@ -483,8 +759,8 @@ function compactTargetTokensForBoundary(boundaryTokens) {
     const boundary = positiveContextWindow(boundaryTokens);
     if (!boundary) return null;
     const explicit = positiveContextWindow(
-        process.env.MIXDOG_COMPACT_TARGET_TOKENS
-            ?? process.env.MIXDOG_BRIDGE_COMPACT_TARGET_TOKENS,
+        process.env.MIXDOG_AGENT_COMPACT_TARGET_TOKENS
+            ?? process.env.MIXDOG_COMPACT_TARGET_TOKENS,
     );
     if (explicit) return Math.max(1, Math.min(boundary, explicit));
     const minTarget = Math.min(boundary, positiveContextWindow(process.env.MIXDOG_COMPACT_TARGET_MIN_TOKENS) || COMPACT_TARGET_MIN_TOKENS);
@@ -493,10 +769,10 @@ function compactTargetTokensForBoundary(boundaryTokens) {
     return Math.max(1, Math.min(boundary, maxTarget, Math.max(minTarget, byRatio)));
 }
 function defaultEffectiveContextWindowPercent(provider) {
-    // Gateway/statusline route metadata reserves a universal 5% headroom from
+    // Gateway/statusline route metadata reserves a universal 10% headroom from
     // the raw catalog window. Keep session compaction on the same effective
     // capacity so /context, the TUI statusline, and gateway telemetry agree.
-    return 95;
+    return 90;
 }
 function resolveSessionContextMeta(provider, model, seed = {}) {
     const info = typeof provider?.getCachedModelInfo === 'function'
@@ -526,7 +802,8 @@ function resolveSessionContextMeta(provider, model, seed = {}) {
     );
     const pct = boundedPercent(effectiveContextWindowPercent, 100);
     const contextWindow = Math.max(1, Math.floor(rawContextWindow * pct / 100));
-    const explicitCompactLimit = positiveContextWindow(
+    const compactBoundaryTokens = contextWindow;
+    const rawCompactLimit = positiveContextWindow(
         seed.autoCompactTokenLimit
             ?? seed.auto_compact_token_limit
             ?? info?.autoCompactTokenLimit
@@ -534,11 +811,27 @@ function resolveSessionContextMeta(provider, model, seed = {}) {
             ?? catalogInfo?.autoCompactTokenLimit
             ?? catalogInfo?.auto_compact_token_limit,
     );
-    const derivedCompactLimit = contextWindow;
-    const autoCompactTokenLimit = explicitCompactLimit && derivedCompactLimit
-        ? Math.min(explicitCompactLimit, derivedCompactLimit)
-        : (explicitCompactLimit || derivedCompactLimit);
-    const compactBoundaryTokens = contextWindow;
+    // Legacy-data migration: old implementations derived autoCompactTokenLimit
+    // from the full effective/raw window and persisted it onto the session.
+    // A resumed session therefore re-seeds autoCompactTokenLimit == boundary
+    // (or the raw window), which compactTriggerForSession / loop policy used to
+    // honor as an explicit trigger, collapsing the compaction buffer to 0. Only
+    // accept an explicit limit that is STRICTLY BELOW the boundary; a value at
+    // or above the boundary is a derived full-window artifact and is dropped to
+    // null so the trigger falls back to the default boundary trigger.
+    const explicitCompactLimit = rawCompactLimit && rawCompactLimit < compactBoundaryTokens
+        ? rawCompactLimit
+        : null;
+    // Do NOT derive the auto-compact limit from the full effective window.
+    // Setting it to contextWindow makes autoTriggerTokens == boundary and the
+    // compaction buffer collapse to 0 (loop.mjs:708-713 / compactTriggerForSession),
+    // so auto-compact only fires when the context is already at the limit —
+    // at which point semantic compact fails ("result exceeds budget" /
+    // "summary cannot fit") and the turn can no longer be resumed.
+    // Leave it null unless the provider/catalog/seed supplies an explicit
+    // limit; the downstream buffer logic (default 10%, capped 25%) then
+    // triggers compaction with headroom, matching the reference auto-compact threshold.
+    const autoCompactTokenLimit = explicitCompactLimit || null;
     return {
         contextWindow,
         rawContextWindow,
@@ -551,10 +844,36 @@ function compactTriggerForSession(session, boundaryTokens) {
     const boundary = positiveContextWindow(boundaryTokens);
     if (!boundary) return null;
     const autoLimit = positiveContextWindow(session?.autoCompactTokenLimit ?? session?.compaction?.autoCompactTokenLimit);
-    if (autoLimit && autoLimit <= boundary) return Math.max(1, autoLimit);
+    // Only honor an explicit auto-compact limit that sits STRICTLY BELOW the
+    // boundary. A persisted value == boundary (or >=) is a legacy derived
+    // full-window artifact; honoring it collapses the compaction buffer to 0,
+    // so fall through to the default boundary trigger instead.
+    if (autoLimit && autoLimit < boundary) return Math.max(1, autoLimit);
     const buffer = compactBufferTokensForSession(session, boundary);
     return Math.max(1, boundary - buffer);
 }
+// Test-only exports for the legacy auto-compact-limit migration + buffer-config
+// preservation (see scripts/compact-trigger-migration-smoke.mjs).
+export const _resolveSessionContextMeta = resolveSessionContextMeta;
+export const _compactTriggerForSession = compactTriggerForSession;
+export const _preserveBufferConfigFields = preserveBufferConfigFields;
+// 'compacting' is a transient in-flight stage written just before semantic /
+// recall-fasttrack compaction runs. If the process crashes or only partially
+// saves while it is set, a later load/resume reads a session that is NOT
+// actually compacting but whose UI marker (App.jsx / ContextPanel) shows
+// "Compacting conversation" permanently. Normalize that stale transient stage
+// to 'interrupted' so the surface recovers. Terminal stages (post_turn /
+// manual / auto_clear / *_failed / overflow_failed) are intentionally left as
+// the durable record of the last real outcome.
+function normalizeStaleCompactingStage(session) {
+    const c = session?.compaction;
+    if (!c || typeof c !== 'object') return false;
+    if (c.lastStage !== 'compacting' && c.inProgress !== true) return false;
+    c.lastStage = 'interrupted';
+    c.inProgress = false;
+    c.lastCheckedAt = Date.now();
+    return true;
+}
 function compactTargetBudget(boundaryTokens, reserveTokens, _sourceTokens = null, _ratio = null) {
     const boundary = positiveContextWindow(boundaryTokens);
     if (!boundary) return null;
@@ -564,12 +883,21 @@ function compactTargetBudget(boundaryTokens, reserveTokens, _sourceTokens = null
 }
 function semanticCompactionEnabledForSession(session) {
     const cfg = session?.compaction || {};
+    if (process.env.MIXDOG_AGENT_COMPACT_SEMANTIC !== undefined) return envFlag('MIXDOG_AGENT_COMPACT_SEMANTIC', true);
     if (process.env.MIXDOG_COMPACT_SEMANTIC !== undefined) return envFlag('MIXDOG_COMPACT_SEMANTIC', true);
-    if (process.env.MIXDOG_BRIDGE_COMPACT_SEMANTIC !== undefined) return envFlag('MIXDOG_BRIDGE_COMPACT_SEMANTIC', true);
     if (cfg.semantic === false || cfg.semantic === 'false' || cfg.semantic === 'off') return false;
     if (cfg.semantic === true || cfg.semantic === 'true' || cfg.semantic === 'on' || cfg.semantic === 'auto') return true;
     return true;
 }
+function compactTypeForSession(session) {
+    const cfg = session?.compaction || {};
+    const configured = process.env.MIXDOG_AGENT_COMPACT_TYPE
+        ?? process.env.MIXDOG_COMPACT_TYPE
+        ?? cfg.type
+        ?? cfg.compactType
+        ?? cfg.compact_type;
+    return normalizeCompactType(configured, DEFAULT_COMPACT_TYPE);
+}
 function addCompactUsageToSession(session, usage) {
     if (!session || !usage) return;
     const inputTokens = usage.inputTokens || 0;
@@ -582,6 +910,73 @@ function addCompactUsageToSession(session, usage) {
     session.totalCacheWriteTokens = (session.totalCacheWriteTokens || 0) + cacheWriteTokens;
     session.tokensCumulative = (session.tokensCumulative || 0) + inputTokens + outputTokens;
 }
+async function runRecallFastTrackForSession(session, messages, opts = {}) {
+    const sessionId = opts.sessionId || session?.id || null;
+    if (!sessionId) throw new Error('recall-fasttrack requires a session id');
+    const query = `session:${sessionId}:all-chunks`;
+    const querySha = createHash('sha256').update(query).digest('hex').slice(0, 16);
+    const callerCtx = {
+        callerSessionId: sessionId,
+        callerCwd: session?.cwd || undefined,
+        routingSessionId: sessionId,
+        clientHostPid: session?.clientHostPid,
+        signal: opts.signal || null,
+    };
+    const hydrateLimit = positiveContextWindow(session?.compaction?.recallIngestLimit)
+        || Math.max(500, Math.min(5000, messages.length || 0));
+    try {
+        await executeInternalTool('memory', {
+            action: 'ingest_session',
+            sessionId,
+            messages,
+            cwd: session?.cwd,
+            limit: hydrateLimit,
+        }, callerCtx);
+    } catch (err) {
+        try { process.stderr.write(`[session] recall-fasttrack ingest skipped (sess=${sessionId}): ${err?.message || err}\n`); } catch {}
+    }
+    const dumpArgs = {
+        action: 'dump_session_roots',
+        sessionId,
+        includeRaw: true,
+        limit: positiveContextWindow(session?.compaction?.recallChunkLimit ?? session?.compaction?.recallLimit) || hydrateLimit,
+    };
+    const runTool = (name, args) => executeInternalTool(name, args, callerCtx);
+    let recallText = await executeInternalTool('memory', dumpArgs, callerCtx);
+    let cycle1Text = '';
+    const hasRawRows = /(?:^|\n)# raw_pending\s+\d+\s+id=/i.test(String(recallText || ''));
+    if (hasRawRows) {
+        try {
+            // Drain this session's cycle1 in window×concurrency units until no
+            // raw rows remain, so the injected root is fully chunked rather than
+            // carrying the unprocessed transcript tail (single-pass left raw in).
+            const drained = await drainSessionCycle1(runTool, {
+                sessionId,
+                dumpArgs,
+                deadlineMs: positiveContextWindow(session?.compaction?.recallCycle1DeadlineMs) || 120_000,
+                maxPasses: positiveContextWindow(session?.compaction?.recallCycle1MaxPasses) || 0,
+                cycleArgs: {
+                    min_batch: 1,
+                    session_cap: 1,
+                    batch_size: positiveContextWindow(session?.compaction?.recallCycle1BatchSize) || 100,
+                    rows_per_session: positiveContextWindow(session?.compaction?.recallRowsPerSession) || 100,
+                    window_size: positiveContextWindow(session?.compaction?.recallWindowSize) || 20,
+                    concurrency: positiveContextWindow(session?.compaction?.recallConcurrency) || 5,
+                },
+            });
+            recallText = drained.recallText;
+            cycle1Text = drained.cycle1Text;
+            if (drained.rawRemaining > 0) {
+                try { process.stderr.write(`[session] recall-fasttrack drained passes=${drained.passes} rawRemaining=${drained.rawRemaining} (sess=${sessionId})\n`); } catch {}
+            }
+        } catch (err) {
+            try { process.stderr.write(`[session] recall-fasttrack cycle1 skipped (sess=${sessionId}): ${err?.message || err}\n`); } catch {}
+        }
+    } else {
+        cycle1Text = 'cycle1: skipped (session chunks already hydrated)';
+    }
+    return { query, querySha, recallText: [`session_id=${sessionId}`, cycle1Text, recallText].map(v => String(v || '').trim()).filter(Boolean).join('\n\n') };
+}
 async function runSessionCompaction(session, opts = {}) {
     if (!session || session.closed === true) return null;
     const mode = opts.mode === 'auto' ? 'auto' : 'manual';
@@ -598,17 +993,18 @@ async function runSessionCompaction(session, opts = {}) {
     }
     const reserveTokens = estimateRequestReserveTokens(session.tools || []);
     const beforeMessageTokens = estimateMessagesTokens(messages);
-    const lastContextTokens = positiveContextWindow(session.lastContextTokens) || 0;
     const triggerTokens = compactTriggerForSession(session, boundary)
         || positiveContextWindow(session.compaction?.triggerTokens)
         || boundary;
     const bufferTokens = Math.max(0, boundary - triggerTokens);
     const bufferRatio = boundary ? (bufferTokens / boundary) : compactBufferRatioForSession(session);
-    const pressureTokens = Math.max(beforeMessageTokens + reserveTokens, lastContextTokens);
+    const pressureTokens = estimateTranscriptContextUsage(messages, session.tools || []);
     const beforeTokens = pressureTokens;
+    const compactType = compactTypeForSession(session);
     if (!force && pressureTokens < triggerTokens) return {
         changed: false,
         reason: 'below threshold',
+        compactType,
         beforeMessages: messages.length,
         afterMessages: messages.length,
         beforeTokens,
@@ -628,13 +1024,43 @@ async function runSessionCompaction(session, opts = {}) {
     const budgetSourceTokens = force ? Math.max(pressureTokens, triggerTokens) : pressureTokens;
     const compactBudget = compactTargetBudget(boundary, reserveTokens, budgetSourceTokens);
     const budget = compactBudget || boundary;
+    try { opts.onStageChange?.('compacting'); } catch { /* best-effort */ }
     const provider = opts.provider || getProvider(session.provider) || null;
     let compacted;
     let compactError = null;
     let semanticCompactResult = null;
     let semanticCompactError = null;
-    if (semanticCompactionEnabledForSession(session)) {
+    let recallFastTrackResult = null;
+    let recallFastTrackError = null;
+    if (compactTypeIsRecallFastTrack(compactType)) {
+        try {
+            const recallPayload = await runRecallFastTrackForSession(session, messages, opts);
+            recallFastTrackResult = recallFastTrackCompactMessages(messages, budget, {
+                reserveTokens,
+                force: true,
+                recallText: recallPayload.recallText,
+                query: recallPayload.query,
+                querySha: recallPayload.querySha,
+                allowEmptyRecall: true,
+                tailTurns: positiveContextWindow(session.compaction?.tailTurns) || 2,
+                keepTokens: positiveContextWindow(session.compaction?.keepTokens ?? session.compaction?.keep?.tokens),
+                preserveRecentTokens: positiveContextWindow(session.compaction?.preserveRecentTokens),
+            });
+            if (Array.isArray(recallFastTrackResult?.messages)) {
+                compacted = recallFastTrackResult.messages;
+            }
+        } catch (err) {
+            recallFastTrackError = err;
+            compactError = err;
+            try {
+                process.stderr.write(`[session] recall-fasttrack ${mode} compact failed (sess=${session.id || 'unknown'}): ${err?.message || err}\n`);
+            } catch { /* best-effort */ }
+        }
+    } else if (compactTypeIsSemantic(compactType)) {
         try {
+            if (!semanticCompactionEnabledForSession(session)) {
+                throw new Error('semantic compact is disabled for this session');
+            }
             if (!provider || typeof provider.send !== 'function') {
                 throw new Error(`semantic compact provider unavailable: ${session.provider || 'unknown'}`);
             }
@@ -663,22 +1089,14 @@ async function runSessionCompaction(session, opts = {}) {
             }
         } catch (err) {
             semanticCompactError = err;
+            compactError = err;
             try {
-                process.stderr.write(`[session] semantic ${mode} compact failed (sess=${session.id || 'unknown'}): ${err?.message || err}; falling back to deterministic compact\n`);
+                process.stderr.write(`[session] semantic ${mode} compact failed (sess=${session.id || 'unknown'}): ${err?.message || err}\n`);
             } catch { /* best-effort */ }
         }
     }
-    try {
-        if (!compacted) compacted = compactMessages(messages, budget, { reserveTokens, force: true });
-    } catch (err) {
-        try {
-            process.stderr.write(`[session] ${mode} compact fallback (sess=${session.id || 'unknown'}): ${err?.message || err}\n`);
-        } catch { /* best-effort */ }
-        try {
-            compacted = compactActiveTurn(messages, budget, { reserveTokens, force: true });
-        } catch (fallbackErr) {
-            compactError = fallbackErr;
-        }
+    if (!compacted && !compactError) {
+        compactError = new Error(`${compactType} compact produced no messages`);
     }
     if (!compacted) {
         const now = Date.now();
@@ -698,13 +1116,19 @@ async function runSessionCompaction(session, opts = {}) {
             lastPressureTokens: pressureTokens,
             lastCheckedAt: now,
             lastChanged: false,
+            type: compactType,
+            compactType,
+            lastCompactType: compactType,
             lastSemantic: false,
             lastSemanticError: semanticCompactError?.message || null,
-            lastError: compactError?.message || semanticCompactError?.message || String(compactError || semanticCompactError || 'compact failed'),
+            lastRecallFastTrack: false,
+            lastRecallFastTrackError: recallFastTrackError?.message || null,
+            lastError: compactError?.message || semanticCompactError?.message || recallFastTrackError?.message || String(compactError || semanticCompactError || recallFastTrackError || 'compact failed'),
         };
         return {
             changed: false,
             error: session.compaction.lastError,
+            compactType,
             beforeMessages: messages.length,
             afterMessages: messages.length,
             beforeTokens,
@@ -721,6 +1145,8 @@ async function runSessionCompaction(session, opts = {}) {
             reserveTokens,
             semanticCompact: false,
             semanticError: semanticCompactError?.message || null,
+            recallFastTrack: false,
+            recallFastTrackError: recallFastTrackError?.message || null,
         };
     }
     let beforeEncoded = '';
@@ -732,6 +1158,7 @@ async function runSessionCompaction(session, opts = {}) {
     const changed = beforeEncoded && afterEncoded
         ? beforeEncoded !== afterEncoded
         : (compacted.length !== messages.length || afterMessageTokens !== beforeMessageTokens);
+    const unchangedReason = changed ? null : (force ? 'nothing to compact' : 'below threshold');
     const now = Date.now();
     session.messages = compacted;
     session.providerState = undefined;
@@ -743,6 +1170,9 @@ async function runSessionCompaction(session, opts = {}) {
         bufferTokens,
         bufferRatio,
         reserveTokens,
+        type: compactType,
+        compactType,
+        lastCompactType: compactType,
         lastStage: mode === 'auto' ? 'post_turn' : 'manual',
         lastBeforeTokens: beforeTokens,
         lastAfterTokens: afterTokens,
@@ -755,6 +1185,9 @@ async function runSessionCompaction(session, opts = {}) {
         lastCompactAt: changed ? now : session.compaction?.lastCompactAt || null,
         lastSemantic: semanticCompactResult?.semantic === true,
         lastSemanticError: semanticCompactError?.message || null,
+        lastRecallFastTrack: recallFastTrackResult?.recallFastTrack === true,
+        lastRecallFastTrackError: recallFastTrackError?.message || null,
+        lastRecallFastTrackQuerySha: recallFastTrackResult?.query ? createHash('sha256').update(recallFastTrackResult.query).digest('hex').slice(0, 16) : null,
         lastSemanticUsage: semanticCompactResult?.usage ? {
             inputTokens: semanticCompactResult.usage.inputTokens || 0,
             outputTokens: semanticCompactResult.usage.outputTokens || 0,
@@ -766,6 +1199,8 @@ async function runSessionCompaction(session, opts = {}) {
     if (changed && mode === 'auto') session.lastContextTokensStaleAfterCompact = true;
     return {
         changed,
+        reason: unchangedReason,
+        compactType,
         beforeMessages: messages.length,
         afterMessages: compacted.length,
         beforeTokens,
@@ -782,20 +1217,20 @@ async function runSessionCompaction(session, opts = {}) {
         reserveTokens,
         semanticCompact: semanticCompactResult?.semantic === true,
         semanticError: semanticCompactError?.message || null,
+        recallFastTrack: recallFastTrackResult?.recallFastTrack === true,
+        recallFastTrackError: recallFastTrackError?.message || null,
         usage: semanticCompactResult?.usage || null,
     };
 }
-async function autoCompactSessionAfterTurn(session, opts = {}) {
-    return runSessionCompaction(session, { ...opts, mode: 'auto', force: false });
-}
 // Provider-scoped unified cache key. Goal: all orchestrator-internal
-// dispatches (bridge/maintenance/mcp/scheduler/webhook) targeting the
+// dispatches (agent/maintenance/mcp/scheduler/webhook) targeting the
 // same provider land in a single server-side cache shard, so the
 // shared prefix (tools + system + pool system prompt) is reused
-// regardless of role. Per-role / per-session differentiation lives in
-// the message tail, which is naturally separated by content hashing.
+// regardless of role. Per-role / per-session differentiation lives after the
+// system prefix (BP3 sessionMarker system block / later messages), which is
+// naturally separated by provider-side content hashing.
 const PROVIDER_ALIAS = {
-    'openai-oauth': 'codex',      // ChatGPT subscription (Codex backend)
+    'openai-oauth': 'codex',      // ChatGPT subscription (OpenAI OAuth backend)
     'anthropic-oauth': 'claude',  // Claude Max subscription
     'openai': 'openai',
     'anthropic': 'anthropic',
@@ -810,9 +1245,10 @@ function providerCacheKey(provider, override) {
 }
 
 // ── Prefetch permission guard ─────────────────────────────────────────────────
-// Mirrors _checkWorkerPermission in loop.mjs for tool calls that originate
-// in the prefetch path (outside the agent loop). Returns an error string if
-// blocked, or null if allowed.
+// Runs the shared permission evaluator for tool calls that originate in the
+// prefetch path (outside the agent loop). Permission enforcement is disabled
+// (the evaluator always returns allow), so this is effectively a pass-through
+// kept for API compatibility. Returns an error string if blocked, or null.
 const _permEvalForPrefetch = (() => {
     const _req = createRequire(import.meta.url);
     try {
@@ -823,9 +1259,8 @@ const _permEvalForPrefetch = (() => {
 })();
 function _guardedPrefetchTool(toolName, toolArgs, session) {
     if (!_permEvalForPrefetch) return null;
-    // Same baseline as _checkWorkerPermission: when no explicit mode is
-    // attached to the session, run the evaluator under 'default' so the
-    // bypass-proof hard-deny patterns still apply during prefetch dispatch.
+    // When no explicit mode is attached to the session, run the evaluator
+    // under 'default'. The evaluator now always allows, so this never blocks.
     const permissionMode = session?.permissionMode || 'default';
     const projectDir = session?.cwd || undefined;
     const userCwd = session?.cwd || undefined;
@@ -844,7 +1279,7 @@ function _guardedPrefetchTool(toolName, toolArgs, session) {
 
 async function _tryBridgeExplicitPrefetch(session, explicitPrefetch) {
     if (!explicitPrefetch || typeof explicitPrefetch !== 'object') return null;
-    if (session?.owner !== 'bridge') return null;
+    if (!isAgentOwner(session)) return null;
     const parts = [];
     const failed = [];
     const totalEntries = [];
@@ -886,7 +1321,7 @@ async function _tryBridgeExplicitPrefetch(session, explicitPrefetch) {
     if (files.length > 0) {
         const _pfGuard = _guardedPrefetchTool('read', { path: files }, session);
         if (_pfGuard) {
-            process.stderr.write(`[bridge-prefetch] files read blocked: ${_pfGuard}\n`);
+            process.stderr.write(`[agent-prefetch] files read blocked: ${_pfGuard}\n`);
             failed.push(...files);
             totalEntries.push(...files);
         } else {
@@ -930,7 +1365,7 @@ async function _tryBridgeExplicitPrefetch(session, explicitPrefetch) {
                     readArgs.n = Number.isFinite(opts.n) ? opts.n : 120;
                 }
                 const out = await executeInternalTool('read', readArgs).catch((e) => {
-                    process.stderr.write(`[bridge-prefetch] file read failed (${f}): ${e && e.message || e}\n`);
+                    process.stderr.write(`[agent-prefetch] file read failed (${f}): ${e && e.message || e}\n`);
                     return null;
                 });
                 if (out !== null) {
@@ -968,9 +1403,11 @@ async function _tryBridgeExplicitPrefetch(session, explicitPrefetch) {
             parts.push(`### prefetch files\nread ${readParts.length}\n\n${readParts.join('\n\n')}`);
         }
         // Log hit/miss counters so dispatch telemetry shows prefetch effectiveness.
-        process.stderr.write(
-            `[prefetch] files=${files.length} cached=${fileHits.length} miss=${fileMisses.length} failed=${failed.length}\n`
-        );
+        if (process.env.MIXDOG_DEBUG_SESSION_LOG) {
+            process.stderr.write(
+                `[prefetch] files=${files.length} cached=${fileHits.length} miss=${fileMisses.length} failed=${failed.length}\n`
+            );
+        }
         // Attach stats to session so post-hoc analyzers (inspect-session.mjs)
         // can see prefetch effectiveness without parsing stderr logs.
         if (session && typeof session === 'object') {
@@ -992,13 +1429,13 @@ async function _tryBridgeExplicitPrefetch(session, explicitPrefetch) {
             totalEntries.push(symbol);
             const blocked = _guardedPrefetchTool('code_graph', cgArgs, session);
             if (blocked) {
-                process.stderr.write(`[bridge-prefetch] callers(${symbol}) blocked: ${blocked}\n`);
+                process.stderr.write(`[agent-prefetch] callers(${symbol}) blocked: ${blocked}\n`);
                 return Promise.resolve({ symbol, out: null, blocked: true });
             }
-            return executeCodeGraphTool('code_graph', cgArgs, session?.cwd)
+            return _executeCodeGraphToolLazy('code_graph', cgArgs, session?.cwd)
                 .then(out => ({ symbol, out }))
                 .catch(e => {
-                    process.stderr.write(`[bridge-prefetch] callers(${symbol}) failed: ${e && e.message || e}\n`);
+                    process.stderr.write(`[agent-prefetch] callers(${symbol}) failed: ${e && e.message || e}\n`);
                     return { symbol, out: null };
                 });
         });
@@ -1023,13 +1460,13 @@ async function _tryBridgeExplicitPrefetch(session, explicitPrefetch) {
             totalEntries.push(symbol);
             const blocked = _guardedPrefetchTool('code_graph', cgArgs, session);
             if (blocked) {
-                process.stderr.write(`[bridge-prefetch] references(${symbol}) blocked: ${blocked}\n`);
+                process.stderr.write(`[agent-prefetch] references(${symbol}) blocked: ${blocked}\n`);
                 return Promise.resolve({ symbol, out: null, blocked: true });
             }
-            return executeCodeGraphTool('code_graph', cgArgs, session?.cwd)
+            return _executeCodeGraphToolLazy('code_graph', cgArgs, session?.cwd)
                 .then(out => ({ symbol, out }))
                 .catch(e => {
-                    process.stderr.write(`[bridge-prefetch] references(${symbol}) failed: ${e && e.message || e}\n`);
+                    process.stderr.write(`[agent-prefetch] references(${symbol}) failed: ${e && e.message || e}\n`);
                     return { symbol, out: null };
                 });
         });
@@ -1064,29 +1501,29 @@ async function _tryBridgeExplicitPrefetch(session, explicitPrefetch) {
     return `${warnLine}<prefetch>\n${parts.join('\n\n')}\n</prefetch>`;
 }
 
-// --- bridge spawn (createSession) ---
+// --- agent spawn (createSession) ---
 // opts can pass either a `preset` object (from config.presets) or raw provider/model.
 // Preset shape: { name, provider, model, effort?, fast?, tools? }
 //
-// Smart Bridge integration:
+// Agent Runtime integration:
 //   opts.taskType / opts.role / opts.profileId — enables profile-aware routing.
 //     Rule-based SmartRouter resolves these synchronously; the resolved
 //     profile controls context filtering (skip.skills/memory/etc) and cache
 //     strategy. If no rule matches, falls back to classic preset behavior.
 //   opts.profile — pre-resolved profile (bypasses router; used by async
-//     callers who already ran SmartBridge.resolve()).
+//     callers who already ran AgentRuntime.resolve()).
 //   opts.providerCacheOpts — pre-resolved cache options merged into ask() sendOpts.
 export function createSession(opts) {
     const presetObj = opts.preset && typeof opts.preset === 'object' ? opts.preset : null;
 
-    // --- Smart Bridge profile resolution (best-effort, sync) ---
+    // --- Agent Runtime profile resolution (best-effort, sync) ---
     let profile = opts.profile || null;
     let providerCacheOpts = opts.providerCacheOpts || null;
     if (!profile && (opts.taskType || opts.role || opts.profileId)) {
-        const smartBridge = getSmartBridgeSync();
-        if (smartBridge) {
+        const agentRuntime = getAgentRuntimeSync();
+        if (agentRuntime) {
             try {
-                const resolved = smartBridge.resolveSync({
+                const resolved = agentRuntime.resolveSync({
                     taskType: opts.taskType,
                     role: opts.role,
                     profileId: opts.profileId,
@@ -1098,10 +1535,10 @@ export function createSession(opts) {
                     providerCacheOpts = resolved.providerCacheOpts;
                 }
             } catch (e) {
-                // Smart Bridge error — log once, fall back to classic behavior.
-                if (!_smartBridgeWarned) {
-                    _smartBridgeWarned = true;
-                    process.stderr.write(`[session] smart bridge resolve failed: ${e.message}\n`);
+                // Agent Runtime error — log once, fall back to classic behavior.
+                if (!_agentRuntimeWarned) {
+                    _agentRuntimeWarned = true;
+                    process.stderr.write(`[session] agent runtime resolve failed: ${e.message}\n`);
                 }
             }
         }
@@ -1129,132 +1566,108 @@ export function createSession(opts) {
         throw new Error(`Provider "${providerName}" not found or not enabled`);
     const id = `sess_${process.pid}_${nextId++}_${Date.now()}_${randomBytes(16).toString('hex')}`;
     const messages = [];
-    const agentTemplate = opts.agent ? loadAgentTemplate(opts.agent, opts.cwd) : null;
-    const skills = opts.skipSkills ? [] : collectSkillsCached(opts.cwd);
-
-    // Bridge shared prefix (bit-identical across roles). Hidden roles reuse the
-    // same shared bridge rules so the cache shard stays stable across bridge
-    // callers. User-defined data (DATA_DIR roles/schedules/webhooks) is baked
-    // into BP1 as a single fixed-value monolithic block so every role shares
-    // one cache shard. A user edit invalidates BP1 once and the new prefix
-    // re-warms across all roles together.
-    const bridgeRulesRole = opts.role || profile?.taskType || null;
-    const injectedRules = opts.skipBridgeRules ? '' : (opts.owner === 'bridge' ? _buildBridgeRules() : _buildLeadRules());
-    const roleSpecific = opts.owner === 'bridge' && !opts.skipBridgeRules ? _buildRoleSpecific(bridgeRulesRole) : '';
-    // mixdog.md user/project context (global + cwd ancestors, broad-to-specific).
-    const projectContext = collectMixdogMd(opts.cwd);
-
-    // Role template (Phase B §4 — UI-managed). Reads <DATA_DIR>/roles/<role>.md
-    // and parses frontmatter (description, permission). The template is
-    // injected into the Tier 3 system-reminder so role differences never
-    // touch the BP_2 cache prefix.
+    const ownerIsAgent = isAgentOwner(opts.owner);
     const resolvedRole = opts.role || profile?.taskType || null;
-    const dataDir = resolvePluginData();
-    const roleTemplate = resolvedRole && dataDir
-        ? loadRoleTemplate(resolvedRole, dataDir)
-        : null;
+    const hiddenRole = getHiddenRole(resolvedRole);
+    const isRetrievalRole = hiddenRole?.kind === 'retrieval';
+    // Skill schema is fixed; the compact manifest is discovered once through
+    // the mtime-cached frontmatter index so BP1 tells every role which Skill()
+    // names are available without loading full SKILL.md bodies.
+    const skills = opts.skipSkills ? [] : collectSkillsCached(opts.cwd);
 
-    // Bridge sessions must not inherit role/profile/preset tool narrowing: Pool
-    // B and Pool C share one bit-identical tool schema for BP_1/BP_2 cache
-    // reuse, and permission differences are enforced only at call time. Raw
-    // non-bridge callers keep the historical profile.tools / preset.tools
+    // BP1 is shared tool policy (+ compact skill manifest in compose). BP2 is
+    // role/system rules. User-defined schedules/webhooks ride as normal user
+    // context below so event data does not rewrite BP3 memory/meta.
+    const agentRulesRole = opts.role || profile?.taskType || null;
+    const agentRulesProfile = isRetrievalRole ? 'retrieval' : 'full';
+    const skipAgentRules = opts.skipAgentRules === true;
+    // Retrieval roles already inject a compact # Tool Use via BP2; skip the full BP1 shared tool policy to avoid duplicating it.
+    const injectedRules = (skipAgentRules || isRetrievalRole) ? '' : _buildSharedRules();
+    const roleRules = skipAgentRules ? '' : (ownerIsAgent ? _buildAgentRules(agentRulesProfile) : _buildLeadRules());
+    const metaContext = skipAgentRules ? '' : (ownerIsAgent ? '' : _buildLeadMetaContext());
+    const roleSpecific = ownerIsAgent && !skipAgentRules ? _buildRoleSpecific(agentRulesRole) : '';
+    // Agent sessions must not inherit role/profile/preset tool narrowing: Pool
+    // B and Pool C share one bit-identical tool schema to maximize provider
+    // prefix reuse, and permission differences are enforced only at call time. Raw
+    // non-agent callers keep the historical profile.tools / preset.tools
     // behaviour.
-    const toolSpec = opts.owner === 'bridge'
+    const toolSpec = ownerIsAgent
         ? 'full'
         : (Array.isArray(profile?.tools) ? profile.tools : toolPreset);
 
     // Prompt permission is metadata only. Preset tool restrictions must NOT
-    // enter the prompt, or they split the shared bridge cache tail; they map
+    // enter the prompt, or they split the shared agent cache tail; they map
     // to toolPermission below and are enforced only at call time.
     const permission = opts.permission
-        || roleTemplate?.permission
         || null;
     const toolPermission = opts.permission
         || profile?.permission
-        || roleTemplate?.permission
         || permissionFromToolSpec(toolPreset)
         || null;
-    let toolsForRouting = resolveSessionTools(toolSpec, skills, { ownerIsBridge: opts.owner === 'bridge' });
-    // Fail-closed permission intersection: when a role declares an explicit
-    // permission (from user-workflow.json or the role template), intersect the
+    let toolsForRouting = resolveSessionTools(toolSpec, skills, { ownerIsAgentSession: ownerIsAgent });
+    // Fail-closed permission intersection: when a session declares an explicit
+    // object-form permission, intersect the
     // resolved tool list with the permission's allow/deny lists. If the
     // intersection produces an empty set the permission config is broken —
     // fail closed (zero tools) rather than silently falling back to the full
     // preset, which would grant the role more surface than declared.
-    if (toolPermission && typeof toolPermission === 'object') {
-        const allowSet = Array.isArray(toolPermission.allow) && toolPermission.allow.length > 0
-            ? new Set(toolPermission.allow.map(n => String(n).toLowerCase()))
-            : null;
-        const denySet = Array.isArray(toolPermission.deny) && toolPermission.deny.length > 0
-            ? new Set(toolPermission.deny.map(n => String(n).toLowerCase()))
-            : null;
-        if (allowSet || denySet) {
-            const filtered = toolsForRouting.filter(t => {
-                const name = String(t?.name || '').toLowerCase();
-                if (denySet && denySet.has(name)) return false;
-                if (allowSet && !allowSet.has(name)) return false;
-                return true;
-            });
-            // Fail-closed: an empty intersection means the permission config is
-            // misconfigured — do not silently fall back to the full preset.
-            toolsForRouting = filtered;
-            if (filtered.length === 0) {
-                process.stderr.write(`[session] WARN: role permission intersection produced 0 tools — failing closed (role=${opts.role || 'unknown'})
-`);
-            }
-        }
+    if (ownerIsAgent) {
+        toolsForRouting = applyToolPermissionNarrowing(toolsForRouting, toolPermission, opts.role || null);
     }
 
-    const { baseRules, roleCatalog, sessionMarker, volatileTail } = composeSystemPrompt({
+    const { baseRules, stableSystemContext, sessionMarker, volatileTail } = composeSystemPrompt({
         userPrompt: opts.systemPrompt,
-        bridgeRules: injectedRules || undefined,
-        roleSpecific: roleSpecific || undefined,
-        skipRoleCatalog: opts.owner !== 'bridge',
-        agentTemplate: agentTemplate || undefined,
-        roleTemplate: roleTemplate || undefined,
-        hasSkills: skills.length > 0,
+        agentRules: injectedRules || undefined,
+        roleRules: roleRules || undefined,
+        metaContext: metaContext || undefined,
+        skipRoleCatalog: !ownerIsAgent,
         profile: profile || undefined,
         role: resolvedRole,
-        skipRoleReminder: opts.skipRoleReminder || false,
-        permission,
-        taskBrief: opts.taskBrief || null,
         workflowContext: opts.workflowContext || null,
         workspaceContext: opts.workspaceContext || null,
         coreMemoryContext: opts.coreMemoryContext || null,
-        projectContext: projectContext || null,
+        skillManifest: buildSkillManifest(skills),
         tools: toolsForRouting,
-        bashIsPersistent: opts.owner === 'bridge' && toolsForRouting.some(t => t?.name === 'shell'),
+        bashIsPersistent: ownerIsAgent && toolsForRouting.some(t => t?.name === 'shell'),
         // Effective cwd rides in tier3Reminder so explore-like tools know
         // their search root without needing to shove "Override cwd:" into
         // the user message body (that used to fragment the shard prefix).
         cwd: opts.cwd || null,
-        // BP2 catalog policy — explicit-cache providers see the unified
-        // all-roles catalog; implicit-prefix-hash providers keep self-only.
         provider: providerName || null,
     });
     // 4-BP layout (see composeSystemPrompt docs):
-    //   system block #1 = baseRules    — BP1 (1h) shared across ALL roles
-    //   system block #2 = roleCatalog  — BP2 (1h) scoped role catalog
-    //   first <system-reminder> user   = sessionMarker — BP3 (1h) mixdog.md + stable role body
-    //   second <system-reminder> user  = volatileTail  — rides near BP4 (5m)
-    // Anthropic multi-block system pins each block with cache_control.
-    // OpenAI gets a stable provider cache key/session prefix. Gemini relies
-    // on implicit prompt caching only, so hits are observed, not treated as a
-    // guaranteed warm shard.
+    //   system block #1 = baseRules — BP1 (1h) shared tool policy + skills
+    //   system block #2 = stableSystemContext — BP2 (1h) role/system rules
+    //   system block #3 = sessionMarker — BP3 (1h) memory/meta + Profile
+    //     Preferences (language/name). It rides as a real `system` block so
+    //     locale/name directives are pinned firmly and do not drift to English
+    //     after a few turns the way a `user <system-reminder>` reminder did.
+    //   later normal messages        = BP4/tail (task, role data, tool history)
+    // Anthropic multi-block system pins each block with cache_control (BP3 is
+    // the 3rd system block and carries the tier3 1h marker). OpenAI/xAI get
+    // stable provider cache keys/session prefixes. Gemini manages explicit
+    // cachedContents inside its provider.
     if (baseRules) {
         messages.push({ role: 'system', content: baseRules });
     }
-    if (roleCatalog) {
-        messages.push({ role: 'system', content: roleCatalog });
+    if (stableSystemContext) {
+        messages.push({ role: 'system', content: stableSystemContext });
     }
     if (sessionMarker) {
-        messages.push({ role: 'user', content: `<system-reminder>\n${sessionMarker}\n</system-reminder>` });
-        messages.push({ role: 'assistant', content: '.' });
+        // cacheTier:'tier3' tells the Anthropic providers to pin THIS system
+        // block with the tier3 1h cache_control (BP3) — distinct from the
+        // BP1/BP2 system TTL. Harmless on non-Anthropic providers (they ignore
+        // 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 (roleSpecific) {
+        messages.push({ role: 'user', content: `<system-reminder>\n${roleSpecific}\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\`\`\``)
@@ -1262,58 +1675,30 @@ export function createSession(opts) {
         messages.push({ role: 'user', content: `Reference files:\n\n${fileContext}` });
         messages.push({ role: 'assistant', content: '.' });
     }
-    let tools = toolsForRouting;
-
-    // Schema filtering applied after schema build:
-    //   - opts.schemaAllowedTools : declarative hidden-role schema profile
-    //     allowlist for tiny specialist roles where one-shot tool routing
-    //     beats the shared-schema cache win.
-    //   - opts.disallowedTools : per-call caller override (Anthropic
-    //     BuiltInAgentDefinition pattern)
-    //   - annotations.bridgeHidden : declarative per-tool flag (tools.json
-    //     and internal tool defs). Pool A (Lead) still sees all tools.
-    //
     const hasCallerAllow = Array.isArray(opts.schemaAllowedTools);
-    const callerAllow = hasCallerAllow ? opts.schemaAllowedTools.map(n => String(n).toLowerCase()) : [];
-    if (hasCallerAllow) {
-        const allowSet = new Set(callerAllow);
-        const before = tools.length;
-        tools = tools.filter(t => allowSet.has(String(t?.name || '').toLowerCase()));
-        if (tools.length !== before && !process.env.MIXDOG_QUIET_SESSION_LOG) {
-            process.stderr.write(`[session] schemaAllowedTools=${callerAllow.join(',')} kept ${tools.length}/${before} tools\n`);
-        }
-    }
-    const callerDeny = Array.isArray(opts.disallowedTools) ? opts.disallowedTools.map(n => String(n)) : [];
-    if (callerDeny.length) {
-        const denySet = new Set(callerDeny);
-        const before = tools.length;
-        tools = tools.filter(t => !denySet.has(String(t?.name || '').toLowerCase()));
-        if (tools.length !== before && !process.env.MIXDOG_QUIET_SESSION_LOG) {
-            process.stderr.write(`[session] disallowedTools=${callerDeny.join(',')} stripped ${before - tools.length} tools\n`);
-        }
-    }
-    if (opts.owner === 'bridge') {
-        const before = tools.length;
-        tools = tools.filter(t => !t?.annotations?.bridgeHidden);
-        if (tools.length !== before && !process.env.MIXDOG_QUIET_SESSION_LOG) {
-            process.stderr.write(`[session] bridgeHidden stripped ${before - tools.length} tools\n`);
-        }
-    }
-
-    // Bridge tool canonicalization: keep route-sensitive tools in policy order
-    // while preserving deterministic MCP/skill order for BP1 shard stability.
-    if (opts.owner === 'bridge') {
-        tools = orderSessionTools(tools);
-    }
+    const tools = finalizeSessionToolList(toolsForRouting, {
+        schemaAllowedTools: hasCallerAllow ? opts.schemaAllowedTools : null,
+        disallowedTools: opts.disallowedTools,
+        ownerIsAgent,
+        resolvedRole,
+    });
 
     // Unified-shard policy — no broad role-specific schema filter. Keep
-    // bridge schemas shared unless a hidden-role schema profile explicitly
+    // agent schemas shared unless a hidden-role schema profile explicitly
     // passes schemaAllowedTools for a small specialist; broad role
     // whitelists would fragment the cache shard.
-    if (resolvedRole && !process.env.MIXDOG_QUIET_SESSION_LOG) {
+    if (resolvedRole && process.env.MIXDOG_DEBUG_SESSION_LOG) {
         process.stderr.write(`[session] role=${resolvedRole} permission=${permission || 'full'} toolPermission=${toolPermission || 'full'} tools=${tools.length}\n`);
     }
     const contextMeta = resolveSessionContextMeta(provider, modelName);
+    const workflowMeta = opts.workflow && typeof opts.workflow === 'object' && String(opts.workflow.id || '').trim()
+        ? {
+            id: String(opts.workflow.id || '').trim(),
+            name: String(opts.workflow.name || opts.workflow.id || '').trim(),
+            description: String(opts.workflow.description || '').trim(),
+            source: String(opts.workflow.source || '').trim(),
+        }
+        : null;
     const session = {
         id,
         provider: providerName,
@@ -1328,13 +1713,27 @@ export function createSession(opts) {
             auto: opts.compaction?.auto !== false,
             prune: opts.compaction?.prune === true,
             semantic: opts.compaction?.semantic ?? 'auto',
+            type: normalizeCompactType(opts.compaction?.type ?? opts.compaction?.compactType ?? opts.compaction?.compact_type, DEFAULT_COMPACT_TYPE),
+            compactType: normalizeCompactType(opts.compaction?.type ?? opts.compaction?.compactType ?? opts.compaction?.compact_type, DEFAULT_COMPACT_TYPE),
             model: opts.compaction?.model || null,
             timeoutMs: positiveContextWindow(opts.compaction?.timeoutMs),
             tailTurns: positiveContextWindow(opts.compaction?.tailTurns),
             bufferTokens: positiveContextWindow(opts.compaction?.bufferTokens ?? opts.compaction?.buffer),
+            // Preserve percent/ratio-named buffer config so the manager/loop/
+            // contextStatus parsers (which read bufferPercent/bufferPct/
+            // bufferRatio/bufferFraction) can honor it. createSession previously
+            // only stored bufferTokens, silently dropping a configured percent.
+            ...preserveBufferConfigFields(opts.compaction),
             keepTokens: positiveContextWindow(opts.compaction?.keepTokens ?? opts.compaction?.keep?.tokens),
             preserveRecentTokens: positiveContextWindow(opts.compaction?.preserveRecentTokens),
             reservedTokens: positiveContextWindow(opts.compaction?.reservedTokens),
+            recallIngestLimit: positiveContextWindow(opts.compaction?.recallIngestLimit),
+            recallChunkLimit: positiveContextWindow(opts.compaction?.recallChunkLimit ?? opts.compaction?.recallLimit),
+            recallCycle1BatchSize: positiveContextWindow(opts.compaction?.recallCycle1BatchSize),
+            recallRowsPerSession: positiveContextWindow(opts.compaction?.recallRowsPerSession),
+            recallWindowSize: positiveContextWindow(opts.compaction?.recallWindowSize),
+            recallConcurrency: positiveContextWindow(opts.compaction?.recallConcurrency),
+            recallCycle1DeadlineMs: positiveContextWindow(opts.compaction?.recallCycle1DeadlineMs),
             boundaryTokens: contextMeta.compactBoundaryTokens,
         },
         tools,
@@ -1346,40 +1745,42 @@ export function createSession(opts) {
         owner: opts.owner || 'user',
         mcpPid: process.pid,
         scopeKey: opts.scopeKey || null,
-        lane: opts.lane || 'bridge',
+        lane: opts.lane || 'agent',
         cwd: opts.cwd,
+        workflow: workflowMeta,
         createdAt: Date.now(),
         updatedAt: Date.now(),
         lastHeartbeatAt: null,
         totalInputTokens: 0,
         totalOutputTokens: 0,
-        // Refreshed on each completed ask() — surfaced by bridge type=list for
+        // Refreshed on each completed ask() — surfaced by agent type=list for
         // debugging + consumed by store.mjs's idle-sweep to reclaim stalled
-        // bridge sessions past RUNNING_STALL_MS.
+        // agent sessions past RUNNING_STALL_MS.
         lastUsedAt: Date.now(),
         tokensCumulative: 0,
         role: opts.role || null,
         taskType: opts.taskType || null,
         maxLoopIterations: Number.isFinite(opts.maxLoopIterations) ? opts.maxLoopIterations : null,
-        // Bridge tag (auto worker{n} on spawn) persisted so the forked status
+        // Agent tag (auto worker{n} on spawn) persisted so the forked status
         // process (statusline) + aggregator can read it from the session JSON.
         // In-process send/close still resolve via _tagSessionRegistry.
-        bridgeTag: opts.bridgeTag || null,
+        agentTag: opts.agentTag || null,
         // Prompt permission is separate from runtime toolPermission so preset
-        // restrictions do not fragment the bridge cache prefix.
+        // restrictions do not fragment the agent cache prefix.
         permission: permission || null,
         toolPermission: toolPermission || null,
-        // Origin tag written into every bridge-trace usage row so analytics
+        schemaAllowedTools: hasCallerAllow ? opts.schemaAllowedTools.map((n) => String(n)) : null,
+        // Origin tag written into every agent-trace usage row so analytics
         // can slice by (sourceType, sourceName) — e.g. maintenance/cycle1,
         // scheduler/daily-standup, webhook/github-push, lead/worker.
         sourceType: opts.sourceType || null,
         sourceName: opts.sourceName || null,
         // Provider-scoped unified cache key — one shard per provider,
-        // shared across all roles / sources (bridge/maintenance/mcp/
+        // shared across all roles / sources (agent/maintenance/mcp/
         // scheduler/webhook). Role or source-specific context must be
         // injected into the message tail, not the shared prefix.
         promptCacheKey: providerCacheKey(presetObj?.provider || opts.provider, opts.cacheKeyOverride),
-        // Bridge shell continuity: when a bridge session explicitly opts into
+        // Agent shell continuity: when an agent session explicitly opts into
         // persistent shell state (`bash` with `persistent:true`, or direct
         // `bash_session`), the minted bash_session id is stored here so later
         // opted-in `bash` calls can reuse the same shell state.
@@ -1388,7 +1789,7 @@ export function createSession(opts) {
         // orchestrator session so closeSession can kill them all, not just
         // the most recently recorded one.
         allBashSessionIds: [],
-        // Smart Bridge metadata — optional. Applied on every ask() to merge
+        // Agent Runtime metadata — optional. Applied on every ask() to merge
         // profile-driven cache settings into provider sendOpts.
         profileId: profile?.id || null,
         permissionMode: opts.permissionMode ?? null,
@@ -1404,7 +1805,7 @@ export function createSession(opts) {
 }
 
 // ── Runtime liveness map ──────────────────────────────────────────────
-// In-memory only. Tracks per-session stage + stream heartbeat so bridge type=list
+// In-memory only. Tracks per-session stage + stream heartbeat so agent type=list
 // can surface whether a session is actually alive vs stuck. Never persisted —
 // heartbeats would otherwise churn the session JSON on every SSE delta.
 // Entry shape: {
@@ -1414,6 +1815,7 @@ export function createSession(opts) {
 //   closed?: boolean,               // flipped by closeSession()
 // }
 const _runtimeState = new Map();
+const _toolActivityHeartbeats = new Map();
 const VALID_STAGES = new Set([
     'connecting', 'requesting', 'streaming', 'tool_running', 'idle', 'error', 'done', 'cancelling',
 ]);
@@ -1425,6 +1827,33 @@ function _touchRuntime(id) {
     }
     return entry;
 }
+
+function _stopToolActivityHeartbeat(id) {
+    if (!id) return;
+    const timer = _toolActivityHeartbeats.get(id);
+    if (!timer) return;
+    try { clearInterval(timer); } catch { /* ignore */ }
+    _toolActivityHeartbeats.delete(id);
+}
+
+function _touchSessionActivityProgress(id) {
+    const entry = _runtimeState.get(id);
+    if (!entry || entry.closed || entry.controller?.signal?.aborted) return;
+    if (entry.stage !== 'tool_running') return;
+    const now = Date.now();
+    entry.lastProgressAt = now;
+    entry.updatedAt = now;
+    publishHeartbeat(id, now);
+}
+
+function _startToolActivityHeartbeat(id) {
+    _stopToolActivityHeartbeat(id);
+    if (!(DEFAULT_ACTIVITY_HEARTBEAT_MS > 0)) return;
+    const timer = setInterval(() => _touchSessionActivityProgress(id), DEFAULT_ACTIVITY_HEARTBEAT_MS);
+    if (typeof timer.unref === 'function') timer.unref();
+    _toolActivityHeartbeats.set(id, timer);
+}
+
 export function updateSessionStage(id, stage) {
     if (!id || !VALID_STAGES.has(stage)) return;
     const entry = _touchRuntime(id);
@@ -1435,6 +1864,7 @@ export function updateSessionStage(id, stage) {
     }
     entry.lastProgressAt = now;
     entry.updatedAt = now;
+    if (stage !== 'tool_running') _stopToolActivityHeartbeat(id);
 }
 
 export function updateSessionRoute(id, route = {}) {
@@ -1500,7 +1930,11 @@ export function updateSessionRoute(id, route = {}) {
  */
 export function markSessionAskStart(id) {
     if (!id) return;
+    _stopToolActivityHeartbeat(id);
     const entry = _touchRuntime(id);
+    entry.usageMetricsTurnIncremental = false;
+    const sessionForTurn = entry.session ?? loadSession(id);
+    if (sessionForTurn) bumpUsageMetricsTurnId(sessionForTurn);
     entry.stage = 'connecting';
     entry.lastStreamDeltaAt = null;
     entry.lastToolCall = null;
@@ -1524,7 +1958,7 @@ export function markSessionAskStart(id) {
     // Publish heartbeat immediately so the status aggregator picks the
     // session up in the connecting / requesting window. Without this the
     // .hb file only landed on the first stream chunk — producing a 3–10s
-    // (xhigh: 30s+) invisible gap where bridge sessions ran but the CC
+    // (xhigh: 30s+) invisible gap where agent sessions ran but the CC
     // statusline showed no maintenance/agent badge. STREAM_FRESH_MS (5 min)
     // still drops a session whose provider truly never returns a chunk;
     // markSessionStreamDelta keeps refreshing once chunks arrive.
@@ -1542,6 +1976,7 @@ export async function markSessionStreamDelta(id) {
     // path). Skip a missing, tombstoned, or aborted entry — never refresh liveness.
     const entry = _runtimeState.get(id);
     if (!entry || entry.closed || entry.controller?.signal?.aborted) return;
+    _stopToolActivityHeartbeat(id);
     const now = Date.now();
     entry.lastStreamDeltaAt = now;
     entry.lastProgressAt = now;
@@ -1571,9 +2006,14 @@ export function markSessionToolCall(id, toolName) {
     entry.lastProgressAt = entry.toolStartedAt;
     entry.updatedAt = entry.toolStartedAt;
     publishHeartbeat(id, entry.toolStartedAt);
+    _startToolActivityHeartbeat(id);
 }
+// Parent AbortSignal listeners are dropped on askSession unwind (finally /
+// terminal return) and on error/cancel/close — not in markSessionDone, which
+// also runs between queued follow-up turns within one ask.
 export function markSessionDone(id, { empty = false } = {}) {
     if (!id) return;
+    _stopToolActivityHeartbeat(id);
     const entry = _touchRuntime(id);
     entry.stage = 'done';
     entry.lastError = null;
@@ -1608,6 +2048,7 @@ export function markSessionEmptyFinal(id) {
 }
 export function markSessionError(id, msg) {
     if (!id) return;
+    _stopToolActivityHeartbeat(id);
     const entry = _touchRuntime(id);
     entry.stage = 'error';
     entry.lastError = msg ? String(msg).slice(0, 200) : null;
@@ -1622,9 +2063,11 @@ export function markSessionError(id, msg) {
     entry.lastProgressAt = errTs;
     entry.updatedAt = errTs;
     deleteHeartbeat(id);
+    _unlinkParentAbortListener(entry);
 }
 export function markSessionCancelled(id) {
     if (!id) return;
+    _stopToolActivityHeartbeat(id);
     const entry = _touchRuntime(id);
     entry.stage = 'done';
     entry.lastError = null;
@@ -1637,11 +2080,24 @@ export function markSessionCancelled(id) {
     entry.lastProgressAt = doneTs;
     entry.updatedAt = doneTs;
     deleteHeartbeat(id);
+    _unlinkParentAbortListener(entry);
 }
 export function getSessionRuntime(id) {
     return id ? (_runtimeState.get(id) || null) : null;
 }
 
+const _COMPACTION_BLOCKED_STAGES = new Set([
+    'connecting', 'requesting', 'streaming', 'tool_running', 'cancelling',
+]);
+
+export function isSessionCompactionBlocked(sessionId) {
+    if (!sessionId) return false;
+    const entry = _runtimeState.get(sessionId);
+    if (!entry || entry.closed === true) return false;
+    if (entry.controller && !entry.controller.signal?.aborted) return true;
+    return _COMPACTION_BLOCKED_STAGES.has(entry.stage);
+}
+
 export function getSessionProgressSnapshot(sessionId) {
     const entry = _runtimeState.get(sessionId);
     if (!entry) return null;
@@ -1681,29 +2137,126 @@ export function forEachSessionRuntime() {
 }
 
 // --- Incremental metric persistence (fix A) ---
-// Per-session idempotency tracking: sessionId → Set of seen iterationIndex keys.
+// Per-session idempotency tracking: sessionId → Set of seen turn:epoch:iteration:source keys.
 const _metricSeenIter = new Map();
 
+/** Monotonic per-session ask/turn id for incremental usage idempotency. */
+export function bumpUsageMetricsTurnId(session) {
+    if (!session || typeof session !== 'object') return 0;
+    const next = (Number(session.usageMetricsTurnId) || 0) + 1;
+    session.usageMetricsTurnId = next;
+    return next;
+}
+
+export function resolveUsageMetricsTurnId(session, delta = {}) {
+    if (delta.usageMetricsTurnId != null && Number.isFinite(Number(delta.usageMetricsTurnId))) {
+        return Number(delta.usageMetricsTurnId);
+    }
+    return Number(session?.usageMetricsTurnId) || 0;
+}
+
+/** Advance loop metrics epoch when agentLoop resets its iteration counter (post-compact). */
+export function bumpUsageMetricsEpoch(session) {
+    if (!session || typeof session !== 'object') return 0;
+    const next = (Number(session.usageMetricsEpoch) || 0) + 1;
+    session.usageMetricsEpoch = next;
+    return next;
+}
+
+/**
+ * Resolve usage-metrics epoch for idempotency (exported for regression smoke).
+ * Prefers session.usageMetricsEpoch (bumped in loop on compact reset) and optional
+ * delta.usageMetricsEpoch; falls back to iteration regression when loop did not bump.
+ */
+export function resolveUsageMetricsEpoch(session, delta = {}) {
+    if (!session) return 0;
+    let epoch = Number(session.usageMetricsEpoch) || 0;
+    if (delta.usageMetricsEpoch != null && Number.isFinite(Number(delta.usageMetricsEpoch))) {
+        epoch = Math.max(epoch, Number(delta.usageMetricsEpoch));
+    }
+    const idx = Number(delta.iterationIndex);
+    const prevLastIdx = typeof session.lastIterationIndex === 'number'
+        ? session.lastIterationIndex
+        : null;
+    if (
+        (delta.usageMetricsEpoch == null || !Number.isFinite(Number(delta.usageMetricsEpoch)))
+        && prevLastIdx !== null
+        && Number.isFinite(idx)
+        && idx < prevLastIdx
+    ) {
+        epoch += 1;
+    }
+    return epoch;
+}
+
+export function usageMetricsSourceKey(delta = {}) {
+    const raw = delta.source ?? delta.usageSource;
+    if (raw == null || raw === '') return 'provider_send';
+    return String(raw);
+}
+
+/** Idempotency key for incremental usage persistence (exported for regression smoke). */
+export function usageMetricsIdempotencyKey(sessionId, session, delta = {}) {
+    const turnId = resolveUsageMetricsTurnId(session, delta);
+    const epoch = resolveUsageMetricsEpoch(session, delta);
+    const source = usageMetricsSourceKey(delta);
+    return `${sessionId}:${turnId}:${epoch}:${delta.iterationIndex}:${source}`;
+}
+
+/**
+ * Apply terminal ask usage to session totals. Skips lifetime totals when incremental
+ * per-iteration persistence already counted this turn (askSession path).
+ */
+export function applyAskTerminalUsageTotals(session, result, options = {}) {
+    if (!session || !result?.usage) return;
+    const skipTotals = options.skipTotalsIfIncremental === true;
+    if (!skipTotals) {
+        session.totalInputTokens = (session.totalInputTokens || 0) + (result.usage.inputTokens || 0);
+        session.totalOutputTokens = (session.totalOutputTokens || 0) + (result.usage.outputTokens || 0);
+        session.tokensCumulative = (session.tokensCumulative || 0)
+            + (result.usage.inputTokens || 0)
+            + (result.usage.outputTokens || 0);
+        session.totalCachedReadTokens = (session.totalCachedReadTokens || 0) + (result.usage.cachedTokens || 0);
+        session.totalCacheWriteTokens = (session.totalCacheWriteTokens || 0) + (result.usage.cacheWriteTokens || 0);
+    }
+    const _lastTurn = result.lastTurnUsage || result.usage || {};
+    session.lastInputTokens = _lastTurn.inputTokens || 0;
+    session.lastOutputTokens = _lastTurn.outputTokens || 0;
+    session.lastCachedReadTokens = _lastTurn.cachedTokens || 0;
+    session.lastCacheWriteTokens = _lastTurn.cacheWriteTokens || 0;
+    const _inputExcludesCache = providerInputExcludesCache(session.provider);
+    session.lastContextTokens = _inputExcludesCache
+        ? (_lastTurn.inputTokens || 0) + (_lastTurn.cachedTokens || 0)
+        : (_lastTurn.inputTokens || 0);
+    session.lastContextTokensUpdatedAt = Date.now();
+    session.lastContextTokensStaleAfterCompact = false;
+}
+
 /**
  * Persist incremental usage delta immediately after each provider.send iteration.
- * Idempotency key `sessionId:iterationIndex` ensures a retry of the same iteration
- * index overwrites instead of double-counting.
+ * Idempotency key `sessionId:turnId:epoch:iterationIndex:source` scopes retries
+ * per ask, compaction epoch, iteration, and usage source.
  */
 export async function persistIterationMetrics(delta) {
     if (!delta || !delta.sessionId) return;
     const { sessionId, iterationIndex, deltaInput, deltaOutput, deltaCachedRead, deltaCacheWrite, ts } = delta;
+    const runtimeEntry = _runtimeState.get(sessionId);
+    const session = runtimeEntry?.session ?? loadSession(sessionId);
+    if (!session || session.closed) return;
+    const epoch = resolveUsageMetricsEpoch(session, delta);
+    if (epoch !== (Number(session.usageMetricsEpoch) || 0)) {
+        session.usageMetricsEpoch = epoch;
+    }
     let seen = _metricSeenIter.get(sessionId);
     if (!seen) {
         seen = new Set();
         _metricSeenIter.set(sessionId, seen);
     }
-    const ikey = `${sessionId}:${iterationIndex}`;
+    const ikey = usageMetricsIdempotencyKey(sessionId, session, delta);
     const isReplay = seen.has(ikey);
     seen.add(ikey);
-    const runtimeEntry = _runtimeState.get(sessionId);
-    const session = runtimeEntry?.session ?? loadSession(sessionId);
-    if (!session || session.closed) return;
     if (!isReplay) {
+        if (runtimeEntry) runtimeEntry.usageMetricsTurnIncremental = true;
         session.totalInputTokens = (session.totalInputTokens || 0) + (deltaInput || 0);
         session.totalOutputTokens = (session.totalOutputTokens || 0) + (deltaOutput || 0);
         session.tokensCumulative = (session.tokensCumulative || 0) + (deltaInput || 0) + (deltaOutput || 0);
@@ -1713,7 +2266,7 @@ export async function persistIterationMetrics(delta) {
         // includes cached_read / cache_write in its terminal usage rollup).
         session.totalCachedReadTokens = (session.totalCachedReadTokens || 0) + (deltaCachedRead || 0);
         session.totalCacheWriteTokens = (session.totalCacheWriteTokens || 0) + (deltaCacheWrite || 0);
-        // Window snapshot updated per iteration so bridge type=list reflects the
+        // Window snapshot updated per iteration so agent type=list reflects the
         // most-recent provider-reported input size even for short dispatches
         // that finish before askSession's terminal save lands.
         session.lastInputTokens = deltaInput || 0;
@@ -1739,6 +2292,14 @@ export async function persistIterationMetrics(delta) {
 
 function standaloneStatusRouteInfo(session) {
     if (!session) return null;
+    // autoCompactTokenLimit is an EXPLICIT sub-boundary auto-compact limit only.
+    // Do NOT fall back to compactBoundaryTokens/contextWindow here — that
+    // labels a derived full-window value as an explicit limit, which the
+    // runtime would treat as the compaction trigger and collapse the buffer.
+    // The boundary/window stays available via contextWindow/rawContextWindow.
+    const _boundary = Number(session.compactBoundaryTokens || session.contextWindow || 0);
+    const _limit = Number(session.autoCompactTokenLimit || 0);
+    const explicitAutoCompactTokenLimit = _limit > 0 && (!_boundary || _limit < _boundary) ? _limit : null;
     return {
         provider: session.provider,
         model: session.model,
@@ -1748,7 +2309,7 @@ function standaloneStatusRouteInfo(session) {
         contextWindow: session.contextWindow || null,
         rawContextWindow: session.rawContextWindow || session.contextWindow || null,
         effectiveContextWindowPercent: session.effectiveContextWindowPercent || null,
-        autoCompactTokenLimit: session.autoCompactTokenLimit || session.compactBoundaryTokens || null,
+        autoCompactTokenLimit: explicitAutoCompactTokenLimit,
         presetId: session.presetId || null,
         presetName: session.presetName || null,
     };
@@ -1763,9 +2324,17 @@ function recordStandaloneStatusTelemetry(session, result, durationMs) {
         model: result.model,
         serviceTier: result.serviceTier,
     };
+    // The transcript estimate is the SSOT for the displayed context footprint.
+    // agentLoop()'s result has no `compact` field, so build a synthetic compact
+    // arg carrying the live monotonic estimate (estimateMessagesTokens+reserve)
+    // as afterTokens. This lights up summarizeGatewayUsage's estimate-based
+    // contextUsedPct branch (provider input_tokens swing wildly / unbounded on
+    // e.g. OpenAI gpt-5.5), and lets a genuine >100% pass through.
+    const _estTokens = estimateTranscriptContextUsage(session.messages, session.tools || []);
+    const _compactArg = { ...(result.compact && typeof result.compact === 'object' ? result.compact : {}), afterTokens: _estTokens };
     try {
         const summary = {
-            ...summarizeGatewayUsage(routeInfo, providerOut, result.compact || null, durationMs),
+            ...summarizeGatewayUsage(routeInfo, providerOut, _compactArg, durationMs),
             requestKind: 'chat',
             sessionId: session.id || null,
             toolCount: result.toolCallsTotal ?? null,
@@ -1828,6 +2397,7 @@ export function getSessionLastProgressAt(sessionId) {
     const entry = _runtimeState.get(sessionId);
     if (!entry) return 0;
     return Math.max(
+        entry.lastProgressAt || 0,
         entry.lastStreamDeltaAt || 0,
         entry.toolStartedAt || 0,
         entry.askStartedAt || 0,
@@ -1836,8 +2406,8 @@ export function getSessionLastProgressAt(sessionId) {
 
 /**
  * Link a parent AbortSignal to a sub-session's controller so that aborting
- * the parent (fan-out deadline or caller ESC) tears down the bridge role's
- * provider call promptly. Safe to call after prepareBridgeSession but before
+ * the parent (fan-out deadline or caller ESC) tears down the agent role's
+ * provider call promptly. Safe to call after prepareAgentSession but before
  * askSession completes. No-op if the session runtime isn't found.
  *
  * @param {string} sessionId — the sub-session to abort
@@ -1854,15 +2424,27 @@ export function linkParentSignalToSession(sessionId, parentSignal) {
         return new Error('parent signal aborted');
     };
     if (parentSignal.aborted) {
+        _unlinkParentAbortListener(entry);
         try { entry.controller.abort(abortReason()); } catch { /* ignore */ }
         return;
     }
-    parentSignal.addEventListener('abort', () => {
+    _unlinkParentAbortListener(entry);
+    const onParentAbort = () => {
         try { entry.controller?.abort(abortReason()); } catch { /* ignore */ }
-    }, { once: true });
+    };
+    parentSignal.addEventListener('abort', onParentAbort, { once: true });
+    entry.parentAbortLink = { signal: parentSignal, listener: onParentAbort };
+}
+function _unlinkParentAbortListener(entry) {
+    const link = entry?.parentAbortLink;
+    if (!link) return;
+    try { link.signal.removeEventListener('abort', link.listener); } catch { /* ignore */ }
+    entry.parentAbortLink = null;
 }
 function _clearSessionRuntime(id) {
     if (id) {
+        _stopToolActivityHeartbeat(id);
+        _unlinkParentAbortListener(_runtimeState.get(id));
         _runtimeState.delete(id);
         // R15: also drop the per-session metric-idempotency Set; otherwise it
         // grows O(sessions x iterations) for the whole server lifetime since
@@ -1914,8 +2496,8 @@ export async function _api_call_with_interrupt(sessionId, fn) {
 
 // Per-session mutex: queues concurrent askSession calls to prevent message loss
 const _sessionLocks = new Map();
-// Per-session pending-message queue (Claude Code `pendingMessages` pattern).
-// A `bridge type=send` to a worker whose turn is still in flight ENQUEUES the
+// Per-session pending-message queue (in-flight send enqueue pattern).
+// A `agent type=send` to a worker whose turn is still in flight ENQUEUES the
 // message here instead of rejecting; askSession drains the queue after each
 // turn and runs the messages as the next user turn(s), preserving order — the
 // queued send runs AFTER the in-flight prompt, which also closes the spawn
@@ -1928,11 +2510,16 @@ const _sessionLocks = new Map();
 // Keeping the queue outside the session JSON avoids racing session saves that
 // loaded before the send arrived.
 //
-// Map<sessionId, string[]>. Shared with index.mjs's bridge send handler via
-// the enqueue/drain accessors below — one queue contract, two call sites.
+// Map<sessionId, Array<string|{text?:string,content:any}>>. Shared with
+// index.mjs's agent send handler via the enqueue/drain accessors below — one
+// queue contract, two call sites. Rich content is kept in memory for the live
+// relay path; the disk mirror stores only a text fallback so image bytes do not
+// leak into the pending-message JSON.
 const _sessionPendingMessages = new Map();
 const PENDING_MESSAGES_FILE = 'session-pending-messages.json';
 const PENDING_MESSAGES_MODE = 0o600;
+const _pendingPersistBuffers = new Map();
+let _pendingPersistImmediate = null;
 
 function pendingMessagesPath() {
     return join(resolvePluginData(), PENDING_MESSAGES_FILE);
@@ -1961,14 +2548,53 @@ function normalizePendingStore(raw) {
     return out;
 }
 
-function persistPendingMessage(sessionId, message) {
+function normalizePendingMessageEntry(entry) {
+    if (typeof entry === 'string') {
+        const text = entry.trim();
+        return text ? { content: text, text } : null;
+    }
+    if (Array.isArray(entry)) {
+        if (entry.length === 0) return null;
+        const text = promptContentText(entry).trim();
+        return { content: entry, text };
+    }
+    if (!entry || typeof entry !== 'object') return null;
+    const content = Object.prototype.hasOwnProperty.call(entry, 'content') ? entry.content : null;
+    if (content == null) return null;
+    const text = typeof entry.text === 'string' ? entry.text.trim() : promptContentText(content).trim();
+    if (Array.isArray(content)) return content.length > 0 ? { content, text } : null;
+    if (typeof content === 'string') {
+        const value = content.trim();
+        return value ? { content: value, text: text || value } : null;
+    }
+    const fallback = promptContentText(content).trim();
+    return fallback ? { content: fallback, text: text || fallback } : null;
+}
+
+function pendingMessageText(entry) {
+    const normalized = normalizePendingMessageEntry(entry);
+    return normalized ? String(normalized.text || promptContentText(normalized.content) || '').trim() : '';
+}
+
+function pendingMessageQueueEntry(entry) {
+    const normalized = normalizePendingMessageEntry(entry);
+    if (!normalized) return null;
+    if (typeof normalized.content === 'string' && normalized.content === normalized.text) return normalized.content;
+    return { content: normalized.content, text: normalized.text || promptContentText(normalized.content).trim() };
+}
+
+function persistPendingMessages(sessionId, messages) {
     if (!isValidPendingSessionId(sessionId)) return 0;
+    const persistedMessages = (Array.isArray(messages) ? messages : [messages])
+        .map(pendingMessageText)
+        .filter(Boolean);
+    if (persistedMessages.length === 0) return 0;
     let depth = 0;
     try {
         updateJsonAtomicSync(pendingMessagesPath(), (raw) => {
             const next = normalizePendingStore(raw);
             const q = Array.isArray(next.sessions[sessionId]) ? next.sessions[sessionId] : [];
-            q.push(message);
+            q.push(...persistedMessages);
             next.sessions[sessionId] = q;
             next.updatedAt = Date.now();
             depth = q.length;
@@ -1980,6 +2606,43 @@ function persistPendingMessage(sessionId, message) {
     return depth;
 }
 
+function flushPendingMessagePersistsSync() {
+    if (_pendingPersistImmediate) {
+        try { clearImmediate(_pendingPersistImmediate); } catch {}
+        _pendingPersistImmediate = null;
+    }
+    if (_pendingPersistBuffers.size === 0) return;
+    const batches = [..._pendingPersistBuffers.entries()];
+    _pendingPersistBuffers.clear();
+    for (const [sid, messages] of batches) {
+        persistPendingMessages(sid, messages);
+    }
+}
+
+function schedulePendingMessagePersist(sessionId, message) {
+    if (!isValidPendingSessionId(sessionId)) return 0;
+    const persistedMessage = pendingMessageText(message);
+    if (!persistedMessage) return 0;
+    const q = _pendingPersistBuffers.get(sessionId) || [];
+    q.push(persistedMessage);
+    _pendingPersistBuffers.set(sessionId, q);
+    if (!_pendingPersistImmediate) {
+        _pendingPersistImmediate = setImmediate(() => {
+            _pendingPersistImmediate = null;
+            flushPendingMessagePersistsSync();
+        });
+    }
+    return q.length;
+}
+
+function takeBufferedPendingMessages(sessionId) {
+    if (!isValidPendingSessionId(sessionId)) return [];
+    const buffered = _pendingPersistBuffers.get(sessionId);
+    if (!buffered || buffered.length === 0) return [];
+    _pendingPersistBuffers.delete(sessionId);
+    return buffered.slice();
+}
+
 function drainPersistedPendingMessages(sessionId) {
     if (!isValidPendingSessionId(sessionId)) return [];
     let drained = [];
@@ -2000,25 +2663,33 @@ function drainPersistedPendingMessages(sessionId) {
 }
 
 export function enqueuePendingMessage(sessionId, message) {
-    if (!sessionId || typeof message !== 'string' || !message) return 0;
+    const entry = pendingMessageQueueEntry(message);
+    if (!sessionId || !entry) return 0;
     let q = _sessionPendingMessages.get(sessionId);
     if (!q) { q = []; _sessionPendingMessages.set(sessionId, q); }
-    q.push(message);
-    const persistedDepth = persistPendingMessage(sessionId, message);
-    return Math.max(q.length, persistedDepth || 0);
+    q.push(entry);
+    const bufferedDepth = schedulePendingMessagePersist(sessionId, entry);
+    return Math.max(q.length, bufferedDepth || 0);
 }
 export function drainPendingMessages(sessionId) {
     const q = _sessionPendingMessages.get(sessionId);
     const memory = q && q.length > 0 ? q.slice() : [];
     _sessionPendingMessages.delete(sessionId);
-    const persisted = drainPersistedPendingMessages(sessionId);
-    if (memory.length === 0) return persisted;
-    if (persisted.length === 0) return memory;
-    const prefixMatches = memory.every((m, i) => persisted[i] === m);
-    if (prefixMatches) return [...memory, ...persisted.slice(memory.length)];
-    const out = persisted.slice();
-    for (const m of memory) {
-        if (!out.includes(m)) out.push(m);
+    const persisted = [...takeBufferedPendingMessages(sessionId), ...drainPersistedPendingMessages(sessionId)];
+    const memoryVisible = modelVisiblePendingMessages(memory);
+    const persistedVisible = modelVisiblePendingMessages(persisted);
+    if (memoryVisible.length === 0) return persistedVisible;
+    if (persistedVisible.length === 0) return memoryVisible;
+    const persistedTexts = persistedVisible.map(pendingMessageText);
+    const prefixMatches = memoryVisible.every((m, i) => persistedTexts[i] === pendingMessageText(m));
+    if (prefixMatches) return [...memoryVisible, ...persistedVisible.slice(memoryVisible.length)];
+    const out = persistedVisible.slice();
+    const seen = new Set(persistedTexts);
+    for (const m of memoryVisible) {
+        const text = pendingMessageText(m);
+        if (!text || seen.has(text)) continue;
+        out.push(m);
+        seen.add(text);
     }
     return out;
 }
@@ -2036,6 +2707,10 @@ function promptContentText(content) {
     return String(content ?? '');
 }
 
+function hasModelVisiblePromptContent(prompt) {
+    return !!promptContentText(prompt).trim();
+}
+
 function promptContentBytes(content) {
     try {
         if (typeof content === 'string') return Buffer.byteLength(content, 'utf8');
@@ -2052,6 +2727,190 @@ function prefixUserTurnContent(content, contextBlock) {
     }
     return `${contextBlock}# Task\n${content}`;
 }
+
+function prefixSessionStartContent(content, sessionBlock) {
+    if (!sessionBlock) return content;
+    if (Array.isArray(content)) {
+        return [{ type: 'text', text: `${sessionBlock}\n\n` }, ...content];
+    }
+    return `${sessionBlock}\n\n${content}`;
+}
+
+function localIsoDate(date = new Date()) {
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, '0');
+    const day = String(date.getDate()).padStart(2, '0');
+    return `${year}-${month}-${day}`;
+}
+
+function localDateTimeWithZone(date = new Date()) {
+    const datePart = localIsoDate(date);
+    const hh = String(date.getHours()).padStart(2, '0');
+    const mm = String(date.getMinutes()).padStart(2, '0');
+    const ss = String(date.getSeconds()).padStart(2, '0');
+    let zone = '';
+    try { zone = Intl.DateTimeFormat().resolvedOptions().timeZone || ''; } catch {}
+    return zone ? `${datePart} ${hh}:${mm}:${ss} ${zone}` : `${datePart} ${hh}:${mm}:${ss}`;
+}
+
+function temporalPromptText(content) {
+    const text = promptContentText(content)
+        .replace(/\s+/g, ' ')
+        .trim()
+        .toLowerCase();
+    return text;
+}
+
+function promptNeedsDateReminder(content) {
+    const text = temporalPromptText(content);
+    if (!text) return false;
+    return /(?:오늘|내일|어제|모레|그저께|요즘|최근|방금|아까|현재\s*(?:날짜|시간|시각)|지금\s*(?:몇\s*시|시간|날짜|요일)|몇\s*월\s*몇\s*일|몇\s*시|무슨\s*요일|요일|날짜|이번\s*(?:주|달|월|년)|지난\s*(?:주|달|월|년)|다음\s*(?:주|달|월|년)|올해|작년|내년|today|tomorrow|yesterday|recently|current\s+(?:date|time)|what\s+(?:date|time)|which\s+day|weekday|this\s+(?:week|month|year)|last\s+(?:week|month|year)|next\s+(?:week|month|year))/i.test(text);
+}
+
+function promptNeedsTimeReminder(content) {
+    const text = temporalPromptText(content);
+    if (!text) return false;
+    return /(?:현재\s*(?:시간|시각)|지금\s*(?:몇\s*시|시간)|몇\s*시|시각|시간|current\s+time|what\s+time|time\s+is\s+it)/i.test(text);
+}
+
+function buildCurrentTimeBlock(content) {
+    const needsTime = promptNeedsTimeReminder(content);
+    if (!needsTime && !promptNeedsDateReminder(content)) return '';
+    return localDateTimeWithZone(new Date());
+}
+
+function sessionModelDisplay(model) {
+    const text = String(model || '').trim();
+    if (!text) return '';
+    return text
+        .replace(/-\d{4}-\d{2}-\d{2}$/, '')
+        .replace(/^gpt-/i, 'GPT-')
+        .replace(/(?:^|-)([a-z])/g, (m) => m.toUpperCase());
+}
+
+function buildSessionStartBlock(session, cwd) {
+    if (!session || session.owner === 'agent') return '';
+    const lines = ['# Session'];
+    const effectiveCwd = String(cwd || session.cwd || '').trim();
+    if (effectiveCwd) lines.push(`Cwd: ${effectiveCwd}`);
+    const modelBits = [
+        sessionModelDisplay(session.model),
+        session.effort ? String(session.effort).trim().toUpperCase() : '',
+        session.fast === true ? 'FAST' : '',
+    ].filter(Boolean);
+    if (modelBits.length) lines.push(`Model: ${modelBits.join(' · ')}`);
+    const workflowName = String(session.workflow?.name || session.workflow?.id || '').trim();
+    if (workflowName) lines.push(`Workflow: ${workflowName}`);
+    return lines.length > 1 ? lines.join('\n') : '';
+}
+
+function isReferenceFilesMessage(message) {
+    return message?.role === 'user'
+        && typeof message.content === 'string'
+        && /^Reference files:\s*/i.test(message.content.trimStart());
+}
+
+function isProtectedContextUserMessage(message) {
+    return message?.role === 'user'
+        && typeof message.content === 'string'
+        && message.content.trimStart().startsWith('<system-reminder>');
+}
+
+function hasUserConversationMessage(messages) {
+    return (Array.isArray(messages) ? messages : []).some((message) => (
+        message?.role === 'user'
+        && !isProtectedContextUserMessage(message)
+        && !isReferenceFilesMessage(message)
+    ));
+}
+
+function modelVisiblePendingMessages(messages) {
+    return (Array.isArray(messages) ? messages : [])
+        .map(pendingMessageQueueEntry)
+        .filter(Boolean)
+        .filter((message) => !isInternalRuntimeNotificationText(
+            message && typeof message === 'object' && Object.prototype.hasOwnProperty.call(message, 'content')
+                ? message.content
+                : message,
+        ));
+}
+
+export function _mergePendingMessageEntries(entries) {
+    const normalized = (Array.isArray(entries) ? entries : [])
+        .map(normalizePendingMessageEntry)
+        .filter(Boolean);
+    if (normalized.length === 0) return null;
+    const displayText = normalized.map((entry) => entry.text || promptContentText(entry.content))
+        .filter((text) => String(text || '').trim())
+        .join('\n');
+    if (normalized.every((entry) => typeof entry.content === 'string')) {
+        return {
+            content: normalized.map((entry) => entry.content).filter(Boolean).join('\n'),
+            text: displayText,
+            count: normalized.length,
+        };
+    }
+    const parts = [];
+    for (const entry of normalized) {
+        if (typeof entry.content === 'string') {
+            if (entry.content.trim()) parts.push({ type: 'text', text: entry.content });
+        } else if (Array.isArray(entry.content)) {
+            parts.push(...entry.content);
+        } else {
+            const text = promptContentText(entry.content);
+            if (text.trim()) parts.push({ type: 'text', text });
+        }
+        parts.push({ type: 'text', text: '\n' });
+    }
+    while (parts.length && parts[parts.length - 1]?.type === 'text' && parts[parts.length - 1]?.text === '\n') parts.pop();
+    return { content: parts, text: displayText || promptContentText(parts), count: normalized.length };
+}
+
+function isInternalRuntimeNotificationText(content) {
+    return contractIsInternalRuntimeNotificationText(promptContentText(content));
+}
+
+export const _isInternalRuntimeNotificationText = isInternalRuntimeNotificationText;
+
+function isInternalCancelledAssistantMessage(message) {
+    if (!message || message.role !== 'assistant') return false;
+    if (message.cancelled === true) return true;
+    const text = promptContentText(message.content).trim();
+    return /^\[cancelled\]\s+This turn was interrupted before completion\./i.test(text)
+        || /Preserve the user request above as the active task context/i.test(text);
+}
+
+function sanitizeSessionMessagesForModel(messages) {
+    // Drop internal runtime-notification turns and cancelled-assistant stubs so
+    // they never reach the model, but KEEP image content intact. Reference-agent
+    // parity: the live transcript and every model request retain attached
+    // images across turns; only the compaction-summary call strips them. The
+    // disk-stored session JSON replaces image bytes with a text placeholder at
+    // serialization time (see store.mjs), so this no longer touches images.
+    if (!Array.isArray(messages) || messages.length === 0) return [];
+    const out = [];
+    let droppingInternalTurn = false;
+    for (const message of messages) {
+        if (isInternalCancelledAssistantMessage(message)) {
+            droppingInternalTurn = false;
+            continue;
+        }
+        if (message?.role === 'user' && isInternalRuntimeNotificationText(message.content)) {
+            droppingInternalTurn = true;
+            continue;
+        }
+        if (droppingInternalTurn) {
+            if (message?.role === 'user') {
+                droppingInternalTurn = false;
+            } else {
+                continue;
+            }
+        }
+        out.push(message);
+    }
+    return out;
+}
+
 function acquireSessionLock(sessionId) {
     let entry = _sessionLocks.get(sessionId);
     if (!entry) {
@@ -2071,19 +2930,114 @@ function acquireSessionLock(sessionId) {
     });
 }
 
+function sessionMessagesSnapshotChanged(before, after) {
+    if (!Array.isArray(before) || !Array.isArray(after)) return before !== after;
+    if (before.length !== after.length) return true;
+    for (let i = 0; i < before.length; i += 1) {
+        if (before[i] !== after[i]) return true;
+        try {
+            if (JSON.stringify(before[i]) !== JSON.stringify(after[i])) return true;
+        } catch {
+            return true;
+        }
+    }
+    return false;
+}
+
+function isCompactedOutgoingFinalAssistantMessage(message) {
+    if (!message || message.role !== 'assistant') return false;
+    if (message.emptyFinal === true) return true;
+    return true;
+}
+
+function sessionMessagesAdvancedBeyondCompactedOutgoing(currentSanitized, compactedSanitized) {
+    if (!Array.isArray(currentSanitized) || !Array.isArray(compactedSanitized)) return false;
+    if (currentSanitized.length !== compactedSanitized.length + 1) return false;
+    const prefix = currentSanitized.slice(0, compactedSanitized.length);
+    if (sessionMessagesSnapshotChanged(compactedSanitized, prefix)) return false;
+    return isCompactedOutgoingFinalAssistantMessage(currentSanitized[currentSanitized.length - 1]);
+}
+
+export const _sessionMessagesAdvancedBeyondCompactedOutgoing = sessionMessagesAdvancedBeyondCompactedOutgoing;
+
+function applyCompactFailurePersistToSession(activeSession, {
+    priorSanitized,
+    sanitized,
+    messagesAdvanced,
+    error = null,
+}) {
+    if (!messagesAdvanced && !sessionMessagesSnapshotChanged(priorSanitized, sanitized)) return false;
+    if (!messagesAdvanced) {
+        activeSession.messages = sanitized;
+        activeSession.providerState = undefined;
+    }
+    activeSession.updatedAt = Date.now();
+    activeSession.lastUsedAt = Date.now();
+    if (activeSession.compaction && typeof activeSession.compaction === 'object'
+        && (activeSession.compaction.lastStage === 'compacting'
+            || activeSession.compaction.lastStage === 'overflow_failed')) {
+        const prev = activeSession.compaction;
+        const cause = error?.cause;
+        const overflow = error?.code === 'AGENT_CONTEXT_OVERFLOW';
+        activeSession.compaction = {
+            ...prev,
+            lastStage: prev.lastStage === 'overflow_failed'
+                ? 'overflow_failed'
+                : (overflow ? 'overflow_failed' : 'failed'),
+            lastCheckedAt: Date.now(),
+            lastError: prev.lastError || cause?.message || error?.message || null,
+            lastSemanticError: prev.lastSemanticError || cause?.message || null,
+            lastRecallFastTrackError: prev.lastRecallFastTrackError
+                || (cause?.message && String(cause?.name || '').includes('Recall') ? cause.message : null),
+        };
+    }
+    return true;
+}
+
+export const _applyCompactFailurePersistToSession = applyCompactFailurePersistToSession;
+
+async function persistCompactedOutgoingAfterAskFailure({
+    sessionId,
+    activeSession,
+    askGeneration,
+    turnOutgoing,
+    error = null,
+}) {
+    if (!activeSession || activeSession.closed === true) return;
+    if (!Array.isArray(turnOutgoing) || turnOutgoing.length === 0) return;
+    const currentRuntime = _runtimeState.get(sessionId);
+    if (currentRuntime?.closed || currentRuntime?.generation !== askGeneration) return;
+    const sanitized = sanitizeSessionMessagesForModel(turnOutgoing);
+    const priorSanitized = sanitizeSessionMessagesForModel(
+        Array.isArray(activeSession.messages) ? activeSession.messages : [],
+    );
+    const messagesAdvanced = sessionMessagesAdvancedBeyondCompactedOutgoing(priorSanitized, sanitized);
+    const applied = applyCompactFailurePersistToSession(activeSession, {
+        priorSanitized,
+        sanitized,
+        messagesAdvanced,
+        error,
+    });
+    if (!applied) return;
+    try {
+        await saveSessionAsync(activeSession, { expectedGeneration: askGeneration });
+    } catch { /* best-effort: preserve in-memory compaction even if disk is slow */ }
+    if (currentRuntime) currentRuntime.session = activeSession;
+}
+
 export async function askSession(sessionId, prompt, context, onToolCall, cwdOverride, explicitPrefetch, askOpts = {}) {
     const _askStartedAt = Date.now();
     const _promptSrc = 'prompt';
     const _prefetchFiles = (explicitPrefetch?.files?.length) || 0;
     const _prefetchCallers = (explicitPrefetch?.callers?.length) || 0;
     const _prefetchRefs = (explicitPrefetch?.references?.length) || 0;
-    if (process.env.MIXDOG_DEBUG_BRIDGE) {
-        process.stderr.write(`[bridge-trace] t0-ask-start sessionHash=${createHash('sha256').update(String(sessionId)).digest('hex').slice(0, 8)} role=? iteration=0 promptSrc=${_promptSrc} prefetchFiles=${_prefetchFiles} callers=${_prefetchCallers} references=${_prefetchRefs}\n`);
+    if (process.env.MIXDOG_DEBUG_AGENT) {
+        process.stderr.write(`[agent-trace] t0-ask-start sessionHash=${createHash('sha256').update(String(sessionId)).digest('hex').slice(0, 8)} role=? iteration=0 promptSrc=${_promptSrc} prefetchFiles=${_prefetchFiles} callers=${_prefetchCallers} references=${_prefetchRefs}\n`);
     }
     const unlock = await acquireSessionLock(sessionId);
     const _lockWaitedMs = Date.now() - _askStartedAt;
-    if (process.env.MIXDOG_DEBUG_BRIDGE) {
-        process.stderr.write(`[bridge-trace] lock-acquired waitedMs=${_lockWaitedMs}\n`);
+    if (process.env.MIXDOG_DEBUG_AGENT) {
+        process.stderr.write(`[agent-trace] lock-acquired waitedMs=${_lockWaitedMs}\n`);
     }
     // The mutex is held for the WHOLE askSession call, including any follow-up
     // turns drained from the pending-message queue below — the single outer
@@ -2092,18 +3046,19 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
     // result, mirroring how a live chat returns the latest turn).
     let _result;
     // Local FIFO of follow-up prompts drained from the pending-message queue
-    // after each turn — keeps queued `bridge type=send` messages in order.
+    // after each turn — keeps queued `agent type=send` messages in order.
     const _pendingTail = [];
     // Hoisted so the outer finally (which runs once after the whole turn loop)
     // can compare against the last turn's generation.
     let askGeneration = 0;
     try {
       // Turn loop (pendingMessages pattern): run the current prompt, then drain
-      // any `bridge type=send` messages that were queued while this turn was in
+      // any `agent type=send` messages that were queued while this turn was in
       // flight and run them — in order — as the next user turn(s). Because the
       // queued send always lands AFTER the in-flight prompt here, ordering is
       // preserved and the spawn/connecting startup race disappears.
       for (;;) {
+        let _pwstTurnDrained = null;
         // After the first turn, the next prompt comes from the drained queue.
         // (On the first iteration _pendingTail is empty and `prompt` is the
         // caller's original message.)
@@ -2113,6 +3068,23 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
             // prefetch is re-applied (those belonged to the original ask).
             context = null;
             explicitPrefetch = null;
+        } else if (!hasModelVisiblePromptContent(prompt)) {
+            // Idle resume: TUI kicks an empty ask() after execution completions
+            // mirror model-visible bodies into session pending. Drain that queue
+            // here so we never synthesize an empty user turn for the model.
+            const _preDrained = drainPendingMessages(sessionId);
+            if (_preDrained.length > 0) {
+                const _mergedPre = _mergePendingMessageEntries(_preDrained);
+                if (_mergedPre?.content) {
+                    prompt = _mergedPre.content;
+                    context = null;
+                    explicitPrefetch = null;
+                }
+            }
+        }
+        if (!hasModelVisiblePromptContent(prompt)) {
+            _unlinkParentAbortListener(_runtimeState.get(sessionId));
+            return _result;
         }
         // ── Synchronous pre-await setup (must happen before any await so
         //    closeSession() can't interleave between load and registration) ──
@@ -2123,6 +3095,11 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
         if (preSession.closed === true) {
             throw new SessionClosedError(sessionId, 'session already closed');
         }
+        // A prior crash/partial-save during compaction may have pinned
+        // compaction.lastStage='compacting'. This ask is starting fresh, so
+        // recover the stale transient stage before the loop's pre-send compact
+        // path runs (it will overwrite lastStage with real telemetry).
+        normalizeStaleCompactingStage(preSession);
         askGeneration = typeof preSession.generation === 'number' ? preSession.generation : 0;
         const runtime = _touchRuntime(sessionId);
         // Fresh controller per ask — the previous ask's controller may have aborted.
@@ -2136,6 +3113,7 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
         // leaving stage='connecting' forever.
         let activeSession = preSession;
         let cancelledUserTurnContent = '';
+        let _turnOutgoing = null;
         try {
             const session = activeSession;
             const provider = getProvider(session.provider);
@@ -2154,6 +3132,8 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
                 ...(session.compaction || {}),
                 auto: session.compaction?.auto !== false,
                 semantic: session.compaction?.semantic ?? 'auto',
+                type: normalizeCompactType(session.compaction?.type ?? session.compaction?.compactType ?? session.compaction?.compact_type, DEFAULT_COMPACT_TYPE),
+                compactType: normalizeCompactType(session.compaction?.type ?? session.compaction?.compactType ?? session.compaction?.compact_type, DEFAULT_COMPACT_TYPE),
                 boundaryTokens: contextMeta.compactBoundaryTokens,
                 bufferTokens: positiveContextWindow(session.compaction?.bufferTokens ?? session.compaction?.buffer) || session.compaction?.bufferTokens || null,
                 keepTokens: positiveContextWindow(session.compaction?.keepTokens ?? session.compaction?.keep?.tokens) || session.compaction?.keepTokens || null,
@@ -2190,7 +3170,8 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
             if (explicitPrefetchResult) {
                 _contextBlock += `# Prefetch\n${_capCtx(explicitPrefetchResult)}\n\n`;
             }
-            const beforeCount = session.messages.length + 1;
+            const historyMessages = sanitizeSessionMessagesForModel(session.messages);
+            const beforeCount = historyMessages.length + 1;
             const promptTextForMetrics = promptContentText(prompt);
             // Soft warning only; real size management (compaction primary,
             // byte-budget trim as safety net) lives in agentLoop. Selecting a
@@ -2201,21 +3182,43 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
                 process.stderr.write(`[session] Warning: prompt is very large (est. ${Math.round(promptTokenEstimate)} tokens vs ${softBudget} soft budget)\n`);
             }
             const effectiveCwd = cwdOverride || session.cwd;
-            const _userTurnContent = prefixUserTurnContent(prompt, _contextBlock);
+            const shouldInjectSessionStart = session.sessionStartMetaInjected !== true
+                && !hasUserConversationMessage(historyMessages);
+            const _sessionStartBlock = shouldInjectSessionStart
+                ? buildSessionStartBlock(session, effectiveCwd)
+                : '';
+            const _currentTimeBlock = buildCurrentTimeBlock(prompt);
+            const _turnReminderBlock = _currentTimeBlock
+                ? `<system-reminder>\n# Current Time\n${_currentTimeBlock}\n</system-reminder>`
+                : '';
+            const _turnPrefixBlock = [_sessionStartBlock, _turnReminderBlock].filter(Boolean).join('\n\n');
+            const _baseUserTurnContent = prefixUserTurnContent(prompt, _contextBlock);
+            const _userTurnContent = prefixSessionStartContent(_baseUserTurnContent, _turnPrefixBlock);
+            if (shouldInjectSessionStart && _sessionStartBlock) {
+                session.sessionStartMetaInjected = true;
+            }
             cancelledUserTurnContent = _userTurnContent;
-            const outgoing = [...session.messages, { role: 'user', content: _userTurnContent }];
+            const outgoing = [...historyMessages, { role: 'user', content: _userTurnContent }];
+            _turnOutgoing = outgoing;
+            // Expose the in-flight working transcript so contextStatus() can
+            // estimate the LIVE context footprint mid-turn. agentLoop mutates
+            // `outgoing` in place (user turn + tool calls/results + compaction),
+            // so the statusline context gauge climbs as the turn accumulates
+            // tool output instead of freezing at the pre-turn snapshot. Cleared
+            // on turn commit (below) and in the ask finally.
+            session.liveTurnMessages = outgoing;
             // Per-turn injected-context trace row (complements kind:"usage").
             // Cheap byte-length accounting — no hashing, no payload bodies.
-            // Honors the same MIXDOG_BRIDGE_TRACE_DISABLE gate as usage rows;
-            // appendBridgeTrace is a no-op when that env is set.
+            // Honors the same MIXDOG_AGENT_TRACE_DISABLE gate as usage rows;
+            // appendAgentTrace is a no-op when that env is set.
             try {
                 const _ctxBytes = Buffer.byteLength(context || '', 'utf8');
                 const _prefetchBytes = Buffer.byteLength(explicitPrefetchResult || '', 'utf8');
                 const _promptBytes = promptContentBytes(prompt);
                 const _userTurnBytes = promptContentBytes(_userTurnContent);
-                const _messagesBytes = Buffer.byteLength(JSON.stringify(session.messages || []), 'utf8');
+                const _messagesBytes = Buffer.byteLength(JSON.stringify(historyMessages || []), 'utf8');
                 const _totalBytes = _userTurnBytes + _messagesBytes;
-                appendBridgeTrace({
+                appendAgentTrace({
                     kind: 'context',
                     sessionId,
                     model: session.model,
@@ -2227,26 +3230,36 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
                         promptBytes: _promptBytes,
                         userTurnBytes: _userTurnBytes,
                         messagesBytes: _messagesBytes,
-                        messagesCount: Array.isArray(session.messages) ? session.messages.length : 0,
+                        messagesCount: historyMessages.length,
                     },
                 });
             } catch { /* trace must never break the ask path */ }
-            const result = await _api_call_with_interrupt(sessionId, (signal) =>
+            const agentLoop = await _getAgentLoop();
+            const priorToolApprovalHook = session.toolApprovalHook;
+            if (typeof askOpts?.onToolApproval === 'function') {
+                session.toolApprovalHook = askOpts.onToolApproval;
+            }
+            let result;
+            try {
+            result = await _api_call_with_interrupt(sessionId, (signal) =>
                 agentLoop(provider, outgoing, session.model, session.tools, onToolCall, effectiveCwd, {
                     effort: session.effort || null,
                     fast: session.fast === true,
                     sessionId,
                     onTextDelta: typeof askOpts?.onTextDelta === 'function' ? askOpts.onTextDelta : undefined,
                     onReasoningDelta: typeof askOpts?.onReasoningDelta === 'function' ? askOpts.onReasoningDelta : undefined,
+                    onAssistantText: typeof askOpts?.onAssistantText === 'function' ? askOpts.onAssistantText : undefined,
                     onUsageDelta: (d) => {
                         persistIterationMetrics(d).catch(() => {});
                         try { askOpts?.onUsageDelta?.(d); } catch {}
                     },
                     onToolResult: typeof askOpts?.onToolResult === 'function' ? askOpts.onToolResult : undefined,
+                    onToolApproval: typeof askOpts?.onToolApproval === 'function' ? askOpts.onToolApproval : undefined,
+                    onCompactEvent: typeof askOpts?.onCompactEvent === 'function' ? askOpts.onCompactEvent : undefined,
                     // Mid-turn steering drain. agentLoop calls this at every
                     // tool-batch boundary (before the next provider.send) and
                     // injects any returned strings as user turns — so input
-                    // (user typing, `bridge type=send`) that arrives WHILE a
+                    // (user typing, `agent type=send`) that arrives WHILE a
                     // long multi-tool turn is in flight is picked up on the
                     // model's very next iteration instead of waiting for the
                     // whole task to finish. The post-turn _pendingTail drain
@@ -2265,6 +3278,7 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
                         return out;
                     },
                     onSteerMessage: typeof askOpts?.onSteerMessage === 'function' ? askOpts.onSteerMessage : undefined,
+                    notifyFn: typeof askOpts?.notifyFn === 'function' ? askOpts.notifyFn : undefined,
                     promptCacheKey: session.promptCacheKey || sessionId,
                     // Provider-scoped cache key (mixdog-codex, mixdog-claude…).
                     // Distinct from sessionId — providers that pool sockets
@@ -2276,7 +3290,7 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
                     signal,
                     providerState: session.providerState ?? undefined,
                     session,
-                    // Smart Bridge cache settings — merged last so session overrides
+                    // Agent Runtime cache settings — merged last so session overrides
                     // don't get overridden by defaults. When session has no profile,
                     // providerCacheOpts is null and this spread is a no-op.
                     ...(session.providerCacheOpts || {}),
@@ -2290,6 +3304,13 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
                     },
                 }),
             );
+            } finally {
+                if (priorToolApprovalHook === undefined) {
+                    delete session.toolApprovalHook;
+                } else {
+                    session.toolApprovalHook = priorToolApprovalHook;
+                }
+            }
             // Post-loop validation: if closeSession() landed while we were awaiting,
             // drop the save so the tombstone on disk isn't overwritten.
             const currentRuntime = _runtimeState.get(sessionId);
@@ -2300,10 +3321,16 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
             // Update and save. outgoing is mutated in place by agentLoop
             // (compaction + safety trim), so its length reflects post-loop state.
             const messagesDropped = Math.max(0, beforeCount - outgoing.length);
-            session.messages = outgoing;
+            session.messages = sanitizeSessionMessagesForModel(outgoing);
+            // Turn committed into session.messages; drop the live-turn alias so
+            // contextStatus() reverts to the authoritative committed transcript.
+            session.liveTurnMessages = null;
             if (result.content || result.reasoningContent) {
                 session.messages.push({
                     role: 'assistant',
+                    // Keep content as-is in memory (model-visible). Image bytes,
+                    // if any, are swapped for a placeholder only at disk write
+                    // time inside the session store (store.mjs _sessionForDisk).
                     content: result.content || '',
                     ...(typeof result.reasoningContent === 'string' && result.reasoningContent
                         ? { reasoningContent: result.reasoningContent }
@@ -2353,46 +3380,17 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
             }
             session.updatedAt = Date.now();
             session.lastUsedAt = Date.now();
-            if (result.usage) {
-                session.totalInputTokens += result.usage.inputTokens;
-                session.totalOutputTokens += result.usage.outputTokens;
-                session.tokensCumulative = (session.tokensCumulative || 0)
-                    + (result.usage.inputTokens || 0)
-                    + (result.usage.outputTokens || 0);
-                // Cache totals — same `||0` undefined-safe accumulation pattern as
-                // persistIterationMetrics so live + terminal paths stay in lock-step
-                // and legacy sessions migrate lazily on first iteration.
-                session.totalCachedReadTokens = (session.totalCachedReadTokens || 0) + (result.usage.cachedTokens || 0);
-                session.totalCacheWriteTokens = (session.totalCacheWriteTokens || 0) + (result.usage.cacheWriteTokens || 0);
-                // Window snapshot = the current context size, which is the LAST
-                // single call — NOT result.usage (that is lastUsage, the per-turn
-                // SUM accumulated with += across iterations in agentLoop). Use
-                // lastTurnUsage (the final iteration's raw usage) so this reflects
-                // "what's in the window now" rather than the lifetime sum.
-                const _lastTurn = result.lastTurnUsage || result.usage || {};
-                session.lastInputTokens = _lastTurn.inputTokens || 0;
-                session.lastOutputTokens = _lastTurn.outputTokens || 0;
-                session.lastCachedReadTokens = _lastTurn.cachedTokens || 0;
-                session.lastCacheWriteTokens = _lastTurn.cacheWriteTokens || 0;
-                // Provider-normalized footprint, identical formula to
-                // persistIterationMetrics so both writers agree: Anthropic
-                // input_tokens excludes cache (add it back), openai/grok/gemini
-                // already include it.
-                const _inputExcludesCache = providerInputExcludesCache(session.provider);
-                session.lastContextTokens = _inputExcludesCache
-                    ? (_lastTurn.inputTokens || 0) + (_lastTurn.cachedTokens || 0)
-                    : (_lastTurn.inputTokens || 0);
-                session.lastContextTokensUpdatedAt = Date.now();
-                session.lastContextTokensStaleAfterCompact = false;
-            }
-            // Smart Bridge cache stats — record hit/miss after every successful
-            // ask so the registry reflects all bridge traffic, not just
-            // maintenance cycles. Guarded against any smart-bridge error so
+            applyAskTerminalUsageTotals(session, result, {
+                skipTotalsIfIncremental: runtime?.usageMetricsTurnIncremental === true,
+            });
+            // Agent Runtime cache stats — record hit/miss after every successful
+            // ask so the registry reflects all agent traffic, not just
+            // maintenance cycles. Guarded against any agent-runtime error so
             // metric recording never breaks the ask itself.
             let prefixHashForLog = null;
-            if (session.profileId && result.usage && _smartBridgeApi) {
+            if (session.profileId && result.usage && _agentRuntimeApi) {
                 try {
-                    const profile = _smartBridgeApi.getProfile(session.profileId);
+                    const profile = _agentRuntimeApi.getProfile(session.profileId);
                     if (profile) {
                         // Collect every leading system-role message (BP1, BP2, ...)
                         // until the first non-system message so the registry hash
@@ -2402,24 +3400,24 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
                             if (m?.role !== 'system') break;
                             systemMsgs.push(typeof m.content === 'string' ? m.content : '');
                         }
-                        _smartBridgeApi.recordCall(profile, session.provider, {
+                        _agentRuntimeApi.recordCall(profile, session.provider, {
                             systemPrompt: systemMsgs,
                             tools: session.tools || [],
                             usage: result.usage,
                         });
-                        const entry = _smartBridgeApi.registry?.data?.profiles?.[session.profileId]?.[session.provider];
+                        const entry = _agentRuntimeApi.registry?.data?.profiles?.[session.profileId]?.[session.provider];
                         prefixHashForLog = entry?.prefixHash || null;
                     }
                 } catch {}
             }
-            // Append to bridge-trace.jsonl with the rich bridge usage fields.
+            // Append to the agent trace store with rich usage fields.
             if (result.usage) {
                 const inputTokens = result.usage.inputTokens || 0;
                 const outputTokens = result.usage.outputTokens || 0;
                 const cacheReadTokens = result.usage.cachedTokens || 0;
                 const cacheWriteTokens = result.usage.cacheWriteTokens || 0;
                 // Unified total-prompt field. Anthropic = input+cache_read+cache_write
-                // (additive); OpenAI/Codex/Gemini = input_tokens already includes the
+                // (additive); OpenAI OAuth/API/Gemini = input_tokens already includes the
                 // cached portion (inclusive), so the fallback must not double-count.
                 const { isInclusiveProvider, computeCostUsd } = await import('../../../shared/llm/cost.mjs');
                 const inclusive = isInclusiveProvider(session.provider);
@@ -2459,29 +3457,61 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
                 recordStandaloneStatusTelemetry(session, result, Date.now() - _askStartedAt);
             }
             // Persist opaque providerState for future stateful providers.
-            // No provider currently emits it (Codex OAuth is stateless per
+            // No provider currently emits it (openai-oauth is stateless per
             // contract), so this branch is dormant — kept so a future
             // Responses-API provider with stable continuation can plug in
             // without reworking the session shape.
             if (result.providerState !== undefined) {
                 session.providerState = result.providerState;
             }
-            const postTurnCompact = await autoCompactSessionAfterTurn(session, {
-                provider,
-                model: session.model,
-                sessionId,
-                signal: getSessionAbortSignal(sessionId),
-            });
-            if (postTurnCompact?.changed) {
+            const terminalResultPreview = {
+                ...result,
+                trimmed: messagesDropped > 0,
+                messagesDropped,
+            };
+            _pwstTurnDrained = drainPendingMessages(sessionId);
+            if (_pwstTurnDrained.length === 0 && typeof askOpts?.onTerminalResult === 'function') {
                 try {
-                    process.stderr.write(
-                        `[session] auto compacted after turn sessionId=${sessionId} ` +
-                        `${postTurnCompact.beforeTokens}->${postTurnCompact.afterTokens} ` +
-                        `pressure=${postTurnCompact.pressureTokens} trigger=${postTurnCompact.triggerTokens}\n`,
-                    );
-                } catch { /* best-effort */ }
+                    askOpts.onTerminalResult(terminalResultPreview, {
+                        sessionId,
+                        beforeSave: true,
+                        durationMs: Date.now() - _askStartedAt,
+                    });
+                } catch { /* best-effort early completion relay */ }
+            }
+            // Auto-compact runs at the start of the next
+            // query/provider send (agentLoop pre-send), not after the previous
+            // answer. This lets queued follow-up prompts resume immediately;
+            // if they need compaction, their own spinner shows compacting first.
+            // Bounded, best-effort terminal save. The result is already produced
+            // and (for agent surfaces) relayed via onTerminalResult above. If the
+            // disk write stalls, blocking the terminal unwind here would strand the
+            // owning background task in `running` and suppress its completion
+            // notification. Cap the wait; let a slow write finish in the
+            // background instead of holding askSession() open indefinitely.
+            {
+                const savePromise = saveSessionAsync(session, { expectedGeneration: askGeneration });
+                let saveTimer = null;
+                const saveTimeout = new Promise((resolveTimeout) => {
+                    saveTimer = setTimeout(() => resolveTimeout('__save_timeout__'), TERMINAL_SAVE_TIMEOUT_MS);
+                    saveTimer.unref?.();
+                });
+                try {
+                    const outcome = await Promise.race([
+                        savePromise.then(() => '__save_ok__', (err) => { throw err; }),
+                        saveTimeout,
+                    ]);
+                    if (outcome === '__save_timeout__') {
+                        try { process.stderr.write(`[session] terminal save exceeded ${TERMINAL_SAVE_TIMEOUT_MS}ms; continuing best-effort (${sessionId})\n`); } catch {}
+                        // Don't drop the write — let it settle in the background.
+                        savePromise.catch((err) => {
+                            try { process.stderr.write(`[session] deferred terminal save failed: ${err?.message || err}\n`); } catch {}
+                        });
+                    }
+                } finally {
+                    if (saveTimer) { try { clearTimeout(saveTimer); } catch {} }
+                }
             }
-            await saveSessionAsync(session, { expectedGeneration: askGeneration });
             activeSession = session;
             runtime.session = session;
             // Tag empty-synthesis BEFORE markSessionDone so the watchdog
@@ -2492,47 +3522,63 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
                 markSessionEmptyFinal(sessionId);
             }
             markSessionDone(sessionId, { empty: isEmptyFinal });
-            _result = {
-                ...result,
-                trimmed: messagesDropped > 0,
-                messagesDropped,
-                postTurnCompact: postTurnCompact?.changed ? postTurnCompact : null,
-            };
+            _result = terminalResultPreview;
         } catch (err) {
+            // Cancellation/error paths bypass the commit point above; drop the
+            // live-turn alias so contextStatus() stops estimating from the
+            // stale in-flight array once the turn unwinds.
+            if (activeSession) activeSession.liveTurnMessages = null;
             if (err instanceof SessionClosedError) {
                 const currentRuntime = _runtimeState.get(sessionId);
-                if (!currentRuntime?.closed && activeSession && cancelledUserTurnContent) {
-                    activeSession.messages = [
-                        ...(Array.isArray(activeSession.messages) ? activeSession.messages : []),
-                        { role: 'user', content: cancelledUserTurnContent },
-                        {
-                            role: 'assistant',
-                            content: '[cancelled] This turn was interrupted before completion. Preserve the user request above as the active task context if the user asks to continue.',
-                            cancelled: true,
-                            ts: Date.now(),
-                        },
-                    ];
-                    activeSession.updatedAt = Date.now();
-                    activeSession.lastUsedAt = Date.now();
-                    try {
-                        await saveSessionAsync(activeSession, { expectedGeneration: askGeneration });
-                    } catch { /* cancellation persistence is best-effort */ }
+                if (!currentRuntime?.closed) {
+                    if (activeSession) {
+                        const originalMessages = Array.isArray(activeSession.messages) ? activeSession.messages : [];
+                        const cleanedMessages = sanitizeSessionMessagesForModel(originalMessages);
+                        const nextMessages = cleanedMessages.slice();
+                        // In-memory cancelled turn keeps its original content
+                        // (images intact for the next model send); the store
+                        // layer placeholders image bytes on disk serialization.
+                        const cancelledStoredContent = cancelledUserTurnContent;
+                        const shouldPreserveUserTurn = cancelledStoredContent && !isInternalRuntimeNotificationText(cancelledStoredContent);
+                        const lastMessage = nextMessages[nextMessages.length - 1];
+                        if (shouldPreserveUserTurn && !(lastMessage?.role === 'user' && promptContentText(lastMessage.content) === promptContentText(cancelledStoredContent))) {
+                            nextMessages.push({ role: 'user', content: cancelledStoredContent });
+                        }
+                        const messagesChanged = nextMessages.length !== originalMessages.length
+                            || nextMessages.some((message, index) => message !== originalMessages[index]);
+                        if (messagesChanged) {
+                            activeSession.messages = nextMessages;
+                            activeSession.updatedAt = Date.now();
+                            activeSession.lastUsedAt = Date.now();
+                            try {
+                                await saveSessionAsync(activeSession, { expectedGeneration: askGeneration });
+                            } catch { /* cancellation cleanup is best-effort */ }
+                        }
+                    }
                     markSessionCancelled(sessionId);
                 }
                 // Cancellation is not an error; propagate silently so callers
                 // can render it as "cancelled" rather than a red failure.
                 throw err;
             }
+            await persistCompactedOutgoingAfterAskFailure({
+                sessionId,
+                activeSession,
+                askGeneration,
+                turnOutgoing: _turnOutgoing,
+                error: err,
+            });
             markSessionError(sessionId, err && err.message ? err.message : String(err));
             throw err;
         }
-        // ── Turn complete. Drain the pending-message queue (Claude Code
-        //    pendingMessages): any `bridge type=send` that arrived while this
+        // ── Turn complete. Drain the pending-message queue: any `agent type=send` that arrived while this
         //    turn was in flight runs next, in order, as a follow-up user turn.
         //    The mutex is still held, so a send racing this drain either landed
         //    before (picked up here) or enqueues for the next loop. When the
         //    queue is empty we return the latest turn's result. ──
-        const _drained = drainPendingMessages(sessionId);
+        const _drained = (_pwstTurnDrained && _pwstTurnDrained.length > 0)
+            ? _pwstTurnDrained
+            : drainPendingMessages(sessionId);
         if (_drained.length > 0) {
             // Same merge rule as the mid-turn steering drain (loop.mjs) and
             // the TUI engine.mjs drain(): a single drain batch is joined with
@@ -2540,11 +3586,9 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
             // Keeps every steering/follow-up path on identical
             // merge-then-deliver semantics. Anything that arrives AFTER this
             // drain enqueues for the next loop pass and is merged there.
-            const _mergedTail = _drained
-                .filter((m) => typeof m === 'string' && m.length > 0)
-                .join('\n');
-            if (_mergedTail.length > 0) {
-                _pendingTail.push(_mergedTail);
+            const _mergedTail = _mergePendingMessageEntries(_drained);
+            if (_mergedTail?.content) {
+                _pendingTail.push(_mergedTail.content);
                 const refreshed = loadSession(sessionId);
                 if (refreshed && refreshed.closed !== true) {
                     activeSession = refreshed;
@@ -2553,14 +3597,16 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
                 continue;
             }
         }
+        _unlinkParentAbortListener(_runtimeState.get(sessionId));
         return _result;
       }
     } finally {
         // Clear the controller only if it's still ours (closeSession may have
-        // swapped it). Leave the rest of the runtime entry intact so bridge type=list
+        // swapped it). Leave the rest of the runtime entry intact so agent type=list
         // can still surface the final stage (done/error/cancelling).
         const entry = _runtimeState.get(sessionId);
         if (entry && entry.generation === askGeneration) {
+            _unlinkParentAbortListener(entry);
             entry.controller = null;
             // Detach the live session reference; ask is over.
             entry.session = null;
@@ -2568,16 +3614,17 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
         unlock();
     }
 }
-// Session lookup by scopeKey — used by CLI bridge to resume a pinned
+// Session lookup by scopeKey — used by CLI agent to resume a pinned
 // scope session when the caller passes --scope (agent/<name>).
 export function findSessionByScopeKey(scopeKey) {
     if (!scopeKey) return null;
-    const sessions = listStoredSessions();
+    const summaries = listStoredSessionSummaries();
     // Exclude tombstoned sessions (`closed === true`) so callers never receive
     // a session whose controller was aborted by closeSession(). The `closed`
     // bit is the authoritative tombstone flag; `status === 'error'` is not,
     // since transient-error sessions remain resumable.
-    return sessions.find(s => s.scopeKey === scopeKey && s.closed !== true) || null;
+    const summary = summaries.find(s => s.scopeKey === scopeKey && s.closed !== true) || null;
+    return summary?.id ? loadSession(summary.id) : null;
 }
 // --- resume (reload tools for a stored session) ---
 export async function resumeSession(sessionId, preset) {
@@ -2589,20 +3636,38 @@ export async function resumeSession(sessionId, preset) {
     // than silently dropping the tool-refresh side effects.
     if (session.closed === true) return null;
     if (!session.owner) session.owner = 'user';
+    // A crash / partial save during compaction can leave compaction.lastStage
+    // pinned at 'compacting'. The TUI (App.jsx openContextPicker) reads that as
+    // an in-progress compaction and would show "Compacting conversation"
+    // forever on resume. No compaction is actually running for a freshly loaded
+    // session, so normalize the stale transient stage back to an interrupted
+    // marker. Successful auto/manual compact persistence (lastStage post_turn /
+    // manual / auto_clear) is untouched.
+    normalizeStaleCompactingStage(session);
     // Refresh tools (MCP connections may have changed).
     // Re-resolve from profile.tools when the session stored a profileId —
     // otherwise fall back to preset.tools. Same resolution order as
     // createSession so resume and spawn produce identical BP_1 shapes.
     const oldTools = session.tools || [];
-    const skills = collectSkillsCached(session.cwd);
-    let toolSpec = preset || session.preset || 'full';
-    if (session.profileId && _smartBridgeApi?.getProfile) {
+    const ownerIsAgent = isAgentOwner(session);
+    const skills = ownerIsAgent ? [] : collectSkillsCached(session.cwd);
+    let toolSpec = ownerIsAgent ? 'full' : (preset || session.preset || 'full');
+    if (session.profileId && _agentRuntimeApi?.getProfile) {
         try {
-            const profile = _smartBridgeApi.getProfile(session.profileId);
-            if (Array.isArray(profile?.tools)) toolSpec = profile.tools;
+            const profile = _agentRuntimeApi.getProfile(session.profileId);
+            if (!ownerIsAgent && Array.isArray(profile?.tools)) toolSpec = profile.tools;
         } catch { /* ignore lookup failures, keep preset fallback */ }
     }
-    session.tools = resolveSessionTools(toolSpec, skills, { ownerIsBridge: session.owner === 'bridge' });
+    let toolsForRouting = resolveSessionTools(toolSpec, skills, { ownerIsAgentSession: ownerIsAgent });
+    if (ownerIsAgent) {
+        toolsForRouting = applyToolPermissionNarrowing(toolsForRouting, session.toolPermission, session.role || null);
+    }
+    session.tools = finalizeSessionToolList(toolsForRouting, {
+        schemaAllowedTools: Array.isArray(session.schemaAllowedTools) ? session.schemaAllowedTools : null,
+        disallowedTools: null,
+        ownerIsAgent,
+        resolvedRole: session.role || null,
+    });
     const newTools = session.tools;
     const missing = oldTools.filter(t => !newTools.find(n => n.name === t.name));
     if (missing.length) {
@@ -2617,47 +3682,92 @@ export function getSession(id) {
 }
 export function listSessions(opts = {}) {
     const includeClosed = opts.includeClosed === true;
-    const sessions = listStoredSessions();
+    const sessions = listStoredSessionSummaries();
     const hiddenIds = new Set([..._runtimeState.entries()].filter(([, e]) => e.listHidden).map(([id]) => id));
     // Tombstoned sessions (closed===true) are excluded unless the caller opts in
-    // (e.g. bridge list includeClosed:true).
+    // (e.g. agent list includeClosed:true).
     return sessions.filter(s => !hiddenIds.has(s.id) && (includeClosed || s.closed !== true));
 }
 // --- Clear messages (keep system prompt + provider/model/cwd) ---
-export async function clearSessionMessages(sessionId) {
+export async function clearSessionMessages(sessionId, options = {}) {
     const session = loadSession(sessionId);
     if (!session)
         return false;
     // Don't resurrect a closed session just to clear its messages.
     if (session.closed === true) return false;
+    const clearOptions = options && typeof options === 'object' ? options : {};
+    const requestedCompactType = clearOptions.compactType ?? clearOptions.compact_type ?? clearOptions.type;
+    const compactBeforeClear = requestedCompactType != null && requestedCompactType !== false && String(requestedCompactType).trim() !== '';
     const keep = [];
-    const messages = Array.isArray(session.messages) ? session.messages : [];
+    let messages = Array.isArray(session.messages) ? session.messages : [];
     const beforeMessageTokens = estimateMessagesTokens(messages);
+    let clearCompactType = null;
+    let clearCompactError = null;
+    if (compactBeforeClear && messages.length >= 3) {
+        clearCompactType = normalizeCompactType(requestedCompactType, DEFAULT_COMPACT_TYPE);
+        session.compaction = {
+            ...(session.compaction || {}),
+            type: clearCompactType,
+            compactType: clearCompactType,
+        };
+        try {
+            const compactResult = await runSessionCompaction(session, { mode: 'manual', force: true, sessionId });
+            if (compactResult?.error) {
+                clearCompactError = new Error(compactResult.error);
+            }
+        } catch (err) {
+            clearCompactError = err;
+            try { process.stderr.write(`[session] auto-clear pre-compact failed (sess=${sessionId}): ${err?.message || err}\n`); } catch { /* best-effort */ }
+        }
+        messages = Array.isArray(session.messages) ? session.messages : [];
+    }
+    if (compactBeforeClear && clearOptions.requireCompactSuccess === true) {
+        const hasRetainedSummary = messages.some((m) => (
+            m?.role === 'user'
+            && typeof m.content === 'string'
+            && m.content.startsWith(SUMMARY_PREFIX)
+        ));
+        if (!hasRetainedSummary && !clearCompactError) {
+            clearCompactError = new Error('compact produced no retained summary');
+        }
+    }
+    if (clearCompactError && clearOptions.requireCompactSuccess === true) {
+        const now = Date.now();
+        session.compaction = {
+            ...(session.compaction || {}),
+            lastStage: 'auto_clear_failed',
+            lastCheckedAt: now,
+            lastChanged: false,
+            lastClearAt: session.compaction?.lastClearAt || null,
+            lastClearCompactType: clearCompactType || session.compaction?.compactType || null,
+            lastClearCompactError: clearCompactError?.message || String(clearCompactError),
+        };
+        session.updatedAt = now;
+        await saveSessionAsync(session, { expectedGeneration: session.generation });
+        throw new Error(`auto-clear compact failed; conversation kept: ${session.compaction.lastClearCompactError}`);
+    }
+    const preserveCompactSummary = compactBeforeClear && clearOptions.keepCompactSummary !== false;
     for (let i = 0; i < messages.length; i += 1) {
         const m = messages[i];
         if (!m) continue;
         if (m.role === 'system') {
+            // BP1/BP2/BP3 all ride `role:'system'` blocks now (BP3 sessionMarker
+            // moved off the `<system-reminder>` user wrapper), so the stable
+            // memory/meta layer is preserved here unconditionally — no sentinel
+            // scan / dummy-assistant pairing needed anymore.
             keep.push(m);
             continue;
         }
-        const stableContext =
-            m.role === 'user'
+        if (preserveCompactSummary
+            && m.role === 'user'
             && typeof m.content === 'string'
-            && m.content.startsWith('<system-reminder>')
-            && m.content.includes('<!-- bp3-sentinel -->');
-        if (stableContext) {
+            && m.content.startsWith(SUMMARY_PREFIX)) {
             keep.push(m);
-            const next = messages[i + 1];
-            if (next?.role === 'assistant' && String(next.content || '').trim() === '.') {
-                keep.push(next);
-                i += 1;
-            }
         }
     }
     const afterMessageTokens = estimateMessagesTokens(keep);
-    const reserveTokens = estimateRequestReserveTokens(session.tools || []);
-    const beforeTokens = Math.max(beforeMessageTokens + reserveTokens, positiveContextWindow(session.lastContextTokens) || 0);
-    const afterTokens = afterMessageTokens + reserveTokens;
+    const beforeTokens = estimateTranscriptContextUsage(messages, session.tools || []);
+    const afterTokens = estimateTranscriptContextUsage(keep, session.tools || []);
     const now = Date.now();
     session.messages = keep;
     session.totalInputTokens = 0;
@@ -2687,6 +3797,8 @@ export async function clearSessionMessages(sessionId) {
         lastClearAfterTokens: afterTokens,
         lastClearBeforeMessageTokens: beforeMessageTokens,
         lastClearAfterMessageTokens: afterMessageTokens,
+        lastClearCompactType: clearCompactType || session.compaction?.compactType || null,
+        lastClearCompactError: clearCompactError?.message || null,
     };
     session.updatedAt = now;
     await saveSessionAsync(session, { expectedGeneration: session.generation });
@@ -2696,6 +3808,9 @@ export async function compactSessionMessages(sessionId) {
     const session = loadSession(sessionId);
     if (!session) return null;
     if (session.closed === true) return null;
+    if (isSessionCompactionBlocked(sessionId)) {
+        return { changed: false, reason: 'compact skipped: turn in progress' };
+    }
     const result = await runSessionCompaction(session, {
         mode: 'manual',
         force: true,
@@ -2723,7 +3838,7 @@ export async function updateSessionStatus(id, status) {
     const session = loadSession(id);
     if (!session) return false;
     // Respect tombstones — don't resurrect a closed session just to update a
-    // status label (bridge handler emits running→idle/error around askSession).
+    // status label (agent handler emits running→idle/error around askSession).
     if (session.closed === true) return false;
     session.status = status;
     session.updatedAt = Date.now();
@@ -2746,6 +3861,7 @@ export async function updateSessionStatus(id, status) {
  */
 export function closeSession(id, reason = 'manual') {
     if (!id) return false;
+    _stopToolActivityHeartbeat(id);
     // Prefer in-memory runtime session — allBashSessionIds may not be persisted
     // yet for shells opened in the current turn (BL-bash-disk-sync).
     const inMemory = _runtimeState.get(id)?.session;
@@ -2782,10 +3898,10 @@ export function closeSession(id, reason = 'manual') {
         const durationMs = (typeof askStartedAt === 'number') ? (Date.now() - askStartedAt) : null;
         const parts = [`session=${id}`, `reason=${reason}`];
         if (durationMs != null) parts.push(`duration=${durationMs}ms`);
-        if (!process.env.MIXDOG_QUIET_SESSION_LOG) process.stderr.write(`[bridge-close] ${parts.join(' ')}\n`);
+        if (process.env.MIXDOG_DEBUG_SESSION_LOG) process.stderr.write(`[agent-close] ${parts.join(' ')}\n`);
     } catch { /* best-effort */ }
     for (const bsid of allBashIds) {
-        try { closeBashSession(bsid, `bridge-close:${id}`); } catch { /* ignore */ }
+        try { _closeBashSessionLazy(bsid, `agent-close:${id}`); } catch { /* ignore */ }
     }
     // Drop session-scoped read dedup cache so the Map doesn't accumulate
     // entries across mcp-server lifetime.
@@ -2805,6 +3921,7 @@ export function closeSession(id, reason = 'manual') {
 }
 export function abortSessionTurn(id, reason = 'turn-abort') {
     if (!id) return false;
+    _stopToolActivityHeartbeat(id);
     const entry = _runtimeState.get(id);
     if (!entry || entry.closed) return false;
     entry.stage = 'cancelling';
@@ -2818,7 +3935,7 @@ export function abortSessionTurn(id, reason = 'turn-abort') {
 
 // --- Periodic idle session cleanup ---
 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', 60 * 1000);
+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
 let _cleanupTimer = null;
@@ -2861,12 +3978,12 @@ function sweepIdleSessions({ includeTombstones = true } = {}) {
                 } else {
                     _clearSessionRuntime(d.id);
                     if (d.bashSessionId) {
-                        try { closeBashSession(d.bashSessionId, `idle-sweep:${d.id}`); } catch { /* ignore */ }
+                        try { _closeBashSessionLazy(d.bashSessionId, `idle-sweep:${d.id}`); } catch { /* ignore */ }
                     }
                 }
-                process.stderr.write(`[bridge-session] idle cleanup: closed ${d.id} (idle ${d.idleMinutes}m, owner=${d.owner})\n`);
+                process.stderr.write(`[agent-session] idle cleanup: closed ${d.id} (idle ${d.idleMinutes}m, owner=${d.owner})\n`);
             }
-            process.stderr.write(`[bridge-session] idle sweep: cleaned ${cleaned} session(s), ${remaining} remaining\n`);
+            process.stderr.write(`[agent-session] idle sweep: cleaned ${cleaned} session(s), ${remaining} remaining\n`);
         }
         if (tombstonesCleaned > 0) {
             for (const d of tombstoneDetails) {
@@ -2883,7 +4000,7 @@ function sweepIdleSessions({ includeTombstones = true } = {}) {
             process.stderr.write(`[session-sweep] cleanup took ${elapsed}ms (idle=${cleaned}, tombstones=${tombstonesCleaned}, remaining=${remaining})\n`);
         }
     } catch (e) {
-        process.stderr.write(`[bridge-session] idle sweep error: ${e && e.message || e}\n`);
+        process.stderr.write(`[agent-session] idle sweep error: ${e && e.message || e}\n`);
     }
 }
 
@@ -2922,7 +4039,17 @@ export function sweepTombstones() {
     }
 }
 
+function hasActiveRuntimeWork() {
+    for (const [, entry] of _runtimeState) {
+        if (!entry || entry.closed === true) continue;
+        if (entry.controller && !entry.controller.signal?.aborted) return true;
+        if (['connecting', 'requesting', 'streaming', 'tool_running', 'cancelling'].includes(entry.stage)) return true;
+    }
+    return false;
+}
+
 function _runCleanupCycle() {
+    if (hasActiveRuntimeWork()) return;
     sweepIdleSessions({ includeTombstones: true });
 }