mixdog 1.4.0 → 1.4.2

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

@@ -1,6 +1,7 @@
 import { readdirSync, readFileSync, statSync } from 'node:fs';
 import { spawnSync } from 'node:child_process';
 import { readdir as readdirAsync } from 'node:fs/promises';
+import { startGitSync } from '../../../../shared/git-launch.mjs';
 import { runGitOffThread } from '../../../../shared/git-runner.mjs';
 import { findPathExecutable } from '../../../../shared/path-executable.mjs';
 import { dirname as pathDirname, join as pathJoin, resolve as pathResolveAbsolute } from 'node:path';
@@ -161,13 +162,15 @@ function _changeStateArgs(root) {
 
 function _probeRepositoryChangeStateSync(root) {
   try {
-    const result = spawnSync('git', _changeStateArgs(root), {
-      encoding: 'utf8',
-      env: { ...process.env, GIT_OPTIONAL_LOCKS: '0' },
-      maxBuffer: 64 * 1024,
-      timeout: 1500,
-      windowsHide: true,
-    });
+    const result = startGitSync({ ...process.env, GIT_OPTIONAL_LOCKS: '0' }, (command, env) =>
+      spawnSync(command, _changeStateArgs(root), {
+        encoding: 'utf8',
+        env,
+        maxBuffer: 64 * 1024,
+        timeout: 1500,
+        windowsHide: true,
+      })
+    );
     const output = String(result.stdout || '').trim();
     if (result.status === 0) return output ? 'changes present' : 'clean';
     if (result.error?.code === 'ENOBUFS' && output) return 'changes present';
@@ -271,14 +274,16 @@ function _checkIgnoreArgs(directory) {
 
 function _probeGitIgnoredEntriesSync(directory, names) {
   try {
-    const result = spawnSync('git', _checkIgnoreArgs(directory), {
-      encoding: 'utf8',
-      input: `${names.join('\0')}\0`,
-      env: { ...process.env, GIT_OPTIONAL_LOCKS: '0' },
-      maxBuffer: 1024 * 1024,
-      timeout: 1500,
-      windowsHide: true,
-    });
+    const result = startGitSync({ ...process.env, GIT_OPTIONAL_LOCKS: '0' }, (command, env) =>
+      spawnSync(command, _checkIgnoreArgs(directory), {
+        encoding: 'utf8',
+        input: `${names.join('\0')}\0`,
+        env,
+        maxBuffer: 1024 * 1024,
+        timeout: 1500,
+        windowsHide: true,
+      })
+    );
     // Exit 1 is "nothing ignored", not a failure.
     if (result.status !== 0 && result.status !== 1) return new Set();
     return new Set(

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,45 @@ 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 +461,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 +490,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 +644,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 +678,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 +768,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 +778,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/code-graph/dispatch/federation.mjs

@@ -129,7 +129,9 @@ function federateRoots(name, args, plan, signal, options, execute) {
   }
   const runOne = async (root, nextArgs) =>
     execute(name, nextArgs, root, signal, { ...options, excludedProjectRoots: excludedRootsFor(root, roots) });
-  const work = _runCodeGraphFederation(roots, runOne, projectArgs, options.scopedCacheOutcome).then((sections) => sections.join('\n\n'));
+  const work = _runCodeGraphFederation(roots, runOne, projectArgs, options.scopedCacheOutcome).then((sections) =>
+    sections.join('\n\n')
+  );
   return raceAbort(work, signal);
 }
 

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

@@ -26,7 +26,7 @@ export const CODE_GRAPH_TOOL_DEFS = [
       compressibleLossless: true,
     },
     description:
-      'Code structure and relations from the parsed graph, no text matching. symbols → file outline rows `[export ]kind name (Lstart-end) signature`; find_symbol returns declaration/body; references adds usages (body opt-in); callers/callees return locations; dependents/impact → importers and blast radius. Exact identifiers: find_symbol/references/callers/callees; keywords: symbol_search/search; literal text and regex belong to grep. Prefer it over read/grep for declarations and relations; every row’s location is a read window. symbols already outlines a file: never pair it with overview for one need.',
+      'Code structure and relations from the parsed graph, no text matching. symbols → file outline rows `[export ]kind name (Lstart-end) signature`; find_symbol returns declaration/body; references adds usages; callers/callees return locations; dependents/impact → importers and blast radius. Exact identifiers: find_symbol/references/callers/callees; keywords: symbol_search/search; literal text and regex belong to grep. Prefer it over read/grep for declarations and relations. symbols already outlines a file: never pair it with overview for one need.',
     inputSchema: {
       type: 'object',
       properties: {

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

@@ -1,30 +1,30 @@
 {
-  "version": "0.1.33",
+  "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.33/mixdog-graph-darwin-arm64",
-      "sha256": "8637d61493eddca3eee80620a64e737f12eead44ea899ad19a18966a3843ff3a"
+      "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.33/mixdog-graph-darwin-x64",
-      "sha256": "49ce311687c3df7e7080ecb7694219c9b51bbbb272864aa43d2102a8baa83550"
+      "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.33/mixdog-graph-linux-arm64",
-      "sha256": "2e2a4ea6dccc5b33f583040b0ee6e8d47f93a1e879eb17343acd0b2f9838696f"
+      "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.33/mixdog-graph-linux-x64",
-      "sha256": "2cd1caa7f39e183d6fb6f7764f49e9a0643863d137c2bfb5f40bb7ac616c8d73"
+      "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.33/mixdog-graph-win32-arm64.exe",
-      "sha256": "592dfa7e95e1e91424c7467e74f35d09758de502be403b7d229444b435600392"
+      "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.33/mixdog-graph-win32-x64.exe",
-      "sha256": "0ed17859a39f0160421865f3a3486ce53957b836ee164d606434519b85b90830"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.35/mixdog-graph-win32-x64.exe",
+      "sha256": "be2abdb0b1c28647332531ac149a4ebba17e8cfb7093b7d5694a4be8bd21e369"
     }
   }
 }

package/src/runtime/agent/orchestrator/tools/lib/isolated-test-env.mjs

@@ -1,9 +1,10 @@
-import { mkdirSync, mkdtempSync } from 'node:fs';
-import { tmpdir } from 'node:os';
+import { mkdirSync } from 'node:fs';
 import { join } from 'node:path';
+import { makeTempDirSync } from '../../../../../../scripts/lib/scoped-temp.mjs';
 
 // Import before runtime modules: several paths are captured at module load.
-export const fixtureRoot = mkdtempSync(join(tmpdir(), 'mixdog-shell-fixture-'));
+// Removed when the importing test process exits.
+export const fixtureRoot = makeTempDirSync('shell-fixture');
 for (const name of [
   'HOME',
   'USERPROFILE',