mixdog 1.1.2 → 1.2.1

package/src/session-runtime/conversation-import/service.mjs

@@ -0,0 +1,369 @@
+/**
+ * "Import conversations from other apps": the runtime API (list / register /
+ * start / status / cancel) and the background import jobs behind it.
+ *
+ * Jobs are process-wide, so a job keeps running and stays observable after the
+ * dialog closes or the user switches conversations (each session runtime of
+ * the daemon reads the same registry). Every file passes one serialized
+ * admission lane shared by all jobs, where the "already imported" check is
+ * repeated right before the session is created, against the session catalog
+ * read once per batch and every commit of this process since.
+ * An import key only counts as imported while its session still exists in
+ * storage, so a deleted import can be imported again.
+ * Cancel stops admitting further files; committed imports stay.
+ */
+import { randomUUID } from 'node:crypto';
+import { access, stat } from 'node:fs/promises';
+import {
+  buildImportOrigin,
+  createImportedSession,
+  importOriginKey,
+} from '../../runtime/agent/orchestrator/session/conversation-import/imported-session.mjs';
+import { IMPORT_WARNING_CWD_MISSING } from '../../runtime/agent/orchestrator/session/conversation-import/turns.mjs';
+import { sessionPath } from '../../runtime/agent/orchestrator/session/store/paths-heartbeat.mjs';
+import {
+  cachedMeta,
+  convertCandidateFile,
+  getCandidate,
+  importError,
+  importedKeyMap,
+  listConversations,
+  recordConversion,
+  registerFile,
+  resolveSourceCwd,
+  resolveViewSelection,
+} from './discovery.mjs';
+
+const MAX_FINISHED_JOBS = 20;
+const MAX_REQUEST_ID_LENGTH = 200;
+
+const jobs = new Map(); // jobId → job (insertion order = start order)
+const jobsByRequest = new Map(); // requestId → jobId
+const pendingStarts = new Map(); // requestId → Promise<job> while a selection resolves
+// import key → session id, imports of this process (summaries can lag a save).
+const committedKeys = new Map();
+let admissionTail = Promise.resolve();
+
+/** Test seam: forget every job and committed key. */
+export function resetConversationImportJobs() {
+  jobs.clear();
+  jobsByRequest.clear();
+  pendingStarts.clear();
+  committedKeys.clear();
+  admissionTail = Promise.resolve();
+}
+
+const EXISTS_CONCURRENCY = 16;
+
+const sessionFileExists = (id) =>
+  access(sessionPath(id)).then(
+    () => true,
+    () => false
+  );
+
+/**
+ * `get(key)` → the id of an existing session imported under `key`, else null.
+ * Candidates come from this process's commits, then summaries; every candidate
+ * id's existence is checked (asynchronously) once, up front. Committed ids
+ * whose session no longer exists are dropped from the commit map.
+ */
+async function importedLookup(summaries, sessionExists) {
+  const fromSummaries = importedKeyMap(summaries);
+  const committedAtStart = new Map(committedKeys);
+  const ids = [...new Set([...committedAtStart.values(), ...[...fromSummaries.values()].flat()])];
+  const existing = new Set();
+  let next = 0;
+  const worker = async () => {
+    while (next < ids.length) {
+      const id = ids[next++];
+      if (await sessionExists(id)) existing.add(id);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(EXISTS_CONCURRENCY, ids.length) }, worker));
+  for (const [key, id] of committedAtStart) {
+    if (!existing.has(id) && committedKeys.get(key) === id) committedKeys.delete(key);
+  }
+  const get = (key) => {
+    const committed = committedAtStart.get(key);
+    if (committed && existing.has(committed)) return committed;
+    return (fromSummaries.get(key) || []).find((id) => existing.has(id)) || null;
+  };
+  return { get, has: (key) => get(key) !== null };
+}
+
+class FatalImportError extends Error {
+  constructor(code) {
+    super(code);
+    this.code = code;
+  }
+}
+
+function admit(task) {
+  const run = admissionTail.then(task, task);
+  admissionTail = run.then(
+    () => {},
+    () => {}
+  );
+  return run;
+}
+
+function snapshot(job) {
+  return {
+    jobId: job.jobId,
+    seq: job.seq,
+    state: job.state,
+    total: job.total,
+    processed: job.imported + job.skippedAlreadyImported + job.failed,
+    imported: job.imported,
+    skippedAlreadyImported: job.skippedAlreadyImported,
+    failed: job.failed,
+    byProject: [...job.byProject.entries()].map(([projectPath, counts]) => ({ projectPath, ...counts })),
+    results: job.results.map((result) => ({ ...result, warnings: [...result.warnings] })),
+    current: job.current ? { ...job.current } : null,
+    ...(job.errorCode ? { errorCode: job.errorCode } : {}),
+  };
+}
+
+function touch(job, patch = {}) {
+  Object.assign(job, patch);
+  job.seq += 1;
+}
+
+const COUNTER = { imported: 'imported', alreadyImported: 'skippedAlreadyImported', failed: 'failed' };
+
+function record(job, { projectPath = null, ...result }) {
+  const counter = COUNTER[result.status];
+  job[counter] += 1;
+  const counts = job.byProject.get(projectPath) || { imported: 0, skippedAlreadyImported: 0, failed: 0 };
+  counts[counter] += 1;
+  job.byProject.set(projectPath, counts);
+  job.results.push(result);
+  touch(job);
+}
+
+function pruneFinishedJobs() {
+  const finished = [...jobs.values()].filter((job) => job.state !== 'running' && job.state !== 'stopping');
+  for (const job of finished.slice(0, Math.max(0, finished.length - MAX_FINISHED_JOBS))) {
+    jobs.delete(job.jobId);
+    if (jobsByRequest.get(job.requestId) === job.jobId) jobsByRequest.delete(job.requestId);
+  }
+}
+
+const failed = (candidateId, errorCode, projectPath = null, warnings = []) => ({
+  candidateId,
+  status: 'failed',
+  errorCode,
+  warnings,
+  projectPath,
+});
+
+async function importOne(candidateId, context) {
+  const candidate = getCandidate(candidateId);
+  if (!candidate) return failed(candidateId, 'unknownCandidate');
+  // The chat keeps the title the user picked it by: a long file's listing
+  // title comes from its prefix and can differ from the converted branch.
+  const listedTitle = cachedMeta(candidate)?.title ?? null;
+  let conversion;
+  try {
+    const info = await stat(candidate.path);
+    if (!info.isFile()) return failed(candidateId, 'unreadable');
+    candidate.size = info.size;
+    candidate.mtimeMs = info.mtimeMs;
+    conversion = await convertCandidateFile(candidate, context.limits);
+  } catch {
+    return failed(candidateId, 'unreadable');
+  }
+  if (listedTitle) conversion = { ...conversion, title: listedTitle };
+  recordConversion(candidate, conversion);
+  const cwdInfo = await resolveSourceCwd(conversion.cwd);
+  const projectPath = cwdInfo.exists ? cwdInfo.path : null;
+  if (conversion.errorCode) return failed(candidateId, conversion.errorCode, projectPath, conversion.warnings);
+  const warnings = [...conversion.warnings, ...(projectPath ? [] : [IMPORT_WARNING_CWD_MISSING])];
+  const key = importOriginKey(candidate.source, conversion.foreignSessionId, candidate.path);
+  // The batch's catalog snapshot, then commits made since (by any job; the
+  // admission lane serializes them).
+  let existing = context.imported.get(key);
+  const committed = committedKeys.get(key);
+  if (!existing && committed && (await context.sessionExists(committed))) existing = committed;
+  if (existing) return { candidateId, status: 'alreadyImported', sessionId: existing, warnings, projectPath };
+  if (!context.leadOptions) {
+    try {
+      context.leadOptions = await context.prepareLeadOptions();
+    } catch (error) {
+      throw new FatalImportError(error?.code || 'noModelRoute');
+    }
+  }
+  let session;
+  try {
+    session = await context.createImportedSession({
+      leadOptions: context.leadOptions,
+      conversation: conversion,
+      origin: buildImportOrigin({
+        source: candidate.source,
+        sourcePath: candidate.path,
+        foreignSessionId: conversion.foreignSessionId,
+        sourceCwd: conversion.cwd,
+        importedAt: Date.now(),
+      }),
+      cwd: projectPath,
+      desktopSession: projectPath
+        ? { classification: 'project', projectPath }
+        : { classification: 'task', projectPath: null },
+    });
+  } catch (error) {
+    return failed(candidateId, typeof error?.code === 'string' ? error.code : 'importFailed', projectPath, warnings);
+  }
+  committedKeys.set(key, session.id);
+  return { candidateId, status: 'imported', sessionId: session.id, warnings, projectPath };
+}
+
+async function runJob(job, candidateIds, context) {
+  try {
+    // One catalog read per batch; later commits are seen through committedKeys.
+    context.imported = await context.importedLookup();
+    for (const candidateId of candidateIds) {
+      if (job.cancelRequested) break;
+      let result;
+      try {
+        result = await admit(async () => {
+          // A cancel that arrived while queued behind other jobs wins here.
+          if (job.cancelRequested) return null;
+          const candidate = getCandidate(candidateId);
+          touch(job, { current: { candidateId, title: (candidate && cachedMeta(candidate)?.title) ?? null } });
+          try {
+            return await importOne(candidateId, context);
+          } finally {
+            job.current = null;
+          }
+        });
+      } catch (error) {
+        if (error instanceof FatalImportError) throw error;
+        result = failed(candidateId, 'importFailed');
+      }
+      if (result === null) break;
+      record(job, result);
+    }
+    touch(job, { state: job.cancelRequested ? 'stopped' : 'completed' });
+  } catch (error) {
+    touch(job, { state: 'failed', current: null, errorCode: error?.code || 'importFailed' });
+  }
+  pruneFinishedJobs();
+}
+
+/** Candidate ids of a selection; a `viewId` resolves the view's complete membership. */
+async function selectionIds(selection, imported) {
+  if (!selection || typeof selection !== 'object') throw new TypeError('selection is required.');
+  if (Array.isArray(selection.ids)) {
+    if (!selection.ids.every((id) => typeof id === 'string' && id)) throw new TypeError('selection.ids must be ids.');
+    return [...new Set(selection.ids)];
+  }
+  if (typeof selection.viewId === 'string') {
+    if (selection.excludeIds !== undefined && !Array.isArray(selection.excludeIds)) {
+      throw new TypeError('selection.excludeIds must be ids.');
+    }
+    return resolveViewSelection(selection.viewId, selection.excludeIds, await imported());
+  }
+  throw new TypeError('selection must carry ids or a viewId.');
+}
+
+function requireParams(params) {
+  if (!params || typeof params !== 'object' || Array.isArray(params)) throw new TypeError('expected one object.');
+  return params;
+}
+
+/**
+ * Runtime API slice. deps:
+ *   listSessionSummaries()  async session summary rows (carrying `importKey`), read once per listing/batch
+ *   prepareLeadOptions()    async createSession options of a Lead session on the current route
+ *   createSession(opts)     the session manager's createSession
+ *   sessionExists(id)       async: whether a session is still in storage (default: its file exists)
+ *   ingestSession(session)  content-search ingestion of an imported session (default: ingestSessionTurn)
+ *   limits                  convertCandidateFile limits (maxFileBytes, maxLineBytes, maxTranscriptChars, …)
+ */
+export function createConversationImportApi({
+  listSessionSummaries,
+  prepareLeadOptions,
+  createSession,
+  env,
+  sessionExists = sessionFileExists,
+  ingestSession,
+  limits,
+}) {
+  const summaries = async () => (await listSessionSummaries?.()) || [];
+  const imported = async () => importedLookup(await summaries(), sessionExists);
+  return {
+    async listImportableConversations(params) {
+      return listConversations(requireParams(params), { imported: await imported(), env });
+    },
+    async registerConversationImportFile(params) {
+      return registerFile(requireParams(params), { imported: await imported(), limits });
+    },
+    getConversationImportJobs(params = {}) {
+      const { jobId } = requireParams(params ?? {});
+      const list = [...jobs.values()].filter((job) => jobId === undefined || jobId === null || job.jobId === jobId);
+      return { jobs: list.map(snapshot) };
+    },
+    async startConversationImport(params) {
+      const { requestId, selection } = requireParams(params);
+      if (typeof requestId !== 'string' || !requestId.trim() || requestId.length > MAX_REQUEST_ID_LENGTH) {
+        throw new TypeError('requestId is required.');
+      }
+      const existing = jobs.get(jobsByRequest.get(requestId));
+      if (existing) return snapshot(existing);
+      let pending = pendingStarts.get(requestId);
+      if (!pending) {
+        pending = (async () => {
+          const candidateIds = await selectionIds(selection, imported);
+          const job = {
+            jobId: randomUUID(),
+            requestId,
+            seq: 0,
+            state: 'running',
+            total: candidateIds.length,
+            imported: 0,
+            skippedAlreadyImported: 0,
+            failed: 0,
+            byProject: new Map(),
+            results: [],
+            current: null,
+            errorCode: null,
+            cancelRequested: false,
+          };
+          jobs.set(job.jobId, job);
+          jobsByRequest.set(requestId, job.jobId);
+          void runJob(job, candidateIds, {
+            importedLookup: imported,
+            imported: null,
+            sessionExists,
+            limits,
+            prepareLeadOptions,
+            leadOptions: null,
+            createImportedSession: (args) =>
+              createImportedSession({
+                ...args,
+                ...(createSession ? { createSessionFn: createSession } : {}),
+                ...(ingestSession ? { ingestFn: ingestSession } : {}),
+              }),
+          });
+          return job;
+        })();
+        pendingStarts.set(requestId, pending);
+        pending.then(
+          () => pendingStarts.delete(requestId),
+          () => pendingStarts.delete(requestId)
+        );
+      }
+      return snapshot(await pending);
+    },
+    cancelConversationImport(params) {
+      const { jobId } = requireParams(params);
+      const job = typeof jobId === 'string' ? jobs.get(jobId) : null;
+      if (!job) throw importError('jobNotFound');
+      if (job.state === 'running') {
+        job.cancelRequested = true;
+        touch(job, { state: 'stopping' });
+      }
+      return snapshot(job);
+    },
+  };
+}

