mixdog 0.9.1 → 0.9.2

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

@@ -10,7 +10,7 @@
  *   BP_1  system#1  (1h)  — shared tool policy + compact skill manifest
  *   BP_2  system#2  (1h)  — role/system rules (Lead / agent / hidden role)
  *   BP_3  system#3  (1h)  — stable memory/meta marker (sessionMarker system block; tier3)
- *   BP_4  messages  (1h/5m) — sliding tool_result / prior user-text tail
+ *   BP_4  messages  (5m)  — sliding tool_result / prior user-text tail
  *
  * Tool schemas still sit before system in the provider prompt prefix. We do
  * not spend a separate cache_control slot on tools; the first system BP covers
@@ -35,7 +35,7 @@
  */
 
 import { createHash } from 'crypto';
-import { getHiddenRole } from '../internal-roles.mjs';
+import { getHiddenAgent } from '../internal-agents.mjs';
 
 /**
  * One-shot, LLM-only maintenance hidden roles (cycle1/cycle2/cycle3-agent):
@@ -49,8 +49,8 @@ import { getHiddenRole } from '../internal-roles.mjs';
  * 'unified' and therefore excluded — they run a tool loop whose tail caches
  * legitimately reuse across iterations.
  */
-function isOneShotMaintenanceRole(role) {
-    const hidden = getHiddenRole(role);
+function isOneShotMaintenanceAgent(agent) {
+    const hidden = getHiddenAgent(agent);
     return Boolean(
         hidden
         && hidden.kind === 'maintenance'
@@ -66,12 +66,15 @@ function isOneShotMaintenanceRole(role) {
  *   '5m'   → ephemeral 5m TTL  (1.25x write premium, 0.1x read)
  *   'none' → no breakpoint written on this layer
  *
- * Public agents stay resumable for up to 1h (the terminal-reap window)
- * for same-task reuse, so their message tail uses 1h too. Hidden multi-turn
- * roles (explorer / scheduler / webhook) run a single fan-out or entry-driven
- * session that is not resumed for same-task reuse, so their volatile tail stays
- * at the cheaper 5m TTL. (Tail TTL only affects explicit-breakpoint providers
- * — Anthropic; no-op elsewhere.)
+ * BP1~3 stay at 1h: the system/role/tier3 prefix is shared across sessions
+ * (pool-stable), so the 2x write premium is amortized cross-session and the
+ * warm window survives per-session gaps. The volatile message tail (BP4) is
+ * per-session and trace data (2026-06) shows request gaps are p99 ≈ 4.5min —
+ * 5m+ gaps mean a cold tail anyway, and the smart-compact path rebuilds the
+ * history at that boundary. So every session's tail uses the cheaper 5m TTL
+ * (1.25x write vs 2x), aligned with the 5m terminal-reap window for agents.
+ * (Tail TTL only affects explicit-breakpoint providers — Anthropic; no-op
+ * elsewhere.)
  *
  * Exception: one-shot LLM-only maintenance roles are asked once on a fresh
  * session and closed, so their volatile per-call message tail is never read
@@ -81,15 +84,15 @@ function isOneShotMaintenanceRole(role) {
  * the 1h TTL expiry (writes every run, 0 reads). All layers go 'none' for
  * these roles — single-iteration calls pay the write premium with no reuse.
  */
-export function resolveCacheStrategy(role) {
-    if (isOneShotMaintenanceRole(role)) {
+export function resolveCacheStrategy(agent) {
+    if (isOneShotMaintenanceAgent(agent)) {
         return { tools: 'none', system: 'none', tier3: 'none', messages: 'none' };
     }
-    if (getHiddenRole(role)) {
+    if (getHiddenAgent(agent)) {
         return { tools: 'none', system: '1h', tier3: '1h', messages: '5m' };
     }
-    // Public agents: resumable up to 1h for same-task reuse -> 1h tail.
-    return { tools: 'none', system: '1h', tier3: '1h', messages: '1h' };
+    // Lead + public agents: per-session volatile tail -> 5m (see doc above).
+    return { tools: 'none', system: '1h', tier3: '1h', messages: '5m' };
 }
 
 /**
@@ -97,7 +100,7 @@ export function resolveCacheStrategy(role) {
  *
  * @param {string} provider
  * @param {string} [sessionId]
- * @param {string} [role]
+ * @param {string} [agent]
  * @returns {object} partial sendOpts — spread into provider.send call
  */
 
@@ -356,8 +359,8 @@ export function resolveProviderPromptCacheLane(provider, opts = {}, config = {})
     };
 }
 
-export function buildProviderCacheOpts(provider, sessionId, role) {
-    const ttls = resolveCacheStrategy(role);
+export function buildProviderCacheOpts(provider, sessionId, agent) {
+    const ttls = resolveCacheStrategy(agent);
     const capability = cacheCapabilityForProvider(provider);
     if (capability === 'explicit-breakpoint') {
         // 2026-03-06 Anthropic dropped default TTL 1h→5m. We send
@@ -400,8 +403,8 @@ export function computePrefixContent(systemPrompt, tools) {
 /**
  * Longest-lived layer TTL (seconds) for registry expiry tracking.
  */
-export function ttlSecondsForCache(role) {
-    const ttls = resolveCacheStrategy(role);
+export function ttlSecondsForCache(agent) {
+    const ttls = resolveCacheStrategy(agent);
     if (
         ttls.tools === 'none'
         && ttls.system === 'none'

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

@@ -19,12 +19,44 @@
 
 import { createSession } from '../session/manager.mjs';
 import { traceAgentPreset } from '../agent-trace.mjs';
-import { resolveAgentSessionPermission } from '../internal-roles.mjs';
+import { resolveAgentSessionPermission } from '../internal-agents.mjs';
 import { loadConfig } from '../config.mjs';
+import { AGENT_OWNER } from '../agent-owner.mjs';
+
+import {
+    COMPACT_TYPE_RECALL_FASTTRACK,
+    COMPACT_TYPE_SEMANTIC,
+    normalizeCompactType,
+} from '../session/compact.mjs';
+
+function memoryModuleEnabled(config) {
+    const entry = config?.modules?.memory;
+    if (entry && typeof entry === 'object' && entry.enabled === false) return false;
+    return true;
+}
+
+function normalizeAgentCompactionConfig(value = {}, { memoryEnabled = true } = {}) {
+    const raw = value && typeof value === 'object' ? value : {};
+    let compactType = normalizeCompactType(
+        raw.compactType ?? raw.compact_type ?? raw.type,
+        COMPACT_TYPE_SEMANTIC,
+    );
+    // recall-fasttrack depends on memory ingest/recall; fall back to semantic when
+    // the memory module is disabled (same rule as Lead session runtime).
+    if (compactType === COMPACT_TYPE_RECALL_FASTTRACK && memoryEnabled === false) {
+        compactType = COMPACT_TYPE_SEMANTIC;
+    }
+    return {
+        ...raw,
+        auto: raw.auto !== false && raw.enabled !== false,
+        type: compactType,
+        compactType,
+    };
+}
 
 /**
  * @param {object} opts
- * @param {string}  opts.role          — canonical role name ('worker', 'explorer', ...)
+ * @param {string}  opts.agent         — canonical agent name ('worker', 'explorer', ...)
  * @param {string}  opts.presetName    — resolved preset identifier
  * @param {object}  opts.preset        — resolved preset object from agent-config
  * @param {object}  opts.runtimeSpec   — resolveRuntimeSpec output; must carry .scopeKey / .lane
@@ -32,7 +64,7 @@ import { loadConfig } from '../config.mjs';
  * @param {string|null} [opts.cwd]     — absolute working dir; null is the fixed agent sentinel meaning "no caller workspace context"
  * @param {string}  [opts.owner='agent']
  * @param {string}  [opts.permissionMode] — permissionMode forwarded from the MCP payload ('bypassPermissions', 'acceptEdits', 'plan', 'dontAsk', 'default')
- * @param {string[]} [opts.schemaAllowedTools] — schema-level allowlist from a hidden-role toolSchemaProfile
+ * @param {string[]} [opts.schemaAllowedTools] — schema-level allowlist from a hidden-agent toolSchemaProfile
  * @param {string}  [opts.sourceType]
  * @param {string}  [opts.sourceName]
  * @param {string}  [opts.taskType]
@@ -42,7 +74,7 @@ import { loadConfig } from '../config.mjs';
  * @returns {{ session: object, effectiveCwd: string|null }}
  */
 export function prepareAgentSession({
-    role,
+    agent,
     presetName,
     preset,
     runtimeSpec,
@@ -61,7 +93,10 @@ export function prepareAgentSession({
     cacheKeyOverride,
     schemaAllowedTools,
 }) {
-    const effectivePermission = resolveAgentSessionPermission(role, permission);
+    const effectivePermission = resolveAgentSessionPermission(agent, permission);
+    // No per-agent loop caps: sessions either pin maxLoopIterations explicitly
+    // or fall through to the shared runaway guard (LEAD_MAX_LOOP_ITERATIONS).
+    const effectiveMaxLoopIterations = maxLoopIterations;
     // Pass cwd through verbatim — null is the fixed agent sentinel meaning
     // "no caller workspace context" (cycle1-agent shards, etc). Upgrading
     // null → process.cwd() here would defeat cache-shard fork suppression.
@@ -73,12 +108,11 @@ export function prepareAgentSession({
     let compaction = null;
     try {
         const cfg = loadConfig({ secrets: false });
-        // Agent worker sessions should keep the higher-quality semantic compact
-        // path even when the Lead session uses recall-fasttrack for cheap
-        // auto-clear/auto-compact. Cycle maintenance prompts are small enough
-        // that this normally only matters for long-lived worker conversations.
-        const base = cfg?.compaction && typeof cfg.compaction === 'object' ? cfg.compaction : {};
-        compaction = { ...base, type: '1', compactType: '1' };
+        if (cfg?.compaction && typeof cfg.compaction === 'object') {
+            compaction = normalizeAgentCompactionConfig(cfg.compaction, {
+                memoryEnabled: memoryModuleEnabled(cfg),
+            });
+        }
     } catch { /* config is best-effort for agent compaction policy */ }
     const sessionOpts = {
         preset,
@@ -86,9 +120,9 @@ export function prepareAgentSession({
         scopeKey: runtimeSpec.scopeKey,
         lane: runtimeSpec.lane,
         cwd: effectiveCwd,
-        role: role || undefined,
+        agent: agent || undefined,
         taskType: taskType || undefined,
-        maxLoopIterations: Number.isFinite(maxLoopIterations) ? maxLoopIterations : undefined,
+        maxLoopIterations: Number.isFinite(effectiveMaxLoopIterations) ? effectiveMaxLoopIterations : undefined,
         sourceType: sourceType || undefined,
         sourceName: sourceName || undefined,
         ownerSessionId: effectiveOwnerSessionId || null,
@@ -106,7 +140,7 @@ export function prepareAgentSession({
     try {
         traceAgentPreset({
             sessionId: session.id,
-            role: role || null,
+            agent: agent || null,
             presetName: presetName || null,
             // runtimeSpec carries scopeKey/lane but resolveRuntimeSpec does not
             // populate model/provider — fall back to preset fields.

package/src/runtime/agent/orchestrator/agent-trace.mjs

@@ -29,7 +29,16 @@ let _toolFailureTimer = null;
 let _toolFailureFlushInFlight = false;
 const _LOCAL_TRACE_FLUSH_LINES = 100;
 const _LOCAL_TRACE_FLUSH_MS = 1000;
-const _LOCAL_TRACE_MAX_BYTES = 10 * 1024 * 1024; // 10 MB — rotate to .1 above this.
+const _LOCAL_TRACE_MAX_BYTES = 10 * 1024 * 1024; // 10 MB — rotate to .1/.2/.3 above this.
+// Rotation generations kept on disk (.1 newest … .N oldest). A single .1
+// generation proved too short a window — bench rounds (session-bench /
+// task-bench re-scoring) were losing their raw turn rows to a second rotation
+// within hours. 3 generations ≈ 40 MB worst case per log. Env-overridable via
+// MIXDOG_AGENT_TRACE_ROTATE_KEEP (positive integer).
+const _LOCAL_TRACE_ROTATE_KEEP = (() => {
+    const v = parseInt(process.env.MIXDOG_AGENT_TRACE_ROTATE_KEEP, 10);
+    return Number.isFinite(v) && v > 0 ? v : 3;
+})();
 const _TOOL_FAILURE_FLUSH_LINES = 50;
 const _TOOL_FAILURE_FLUSH_MS = 1000;
 const MIXDOG_SLOW_TOOL_TRACE_MS = (() => {
@@ -59,7 +68,15 @@ function _rotateLocalTraceIfNeeded(path) {
     try {
         const stat = statSync(path);
         if (stat && stat.size > _LOCAL_TRACE_MAX_BYTES) {
-            try { renameSync(path, `${path}.1`); }
+            try {
+                // Shift generations oldest-first: .2 → .3, .1 → .2, live → .1.
+                // The oldest (.KEEP) is overwritten by the rename below it.
+                for (let gen = _LOCAL_TRACE_ROTATE_KEEP - 1; gen >= 1; gen -= 1) {
+                    const src = `${path}.${gen}`;
+                    if (existsSync(src)) renameSync(src, `${path}.${gen + 1}`);
+                }
+                renameSync(path, `${path}.1`);
+            }
             catch (err) {
                 warnAgentOnce('agent-trace:local-rotate', `[agent-trace] local rotate failed (${err?.message})`);
             }
@@ -364,6 +381,7 @@ function traceAgentCompact({
     iteration,
     stage,
     trigger,
+    compact_type,
     prune_count,
     compact_changed,
     input_prefix_hash,
@@ -373,20 +391,26 @@ function traceAgentCompact({
     after_bytes,
     context_window,
     budget_tokens,
+    boundary_tokens,
+    target_budget_tokens,
     reserve_tokens,
+    pressure_tokens,
+    trigger_tokens,
     message_tokens_est,
+    duration_ms,
     provider,
     model,
     error,
     error_code,
+    details,
 }) {
-    if (process.env.MIXDOG_AGENT_TRACE_VERBOSE !== '1') return;
     appendAgentTrace({
         sessionId,
         iteration,
         kind: 'compact_meta',
         stage: stage || null,
         trigger: trigger || null,
+        compact_type: compact_type || null,
         prune_count: prune_count ?? 0,
         compact_changed: !!compact_changed,
         input_prefix_hash: input_prefix_hash || null,
@@ -396,12 +420,18 @@ function traceAgentCompact({
         after_bytes: after_bytes ?? null,
         context_window: context_window ?? null,
         budget_tokens: budget_tokens ?? null,
+        boundary_tokens: boundary_tokens ?? null,
+        target_budget_tokens: target_budget_tokens ?? null,
         reserve_tokens: reserve_tokens ?? null,
+        pressure_tokens: pressure_tokens ?? null,
+        trigger_tokens: trigger_tokens ?? null,
         message_tokens_est: message_tokens_est ?? null,
+        duration_ms: duration_ms ?? null,
         provider: provider || null,
         model: model || null,
         error: error || null,
         error_code: error_code || null,
+        details: details && typeof details === 'object' ? details : null,
     });
 }
 
@@ -488,6 +518,22 @@ function summarizeToolArgs(toolName, args) {
     return Object.keys(out).length ? out : null;
 }
 
+function stableTraceStringify(value) {
+    if (value === null || value === undefined) return JSON.stringify(value);
+    if (typeof value !== 'object') return JSON.stringify(value);
+    if (Array.isArray(value)) return '[' + value.map(stableTraceStringify).join(',') + ']';
+    const keys = Object.keys(value).sort();
+    return '{' + keys.map((k) => `${JSON.stringify(k)}:${stableTraceStringify(value[k])}`).join(',') + '}';
+}
+
+function hashTraceValue(value) {
+    try {
+        return createHash('sha256').update(stableTraceStringify(value)).digest('hex').slice(0, 16);
+    } catch {
+        return null;
+    }
+}
+
 function _resolveToolFailurePath() {
     if (process.env.MIXDOG_TOOL_FAILURE_LOG_DISABLE === '1') return null;
     if (_toolFailurePath) return _toolFailurePath;
@@ -601,7 +647,7 @@ function classifyToolFailure(resultText, toolName) {
     return 'runtime/failure';
 }
 
-function traceAgentToolFailure({ sessionId, iteration, toolName, toolKind, toolMs, toolArgs, role, model, cwd, resultText, resultKind = 'error' }) {
+function traceAgentToolFailure({ sessionId, iteration, toolName, toolKind, toolMs, toolArgs, agent, model, cwd, resultText, resultKind = 'error' }) {
     if (process.env.MIXDOG_AGENT_TRACE_DISABLE === '1') return;
     if (!_resolveToolFailurePath()) return;
     try {
@@ -614,7 +660,7 @@ function traceAgentToolFailure({ sessionId, iteration, toolName, toolKind, toolM
             tool_kind: toolKind || null,
             result_kind: resultKind || 'error',
             category: classifyToolFailure(cleanText, toolName),
-            role: role || null,
+            agent: agent || null,
             model: model || null,
             cwd: cwd || null,
             tool_ms: Number.isFinite(Number(toolMs)) ? Number(toolMs) : null,
@@ -630,12 +676,13 @@ function traceAgentToolFailure({ sessionId, iteration, toolName, toolKind, toolM
     }
 }
 
-function traceAgentTool({ sessionId, iteration, toolName, toolKind, toolMs, toolArgs, role, resultKind, model, resultText, cwd }) {
+function traceAgentTool({ sessionId, iteration, toolName, toolKind, toolMs, toolArgs, agent, resultKind, model, resultText, cwd }) {
     const nextCallCount = countJsonNextCalls(resultText);
     const resultBytesEst = typeof resultText === 'string' ? Buffer.byteLength(resultText, 'utf8') : 0;
     const resultLinesEst = typeof resultText === 'string' && resultText.length > 0 ? resultText.split('\n').length : 0;
     const numericToolMs = Number(toolMs);
     const summarizedArgs = summarizeToolArgs(toolName, toolArgs);
+    const toolArgsHash = summarizedArgs ? hashTraceValue(summarizedArgs) : null;
     // Flat shape — fields named exactly as the agent_calls PG columns so
     // insertAgentCalls can pick them up by direct property access without
     // a payload-unwrap step. result_kind has no column and rides as plain
@@ -644,12 +691,14 @@ function traceAgentTool({ sessionId, iteration, toolName, toolKind, toolMs, tool
         sessionId,
         iteration,
         kind: 'tool',
-        role: role || null,
+        agent: agent || null,
         model: model || null,
         tool_name: toolName,
         tool_kind: toolKind,
         tool_ms: toolMs,
         tool_args: summarizedArgs,
+        tool_args_hash: toolArgsHash,
+        tool_args_summary: summarizedArgs,
         result_kind: resultKind || null,
         result_has_next_call: nextCallCount > 0,
         result_next_call_count: nextCallCount,
@@ -665,7 +714,7 @@ function traceAgentTool({ sessionId, iteration, toolName, toolKind, toolMs, tool
             sessionId,
             iteration,
             kind: 'tool_slow',
-            role: role || null,
+            agent: agent || null,
             model: model || null,
             tool_name: toolName,
             tool_kind: toolKind,
@@ -674,6 +723,8 @@ function traceAgentTool({ sessionId, iteration, toolName, toolKind, toolMs, tool
                 threshold_ms: MIXDOG_SLOW_TOOL_TRACE_MS,
                 result_kind: resultKind || null,
                 tool_args: summarizedArgs,
+                tool_args_hash: toolArgsHash,
+                tool_args_summary: summarizedArgs,
                 result_has_next_call: nextCallCount > 0,
                 result_next_call_count: nextCallCount,
                 result_bytes_est: resultBytesEst,
@@ -683,7 +734,7 @@ function traceAgentTool({ sessionId, iteration, toolName, toolKind, toolMs, tool
         });
     }
     if (resultKind === 'error') {
-        traceAgentToolFailure({ sessionId, iteration, toolName, toolKind, toolMs, toolArgs, role, model, cwd, resultText, resultKind });
+        traceAgentToolFailure({ sessionId, iteration, toolName, toolKind, toolMs, toolArgs, agent, model, cwd, resultText, resultKind });
     }
 }
 
@@ -741,25 +792,27 @@ function traceStreamAborted({ sessionId, info }) {
     });
 }
 
-function traceAgentPreset({ sessionId, role, presetName, model, provider, parentSessionId }) {
+function traceAgentPreset({ sessionId, agent, presetName, model, provider, parentSessionId }) {
     // Fires once per dispatch right after the preset has been resolved and
     // its runtime spec (provider/model) assembled. Useful for after-the-fact
-    // routing analysis: "which role landed on which preset / provider / model
+    // routing analysis: "which agent landed on which preset / provider / model
     // on this request?"
     appendAgentTrace({
         sessionId,
         kind: 'preset_assign',
-        role: role || null,
+        agent: agent || null,
         preset_name: presetName || null,
         model: model || null,
         provider: provider || null,
         parent_session_id: parentSessionId || null,
+        parentSessionId: parentSessionId || null,
     });
 }
 
 function traceAgentFetch({ sessionId, headersMs, httpStatus, handshakeRetries, handshakeRetryClassifiers, provider, model, transport }) {
     const payload = {
         headers_ms: headersMs,
+        phase: 'http_response_headers',
         http_status: httpStatus,
         provider: provider || null,
         model: model || null,
@@ -786,17 +839,23 @@ function traceAgentFetch({ sessionId, headersMs, httpStatus, handshakeRetries, h
 }
 
 function traceAgentSse({ sessionId, sseParseMs, ttftMs, provider, model, transport }) {
+    const streamTotalMs = sseParseMs;
+    const firstTokenMs = ttftMs;
     appendAgentTrace({
         sessionId,
         kind: 'sse',
         sse_parse_ms: sseParseMs,
+        stream_total_ms: streamTotalMs,
         ttft_ms: ttftMs,
+        first_token_ms: firstTokenMs,
         provider: provider || null,
         model: model || null,
         transport: transport || null,
         payload: {
             sse_parse_ms: sseParseMs,
+            stream_total_ms: streamTotalMs,
             ttft_ms: ttftMs,
+            first_token_ms: firstTokenMs,
             provider: provider || null,
             model: model || null,
             transport: transport || null,
@@ -804,6 +863,19 @@ function traceAgentSse({ sessionId, sseParseMs, ttftMs, provider, model, transpo
     });
 }
 
+function extractThinkingTokens(rawUsage) {
+    if (!rawUsage || typeof rawUsage !== 'object') return null;
+    const direct = Number(rawUsage.thinking_tokens ?? rawUsage.thinkingTokens);
+    if (Number.isFinite(direct) && direct >= 0) return direct;
+    const details = rawUsage.output_tokens_details
+        || rawUsage.completion_tokens_details;
+    if (details && typeof details === 'object') {
+        const nested = Number(details.reasoning_tokens ?? details.thinking_tokens);
+        if (Number.isFinite(nested) && nested >= 0) return nested;
+    }
+    return null;
+}
+
 function traceAgentUsage({ sessionId, iteration, inputTokens, outputTokens, cachedTokens, cacheWriteTokens, promptTokens, model, modelDisplay, responseId, rawUsage, provider, serviceTier, requestKind }) {
     const inclusive = isInclusiveProvider(provider);
     const inTok = inputTokens || 0;
@@ -816,12 +888,14 @@ function traceAgentUsage({ sessionId, iteration, inputTokens, outputTokens, cach
             ? Math.max(inTok, cacheRead + cacheWrite)
             : inTok + cacheRead + cacheWrite);
     const resolvedServiceTier = serviceTier || rawUsage?.service_tier || rawUsage?.serviceTier || null;
+    const thinkingTokens = extractThinkingTokens(rawUsage);
     appendAgentTrace({
         sessionId,
         iteration,
         kind: 'usage_raw',
         input_tokens: inputTokens,
         output_tokens: outputTokens,
+        thinking_tokens: thinkingTokens,
         cached_tokens: cachedTokens,
         cache_write_tokens: cacheWrite,
         uncached_input_tokens: uncachedInputTokens,
@@ -837,6 +911,7 @@ function traceAgentUsage({ sessionId, iteration, inputTokens, outputTokens, cach
             provider: provider || null,
             prompt_tokens: promptTotal,
             uncached_input_tokens: uncachedInputTokens,
+            thinking_tokens: thinkingTokens,
             model_display: modelDisplay || null,
             response_id: responseId || null,
             service_tier: resolvedServiceTier,

package/src/runtime/agent/orchestrator/config.mjs

@@ -383,6 +383,7 @@ export function loadConfig(options = {}) {
                 trajectory: { enabled: true, ...raw.trajectory },
                 runtime: raw.runtime && typeof raw.runtime === 'object' ? raw.runtime : {},
                 shell: raw.shell && typeof raw.shell === 'object' ? raw.shell : {},
+                update: raw.update && typeof raw.update === 'object' ? { ...raw.update } : {},
             };
         }
         catch { /* fall through */ }
@@ -408,6 +409,7 @@ export function loadConfig(options = {}) {
         trajectory: { enabled: true },
         runtime: {},
         shell: {},
+        update: {},
     };
 }
 /**
@@ -482,6 +484,7 @@ export function saveConfig(config) {
         trajectory: config.trajectory || {},
         runtime: config.runtime || {},
         shell: config.shell || {},
+        update: config.update || {},
     }));
 }
 // --- Preset helpers ---