mixdog 1.4.1 → 1.4.3

package/src/runtime/agent/orchestrator/tools/builtin/shell-jobs.mjs

@@ -22,7 +22,7 @@ import {
   waitNativeTask,
 } from '../lib/native-spawn-client.mjs';
 import { attachJobInsights, shellJobPublicTaskResult } from './lib/shell-job-insights.mjs';
-import { tryAdmitWorkspaceActivity } from '../../../../shared/worktrees/activity-gate.mjs';
+import { tryAdmitWorkspaceActivityAsync } from '../../../../shared/worktrees/activity-gate.mjs';
 import { worktreeError } from '../../../../shared/worktrees/contract.mjs';
 import {
   adoptShellWorkspaceAdmission,
@@ -30,6 +30,7 @@ import {
   completeShellJobRecord,
   listShellJobRecords,
   markShellJobTerminationUnconfirmed,
+  pendingWorkspaceAdmission,
   publishShellJobRecord,
   recordShellJobHop,
   registerTerminationHold,
@@ -37,9 +38,12 @@ import {
   takeReleaseRequest,
 } from './lib/shell-job-records.mjs';
 import {
+  createContainedTreeTracker,
   createProcessTreeTracker,
+  endWatchWhenUnconfirmable,
   killAfterSnapshot,
   PROCESS_TABLE_READ_BOUND_MS,
+  sweepLiveIdentities,
   watchTermination,
   withinBound,
 } from '../lib/shell-descendants.mjs';
@@ -61,13 +65,33 @@ const PRE_DEADLINE_CAPTURE_MS = PROCESS_TABLE_READ_BOUND_MS + 1_000;
 // the promotion baseline predates whatever the job started since (a server,
 // an npm child); the baseline still stands when the fresh read fails. Marks
 // the job killed, so its settle relies on this snapshot instead of an
-// after-exit observation.
+// after-exit observation. A job the spawn server contains needs none (true at
+// once): its kill is verified by the server's empty-job report.
 function prepareTrackedKill(entry) {
   entry.killed = true;
+  if (entry.contained) return true;
   return (entry.baseline || Promise.resolve(false)).then(() =>
     entry.tracker.capture().catch(() => entry.tracker.complete)
   );
 }
+
+const FINAL_TREE_OUTCOMES = new Set(['empty', 'unverified', 'released']);
+
+/** The tracker of a contained job's killed or emptied tree, driven by the
+ *  server's outcome (a final one latched: the task entry may expire).
+ *  Survivors the server kept in the job are cancelled through it. */
+function containedJobTracker(jobId) {
+  let final = null;
+  return createContainedTreeTracker({
+    outcome: () => {
+      if (final) return final;
+      const outcome = getNativeTask(jobId)?.treeOutcome ?? null;
+      if (FINAL_TREE_OUTCOMES.has(outcome)) final = outcome;
+      return outcome;
+    },
+    cancel: () => cancelNativeTask(jobId),
+  });
+}
 import { isPidAlive } from '../../../../shared/pid-liveness.mjs';
 import { hopOf } from '../../../../shared/bot-hops.mjs';
 import {
@@ -110,22 +134,30 @@ function demoteBackgroundShellPriority(pid) {
 // The workspace admission a job record holds is released only once the job's
 // processes are confirmed gone — the same confirmation path a foreground run
 // uses, not the native terminal status alone.
-function trackShellJobRecord(task, options) {
+// Resolves once both workspace leases are written; the promoted run's own
+// admission is released only after that (handOverLease).
+async function trackShellJobRecord(task, options) {
   const jobId = String(task?.jobId || '').trim();
   if (!jobId) return;
-  publishShellJobRecord(task, options);
+  const published = publishShellJobRecord(task, options);
   if (task?.cwd) {
     // The record's own reader is filed under the job's root pid, which the
     // gate drops the moment that pid dies. Survivors must keep the folder
     // reserved, so this runtime holds it under its own live pid as well.
-    const hold = tryAdmitWorkspaceActivity(options?.ownerSessionId || jobId, task.cwd, { kind: 'command' });
-    if (!hold) throw worktreeError('WORKTREE_BUSY_JOBS', 'The command folder is being managed.');
-    adoptShellWorkspaceAdmission(jobId, hold);
+    await published;
+    const holding = tryAdmitWorkspaceActivityAsync(options?.ownerSessionId || jobId, task.cwd, { kind: 'command' });
+    adoptShellWorkspaceAdmission(jobId, pendingWorkspaceAdmission(holding));
+    if (!(await holding)) throw worktreeError('WORKTREE_BUSY_JOBS', 'The command folder is being managed.');
   }
   const tracker = task?.cwd ? createProcessTreeTracker({ pid: task.pid }) : null;
+  // Killed, or emptied on its own, a contained job is confirmed by the server
+  // (containedJobTracker); the process tracker still observes the survivors a
+  // root that exited on its own leaves.
+  const contained = task?.contained === true;
   let resolveTerminated = null;
   const entry = {
     tracker,
+    contained,
     killed: false,
     baseline: null,
     // Settles once every process of the job is confirmed gone (or the user
@@ -150,7 +182,7 @@ function trackShellJobRecord(task, options) {
   // identities of what the job started since its promotion.
   const deadlineMs = Math.floor(Number(options?.timeoutMs) || 0);
   const deadlineCapture =
-    tracker && deadlineMs > 0
+    tracker && !contained && deadlineMs > 0
       ? setTimeout(
           () => {
             if (!settled) void tracker.capture().catch(() => false);
@@ -177,31 +209,44 @@ function trackShellJobRecord(task, options) {
     // settle does. A killed one relies on the snapshot taken before the kill.
     const killed = entry.killed || detail.killed || detail.timedOut || String(detail.status) === 'cancelled';
     if (!killed) tracker.acceptExitObservation();
+    const watched = contained && (killed || detail.treeOutcome === 'empty') ? containedJobTracker(jobId) : tracker;
     // The completion notice is already on its way (watchBackgroundShellJob);
     // the record — and with it the workspace admission — completes only once
     // every process is confirmed gone, or the user releases it explicitly.
+    // A force-release only drops the workspace hold (the record completes);
+    // the job stays tracked and observed until its processes are confirmed
+    // gone, and only that confirmation reports it terminated.
+    let released = null;
+    const releaseHold = () => {
+      clearTerminationHold(jobId);
+      released ??= completeShellJobRecord(jobId, normalized);
+      return released;
+    };
     let finished = false;
     const finish = () => {
       if (finished) return;
       finished = true;
       stop();
-      clearTerminationHold(jobId);
       if (backgroundTrackers.get(jobId) === entry) backgroundTrackers.delete(jobId);
       resolveTerminated(true);
-      return completeShellJobRecord(jobId, normalized);
+      return releaseHold();
     };
     const stop = watchTermination({
-      tracker,
+      tracker: endWatchWhenUnconfirmable(watched, { released: () => released !== null, stop: () => stop() }),
       // A killed job is not over while processes it started still run.
       sweep: killed,
       onTerminated: finish,
-      releaseRequested: () => takeReleaseRequest(jobId),
+      // A release requested from another process is the same force-release.
+      releaseRequested: () => {
+        if (takeReleaseRequest(jobId)) void releaseHold();
+        return false;
+      },
       onUnconfirmed: () => {
         void markShellJobTerminationUnconfirmed(jobId);
         registerTerminationHold(jobId, {
           ownerSessionId: options?.ownerSessionId || null,
           cwd: task.cwd,
-          release: finish,
+          release: releaseHold,
         });
       },
     });
@@ -415,7 +460,27 @@ export function killShellJob(jobId) {
     // complete, a fresh read). The kill waits for it at most the read bound
     // and is sent regardless; without a snapshot the outcome stays unknown and
     // the folder stays held under the observation loop.
-    void killAfterSnapshot(prepareTrackedKill(tracked), () => cancelNativeTask(jobId));
+    // The kill never outruns the promotion baseline itself: a read still in
+    // flight takes its table after a kill sent beside it, finds the root gone,
+    // and the job could never be confirmed terminated. That read ends by its
+    // own enumeration deadline. A contained job is cancelled at once.
+    const snapshot = prepareTrackedKill(tracked);
+    tracked.killSent =
+      snapshot === true
+        ? new Promise((resolve) => resolve(cancelNativeTask(jobId)))
+        : tracked.baseline.then(() => killAfterSnapshot(snapshot, () => cancelNativeTask(jobId)));
+    return { ...attachJobInsights(normalizeShellJobDetail(current)), killed: true };
+  }
+  if (tracked) {
+    // The root already exited but its tracked descendants run on: the stop
+    // reaches them through the tracker alone, whether or not the native task
+    // is still cached; the termination watch then releases the folder.
+    void tracked.tracker
+      .observe({ rootExited: true })
+      .then(() => sweepLiveIdentities(tracked.tracker))
+      .catch(() => {});
+    // An expired native entry says nothing about the root, so none is claimed.
+    if (!current) return { jobId, killed: true };
     return { ...attachJobInsights(normalizeShellJobDetail(current)), killed: true };
   }
   const detail = cancelNativeTask(jobId);
@@ -424,6 +489,12 @@ export function killShellJob(jobId) {
   return { ...attachJobInsights(normalizeShellJobDetail(detail)), killed: wasRunning };
 }
 
+/** Settles once the kill a stop of the tracked job queued has been sent (at
+ *  once when none is pending). */
+export function shellJobKillSent(jobId) {
+  return Promise.resolve(backgroundTrackers.get(String(jobId || ''))?.killSent).catch(() => {});
+}
+
 /** True once every process of a tracked background job is confirmed gone,
  *  false while any is still alive when `timeoutMs` passes. A job without a
  *  process tracker (or one already finished) has nothing left to confirm. */
@@ -572,7 +643,7 @@ export async function promoteForegroundShellJob({
   }
   // Added before tracking: the record's settlement removes it again.
   promotedJobIds.add(native.jobId);
-  trackShellJobRecord(native, { ownerSessionId, clientHostPid, startedAtMs: started, timeoutMs });
+  await trackShellJobRecord(native, { ownerSessionId, clientHostPid, startedAtMs: started, timeoutMs });
   return native;
 }
 
@@ -606,8 +677,8 @@ export function publishForegroundShellRecord({
   clientHostPid = null,
   terminationUnconfirmed = false,
 }) {
-  if (!jobId || !Number.isFinite(Number(pid)) || Number(pid) <= 0) return;
-  publishShellJobRecord(
+  if (!jobId || !Number.isFinite(Number(pid)) || Number(pid) <= 0) return Promise.resolve();
+  return publishShellJobRecord(
     { jobId, command, cwd, pid: Number(pid), shellType },
     {
       ownerSessionId,
@@ -696,8 +767,9 @@ export async function shutdownShellJobs(_reason = 'runtime-close', { scope = nul
   let cancelledWatchers = 0;
   // Identities first, as every other kill does: once a root dies, what it
   // started outside its process group is reparented and can no longer be
-  // found. The cancel is sent at the snapshot bound regardless.
-  await killAfterSnapshot(Promise.all(prepareOwnedShellTreeKills(scoped ? ownerSessionId : null)), () => {
+  // found. The cancel is sent at the snapshot bound regardless — and at once
+  // when no snapshot is pending (every tree contained, or already captured).
+  const cancelAll = () => {
     for (const task of jobs) {
       if (cancelBackgroundShellJobWatch(task.jobId)) cancelledWatchers += 1;
       try {
@@ -705,7 +777,10 @@ export async function shutdownShellJobs(_reason = 'runtime-close', { scope = nul
       } catch {}
       jobNotifyCtxByJobId.delete(task.jobId);
     }
-  });
+  };
+  const snapshots = prepareOwnedShellTreeKills(scoped ? ownerSessionId : null);
+  if (snapshots.length === 0) cancelAll();
+  else await killAfterSnapshot(Promise.all(snapshots), cancelAll);
   const settled = await Promise.all(jobs.map((task) => waitNativeTask(task.jobId, 1_200).catch(() => null)));
   // A process still running after the wait is not forgotten: it keeps being
   // stopped until its exit is confirmed.

package/src/runtime/agent/orchestrator/tools/builtin/task-tool.mjs

@@ -1,11 +1,13 @@
 // Generic background-task tool (status/wait/cancel).
 import {
   buildJobNotFoundMessage,
+  isShellJobRunning,
   peekShellJob,
   killShellJob,
   otherSessionBackgroundShellJobCount,
   cancelBackgroundShellJobWatch,
   clearShellJobNotifyCtx,
+  shellJobKillSent,
   shellJobPublicTaskResult,
   shellJobTaskStatus,
   waitForShellJob,
@@ -21,6 +23,7 @@ import {
   cancelBackgroundTask,
   completeBackgroundTask,
   getBackgroundTask,
+  listBackgroundTasks,
   registerBackgroundTask,
   renderBackgroundTask,
   renderBackgroundTaskList,
@@ -227,12 +230,16 @@ async function cancelShellTaskOutcome(task, taskId, options) {
   // their shell). Remember that it WAS live so the outcome is
   // reported as a cancellation rather than "task not found".
   const wasRunning = task.status === 'running';
+  // A tracked tree outlives the native task's cache entry: its own
+  // termination watch, not the native task, confirms the stop.
+  const trackedTree = isShellJobRunning(taskId);
   const job = killShellJob(taskId);
   if (job) {
     // Confirm the process actually terminated before reporting a
     // terminal status. Removing the watcher on the strength of a
     // delivered signal left a live, unmonitored process behind a
-    // false 'cancelled'.
+    // false 'cancelled'. The window opens once the kill is actually sent.
+    await shellJobKillSent(taskId);
     const confirmed = await waitForShellJob(taskId, { timeoutMs: TASK_CANCEL_CONFIRM_MS });
     if (confirmed && confirmed.status === 'running') {
       // Watcher and notify context stay armed: the eventual exit
@@ -248,10 +255,10 @@ async function cancelShellTaskOutcome(task, taskId, options) {
     }
     // The root exited; what it started outside its process group is swept
     // by the job's termination watch. Cancelled means all of it is gone.
-    if (confirmed && !(await waitShellJobTerminated(taskId, TASK_CANCEL_TREE_CONFIRM_MS))) {
+    if ((confirmed || trackedTree) && !(await waitShellJobTerminated(taskId, TASK_CANCEL_TREE_CONFIRM_MS))) {
       return { outcome: 'unconfirmed', text: cancelPendingText(taskId) };
     }
-    if (!confirmed) {
+    if (!confirmed && !trackedTree) {
       // No terminal event and no observable task: absence of
       // state is not proof of termination. Stop tracking it so it
       // cannot hang as 'running' forever, but never claim it died.
@@ -273,7 +280,7 @@ async function cancelShellTaskOutcome(task, taskId, options) {
   cancelBackgroundTask(taskId, 'cancelled by task control');
   // A task whose own cancel hook kills (what a finished command left running)
   // reports what that kill confirmed.
-  const hookKill = job ? null : await task.cancelOutcome;
+  const hookKill = await task.cancelOutcome;
   if (hookKill && hookKill.terminated !== true) return { outcome: 'unconfirmed', text: cancelPendingText(taskId) };
   return job || wasRunning
     ? {
@@ -298,22 +305,64 @@ export async function stopBackgroundShellJob(taskId, options = {}) {
   const id = typeof taskId === 'string' ? taskId.trim() : '';
   if (!id) return { stopped: false, error: 'task_id is required' };
   const task = getBackgroundTask(id, { context: options });
-  if (!task || task.surface !== 'shell') return { stopped: false, error: `task not found: ${id}` };
+  if (task?.surface !== 'shell') return { stopped: false, error: `task not found: ${id}` };
   const job = peekShellJob(id);
   const status = job ? job.status : task.status;
-  if (status !== 'running') return { stopped: false, error: `task already ${status}: ${id}` };
+  // A root that exited while tracked descendants run is still stoppable, and
+  // so is the survivors task of a finished command (`detached`): its own
+  // registry status, not the finished command's cached native entry, says
+  // whether anything still runs.
+  const survivors = task.detached === true && task.status === 'running';
+  if (status !== 'running' && !isShellJobRunning(id) && !survivors)
+    return { stopped: false, error: `task already ${status}: ${id}` };
   try {
     const { outcome, text } = await cancelShellTaskOutcome(task, id, options);
     if (outcome === 'cancelled') return { stopped: true };
-    return {
-      stopped: false,
-      error: outcome === 'unconfirmed' ? `cancellation not confirmed: ${id}` : text.replace(/^Error:\s*/, ''),
-    };
+    if (outcome === 'unconfirmed')
+      return { stopped: false, unconfirmed: true, error: `cancellation not confirmed: ${id}` };
+    return { stopped: false, error: text.replace(/^Error:\s*/, '') };
   } catch (error) {
     return { stopped: false, error: error instanceof Error ? error.message : String(error) };
   }
 }
 
+// The running shell tasks the caller's session owns (promoted jobs and the
+// survivors a finished command left), including a task whose command already
+// exited while its tracked descendants still run (what the island lists as
+// termination unconfirmed). A foreground command holds no background task, so
+// it never appears here.
+function sessionShellTasks(options) {
+  const sessionId = String(options.callerSessionId || '').trim();
+  if (!sessionId) return [];
+  return listBackgroundTasks({ ...options, surface: 'shell' })
+    .filter((row) => row.status === 'running' || isShellJobRunning(row.task_id))
+    .map((row) => getBackgroundTask(row.task_id))
+    .filter((task) => task?.ownerSessionId === sessionId);
+}
+
+/** What `/stop` would stop: this session's running background shells. */
+export function listStoppableShellJobs(options = {}) {
+  return sessionShellTasks(options).map((task) => ({
+    taskId: task.taskId,
+    command: String(task.input?.command || task.label || ''),
+  }));
+}
+
+/**
+ * Stop every background shell of the caller's session, each through the same
+ * confirmed cancel as a single stop. `stopping` counts the ones whose
+ * processes are not yet confirmed gone (they keep being terminated).
+ */
+export async function stopBackgroundShellJobs(options = {}) {
+  const results = await Promise.all(
+    sessionShellTasks(options).map((task) => stopBackgroundShellJob(task.taskId, options))
+  );
+  return {
+    stopped: results.filter((result) => result.stopped).length,
+    stopping: results.filter((result) => result.unconfirmed).length,
+  };
+}
+
 export async function executeTaskTool(args, options = {}) {
   const action = typeof args.action === 'string' ? args.action.toLowerCase() : '';
   if (!action) return 'Error: task action is required';

package/src/runtime/agent/orchestrator/tools/builtin.mjs

@@ -97,30 +97,12 @@ import {
   streamSmartReadSummary as _streamSmartReadSummaryImpl,
 } from './builtin/read-streaming.mjs';
 export {
-  coerceShapeFlex,
   normalizeInputPath,
   normalizeOutputPath,
-  posixPathToWindowsPath,
   resolveAgainstCwd,
-  toDisplayPath,
 } from './builtin/path-utils.mjs';
-export {
-  buildGlobCacheKey,
-  buildGrepCacheKey,
-  buildGrepRgArgs,
-  buildListCacheKey,
-} from './builtin/search-builders.mjs';
-export {
-  analyzeShellCommandEffects,
-  preflightShellLargeFileProbe,
-} from './builtin/shell-analysis.mjs';
-export { BUILTIN_TOOLS } from './builtin/builtin-tools.mjs';
 export { withBuiltinPathLocks } from './builtin/path-locks.mjs';
-export {
-  getCachedReadOnlyStat,
-  invalidateBuiltinResultCache,
-} from './builtin/cache-layers.mjs';
-export { atomicWrite } from './builtin/atomic-write.mjs';
+export { invalidateBuiltinResultCache } from './builtin/cache-layers.mjs';
 // User-cwd persistence hook: writes user-cwd.txt on SessionStart so
 // the MCP server (spawned from cache dir) resolves the correct sandbox root.
 // Helper extracted to src/shared/user-cwd.mjs so server-main.mjs can import
@@ -616,8 +598,3 @@ export function clearReadSnapshotForPath(fullPath, _scope) {
     _deleteReadSnapshotPathEverywhere(fullPath);
   } catch {}
 }
-
-// Re-export from the side-effect-free code-graph definition source so callers that already import other
-// helpers from builtin.mjs (result-compression.mjs) can pick up the tool
-// def list from the same module without a parallel path.
-export { CODE_GRAPH_TOOL_DEFS } from './code-graph-tool-defs.mjs';

package/src/runtime/agent/orchestrator/tools/code-graph/graph-binary/child-kill.mjs

@@ -1,6 +1,7 @@
 // Kill escalation for a spawned native child: SIGTERM first, then after a
-// grace period a forced kill (taskkill /t /f on Windows, SIGKILL elsewhere).
-import { spawn } from 'node:child_process';
+// grace period a forced kill (the shared creation-checked tree kill on
+// Windows, SIGKILL elsewhere).
+import { spawnTreeKill } from '../../../mcp/child-tree.mjs';
 
 const KILL_GRACE_MS = 3000;
 
@@ -14,7 +15,7 @@ export function createChildKiller(proc) {
     if (!pid) return;
     try {
       if (process.platform === 'win32') {
-        spawn('taskkill', ['/pid', String(pid), '/t', '/f'], { windowsHide: true, stdio: 'ignore' });
+        spawnTreeKill([pid], { root: proc });
       } else {
         try {
           proc.kill('SIGKILL');

package/src/runtime/agent/orchestrator/tools/code-graph/graph-binary.mjs

@@ -23,8 +23,7 @@ function _graphBinaryPath() {
   const moduleDir = dirname(fileURLToPath(import.meta.url));
   const binName = process.platform === 'win32' ? 'mixdog-graph.exe' : 'mixdog-graph';
   // Prefer a local cargo build, then a previously fetched/cached prebuilt.
-  // This module is one dir deeper than the legacy code-graph.mjs, so the
-  // relative walk to repo-root native/ needs six `../` hops
+  // The relative walk to repo-root native/ needs six `../` hops
   // (code-graph → tools → orchestrator → agent → runtime → src → root).
   const localBuild = pathResolve(moduleDir, '../../../../../../native/mixdog-graph/target/release', binName);
   if (existsSync(localBuild)) return localBuild;

package/src/runtime/agent/orchestrator/tools/code-graph/modes/calls.mjs

@@ -128,7 +128,7 @@ export async function callers(ctx) {
   const depth = Math.max(1, Math.min(5, Math.floor(Number(args?.depth) || 1)));
   if (depth > 1) {
     // Scope and limit are honoured at every level: a file/directory anchor
-    // and an explicit limit used to be dropped for depth>1.
+    // and an explicit limit apply for depth>1 too.
     return _formatTransitiveCallers(graph, symbol, cwd, {
       language: lang,
       depth,

package/src/runtime/agent/orchestrator/tools/code-graph/modes/symbols.mjs

@@ -132,8 +132,8 @@ export async function symbolSearch(ctx) {
   if (!keywords.length) throw new Error('code_graph symbol_search: "symbol" (or "symbols[]") is required.');
   // Native graph symbols answer without source text at all: nodes without
   // them have no keyword matches to contribute, so nothing is read here.
-  // Honour the file/directory anchor: symbol_search used to scan the whole
-  // graph even when the caller scoped the call.
+  // Honour the file/directory anchor: a scoped symbol_search must not scan
+  // the whole graph.
   if (rel && !node) return fileNotFound('symbol_search', ctx);
   const search = (kw) => _searchSymbolsByKeyword(graph, kw, cwd, { language, limit, fileRel: rel, scopeRelPrefix });
   if (keywords.length === 1) return search(keywords[0]);

package/src/runtime/agent/orchestrator/tools/code-graph/search.mjs

@@ -407,12 +407,11 @@ export function _findSymbolHits(graph, symbol, { language = null } = {}) {
   return _findSymbolHitsOnNodes(graph, cleanSymbol, candidateNodes, { language });
 }
 
-// Declarations come from the native record ONLY. The regex declaration
-// matchers that used to run for files without symbols are gone: they marked
+// Declarations come from the native record ONLY. A regex fallback would mark
 // `declarationLike` on lines the extractor never called a declaration, so the
-// hit ranking (and, through it, the caller/callee anchors) depended on which
-// path produced the hit. A file with no symbols still yields reference hits —
-// it just declares nothing.
+// hit ranking (and, through it, the caller/callee anchors) would depend on
+// which path produced the hit. A file with no symbols still yields reference
+// hits — it just declares nothing.
 function _findSymbolHitsOnNodes(graph, cleanSymbol, candidateNodes, { language = null } = {}) {
   if (!cleanSymbol) return [];
   const escaped = _escapeRegExp(cleanSymbol);

package/src/runtime/agent/orchestrator/tools/code-graph/symbol-index.mjs

@@ -5,10 +5,9 @@
 // Symbols and tokens have NO text fallback. `node.symbols` (record v2:
 // {name, kind, startLine, endLine, startCol, endCol, exported?, sig?, parent?})
 // and `node.tokenSymbols` are the only sources; a node that carries neither
-// contributes nothing to an outline or a candidate set. The cheap regex outline
-// matchers and the JS identifier re-tokenizer that used to stand in for them
-// are gone — they disagreed with the extractor, so an answer's content depended
-// on which of the two produced it.
+// contributes nothing to an outline or a candidate set. A regex outline or JS
+// identifier re-tokenizer would disagree with the extractor, so an answer's
+// content would depend on which of the two produced it.
 import { _langUsesDollarInIdentifiers, _langAllowsBangQuestionSuffix } from './lang-predicates.mjs';
 import { EXTRACTION_SYMBOL_LANGS } from './constants.mjs';
 import { _getSourceTextForNode, _graphRel } from './source-access.mjs';

package/src/runtime/agent/orchestrator/tools/code-graph.mjs

@@ -4,35 +4,17 @@
 // build, search, dispatch).
 //
 // Public surface:
-//   markCodeGraphDirtyPaths, CODE_GRAPH_TOOL_DEFS,
-//   _pruneCodeGraphMemoryCache, _pruneCodeGraphManifestForBudget,
-//   drainCodeGraphCache, prewarmCodeGraph, prewarmCodeGraphSymbols,
-//   prewarmCodeGraphIfProject, buildCodeGraphAsync, _lookupCandidateNodes,
-//   _buildCodeGraph and _postCodeGraphWorkerSuccess (worker-only),
-//   executeCodeGraphTool, isCodeGraphTool.
+//   prewarmCodeGraphIfProject (read through the lazy module namespace in
+//   session-runtime/prewarm), _buildCodeGraph and _postCodeGraphWorkerSuccess
+//   (worker-only), executeCodeGraphTool.
 //
 // NOTE: code-graph-prewarm-worker.mjs imports { _buildCodeGraph } from THIS
 // facade; the facade re-exports it from ./code-graph/build.mjs, and the async
 // build path spawns that worker via a path RELATIVE to build.mjs — so no
 // module dynamically imports its own path.
-export { markCodeGraphDirtyPaths } from './code-graph-state.mjs';
-export { CODE_GRAPH_TOOL_DEFS } from './code-graph-tool-defs.mjs';
-
-export { _pruneCodeGraphMemoryCache } from './code-graph/memory-cache.mjs';
 export {
-  _pruneCodeGraphManifestForBudget,
-  drainCodeGraphCache,
-} from './code-graph/disk-cache.mjs';
-export { _lookupCandidateNodes } from './code-graph/symbol-index.mjs';
-export {
-  prewarmCodeGraph,
-  prewarmCodeGraphSymbols,
   prewarmCodeGraphIfProject,
-  buildCodeGraphAsync,
   _buildCodeGraph,
   _postCodeGraphWorkerSuccess,
 } from './code-graph/build.mjs';
-export {
-  executeCodeGraphTool,
-  isCodeGraphTool,
-} from './code-graph/dispatch.mjs';
+export { executeCodeGraphTool } from './code-graph/dispatch.mjs';

package/src/runtime/agent/orchestrator/tools/graph-manifest.json

@@ -1,30 +1,30 @@
 {
-  "version": "0.1.34",
+  "version": "0.1.35",
   "_comment": "Synced from immutable graph-v release assets.",
   "assets": {
     "darwin-arm64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.34/mixdog-graph-darwin-arm64",
-      "sha256": "5bcf8c79135224d2e77eec70a57debd06d462bab01418ce1a6c1656a858eedad"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.35/mixdog-graph-darwin-arm64",
+      "sha256": "f7a6a0bf10e4a541e9f7c529388fc14401b5f1727a5e8629fbeaf17c094300b2"
     },
     "darwin-x64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.34/mixdog-graph-darwin-x64",
-      "sha256": "2845ea2afa2802841589bd74c8785670cfe8c6b58b2ad5b258ac928afccbaa94"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.35/mixdog-graph-darwin-x64",
+      "sha256": "a0d2bc124e264f7c5699af71adae3f047ee07591ddff415274bea23935bdbb75"
     },
     "linux-arm64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.34/mixdog-graph-linux-arm64",
-      "sha256": "0364bc1c3741683fbdb45ed755f2baabb50a0556e2354c13a05f3d816bc1c461"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.35/mixdog-graph-linux-arm64",
+      "sha256": "ed5d75b8cd3a4de5366c233cfd55b07931b56fac7dd82fadad6a7b172ced97ed"
     },
     "linux-x64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.34/mixdog-graph-linux-x64",
-      "sha256": "4f9091b2c5a89631efade89aae17e5411dda8bfec99e15ff64948906f9fa20d0"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.35/mixdog-graph-linux-x64",
+      "sha256": "b9b54529264d93648c16142ad05ba706c2757304688ccbf7d89e1a46762f4c13"
     },
     "win32-arm64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.34/mixdog-graph-win32-arm64.exe",
-      "sha256": "03abef6f09b095b86c5cc32c6bead3f5d82f77961220c31221ab0b3f60974110"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.35/mixdog-graph-win32-arm64.exe",
+      "sha256": "dd9fb667ddeb366dbfeabf58b3023e8b0f40b09edccc50dc5902b33de97de233"
     },
     "win32-x64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.34/mixdog-graph-win32-x64.exe",
-      "sha256": "650cffe82ccbe9898e7ac8fc9b025c92098a810ad3ca95276c0bb8c19a328993"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.35/mixdog-graph-win32-x64.exe",
+      "sha256": "be2abdb0b1c28647332531ac149a4ebba17e8cfb7093b7d5694a4be8bd21e369"
     }
   }
 }