mixdog 0.9.95 → 0.9.96

package/src/runtime/shared/turn-snapshot.mjs

@@ -83,6 +83,8 @@ function createDiffTracker(meta = {}) {
   return {
     ownerSessionId: clean(meta.ownerSessionId) || null,
     ownerGeneration: Number(meta.ownerGeneration) || 0,
+    worktreeRequest: clean(meta.worktreeRequest),
+    worktreeContended: false,
     valid: true,
     sealed: false,
     revision: 0,
@@ -336,13 +338,31 @@ export async function beginTurnSnapshot(_worktree, sessionId) {
     generation,
     agents: new Map(),
   });
-  const tracker = resetDiffTracker(ownerSessionId);
+  const worktreeRequest = pathKey(_worktree);
+  const tracker = resetDiffTracker(ownerSessionId, { worktreeRequest });
   trimTurnCache();
   if (!tracker) return;
+  for (const [otherSessionId, other] of _diffTrackersBySession) {
+    if (otherSessionId === ownerSessionId || other.sealed) continue;
+    if (!worktreeRequest || other.worktreeRequest !== worktreeRequest) continue;
+    tracker.worktreeContended = true;
+    other.worktreeContended = true;
+  }
   try {
     const snapshot = await createTurnWorktreeSnapshot(_worktree);
     if (_diffTrackersBySession.get(ownerSessionId) === tracker) {
       tracker.worktreeSnapshot = snapshot;
+      if (snapshot?.root) {
+        for (const [otherSessionId, other] of _diffTrackersBySession) {
+          if (otherSessionId === ownerSessionId) continue;
+          if (other.worktreeSnapshot?.root !== snapshot.root) continue;
+          // A whole-worktree baseline cannot attribute concurrent mutations
+          // to either session. Mark both turns permanently contended and fall
+          // back to their exact session-owned mutation trackers.
+          tracker.worktreeContended = true;
+          other.worktreeContended = true;
+        }
+      }
     }
   } catch {
     // Git is optional. Exact apply_patch tracking remains the fallback.
@@ -421,7 +441,7 @@ export function completeAgentTurnReview(handle, patches = []) {
 export async function completeTurnSnapshot(sessionId) {
   const tracker = _diffTrackersBySession.get(clean(sessionId));
   if (!tracker) return false;
-  if (tracker.worktreeSnapshot) {
+  if (tracker.worktreeSnapshot && !tracker.worktreeContended) {
     try { await refreshTurnWorktreeSnapshot(tracker.worktreeSnapshot); } catch {}
   }
   tracker.sealed = true;
@@ -435,10 +455,13 @@ export async function getTurnReviewDiff(_worktree, sessionId) {
   const ownerSessionId = clean(sessionId);
   const turn = _turnsBySession.get(ownerSessionId);
   const tracker = _diffTrackersBySession.get(ownerSessionId);
-  if (tracker?.worktreeSnapshot && !tracker.sealed) {
-    try { await refreshTurnWorktreeSnapshot(tracker.worktreeSnapshot); } catch {}
+  const isolatedWorktreeSnapshot = tracker?.worktreeContended
+    ? null
+    : tracker?.worktreeSnapshot || null;
+  if (isolatedWorktreeSnapshot && !tracker.sealed) {
+    try { await refreshTurnWorktreeSnapshot(isolatedWorktreeSnapshot); } catch {}
   }
-  const snapshot = tracker?.worktreeSnapshot || null;
+  const snapshot = isolatedWorktreeSnapshot;
   return {
     supported: true,
     files: snapshot?.files || [],
@@ -455,6 +478,9 @@ export async function getTurnReviewDiff(_worktree, sessionId) {
 export async function revertTurnReviewFile(_worktree, sessionId, file) {
   const ownerSessionId = clean(sessionId);
   const tracker = _diffTrackersBySession.get(ownerSessionId);
+  if (tracker?.worktreeContended) {
+    throw new Error('turn review revert is unavailable while sessions share a worktree');
+  }
   if (!tracker?.worktreeSnapshot) throw new Error('turn worktree snapshot is unavailable');
   await revertTurnWorktreeFile(tracker.worktreeSnapshot, file);
   return await getTurnReviewDiff(_worktree, ownerSessionId);

package/src/runtime/shared/turn-worktree-snapshot.mjs

@@ -43,15 +43,17 @@ function runGit(args, {
   allowFailure = false,
 } = {}) {
   return new Promise((resolvePromise, rejectPromise) => {
+    const hasInput = (typeof input === 'string' || Buffer.isBuffer(input)) && input.length > 0;
     const child = spawn('git', args, {
       cwd,
       windowsHide: true,
-      stdio: ['pipe', 'pipe', 'pipe'],
+      stdio: [hasInput ? 'pipe' : 'ignore', 'pipe', 'pipe'],
     });
     const stdout = [];
     const stderr = [];
     let stdoutBytes = 0;
     let stderrBytes = 0;
+    let stdinError = null;
     let settled = false;
     const finish = (error, result) => {
       if (settled) return;
@@ -93,9 +95,19 @@ function runGit(args, {
         finish(commandError(args, result.stderr, result.code));
         return;
       }
+      if (stdinError && result.code === 0) {
+        finish(stdinError);
+        return;
+      }
       finish(null, result);
     });
-    child.stdin.end(input);
+    if (child.stdin) {
+      // A short-lived git command can close before Node flushes stdin. Keep
+      // that transport race inside this promise instead of emitting an
+      // unhandled EPIPE that terminates the entire release validator.
+      child.stdin.on('error', (error) => { stdinError = error; });
+      child.stdin.end(input);
+    }
   });
 }
 

package/src/session-runtime/config-helpers.mjs

@@ -7,11 +7,13 @@ import { routeFastKey, fastPreferenceFor } from './model-capabilities.mjs';
 export const DEFAULT_PROVIDER = 'anthropic-oauth';
 export const DEFAULT_MODEL = '';
 
-// Resolve the provider to use when a route carries no explicit provider.
-// Priority: config.defaultProvider (when it names a known provider) > DEFAULT_PROVIDER.
+// Resolve a provider-less MAIN selector against the selected Main preset.
+// DEFAULT_PROVIDER is only the unconfigured bootstrap fallback (model remains
+// empty); agent/search override resolution never calls this to synthesize one.
 export function makeResolveDefaultProvider(isKnownProvider) {
   return function resolveDefaultProvider(config) {
-    const configured = clean(config?.defaultProvider);
+    const selectedMain = findPreset(config, config?.default);
+    const configured = clean(selectedMain?.provider);
     if (configured && isKnownProvider(configured)) return configured;
     return DEFAULT_PROVIDER;
   };
@@ -46,16 +48,18 @@ export function makeResolveRoute(resolveDefaultProvider) {
     if (explicitModel && !explicitProvider) {
       const preset = findPreset(config, explicitModel);
       if (preset) {
-        const p = clean(preset.provider) || DEFAULT_PROVIDER;
+        const p = clean(preset.provider);
         const m = clean(preset.model) || DEFAULT_MODEL;
-        const saved = modelSettingsFor(config, p, m);
-        return {
-          provider: p,
-          model: m,
-          preset,
-          effort: hasExplicitEffort ? explicitEffort : normalizeSavedEffort(saved.effort ?? preset.effort),
-          fast: hasExplicitFast ? explicitFast : (hasOwn(saved, 'fast') ? saved.fast === true : (preset.fast === true || fastPreferenceFor(config, p, m))),
-        };
+        if (p && m) {
+          const saved = modelSettingsFor(config, p, m);
+          return {
+            provider: p,
+            model: m,
+            preset,
+            effort: hasExplicitEffort ? explicitEffort : normalizeSavedEffort(saved.effort ?? preset.effort),
+            fast: hasExplicitFast ? explicitFast : (hasOwn(saved, 'fast') ? saved.fast === true : (preset.fast === true || fastPreferenceFor(config, p, m))),
+          };
+        }
       }
     }
 
@@ -63,16 +67,18 @@ export function makeResolveRoute(resolveDefaultProvider) {
       const defaultKey = config?.default;
       const preset = findPreset(config, defaultKey);
       if (preset) {
-        const p = clean(preset.provider) || DEFAULT_PROVIDER;
+        const p = clean(preset.provider);
         const m = clean(preset.model) || DEFAULT_MODEL;
-        const saved = modelSettingsFor(config, p, m);
-        return {
-          provider: p,
-          model: m,
-          preset,
-          effort: hasExplicitEffort ? explicitEffort : normalizeSavedEffort(saved.effort ?? preset.effort),
-          fast: hasExplicitFast ? explicitFast : (hasOwn(saved, 'fast') ? saved.fast === true : (preset.fast === true || fastPreferenceFor(config, p, m))),
-        };
+        if (p && m) {
+          const saved = modelSettingsFor(config, p, m);
+          return {
+            provider: p,
+            model: m,
+            preset,
+            effort: hasExplicitEffort ? explicitEffort : normalizeSavedEffort(saved.effort ?? preset.effort),
+            fast: hasExplicitFast ? explicitFast : (hasOwn(saved, 'fast') ? saved.fast === true : (preset.fast === true || fastPreferenceFor(config, p, m))),
+          };
+        }
       }
     }
 
@@ -197,14 +203,14 @@ export function resolveAgentTerminalReapMs(config, provider) {
 // fall back to the provider's default; else the global 1h default.
 export function resolveAutoClearIdleMs(config, provider) {
   const raw = config?.autoClear && typeof config.autoClear === 'object' ? config.autoClear : {};
-  const idleMs = Number(raw.idleMs ?? raw.thresholdMs ?? raw.idleMillis);
+  const idleMs = Number(raw.idleMs);
   if (Number.isFinite(idleMs) && idleMs > 0) return Math.max(60_000, Math.round(idleMs));
-  return autoClearIdleMsForProvider(provider, raw.providerIdleMs ?? raw.providerDefaults ?? raw.providers);
+  return autoClearIdleMsForProvider(provider, raw.providerIdleMs);
 }
 
 export function normalizeSystemShellConfig(value = {}) {
   const raw = value && typeof value === 'object' ? value : {};
-  const command = clean(raw.command ?? raw.path ?? raw.executable ?? raw.shell);
+  const command = clean(raw.command);
   const envCommand = clean(process.env.MIXDOG_SHELL);
   return {
     command,
@@ -227,7 +233,7 @@ export function normalizeSystemShellCommand(value) {
 
 export function normalizeAutoClearConfig(value = {}) {
   const raw = value && typeof value === 'object' ? value : {};
-  const idleMs = Number(raw.idleMs ?? raw.thresholdMs ?? raw.idleMillis);
+  const idleMs = Number(raw.idleMs);
   const hasExplicitIdle = Number.isFinite(idleMs) && idleMs > 0;
   const rawMinPct = Number(raw.minContextPercent);
   const minContextPercent = Number.isFinite(rawMinPct)
@@ -241,7 +247,7 @@ export function normalizeAutoClearConfig(value = {}) {
     enabled: raw.enabled !== false,
     idleMs: hasExplicitIdle ? Math.max(60_000, Math.round(idleMs)) : null,
     custom: hasExplicitIdle,
-    providerIdleMs: normalizeAutoClearProviderIdleMs(raw.providerIdleMs ?? raw.providerDefaults ?? raw.providers),
+    providerIdleMs: normalizeAutoClearProviderIdleMs(raw.providerIdleMs),
     minContextPercent,
   };
 }
@@ -254,16 +260,15 @@ export function normalizeCompactTypeSetting(value, fallback = 'recall-fasttrack'
   return fallback;
 }
 
-export function normalizeCompactionConfig(value = {}, { memoryEnabled = true } = {}) {
+export function normalizeCompactionConfig(value = {}) {
   const raw = value && typeof value === 'object' ? value : {};
-  let compactType = normalizeCompactTypeSetting(raw.compactType ?? raw.compact_type ?? raw.type, 'recall-fasttrack');
-  // Memory is now always-on, so recall-fasttrack no longer downgrades to
-  // semantic. `memoryEnabled` is retained as a param for API compatibility but
-  // is intentionally ignored (fasttrack drains run on-demand regardless of the
-  // recap/background-cycle toggle).
-  void memoryEnabled;
+  const compactType = normalizeCompactTypeSetting(raw.type, 'recall-fasttrack');
+  const next = { ...raw };
+  delete next.compactType;
+  delete next.compact_type;
+  delete next.enabled;
   return {
-    ...raw,
+    ...next,
     auto: raw.auto !== false && raw.enabled !== false,
     type: compactType,
     compactType,
@@ -284,9 +289,6 @@ export function moduleEnabled(configLike, name, fallback = true) {
 export function recapEnabled(configLike, fallback = true) {
   const entry = configLike?.recap;
   if (entry && typeof entry === 'object' && entry.enabled === false) return false;
-  // Legacy fallback: pre-migration configs may still carry modules.memory=false.
-  if (configLike?.modules?.memory === false) return false;
-  if (moduleEnabled(configLike, 'memory', true) === false) return false;
   return fallback !== false;
 }
 

package/src/session-runtime/model-route-api.mjs

@@ -64,11 +64,13 @@ export function createModelRouteApi(deps) {
       return await collectSearchProviderModels({ force: options.force === true || options.refresh === true });
     },
     async setSearchRoute(next) {
-      const searchRoute = getSearchRouteState();
-      let selectedRoute = normalizeSearchRouteConfig(next);
-      if (!selectedRoute && next?.model && searchRoute?.provider) {
-        selectedRoute = normalizeSearchRouteConfig({ ...next, provider: searchRoute.provider });
-      }
+      let selectedRoute = clean(next?.provider)
+        ? normalizeSearchRouteConfig(next)
+        : normalizeSearchRouteConfig({
+          provider: SEARCH_DEFAULT_PROVIDER,
+          model: SEARCH_DEFAULT_MODEL,
+          ...(next?.toolType ? { toolType: next.toolType } : {}),
+        });
       if (!selectedRoute) throw new Error('search route requires provider and model');
       if (isDefaultSearchRouteConfig(selectedRoute)) {
         await awaitKeychainPrewarm();

package/src/session-runtime/provider-auth-api.mjs

@@ -193,12 +193,5 @@ export function createProviderAuthApi({
         quick: options.quick === true,
       });
     },
-    async setDefaultProvider(provider) {
-      const requested = clean(provider);
-      if (!requested) throw new Error('provider is required');
-      if (!isKnownProvider(requested)) throw new Error(`unknown provider "${provider}"`);
-      saveConfigAndAdopt({ ...getConfig(), defaultProvider: requested });
-      return requested;
-    },
   };
 }

package/src/session-runtime/runtime-core.mjs

@@ -428,11 +428,8 @@ export async function createMixdogSessionRuntime({
   rt.searchModPromise = null;
   rt.codeGraphModPromise = null;
 
-  // Memory module is always-on. `memoryEnabled()` is kept as a thin alias that
-  // now always returns true (callers/compaction helpers still reference it);
-  // the user-facing toggle is `recap` (background cycles only), read via
-  // recapEnabled(config).
-  const memoryEnabled = () => true;
+  // Memory is always-on. The user-facing toggle is `recap` (background cycles
+  // only), read via recapEnabled(config).
   const recapEnabledFn = () => recapEnabled(rt.config, true);
   const channelsEnabled = () => moduleEnabled(rt.config, 'channels', true);
 
@@ -469,10 +466,6 @@ export async function createMixdogSessionRuntime({
 
     const nextConfig = { ...(rt.config || {}) };
     nextConfig.presets = upsertWorkflowPreset(nextConfig.presets, 'lead', leadRoute);
-    nextConfig.workflowRoutes = {
-      ...(nextConfig.workflowRoutes || {}),
-      lead: leadRoute,
-    };
     nextConfig.default = workflowPresetId('lead');
 
     saveConfigAndAdopt(nextConfig);
@@ -1198,7 +1191,6 @@ export async function createMixdogSessionRuntime({
     reg,
     cfgMod,
     activeWorkflowContext,
-    memoryEnabled,
     hooks,
     hookCommonPayload,
     mcpClient,
@@ -1368,7 +1360,6 @@ export async function createMixdogSessionRuntime({
     parseDurationMs,
     formatDurationMs,
     localPackageVersion,
-    memoryEnabled,
     recapEnabledFn,
     channelsEnabled,
     autoUpdateEnabled,
@@ -1651,6 +1642,15 @@ export async function createMixdogSessionRuntime({
         throw new Error(`session ${rt.session.id} is already materialized`);
       }
       rt.reservedSessionId = id;
+      // Reservation is the earliest safe point to prepare keychain, memory,
+      // provider metadata, hooks, and the provider transport. This starts no
+      // model response and therefore incurs no inference/token usage. The first
+      // submit joins this single-flight promise instead of paying cold setup.
+      void createCurrentSession('reservation').catch((error) => {
+        bootProfile('session:reservation-prewarm-failed', {
+          error: error?.message || String(error),
+        });
+      });
       return id;
     },
     get provider() {

package/src/session-runtime/runtime-tunables.mjs

@@ -24,10 +24,10 @@ export function readRuntimeTunables() {
     statuslineUsageRefreshDelayMs: envDelayMs('MIXDOG_STATUSLINE_USAGE_REFRESH_MS', 240_000, { min: 30_000, max: 540_000 }),
     channelStartDelayMs: envDelayMs('MIXDOG_CHANNEL_START_DELAY_MS', 10_000, { min: 0, max: 120_000 }),
     backgroundBusyRetryMs: envDelayMs('MIXDOG_BACKGROUND_BUSY_RETRY_MS', 1_000, { min: 50, max: 10_000 }),
-    // MCP startup must not own the first-token critical path. Servers that do
-    // not connect inside this small grace period join through the existing
-    // late-tool announcement path on the next turn.
-    mcpTurnGraceMs: envDelayMs('MIXDOG_MCP_TURN_GRACE_MS', 150, { min: 0, max: 2_000 }),
+    // MCP startup never owns the first-token critical path by default. Already
+    // connected tools fold synchronously; in-flight servers join through the
+    // late-tool announcement path. Operators may opt back into a grace window.
+    mcpTurnGraceMs: envDelayMs('MIXDOG_MCP_TURN_GRACE_MS', 0, { min: 0, max: 2_000 }),
     // Boot-time remote start is deferred past the first frame; see the caller.
     remoteAutoStartDelayMs: envDelayMs('MIXDOG_REMOTE_AUTOSTART_DELAY_MS', 1_500, { min: 0, max: 60_000 }),
     providerWarmupEnabled: !envFlag('MIXDOG_DISABLE_PROVIDER_WARMUP')

package/src/session-runtime/session-lifecycle.mjs

@@ -30,7 +30,6 @@ export function createSessionLifecycle({
   reg,
   cfgMod,
   activeWorkflowContext,
-  memoryEnabled,
   hooks,
   hookCommonPayload,
   mcpClient,
@@ -140,6 +139,14 @@ export function createSessionLifecycle({
 
     const startedAt = performance.now();
     bootProfile('session:create:start', { mode: rt.mode, reason });
+    // A daemon reservation is deliberate user-think-time prewarm. Start the
+    // one-time agent-loop module load now so the first real prompt does not pay
+    // its ~100ms dynamic-import graph immediately before provider.send.
+    if (reason === 'reservation' && typeof mgr.prewarmAgentLoop === 'function') {
+      void mgr.prewarmAgentLoop().catch((error) => {
+        bootProfile('agent-loop:prewarm-failed', { error: error?.message || String(error) });
+      });
+    }
     const promise = (async () => {
       // Demand-only: this starts only after the user submits (unless an
       // explicitly enabled prewarm caller asks for a session). Core-memory
@@ -187,7 +194,7 @@ export function createSessionLifecycle({
         workflowContext,
         fast: rt.route.fast === true,
         compaction: rt.config.compaction && typeof rt.config.compaction === 'object'
-          ? normalizeCompactionConfig(rt.config.compaction, { memoryEnabled: memoryEnabled() })
+          ? normalizeCompactionConfig(rt.config.compaction)
           : undefined,
       };
       if (hasOwn(rt.route, 'effort') || rt.route.effectiveEffort) {

package/src/session-runtime/session-turn-api.mjs

@@ -12,6 +12,7 @@ import {
 import { getMcpTools } from '../runtime/agent/orchestrator/mcp/client.mjs';
 import { traceTurnTiming } from '../runtime/agent/orchestrator/agent-trace.mjs';
 import { beginTurnSnapshot, completeTurnSnapshot } from '../runtime/shared/turn-snapshot.mjs';
+import { isVisibleStreamProgress } from '../runtime/shared/stream-progress.mjs';
 
 export function splitToolStatusCounts(rows) {
   const list = Array.isArray(rows) ? rows : [];
@@ -44,7 +45,7 @@ export function createSessionTurnApi(deps) {
     scheduleProviderWarmup, scheduleProviderModelWarmup, invalidateContextStatusCache,
     agentTool, recreateCurrentSessionIfReady, invalidatePreSessionToolSurface,
     activeToolSurface, applyResolvedCwd, resolveCwdPath, agentStatusState, notificationListeners,
-    awaitInitialMcpConnect, mcpTurnGraceMs = 150, awaitRoutePreparation,
+    awaitInitialMcpConnect, mcpTurnGraceMs = 0, awaitRoutePreparation,
     getReservedSessionId, sessionTitles,
   } = deps;
   const enqueueRemoteAttachedPrompt = (prompt) => {
@@ -79,7 +80,14 @@ export function createSessionTurnApi(deps) {
       // a normal user turn and this surface refreshes from disk.
       const attachedSession = getSession();
       if (attachedSession?.remoteAttached) {
-        const delivered = enqueueRemoteAttachedPrompt(prompt);
+        // Carry the submission id into the spool: the owner reuses it for the
+        // queue entry and the settled user row, so the submitting surface's
+        // optimistic bubble is released instead of standing beside the
+        // mirrored twin (user: 같은 세션에서 메세지가 두 개로 보인다).
+        const submissionId = String(options.id || '').trim();
+        const delivered = enqueueRemoteAttachedPrompt(
+          submissionId ? { content: prompt, id: submissionId } : prompt,
+        );
         return {
           // This branch is only a race-safe fallback for callers that reached
           // ask() before the live pipe was ready. Never manufacture an
@@ -117,9 +125,10 @@ export function createSessionTurnApi(deps) {
       let turnTimingEmitted = false;
       // Heavy runtime warmup is one-shot and demand-driven: idle desktop panes
       // never spawn shell/token/shard helpers or a code-graph worker. More
-      // importantly, do not start them until the provider has produced its
-      // first stream delta: launching PowerShell + graph workers before that
-      // point directly competes with the first-token critical path.
+      // importantly, do not start them until the provider has produced visible
+      // text/reasoning/tool progress: transport headers and response-created
+      // acknowledgements arrive earlier and would make PowerShell + graph
+      // workers compete with the actual first-token critical path.
       const heavyRuntimeWarmupPending = typeof getCodeGraphFirstTurnPrewarmDone === 'function'
         && !getCodeGraphFirstTurnPrewarmDone();
       if (heavyRuntimeWarmupPending) {
@@ -264,7 +273,6 @@ export function createSessionTurnApi(deps) {
           .map((part) => String(part || '').trim())
           .filter(Boolean)
           .join('\n\n');
-        providerStartedAt = performance.now();
         const result = await mgr.askSession(
           session0.id,
           prompt,
@@ -322,14 +330,26 @@ export function createSessionTurnApi(deps) {
             onToolApproval: options.onToolApproval,
             onCompactEvent: options.onCompactEvent,
             onStageChange: options.onStageChange,
+            onProviderSendStarted: (...args) => {
+              // This callback is emitted immediately before provider.send,
+              // after session locking, history shaping and pre-send compact.
+              // The old timestamp above mgr.askSession mislabeled all of that
+              // Mixdog work as provider latency.
+              if (!providerStartedAt) providerStartedAt = performance.now();
+              return options.onProviderSendStarted?.(...args);
+            },
+            onToolPhaseStarted: options.onToolPhaseStarted,
+            onToolPhaseCompleted: options.onToolPhaseCompleted,
             onStreamDelta: (...args) => {
               let value;
               try {
                 value = options.onStreamDelta?.(...args);
               } finally {
-                turnTimingStatus = 'first-delta';
-                emitTurnTiming(turnTimingStatus);
-                armHeavyRuntimeWarmup('first-stream');
+                if (isVisibleStreamProgress(args[0])) {
+                  turnTimingStatus = 'first-visible';
+                  emitTurnTiming(turnTimingStatus);
+                  armHeavyRuntimeWarmup('first-visible');
+                }
               }
               return value;
             },
@@ -399,6 +419,18 @@ export function createSessionTurnApi(deps) {
       pushTranscriptRebind?.();
       return true;
     },
+    // Message-selector rewind: drop the chosen user prompt and everything
+    // after it from the model history. Unlike clear() the session object is
+    // kept (same id, same provider/model/cwd) — only the tail is undone.
+    async rewindMessages(options = {}) {
+      const session = getSession();
+      if (!session?.id) return null;
+      const result = await mgr.rewindSessionMessagesTo?.(session.id, options);
+      if (!result) return null;
+      setSession(mgr.getSession(session.id) || session);
+      invalidateContextStatusCache();
+      return result;
+    },
     // session_manage tool handoff: the engine polls this at turn end and, if
     // set, runs the same clear path the idle auto-clear uses. One-shot read.
     consumePendingSessionReset() {

package/src/session-runtime/settings-api.mjs

@@ -35,7 +35,6 @@ export function createSettingsApi({
   formatDurationMs,
   localPackageVersion,
   // state getters / feature flags
-  memoryEnabled,
   recapEnabledFn,
   channelsEnabled,
   autoUpdateEnabled,
@@ -173,11 +172,11 @@ export function createSettingsApi({
     },
     getCompactionSettings() {
       const config = getConfig();
-      return normalizeCompactionConfig(config.compaction, { memoryEnabled: memoryEnabled() });
+      return normalizeCompactionConfig(config.compaction);
     },
     setCompactionSettings(input = {}) {
       const config = getConfig();
-      const current = normalizeCompactionConfig(config.compaction, { memoryEnabled: memoryEnabled() });
+      const current = normalizeCompactionConfig(config.compaction);
       const next = { ...current };
       if (hasOwn(input, 'auto')) next.auto = input.auto !== false;
       if (hasOwn(input, 'enabled')) next.auto = input.enabled !== false;
@@ -193,18 +192,18 @@ export function createSettingsApi({
         if (hasOwn(input, key)) next[key] = input[key];
       }
       const nextConfig = { ...config };
-      nextConfig.compaction = normalizeCompactionConfig(next, { memoryEnabled: memoryEnabled() });
+      nextConfig.compaction = normalizeCompactionConfig(next);
       saveConfigAndAdopt(nextConfig);
       const config2 = getConfig();
       const session = getSession();
       if (session) {
         session.compaction = {
           ...(session.compaction || {}),
-          ...normalizeCompactionConfig(config2.compaction, { memoryEnabled: memoryEnabled() }),
+          ...normalizeCompactionConfig(config2.compaction),
         };
       }
       invalidateContextStatusCache();
-      return normalizeCompactionConfig(config2.compaction, { memoryEnabled: memoryEnabled() });
+      return normalizeCompactionConfig(config2.compaction);
     },
     // Recap toggle: user-facing switch that gates ONLY the background memory
     // cycles (1/2/3). The memory module (transcript watcher/ingest, on-demand
@@ -223,17 +222,6 @@ export function createSettingsApi({
       invalidateContextStatusCache();
       return this.getRecapSettings();
     },
-    // Thin aliases kept for the current TUI callsites (updated separately).
-    // enabled here reflects the recap toggle; memory itself is always-on.
-    getMemorySettings() {
-      return {
-        enabled: recapEnabledFn(),
-        compactFastTrackAvailable: true,
-      };
-    },
-    async setMemoryEnabled(enabled) {
-      return this.setRecapEnabled(enabled);
-    },
     getChannelSettings(options = {}) {
       return {
         enabled: channelsEnabled(),

package/src/session-runtime/tool-defs.mjs

@@ -13,7 +13,7 @@ export const TOOL_SEARCH_TOOL = {
     openWorldHint: false,
     agentHidden: true,
   },
-  description: 'Load deferred tools by exact name via names[]; reports loaded/already-active/missing plus MCP servers still connecting or failed. Deferred tools also auto-load when called directly.',
+  description: 'Deferred-tool activation status; direct calls auto-load.',
   inputSchema: {
     type: 'object',
     properties: {
@@ -34,7 +34,7 @@ export const CWD_TOOL = {
     openWorldHint: false,
     agentHidden: true,
   },
-  description: 'Show or set the session work project for tool execution. Use only for explicit project path changes.',
+  description: 'Show or set the session work project for tool execution.',
   inputSchema: {
     type: 'object',
     properties: {
@@ -84,7 +84,7 @@ export const SESSION_MANAGE_TOOL = {
     openWorldHint: false,
     agentHidden: true,
   },
-  description: 'Reset this conversation on explicit user request. action=clear wipes all context (like /clear); action=compact_clear summarizes first and carries context forward (auto-clear style). Applies when the current turn ends.',
+  description: 'Schedule conversation reset at current-turn end.',
   inputSchema: {
     type: 'object',
     properties: {