mixdog 1.2.2 → 1.2.4

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

@@ -13,6 +13,8 @@ import { isScratchConversation } from '../shared.mjs';
 import { compactionArchiveRange } from '../../../runtime/agent/orchestrator/session/compaction-archive.mjs';
 import { stampCompactionMessageIds } from '../../../runtime/agent/orchestrator/session/compaction-archive-capture.mjs';
 import { boundWorkspaceCwd, restoreWorkspaceAfterResume } from '../../workspace/workspace-state.mjs';
+import { toolExposureMigrationNeeded } from '../../../runtime/agent/orchestrator/runtime-core/tool-exposure.mjs';
+import { markToolSurfaceMigrated } from '../../../runtime/agent/orchestrator/session/loop/tool-exposure-migration.mjs';
 
 export function resolveResumeCwd(session, currentCwd) {
   // A worktree-bound Lead resumes in its worktree whatever its desktop class;
@@ -61,10 +63,14 @@ export function createSessionResume(deps, { ingestSessionIntoMemory, closeSurfac
   } = deps;
 
   function restoreResumedToolSurface(target, targetRoute) {
+    // A surface persisted with another tool exposure (e.g. a pre-bridge
+    // fixed canonical surface) migrates here; legacy selections never widen it.
+    const migrating = toolExposureMigrationNeeded(target, targetRoute.provider);
     applyDeferredToolSurface(target, deferredSurfaceModeForLead(getMode()), getStandaloneTools(), {
       provider: targetRoute.provider,
       model: targetRoute.model,
     });
+    if (migrating) markToolSurfaceMigrated(target);
   }
 
   // The resumed session's OWN effort wins. resolveRoute always returns an

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

@@ -1,13 +1,19 @@
 /**
- * session-switch/session-delete.mjs — deleting a catalogued session together
- * with its linked agent children, and releasing the work a closing session
- * owns (shared with the context switch).
+ * session-switch/session-delete.mjs — deleting one catalogued session (Lead
+ * or agent), and releasing the execution work a closing session owns
+ * (shared with the context switch).
  */
 import { clean } from '../../../runtime/agent/orchestrator/runtime-core/session-text.mjs';
 import { forgetSessionSearch } from '../../../runtime/session-search/session-search-ingest.mjs';
-import { listLeadSessions } from '../session-catalog.mjs';
+import { leadSessionRow } from '../session-catalog.mjs';
+import { getStoreDir } from '../../../runtime/agent/orchestrator/session/store/session-paths.mjs';
+import {
+  STORED_SESSION_UNREADABLE,
+  _storedSessionFromFile,
+} from '../../../runtime/agent/orchestrator/session/store/serialize.mjs';
 import { SESSION_ID_PATTERN } from '../shared.mjs';
 import { replacementSessionCwd } from '../../workspace/workspace-state.mjs';
+import { isHistoricalAutomaticClosure } from '../../../runtime/agent/orchestrator/session/historical-session-closure.mjs';
 
 export function createSessionDelete(deps, { cancelBackgroundTasks }) {
   const {
@@ -21,33 +27,22 @@ export function createSessionDelete(deps, { cancelBackgroundTasks }) {
     invalidatePreSessionToolSurface,
   } = deps;
 
-  // Cancel the work a closing session owns: background tasks, agent workers,
-  // and its gateway status route.
+  // Release this execution session, not independent sessions it delegated to.
   function releaseSessionWork(sessionId, reason) {
     try {
-      cancelBackgroundTasks({ reason, notify: false, callerSessionId: sessionId });
-    } catch {}
-    try {
-      agentTool?.closeAll?.(reason, { callerSessionId: sessionId });
+      cancelBackgroundTasks({ reason, notify: false, executionSessionId: sessionId });
     } catch {}
     statusRoutes?.clearGatewaySessionRoute?.(sessionId);
   }
 
-  function ownedAgentSessionIds(sessionId) {
-    try {
-      const candidates = mgr.listOwnedAgentSessionIds?.(sessionId);
-      if (!Array.isArray(candidates)) return [];
-      return [
-        ...new Set(
-          candidates
-            .map(clean)
-            .filter((childId) => childId && childId !== sessionId && SESSION_ID_PATTERN.test(childId))
-        ),
-      ];
-    } catch {
-      /* parent deletion remains available if child enumeration fails */
-      return [];
-    }
+  // Availability is one strict read of the session's own file, filtered like
+  // the session catalog (an unreadable, foreign, closed or non-catalogued
+  // record is not deletable). No catalog rebuild, no folder scan.
+  function isAvailableSession(sessionId) {
+    const stored = _storedSessionFromFile(getStoreDir(), `${sessionId}.json`);
+    if (!stored || stored === STORED_SESSION_UNREADABLE) return false;
+    if (stored.closed === true && !isHistoricalAutomaticClosure(stored)) return false;
+    return leadSessionRow(stored) !== null;
   }
 
   // The deleted task's worktree: the autoCleanup setting decides (clean and
@@ -61,43 +56,36 @@ export function createSessionDelete(deps, { cancelBackgroundTasks }) {
   async function deleteSession(id) {
     const sessionId = clean(id);
     if (!sessionId || !SESSION_ID_PATTERN.test(sessionId)) return false;
-    const available = listLeadSessions(mgr, { refreshFromStorage: true }).some((row) => row.id === sessionId);
-    if (!available) return false;
-    const childIds = ownedAgentSessionIds(sessionId);
+    if (!isAvailableSession(sessionId)) return false;
     const current = getSession();
+    const cleanupReason = 'desktop-session-delete';
     if (current?.id !== sessionId) {
-      const deleted = mgr.deleteSession(sessionId) === true;
+      // A turn can still be running in a session that is no longer current.
+      // Stop its runtime first (controller abort, shells, generation bump) and
+      // release its worker row and its own background tasks, so nothing can
+      // write it back. Sessions it delegated to are independent and keep running.
+      if (mgr.closeSession(sessionId, cleanupReason, { tombstone: false }) !== true) return false;
+      agentTool?.forgetLeadSession?.(sessionId);
+      releaseSessionWork(sessionId, cleanupReason);
+      const deleted = mgr.deleteSession(sessionId, { fenceWrites: true }) === true;
       if (!deleted) return false;
       void forgetSessionSearch(sessionId);
-      // The parent is already irreversibly gone, so child cleanup is
-      // best-effort and idempotent. Any vetoed child becomes sweep-eligible
-      // because its retained-parent proof disappeared with the parent.
-      for (const childId of childIds) {
-        try {
-          mgr.deleteSession(childId);
-        } catch {}
-      }
       void releaseDeletedWorktree(sessionId);
       return true;
     }
-    // Leaving a worktree-bound Lead: the replacement starts in the Project
-    // folder, and the worktree can go once nothing runs in it.
+    // Leaving a worktree-bound current session: the replacement starts in the
+    // Project folder, and the worktree can go once nothing runs in it.
     const projectFolder = replacementSessionCwd(current);
-    const cleanupReason = 'desktop-session-delete';
     releaseSessionWork(sessionId, cleanupReason);
     // Active sessions retain a tombstone until the normal sweep. Unlinking
     // immediately would let a late provider/save continuation resurrect the
     // deleted conversation after the user has moved to its replacement.
     if (mgr.closeSession(sessionId, cleanupReason, { tombstone: true }) !== true) return false;
+    // The unwinding turn's late saves and its idle lead-row upsert must not
+    // touch the deleted conversation (an unguarded save would pass the tombstone).
+    mgr.fenceSessionWrites?.(sessionId);
+    agentTool?.forgetLeadSession?.(sessionId);
     void forgetSessionSearch(sessionId);
-    // Active parent deletion uses the same durable tombstone boundary for
-    // every linked child. Their files then mature with the parent instead of
-    // disappearing while the parent task is still retained.
-    for (const childId of childIds) {
-      try {
-        mgr.closeSession(childId, cleanupReason, { tombstone: true });
-      } catch {}
-    }
     setSession(null);
     if (projectFolder) await deps.applyResolvedCwd?.(projectFolder);
     invalidateContextStatusCache();

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

@@ -4,7 +4,7 @@
  * session-switch/: session-delete (delete + work release), context-switch
  * (switch + new), resume.
  */
-import { getStoreDir } from '../../runtime/agent/orchestrator/session/store/paths-heartbeat.mjs';
+import { getStoreDir } from '../../runtime/agent/orchestrator/session/store/session-paths.mjs';
 import { toolSpecForMode } from '../../runtime/agent/orchestrator/runtime-core/effort.mjs';
 import { listLeadSessions } from './session-catalog.mjs';
 import { createSessionDelete } from './session-switch/session-delete.mjs';

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

@@ -12,7 +12,11 @@ export { SESSION_ID_PATTERN } from '../../runtime/agent/orchestrator/runtime-cor
 // message there, not yet in session.messages, so it must also be checked or a
 // first-turn exit could still burn a real session.
 export function isScratchConversation(messages, liveTurnMessages) {
-  return !hasUserConversationMessage(messages) && !hasUserConversationMessage(liveTurnMessages);
+  return [messages, liveTurnMessages].every(
+    (items) =>
+      !hasUserConversationMessage(items) &&
+      !(Array.isArray(items) && items.some((message) => message?.meta?.transcript?.completion))
+  );
 }
 
 export function isScratchSession(session) {
@@ -22,11 +26,6 @@ export function isScratchSession(session) {
 export function createSurfaceSessionCloser(mgr) {
   return function closeSurfaceSession(session, reason, options) {
     if (!session?.id) return false;
-    // A remote-attached session is only a viewer handle owned by this surface.
-    // Closing it through the shared manager bumps the durable generation and
-    // invalidates the real owner's in-flight turn. Viewer exits therefore
-    // detach locally; only the process that owns the runtime may close it.
-    if (session.remoteAttached === true) return true;
     return mgr.closeSession(session.id, reason, options);
   };
 }

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

@@ -60,21 +60,22 @@ export function closeOwnSession(deps, closeSurfaceSession, reason) {
   return ok;
 }
 
-/** Plant the ordinary manager/store tombstone barrier for a canonical
- *  child session without running whole-process teardown. */
-export function closeCanonicalSession(deps, reason = 'canonical-session-close') {
+/** Fence a canonical runtime without deleting its conversation.
+ *  Explicit deletion may request a tombstone; blank scratch follows ordinary policy. */
+export function closeCanonicalSession(deps, reason = 'canonical-session-close', options = {}) {
   const { getSession, setSession, mgr, invalidateContextStatusCache, beginCanonicalClose, finishCanonicalClose } = deps;
   // Already terminal: closing is idempotent and keeps the address.
   if (deps.isCanonicallyClosed?.() === true) return true;
   const session = getSession?.();
-  if (!session?.id || session.remoteAttached === true) return false;
+  if (!session?.id) return false;
   // Fence execution admission BEFORE the manager close: that close cancels the
   // session's shells synchronously, and their completions must not be able to
   // enqueue model work or create a conversation.
   const fence = beginCanonicalClose?.(session.id);
   let closed = false;
   try {
-    closed = mgr.closeSession(session.id, reason, { tombstone: true }) === true;
+    closed =
+      mgr.closeSession(session.id, reason, { tombstone: options.tombstone ?? isScratchSession(session) }) === true;
   } finally {
     // Terminal after a durable close; admission restored when it failed.
     finishCanonicalClose?.(fence, closed);

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

@@ -7,10 +7,12 @@
  */
 import { SessionClosedError } from '../../runtime/agent/orchestrator/session/manager/session-errors.mjs';
 import { forgetSessionSaveBaseline } from '../../runtime/agent/orchestrator/session/store/save-worker.mjs';
+import { flushAllIndexWrites } from '../services/agent-tool/index-write-queue.mjs';
 import { unregisterLiveSession } from '../../runtime/shared/staged-update.mjs';
 import { abortRuntime, closeCanonicalSession, closeOwnSession, dispatchSessionEnd } from './teardown/session-close.mjs';
 import { settleAll, settleDetached, startRuntimeStops, startWorkStops } from './teardown/runtime-stops.mjs';
 
+const CLOSE_ALL_DEADLINE_MS = 5000;
 const PROCESS_EXIT_REASON = /exit|quit|shutdown|sighup|sigint|sigterm/;
 const WARMUP_TIMER_KEYS = [
   'providerSetupWarmupTimer',
@@ -112,12 +114,51 @@ export function createTeardown(deps, { ingestSessionIntoMemory, closeSurfaceSess
       // A task that dies for a reason its owner never asked for must still be reported.
       cancelBackgroundTasks(
         scope.scopedTeardown
-          ? { reason, notify: true, callerSessionId: scope.closingSessionId }
+          ? { reason, notify: true, executionSessionId: scope.closingSessionId }
           : { reason, notify: false }
       );
     } catch {}
   }
 
+  // Agent closes that have not settled yet (one per close invocation, kept
+  // past the bounded wait if it overran).
+  const outstandingCloses = new Set();
+
+  /** Persist every queued index write. A close only ever drains: the shared
+   *  indexes stay registered (exit hook included) for the closes still to come. */
+  async function drainIndexWrites() {
+    try {
+      await agentTool.flushIndexWrites?.();
+      await flushAllIndexWrites();
+    } catch {}
+  }
+
+  // The disposal in progress (if any). New closes wait for it before starting
+  // their own closeAll, so no close produces writes while registrations are
+  // being released.
+  let indexDisposal = null;
+
+  /** Release this runtime's per-runtime index registrations (exit callbacks,
+   *  approval writer, store refs) once its drain has completed. Idempotent. A
+   *  drain that cannot complete tears nothing down: the registrations stay until
+   *  a later close drains successfully. Exit flushing itself is process-owned. */
+  function disposeIndexes(settle) {
+    // Assign before disposal runs (deferred), clear on settlement: a synchronous
+    // dispose must not clear the slot before it is assigned.
+    indexDisposal ??= Promise.resolve()
+      .then(async () => {
+        if (typeof agentTool.disposeAsync === 'function') await agentTool.disposeAsync({ settle });
+        else agentTool.dispose?.({ settle });
+      })
+      .catch(() => {
+        /* drain failed: registrations are kept for a later retry */
+      })
+      .finally(() => {
+        indexDisposal = null;
+      });
+    return indexDisposal;
+  }
+
   async function close(reason = 'cli-exit', options = {}) {
     quiesce(reason);
     const scope = teardownScope(reason, options, String(getSession()?.id || ''));
@@ -155,21 +196,36 @@ export function createTeardown(deps, { ingestSessionIntoMemory, closeSurfaceSess
       // session-pinned intent so the resumed session can reclaim it.
       preserveRemoteIntent: true,
     });
-    // Agent workers die with a REAL teardown only (process exit, explicit
-    // close). A keepBackgroundWork dispose (daemon idle eviction) reclaims
-    // memory and must leave workers/rows for the re-materialized owner.
-    // Scoped teardown closes only THIS session's workers — the worker index
-    // is shared across every Lead in the process.
-    if (scope.teardownReapsWork) {
+    // Only process-wide teardown closes delegated sessions. Session-local
+    // disposal already stopped its own execution work above.
+    let closing = null;
+    while (indexDisposal) await indexDisposal;
+    if (scope.teardownReapsWork && !scope.scopedTeardown) {
+      const settled = () => {
+        outstandingCloses.delete(closing);
+      };
+      closing = new Promise((resolve) => resolve(agentTool.closeAll(reason, {}))).then(settled, settled);
+      outstandingCloses.add(closing);
       try {
-        agentTool.closeAll(reason, scope.scopedTeardown ? { callerSessionId: scope.closingSessionId } : {});
+        await withTeardownDeadline(closing, CLOSE_ALL_DEADLINE_MS, false);
       } catch {}
     }
-    // Release the worker/lead index exit registrations (persists pending rows
-    // first). Idempotent, so repeated closes of one runtime dispose once.
-    try {
-      agentTool.dispose?.({ settle: scope.teardownReapsWork === true });
-    } catch {}
+    // Drain after the closes settle, then release this runtime's index
+    // registrations. A close that overran its deadline chains this onto its
+    // settlement (teardown may return before then). The live outstanding set is
+    // re-checked after every wait and drain, so the single disposal runs only
+    // when no close is outstanding; the check and the disposal start share one
+    // tick, and closes admitted afterwards wait for it.
+    const finish = async () => {
+      for (;;) {
+        while (outstandingCloses.size > 0) await Promise.allSettled([...outstandingCloses]);
+        await drainIndexWrites();
+        if (outstandingCloses.size === 0) break;
+      }
+      await disposeIndexes(scope.teardownReapsWork === true);
+    };
+    if (outstandingCloses.size > 0) void finish();
+    else await finish();
     const { ok, stops } = await inOwnLoopTurn(() => {
       const runtimeStops = startRuntimeStops(deps, reason, scope);
       const closed = closeOwnSession(deps, closeSurfaceSession, reason);
@@ -194,7 +250,7 @@ export function createTeardown(deps, { ingestSessionIntoMemory, closeSurfaceSess
   }
 
   return {
-    closeCanonicalSession: (reason) => closeCanonicalSession(deps, reason),
+    closeCanonicalSession: (reason, options) => closeCanonicalSession(deps, reason, options),
     close,
     abort: (reason) => abortRuntime(deps, reason),
   };

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

@@ -42,5 +42,6 @@ export function createLifecycleApi(deps) {
     resume: switching.resume,
     inheritancePreflight: inheritance.inheritancePreflight,
     inheritFrom: inheritance.inheritFrom,
+    inheritToNewSession: inheritance.inheritToNewSession,
   };
 }

package/src/session-runtime/mcp-glue/connect.mjs

@@ -209,19 +209,31 @@ export function createMcpConnect({
         budgetMs = Math.min(budgetMs, requestedMaxWaitMs);
       }
     }
-    // Swallow the in-flight rejection: failures are already captured in
-    // state.mcpFailures, and this gate must never reject the turn.
-    const settled = Promise.resolve(inFlight).catch(() => {});
     // Budget disabled (0/off) = no per-server startup timeout, so the connect
     // promise may never settle; never gate the turn on it — fall back to the
     // legacy fire-and-forget behavior (late servers use the deferred path).
     if (!(budgetMs > 0)) return;
     let timer = null;
+    let expired = false;
     const budget = new Promise((resolveBudget) => {
-      timer = setTimeout(resolveBudget, budgetMs);
+      timer = setTimeout(() => {
+        expired = true;
+        resolveBudget();
+      }, budgetMs);
     });
     try {
-      await Promise.race([settled, budget]);
+      // Follow replacement connects (a reconnect queued behind the captured
+      // run installs a new in-flight promise) inside ONE fixed deadline.
+      // Failures are already captured in state.mcpFailures, so rejections are
+      // swallowed: this gate must never reject the turn.
+      let current = inFlight;
+      while (current && !expired) {
+        await Promise.race([Promise.resolve(current).catch(() => {}), budget]);
+        if (expired) break;
+        // Let a queued reconnect install its promise before re-checking.
+        await Promise.race([new Promise((resolveTick) => setImmediate(resolveTick)), budget]);
+        current = state.mcpConnectInFlight;
+      }
     } finally {
       if (timer) clearTimeout(timer);
     }

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

@@ -52,6 +52,14 @@ export function createMediaApi() {
     async setMediaDefault(input) {
       return (await defaults()).setMediaDefault(input || {});
     },
+    // Settings → Built-in → Media generation: the default generator the media
+    // tool uses per kind when the chat does not name one.
+    async getMediaPins() {
+      return (await defaults()).getMediaPins();
+    },
+    async setMediaPin(input) {
+      return (await defaults()).setMediaPin(input || {});
+    },
     async startMediaJob(input) {
       return (await jobs()).startMediaJob(input || {});
     },

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

@@ -0,0 +1,60 @@
+/**
+ * route-ownership.mjs — who a route selection belongs to.
+ *
+ * A runtime holds one conversation at a time; reset, resume, new-session and
+ * close replace it, or leave none. Every such transition advances the session
+ * generation. A selection captures the generation when it is enqueued and
+ * holds a lease on it: once the generation has moved, the selection's route
+ * side effects (adopt, refresh completion, pending registration, session
+ * updates, display rollback) are no-ops, and the current route stands.
+ */
+
+const sessionOwner = (session) => (session ? (session.id ?? session) : null);
+
+/** Make `holder.session` advance `holder.sessionGeneration` whenever another
+ *  conversation (or none) is installed. Re-installing the same conversation
+ *  (a refreshed object for the same id) is not a transition. */
+export function trackSessionGeneration(holder) {
+  let session = holder.session ?? null;
+  let generation = 0;
+  Object.defineProperty(holder, 'session', {
+    enumerable: true,
+    configurable: true,
+    get: () => session,
+    set: (next) => {
+      const installed = next ?? null;
+      if (sessionOwner(installed) !== sessionOwner(session)) generation += 1;
+      session = installed;
+    },
+  });
+  Object.defineProperty(holder, 'sessionGeneration', {
+    enumerable: true,
+    configurable: true,
+    get: () => generation,
+  });
+  return holder;
+}
+
+/** A selection's hold on the generation it was enqueued under. The token is
+ *  compared strictly; an absent token is a token like any other. */
+export function openRouteLease(getGeneration, token = getGeneration()) {
+  const valid = () => getGeneration() === token;
+  return {
+    token,
+    valid,
+    /** The one way a selection touches route or session state: `effect` runs
+     *  only if the lease holds at this very point, else `otherwise()` stands.
+     *  Anything after an `await` (even one that resolved without error) must
+     *  come through here, since a transition can run between the awaited call
+     *  returning and its caller continuing. */
+    run: (effect, otherwise) => (valid() ? effect() : otherwise()),
+  };
+}
+
+/** A selection that is not addressed to a conversation (a default for new
+ *  sessions) belongs to no session and survives every transition. */
+export const UNOWNED_LEASE = Object.freeze({
+  token: undefined,
+  valid: () => true,
+  run: (effect) => effect(),
+});

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

@@ -35,12 +35,13 @@ export function createRoutePersistence(deps) {
         hasSecrets: getConfigHasSecrets(),
       });
     },
-    persistAdoptedModelSettings(route, { keepMainModel = false } = {}) {
+    persistAdoptedModelSettings(route, { keepMainModel } = {}) {
       // saveModelSettings is in-memory only. persistLeadRoute debounce-writes
       // the adopted config (including modelSettings). If the lead preset cannot
       // be normalized, still debounce-persist so effort/fast are not memory-only.
       const leadRoute =
-        keepMainModel || tunesNonMainModel(getRoute(), route, resolveRoute(getConfig(), {}))
+        keepMainModel === true ||
+        (keepMainModel !== false && tunesNonMainModel(getRoute(), route, resolveRoute(getConfig(), {})))
           ? null
           : persistLeadRoute(route);
       if (!leadRoute) saveConfigAndAdopt(getConfig());