mixdog 1.1.2 → 1.2.1

package/src/session-runtime/internal-tool-executor.mjs

@@ -31,6 +31,7 @@ export function createInternalToolExecutor({
   mcpStatus,
   applyResolvedCwd,
   skillToolContent,
+  getWorkspaceApi,
 }) {
   const handlers = {
     ...createBridgeToolHandlers({ rt }),
@@ -46,7 +47,14 @@ export function createInternalToolExecutor({
       mcpStatus,
       skillToolContent,
     }),
-    ...createWorkspaceToolHandlers({ rt, goalRuntime, agentTool, notifyFnForSession, applyResolvedCwd }),
+    ...createWorkspaceToolHandlers({
+      rt,
+      goalRuntime,
+      agentTool,
+      notifyFnForSession,
+      applyResolvedCwd,
+      getWorkspaceApi,
+    }),
   };
 
   // Settings-disabled features are refused for model-initiated calls before

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

@@ -8,7 +8,12 @@ import {
   isRootLeadSession,
 } from '../../runtime/agent/orchestrator/session/store-summary-visibility.mjs';
 import { listSessionHeartbeatMtimes } from '../../runtime/agent/orchestrator/session/store/paths-heartbeat.mjs';
-import { sessionMessageText, isSessionPreviewNoise, cleanSessionPreview, clean } from '../../runtime/agent/orchestrator/runtime-core/session-text.mjs';
+import {
+  sessionMessageText,
+  isSessionPreviewNoise,
+  cleanSessionPreview,
+  clean,
+} from '../../runtime/agent/orchestrator/runtime-core/session-text.mjs';
 
 const VISIBLE_OWNERS = ['cli', 'user', 'mixdog'];
 
@@ -58,6 +63,8 @@ function leadSessionRow(s, heartbeatMtimes) {
   // it remains an ordinary resumable session, not a child dispatch.
   if (!isRootLeadSession(s) && owner && !VISIBLE_OWNERS.includes(owner)) return null;
   const sourceType = clean(s.sourceType || '').toLowerCase();
+  // One-shot `mixdog exec` runs are never resumable conversations.
+  if (sourceType === 'exec') return null;
   if (!isLeadShaped(s, owner, sourceType)) return null;
   const { preview, messageCount } = previewOf(s);
   if (!preview && messageCount === 0) return null;

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

@@ -3,6 +3,7 @@
  * new desktop context (cwd + desktop session) or a fresh session.
  */
 import { isScratchSession } from '../shared.mjs';
+import { replacementSessionCwd } from '../../workspace/workspace-state.mjs';
 
 export function createContextSwitch(deps, { ingestSessionIntoMemory, closeSurfaceSession, releaseSessionWork }) {
   const {
@@ -59,11 +60,15 @@ export function createContextSwitch(deps, { ingestSessionIntoMemory, closeSurfac
   async function newSession() {
     deps.assertNotAddressed?.('newSession');
     const session = getSession();
+    // Leaving a worktree-bound Lead: the new session starts in the Project
+    // folder, never in the worktree the old session retains.
+    const projectFolder = replacementSessionCwd(session);
     if (session?.id) {
       void ingestSessionIntoMemory(session);
       closeSurfaceSession(session, 'cli-new', { tombstone: isScratchSession(session) });
       setSession(null);
     }
+    if (projectFolder) await applyResolvedCwd(projectFolder);
     invalidateContextStatusCache();
     await createCurrentSession();
     return getSession().id;

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

@@ -10,8 +10,16 @@ import {
   deferredSurfaceModeForLead,
 } from '../../../runtime/agent/orchestrator/runtime-core/effort.mjs';
 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';
 
 export function resolveResumeCwd(session, currentCwd) {
+  // A worktree-bound Lead resumes in its worktree whatever its desktop class;
+  // a vanished worktree resumes in the Project folder in `recovery`, where
+  // turns are refused (restoreWorkspaceAfterResume) rather than silently run.
+  const bound = boundWorkspaceCwd(session);
+  if (bound) return bound.cwd;
   const desktop = session?.desktopSession;
   if (desktop?.classification === 'project') {
     // `session.cwd` is the execution source of truth. Older builds updated it
@@ -60,9 +68,9 @@ export function createSessionResume(deps, { ingestSessionIntoMemory, closeSurfac
   }
 
   // The resumed session's OWN effort wins. resolveRoute always returns an
-  // effort key, so this used to reinstate the effort of whichever session
-  // happened to be open before — a schedule/webhook session opened with a
-  // different effort than the one it actually ran with.
+  // effort key, so the route's effort applies only when the session has none —
+  // otherwise a schedule/webhook session would reopen with the effort of
+  // whichever session happened to be open before.
   function resumedRouteFor(resumed) {
     const route = getRoute();
     const resumeEffort = resumed.effort || (hasOwn(route, 'effort') ? route.effort : undefined);
@@ -71,6 +79,7 @@ export function createSessionResume(deps, { ingestSessionIntoMemory, closeSurfac
       model: resumed.model,
       effort: resumeEffort,
       fast: resumed.fast === true,
+      autoEffort: resumed.autoEffort !== false,
       modelParameters: resumed.modelParameters || {},
     });
   }
@@ -92,6 +101,8 @@ export function createSessionResume(deps, { ingestSessionIntoMemory, closeSurfac
       const activeSession = getSession();
       activeSession.effort = getRoute().effectiveEffort || null;
       activeSession.fast = getRoute().fast === true;
+      if (getRoute().autoEffort === false) activeSession.autoEffort = false;
+      else delete activeSession.autoEffort;
       activeSession.cwd = getCurrentCwd();
       restoreResumedToolSurface(activeSession, getRoute());
       writeStatuslineRoute(statusRoutes, activeSession, getRoute());
@@ -124,11 +135,16 @@ export function createSessionResume(deps, { ingestSessionIntoMemory, closeSurfac
     };
     const resumed = await mgr.resumeSession(id, toolSpecForMode(getMode()), resumeOptions);
     if (!resumed) return null;
+    // Restored rows carry their messages' stable ids (legacy transcripts are
+    // stamped here and persisted), so a live compaction can grey exactly the
+    // rows of what it drops.
+    stampCompactionMessageIds(resumed.messages, resumed.id || id);
     retirePrevious(previous, resumed);
     setSession(resumed);
     // Resume is not work: the Lead pool row is written only by turn
     // start/settle, so opening an old conversation never re-lists it in the
     // Agent window for another reap window (user report).
+    restoreWorkspaceAfterResume(resumed);
     applyResolvedCwd(resolveResumeCwd(resumed, getCurrentCwd()));
     // Commit the applied cwd before returning the resume transcript.
     resumed.cwd = getCurrentCwd();
@@ -154,6 +170,8 @@ export function createSessionResume(deps, { ingestSessionIntoMemory, closeSurfac
       cwd: getCurrentCwd(),
       provider: resumed.provider,
       model: resumed.model,
+      // The display-only compaction archive above the restored rows.
+      transcriptArchive: compactionArchiveRange(resumed),
     };
   }
 

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

@@ -7,6 +7,7 @@ import { clean } from '../../../runtime/agent/orchestrator/runtime-core/session-
 import { forgetSessionSearch } from '../../../runtime/session-search/session-search-ingest.mjs';
 import { listLeadSessions } from '../session-catalog.mjs';
 import { SESSION_ID_PATTERN } from '../shared.mjs';
+import { replacementSessionCwd } from '../../workspace/workspace-state.mjs';
 
 export function createSessionDelete(deps, { cancelBackgroundTasks }) {
   const {
@@ -49,6 +50,14 @@ export function createSessionDelete(deps, { cancelBackgroundTasks }) {
     }
   }
 
+  // The deleted task's worktree: the autoCleanup setting decides (clean and
+  // merged → removed; otherwise kept). Off the deletion path; never fails it.
+  function releaseDeletedWorktree(sessionId) {
+    return Promise.resolve()
+      .then(() => deps.cleanupDeletedSessionWorktree?.(sessionId))
+      .catch(() => {});
+  }
+
   async function deleteSession(id) {
     const sessionId = clean(id);
     if (!sessionId || !SESSION_ID_PATTERN.test(sessionId)) return false;
@@ -68,8 +77,12 @@ export function createSessionDelete(deps, { cancelBackgroundTasks }) {
           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.
+    const projectFolder = replacementSessionCwd(current);
     const cleanupReason = 'desktop-session-delete';
     releaseSessionWork(sessionId, cleanupReason);
     // Active sessions retain a tombstone until the normal sweep. Unlinking
@@ -86,15 +99,18 @@ export function createSessionDelete(deps, { cancelBackgroundTasks }) {
       } catch {}
     }
     setSession(null);
+    if (projectFolder) await deps.applyResolvedCwd?.(projectFolder);
     invalidateContextStatusCache();
     invalidatePreSessionToolSurface();
     // An addressed runtime never mints a replacement under the deleted
     // address: it becomes terminal and a new conversation needs a new entry.
     if (deps.getAddressedSessionId?.()) {
       deps.markAddressTerminal?.();
+      void releaseDeletedWorktree(sessionId);
       return true;
     }
     await createCurrentSession();
+    void releaseDeletedWorktree(sessionId);
     return true;
   }
 

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

@@ -3,32 +3,50 @@
 // connect. All mutable progress lives on the caller-owned `state`.
 import { clean } from '../../runtime/agent/orchestrator/runtime-core/session-text.mjs';
 import { envFlag } from '../../runtime/shared/env.mjs';
+import { ensurePluginServerData } from './plugin-servers.mjs';
 
-export function createMcpConnect({ mcpClient, getMcpScopeId, state, resolveEffectiveMcpServers, mcpStatus }) {
+export function createMcpConnect({
+  mcpClient,
+  getMcpScopeId,
+  getCurrentCwd = () => '',
+  state,
+  resolveEffectiveMcpServers,
+  mcpStatus,
+}) {
   const scopeOptions = () => ({ scopeId: getMcpScopeId() });
+  // name -> the resolved config this runtime last (re)connected the server
+  // with. Reconcile compares against it so only new or changed servers
+  // reconnect (a cwd switch changes only cwd-following plugin servers).
+  const applied = () => {
+    if (!(state.mcpApplied instanceof Map)) state.mcpApplied = new Map();
+    return state.mcpApplied;
+  };
+  const fingerprint = (cfg) => JSON.stringify(cfg);
+  // Roots advertised by cwd-following servers track this runtime's cwd.
+  const syncScopeRoot = () => mcpClient.setMcpScopeRoot?.(getMcpScopeId(), clean(getCurrentCwd?.()));
 
   // Connect/disconnect exactly one server in the live registry, leaving all
   // others untouched. Used by the enable/disable toggle so a single-server
   // change never triggers a full disconnectAll()/reconnect freeze.
-  async function applyMcpServerConnection(name, enabled) {
+  async function applyMcpServerConnection(name, enabled, servers = resolveEffectiveMcpServers().servers) {
     const target = clean(name);
     if (!target) return;
-    const { servers } = resolveEffectiveMcpServers();
     // Changing this server's state clears any stale failure record for it.
     if (Array.isArray(state.mcpFailures)) {
       state.mcpFailures = state.mcpFailures.filter((row) => row.name !== target);
     }
-    if (enabled === false) {
+    const cfg = servers[target];
+    if (enabled === false || !cfg || cfg.enabled === false) {
+      applied().delete(target);
       await mcpClient.disconnectMcpServer?.(target, scopeOptions());
       return;
     }
-    const cfg = servers[target];
-    if (!cfg) return;
-    // Drop any existing live entry first so connectMcpServers doesn't overwrite
-    // the registry Map entry and leak the old transport/process.
-    await mcpClient.disconnectMcpServer?.(target, scopeOptions());
+    applied().set(target, fingerprint(cfg));
+    // Close-then-connect as one generation-guarded op: a shutdown landing
+    // between the close and the connect never resurrects the server.
     try {
-      await mcpClient.connectMcpServers({ [target]: cfg }, scopeOptions());
+      ensurePluginServerData(cfg);
+      await mcpClient.reconnectSingleMcpServer(getMcpScopeId(), target, cfg);
     } catch (error) {
       const failures = Array.isArray(error?.failures)
         ? error.failures
@@ -37,10 +55,28 @@ export function createMcpConnect({ mcpClient, getMcpScopeId, state, resolveEffec
     }
   }
 
-  async function connectConfiguredMcp({ reset = false, only = null, enabled = true } = {}) {
+  // Bring the registry in line with the effective set: drop servers that are
+  // gone or disabled, (re)connect servers that are new or whose resolved
+  // config changed; untouched servers keep their connection.
+  async function reconcileServers() {
+    syncScopeRoot();
+    const { servers } = resolveEffectiveMcpServers();
+    const known = applied();
+    const drops = [...known.keys()].filter((name) => !servers[name] || servers[name].enabled === false);
+    const connects = Object.entries(servers)
+      .filter(([name, cfg]) => cfg?.enabled !== false && known.get(name) !== fingerprint(cfg))
+      .map(([name]) => name);
+    await Promise.allSettled([
+      ...drops.map((name) => applyMcpServerConnection(name, false, servers)),
+      ...connects.map((name) => applyMcpServerConnection(name, true, servers)),
+    ]);
+  }
+
+  async function connectConfiguredMcp({ reset = false, only = null, enabled = true, reconcile = false } = {}) {
     if (envFlag('MIXDOG_DISABLE_MCP')) {
       ++state.mcpConnectGeneration;
       state.mcpFailures = [];
+      applied().clear();
       if (only) await mcpClient.disconnectMcpServer?.(only, scopeOptions());
       else await mcpClient.disconnectAll?.(scopeOptions());
       return mcpStatus();
@@ -50,7 +86,7 @@ export function createMcpConnect({ mcpClient, getMcpScopeId, state, resolveEffec
     // just wait for any in-flight run, then bail if a newer full reset has
     // been requested in the meantime. Registering as in-flight makes a later
     // reset serialize behind us instead of interleaving disconnect/connect.
-    if (only) {
+    if (only || reconcile) {
       // Atomically capture the current generation AND the prior in-flight
       // promise in the same synchronous step, then chain our op onto it. No
       // await sits between the capture and the `state.mcpConnectInFlight = run`
@@ -69,7 +105,8 @@ export function createMcpConnect({ mcpClient, getMcpScopeId, state, resolveEffec
           }
         }
         if (gen !== state.mcpConnectGeneration) return;
-        await applyMcpServerConnection(only, enabled);
+        if (reconcile) await reconcileServers();
+        else await applyMcpServerConnection(only, enabled);
       })();
       state.mcpConnectInFlight = run;
       try {
@@ -96,11 +133,20 @@ export function createMcpConnect({ mcpClient, getMcpScopeId, state, resolveEffec
     }
     if (gen !== state.mcpConnectGeneration) return mcpStatus();
     const run = (async () => {
-      if (reset) await mcpClient.disconnectAll?.(scopeOptions());
+      if (reset) {
+        await mcpClient.disconnectAll?.(scopeOptions());
+        applied().clear();
+      }
       state.mcpFailures = [];
+      syncScopeRoot();
       const { servers } = resolveEffectiveMcpServers();
+      for (const [name, cfg] of Object.entries(servers)) {
+        if (cfg?.enabled === false) applied().delete(name);
+        else applied().set(name, fingerprint(cfg));
+      }
       if (Object.keys(servers).length === 0) return;
       try {
+        for (const cfg of Object.values(servers)) if (cfg?.enabled !== false) ensurePluginServerData(cfg);
         await mcpClient.connectMcpServers(servers, scopeOptions());
       } catch (error) {
         state.mcpFailures = Array.isArray(error?.failures)
@@ -126,8 +172,14 @@ export function createMcpConnect({ mcpClient, getMcpScopeId, state, resolveEffec
     if (!inFlight) return;
     let budgetMs = 10000;
     try {
-      const resolved = mcpClient.resolveMcpStartupTimeoutMs?.({});
-      if (Number.isFinite(resolved)) budgetMs = resolved;
+      // The gate must outlast the slowest enabled server's own startup budget;
+      // a server with its budget disabled (0) means the connect may never
+      // settle, so the whole gate is disabled (handled below).
+      const configs = Object.values(resolveEffectiveMcpServers().servers).filter((cfg) => cfg?.enabled !== false);
+      const budgets = (configs.length > 0 ? configs : [{}])
+        .map((cfg) => mcpClient.resolveMcpStartupTimeoutMs?.(cfg))
+        .filter((value) => Number.isFinite(value));
+      if (budgets.length > 0) budgetMs = budgets.includes(0) ? 0 : Math.max(...budgets);
     } catch {
       /* fall back to default budget */
     }