package/src/session-runtime/cwd-plugins/cwd-apply.mjs

@@ -1,6 +1,9 @@
 // cwd-plugins/cwd-apply.mjs — resolving a requested cwd and retargeting the
 // live session to it (project selection persistence, code-graph prewarm,
 // CwdChanged hook) without recreating the session.
+import { setWorkspaceCwdLock } from '../workspace/admission-gate.mjs';
+import { workspaceForProjectSelection } from '../workspace/workspace-state.mjs';
+
 export function createCwdApply({
   getCurrentCwd,
   setCurrentCwd,
@@ -17,6 +20,7 @@ export function createCwdApply({
   writeLastSessionCwd,
   updateCurrentCwdOverride,
   persistSession,
+  onCwdChanged,
   clean,
   resolve,
   statSync,
@@ -31,9 +35,16 @@ export function createCwdApply({
   }
 
   function persistProjectSelection(session, currentCwd) {
+    // A Lead in its worktree keeps the registered Project as projectPath; a
+    // switch elsewhere leaves the worktree at a new workspace revision.
+    const { workspace, projectPath } = workspaceForProjectSelection(session, currentCwd);
+    if (session && workspace !== (session.workspace ?? null)) {
+      session.workspace = workspace;
+      setWorkspaceCwdLock(session.id, null);
+    }
     const desktop = getDesktopSession?.() || session?.desktopSession;
     if (desktop && typeof desktop === 'object') {
-      const nextDesktop = { classification: 'project', projectPath: currentCwd };
+      const nextDesktop = { classification: 'project', projectPath };
       setDesktopSession?.(nextDesktop);
       if (session) session.desktopSession = nextDesktop;
     }
@@ -43,10 +54,11 @@ export function createCwdApply({
     }
   }
 
-  // cwd changes NEVER recreate the session and never reload MCP or Skills
-  // (extension settings are global): a mid-conversation cwd switch must
-  // preserve the full message history. The live execution cwd is retargeted in
-  // place; the BP3 session snapshot remains the session-start environment.
+  // cwd changes NEVER recreate the session and never reload Skills (extension
+  // settings are global): a mid-conversation cwd switch must preserve the full
+  // message history. The live execution cwd is retargeted in place; the BP3
+  // session snapshot remains the session-start environment. `onCwdChanged`
+  // lets MCP reconnect only the plugin servers that run in the session cwd.
   function applyResolvedCwd(nextCwd, { persistProjectSelection: persist = false } = {}) {
     const resolved = resolve(nextCwd);
     const stat = statSync(resolved);
@@ -74,7 +86,10 @@ export function createCwdApply({
     if (changed) {
       try {
         void hooks.dispatch('CwdChanged', hookCommonPayload({ cwd: currentCwd }));
-      } catch {}
+      } catch {
+        // Hook dispatch is fire-and-forget; a synchronous throw must not block the cwd switch.
+      }
+      onCwdChanged?.(currentCwd);
     }
     return currentCwd;
   }

package/src/session-runtime/cwd-plugins/plugin-status.mjs

@@ -1,16 +1,15 @@
 // cwd-plugins/plugin-status.mjs — the registered-plugin status list with its
-// per-root caches (manifest keyed on mtime, MCP discovery and skill-file count
-// on a short TTL).
+// manifest cache (keyed on mtime); skill count and MCP discovery are live.
 import { readFileSync } from 'node:fs';
 import { discoverPluginMcp } from '../../runtime/agent/orchestrator/runtime-core/plugin-mcp.mjs';
+import { PLUGIN_MANIFEST_FILES, pluginSkillsRoots } from '../../runtime/shared/plugin-manifest.mjs';
 import { pluginMetadata } from '../../runtime/shared/plugin-metadata.mjs';
 
 export function createPluginStatus({
-  getConfig,
   listRegisteredPlugins,
   pluginAdminStatus,
   pluginManifest,
-  pluginMcpServerName,
+  pluginMcpSummary = () => new Map(),
   countSkillFiles,
   clean,
   resolve,
@@ -18,16 +17,13 @@ export function createPluginStatus({
   existsSync,
   cfgMod,
 }) {
-  // Per-plugin-root caches for pluginsStatus(): manifest + MCP discovery keyed
-  // by root path + manifest mtime (invalidated on manifest edit); recursive
-  // skill-file count keyed by root with a ~5s TTL fallback (the walk has no
-  // single mtime to key on).
+  // Per-plugin-root manifest cache keyed by root path + manifest mtimes
+  // (invalidated on manifest edit). Skill count and MCP discovery are
+  // recomputed on every call so file add/remove shows up immediately.
   const pluginRootCache = new Map();
-  const skillCountCache = new Map();
-  const mcpDiscoveryCache = new Map();
   function manifestMtimeKey(root) {
     let key = '';
-    for (const rel of ['.codex-plugin/plugin.json', 'plugin.json']) {
+    for (const rel of PLUGIN_MANIFEST_FILES) {
       try {
         key += `${statSync(resolve(root, rel)).mtimeMs}:`;
       } catch {
@@ -38,7 +34,7 @@ export function createPluginStatus({
   }
   // A manifest file that exists but is not a JSON object is breakage.
   function manifestInvalid(root) {
-    for (const rel of ['.codex-plugin/plugin.json', 'plugin.json']) {
+    for (const rel of PLUGIN_MANIFEST_FILES) {
       const file = resolve(root, rel);
       if (!existsSync(file)) continue;
       try {
@@ -58,33 +54,20 @@ export function createPluginStatus({
     pluginRootCache.set(root, entry);
     return entry;
   }
-  // MCP discovery probes candidate script files (.mcp.json, scripts/run-mcp.mjs,
-  // ...) whose add/remove is NOT reflected in the manifest mtime, so key it on a
-  // short TTL instead (~5s, like the skill-file count).
-  function cachedMcpDiscovery(root) {
-    const now = Date.now();
-    const hit = mcpDiscoveryCache.get(root);
-    if (hit && now - hit.at < 5000) return hit.mcp;
-    const mcp = discoverPluginMcp(root);
-    mcpDiscoveryCache.set(root, { at: now, mcp });
-    return mcp;
-  }
-  function cachedSkillCount(root) {
-    const now = Date.now();
-    const hit = skillCountCache.get(root);
-    if (hit && now - hit.at < 5000) return hit.count;
-    const count = countSkillFiles(root);
-    skillCountCache.set(root, { at: now, count });
-    return count;
-  }
 
-  function registeredPlugin(entry, configuredMcp) {
+  function registeredPlugin(entry, mcpByPlugin) {
     const root = clean(entry.root);
     if (!root) return null;
-    if (!existsSync(root)) return { missing: true, id: clean(entry.id) || clean(entry.name) || root, name: clean(entry.name) || clean(entry.id) || root.split(/[\\/]/).pop() || root };
+    if (!existsSync(root))
+      return {
+        missing: true,
+        id: clean(entry.id) || clean(entry.name) || root,
+        name: clean(entry.name) || clean(entry.id) || root.split(/[\\/]/).pop() || root,
+      };
     const { manifest, invalid } = cachedPluginData(root);
     const name = clean(manifest.name) || clean(manifest.id) || clean(entry.name) || root.split(/[\\/]/).pop() || root;
-    const { mcpScript, mcpInline } = cachedMcpDiscovery(root);
+    const { mcpScript, mcpInline } = discoverPluginMcp(root);
+    const skillCount = countSkillFiles(root);
     const plugin = {
       id: clean(entry.id) || name,
       name,
@@ -101,26 +84,48 @@ export function createPluginStatus({
       root,
       installedAt: entry.installedAt || null,
       updatedAt: entry.updatedAt || null,
-      skillCount: cachedSkillCount(root),
+      skillCount,
       mcpScript,
       mcpInline,
     };
     if (invalid) plugin.invalid = true;
-    plugin.mcpServerName = pluginMcpServerName(plugin);
-    plugin.mcpEnabled =
-      Object.hasOwn(configuredMcp, plugin.mcpServerName) ||
-      Object.keys(configuredMcp).some((k) => k.startsWith(`${plugin.mcpServerName}--`));
+    if (plugin.enabled && skillCount === 0 && !mcpScript && !mcpInline) {
+      plugin.searchedSkillRoots = pluginSkillsRoots(root);
+      plugin.warning = `No skills or MCP server found. Searched skill roots: ${plugin.searchedSkillRoots.join(', ')}`;
+    }
+    // Servers the plugin declares, live: name, declared key, intent/effective
+    // state, connection, and declaration problems.
+    const mcp = mcpByPlugin.get(plugin.id) || { format: 'none', errors: [], servers: [] };
+    plugin.mcpFormat = mcp.format;
+    plugin.mcpErrors = mcp.errors;
+    plugin.mcpServers = mcp.servers.filter(Boolean).map((row) => ({
+      name: row.name,
+      key: row.owner?.key || '',
+      enabled: row.enabled !== false,
+      serverEnabled: row.serverEnabled !== false,
+      connected: row.connected === true,
+      status: row.status,
+      error: row.error || null,
+      warnings: row.warnings || [],
+      cwdDependent: row.owner?.cwdDependent === true,
+    }));
+    plugin.mcpServerName = plugin.mcpServers[0]?.name || '';
+    plugin.mcpEnabled = plugin.mcpServers.some((server) => server.serverEnabled);
     return plugin;
   }
 
   function pluginsStatus() {
-    const config = getConfig();
     const dataDir = cfgMod.getPluginData?.();
-    const configuredMcp = config?.mcpServers && typeof config.mcpServers === 'object' ? config.mcpServers : {};
+    let mcpByPlugin = new Map();
+    try {
+      mcpByPlugin = pluginMcpSummary();
+    } catch {
+      /* status still lists plugins without their MCP rows */
+    }
     const plugins = [];
     const missing = [];
     for (const entry of listRegisteredPlugins({ dataDir })) {
-      const plugin = registeredPlugin(entry, configuredMcp);
+      const plugin = registeredPlugin(entry, mcpByPlugin);
       if (plugin?.missing) missing.push({ id: plugin.id, name: plugin.name, enabled: entry.enabled !== false });
       else if (plugin) plugins.push(plugin);
     }

package/src/session-runtime/global-extensions.mjs

@@ -16,11 +16,11 @@ export function subscribeGlobalExtensionChanges(listener) {
   };
 }
 
-export async function publishGlobalExtensionChange(kind, originId = null) {
+export async function publishGlobalExtensionChange(kind, originId = null, detail = null) {
   const jobs = [];
   for (const [id, listener] of subscribers) {
     if (id === originId) continue;
-    jobs.push(Promise.resolve().then(() => listener(kind)));
+    jobs.push(Promise.resolve().then(() => listener(kind, detail)));
   }
   await Promise.allSettled(jobs);
 }

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

@@ -3,7 +3,8 @@
 import { executeBrowserTool } from '../../runtime/browser-bridge/client.mjs';
 import { executeComputerTool } from '../../runtime/computer-bridge/client.mjs';
 import { executeTerminalTool } from '../../runtime/terminal-bridge/client.mjs';
-import { featureEnvOverride } from '../../runtime/agent/orchestrator/runtime-core/config-helpers.mjs';
+import { executeVisualizeTool } from '../../runtime/visualize-bridge/client.mjs';
+import { featureEnvOverride, moduleEnabled } from '../../runtime/agent/orchestrator/runtime-core/config-helpers.mjs';
 import { createCallerContextResolvers } from './caller-context.mjs';
 
 export function createBridgeToolHandlers({ rt }) {
@@ -50,5 +51,29 @@ export function createBridgeToolHandlers({ rt }) {
     });
   };
 
-  return { browser, browser_devtools: browser, computer, terminal };
+  const visualize = async (args, { callerCtx, callerCwd }) => {
+    if (environmentDisabled(callerCtx, 'MIXDOG_FEATURE_VISUALIZE')) {
+      throw new Error('the visualize tool is disabled in this environment');
+    }
+    // A conversation keeps its frozen tool list, so honor the Settings toggle
+    // at execution time too (an env override wins, as in builtinFeatureActive).
+    if (!(featureEnvOverride('MIXDOG_FEATURE_VISUALIZE') ?? moduleEnabled(rt.config, 'visualize', true))) {
+      return {
+        content: [
+          {
+            type: 'text',
+            text: 'Error: Visualize is turned off in Settings by the user. Do not turn it back on unless the user asks; give the file path instead.',
+          },
+        ],
+        isError: true,
+      };
+    }
+    return await executeVisualizeTool(args, {
+      sessionId: sessionIdFor(callerCtx),
+      cwd: callerCwd,
+      signal: signalFor(callerCtx),
+    });
+  };
+
+  return { browser, browser_devtools: browser, computer, terminal, visualize };
 }

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

@@ -5,9 +5,40 @@ import { resolve } from 'node:path';
 import { listProjects } from '../../runtime/shared/projects.mjs';
 import { clean } from '../../runtime/agent/orchestrator/runtime-core/session-text.mjs';
 
-export function createWorkspaceToolHandlers({ rt, goalRuntime, agentTool, notifyFnForSession, applyResolvedCwd }) {
+export function createWorkspaceToolHandlers({
+  rt,
+  goalRuntime,
+  agentTool,
+  notifyFnForSession,
+  applyResolvedCwd,
+  getWorkspaceApi = () => null,
+}) {
+  // The Lead's own worktree, on the user's request: the same authority the
+  // branch chip menu drives, tolerating the calling turn but nothing else
+  // running (workers, background shells).
+  const worktreeAction = async (action, args, callerCtx) => {
+    const workspace = getWorkspaceApi();
+    if (!workspace) throw new Error(`cwd: ${action} is unavailable in this runtime`);
+    const callerSessionId = callerCtx?.callerSessionId || rt.session?.id || null;
+    if (!rt.session?.id || callerSessionId !== rt.session.id) {
+      throw new Error(`cwd: ${action} belongs to the Lead session`);
+    }
+    const result =
+      action === 'merge-worktree'
+        ? await workspace.mergeWorkspace({ confirmed: true }, { ownTurn: true })
+        : action === 'remove-worktree'
+          ? await workspace.removeWorktree({ force: args?.force === true }, { ownTurn: true })
+          : action === 'list-worktrees'
+            ? await workspace.listWorktrees()
+            : await workspace.pruneWorktrees();
+    return JSON.stringify({ action, cwd: rt.currentCwd, result }, null, 2);
+  };
+
+  const WORKTREE_ACTIONS = new Set(['merge-worktree', 'remove-worktree', 'list-worktrees', 'prune-worktrees']);
+
   const cwd = async (args, { callerCtx, callerCwd }) => {
     const action = clean(args?.action || (args?.path ? 'set' : 'get')).toLowerCase();
+    if (WORKTREE_ACTIONS.has(action)) return worktreeAction(action, args, callerCtx);
     let currentCwd = callerCwd;
     if (action === 'list') {
       return JSON.stringify(