mixdog 1.4.0 → 1.4.1

package/src/runtime/agent/orchestrator/tools/builtin/lib/scoped-search-flight.mjs

@@ -8,11 +8,15 @@ import {
 // A shared scan's outcome belongs to every subscriber, not only the caller
 // whose computation won admission. Persisted cache hits contain safe text.
 export async function runScopedSearchInFlight(key, compute, options, outcome) {
-  const settled = await runResultCacheInFlight(key, async ({ signal }) => {
-    const scopedCacheOutcome = createScopedCacheOutcome();
-    const result = await compute({ signal, scopedCacheOutcome });
-    return { result, scopedCacheOutcome };
-  }, options);
+  const settled = await runResultCacheInFlight(
+    key,
+    async ({ signal }) => {
+      const scopedCacheOutcome = createScopedCacheOutcome();
+      const result = await compute({ signal, scopedCacheOutcome });
+      return { result, scopedCacheOutcome };
+    },
+    options
+  );
   if (typeof settled === 'string') return settled;
   if (settled.scopedCacheOutcome.complete === false) markScopedCacheIncomplete(outcome);
   if (settled.scopedCacheOutcome.cacheSafe === false) markScopedCacheUnsafe(outcome);

package/src/runtime/agent/orchestrator/tools/builtin/read-single-stream.mjs

@@ -53,7 +53,13 @@ export async function streamRangeResult(ctx, { source, fileHandle, prefixBuffer
       res.firstEmitted && res.lastEmitted ? [{ startLine: res.firstEmitted, endLine: res.lastEmitted }] : [];
     const snapshotMeta = { source, ranges, rangeHashes: _rangeHashesFromRenderedReadText(res.text, ranges) };
     if (!res.readSnapshotStat) return res.text;
-    return await commitStreamResult({ ...ctx, st: res.readSnapshotStat }, res.text, snapshotMeta, res.prefixHash, helpers);
+    return await commitStreamResult(
+      { ...ctx, st: res.readSnapshotStat },
+      res.text,
+      snapshotMeta,
+      res.prefixHash,
+      helpers
+    );
   } catch (err) {
     return `Error: ${normalizeErrorMessage(err instanceof Error ? err.message : String(err))}`;
   }

package/src/runtime/agent/orchestrator/tools/builtin/read-streaming.mjs

@@ -137,9 +137,12 @@ async function readRangeFromHandle(fh, fullPath, offset, limit, stHint, hooks) {
   }
   if (!stop) lines.finishTail();
   let readSnapshotStat = null;
-  if (!(await publishReadRangeIndex(rangeIndex, fh, null, checkDeadline, (version) => {
-    readSnapshotStat = version;
-  }))) checkDeadline();
+  if (
+    !(await publishReadRangeIndex(rangeIndex, fh, null, checkDeadline, (version) => {
+      readSnapshotStat = version;
+    }))
+  )
+    checkDeadline();
 
   ioTraceDone('read_range_stream', traceStart, {
     pathHash: hashText(fullPath).slice(0, 12),

package/src/runtime/agent/orchestrator/tools/builtin/read-tool/batch-dispatch.mjs

@@ -41,7 +41,7 @@ async function estimateTaskBytes(entry, workDir) {
   const st = await stat(resolvePath(workDir || '.', String(entry?.path || ''))).catch(() => null);
   if (!st?.isFile()) return Infinity;
   const lines = Math.max(1, st.size / AVG_LINE_BYTES);
-  let need = st.size + st.size / MIN_LINE_BYTES * LINE_PREFIX_BYTES;
+  let need = st.size + (st.size / MIN_LINE_BYTES) * LINE_PREFIX_BYTES;
   // A coalesced entry reads its whole union window, not only its own slot.
   const limit = Number(readEntryCoalescedDiskWindow(entry)?.limit ?? entry?.limit);
   if (Number.isFinite(limit) && limit > 0) need *= Math.min(1, limit / lines);

package/src/runtime/agent/orchestrator/tools/builtin/read-tool/batch-publication.mjs

@@ -85,10 +85,14 @@ export async function runBatchReadSnapshotPublication(executeChildBuiltinTool, h
       // A numbered row may end halfway through its content at the byte cap.
       // Only this slot's producer can certify complete lines; another read of
       // the same path must not authorize hashing this slot's partial text.
-      return mergeReadRanges(ranges.flatMap((range) => (observation?.ranges ?? []).map((complete) => ({
-        startLine: Math.max(range.startLine, complete.startLine),
-        endLine: Math.min(range.endLine, complete.endLine),
-      }))));
+      return mergeReadRanges(
+        ranges.flatMap((range) =>
+          (observation?.ranges ?? []).map((complete) => ({
+            startLine: Math.max(range.startLine, complete.startLine),
+            endLine: Math.min(range.endLine, complete.endLine),
+          }))
+        )
+      );
     },
     _recordReadSnapshot: (fullPath, _st, scope, meta) => {
       corrections.set(fullPath, { scope: scope ?? null, meta });
@@ -104,22 +108,29 @@ export async function runBatchReadSnapshotPublication(executeChildBuiltinTool, h
     }
     for (const [fullPath, correction] of corrections) {
       const delivered = tasks.filter((task) => task.fullPath === fullPath && hasRenderedLines(task.body));
-      const observations = delivered.map((task) => task.records.findLast(
-        (record) => record.fullPath === fullPath && record.scope === correction.scope
-      ));
+      const observations = delivered.map((task) =>
+        task.records.findLast((record) => record.fullPath === fullPath && record.scope === correction.scope)
+      );
       // Never combine different versions or bless stale/missing observations.
       // The eventual recorder rechecks the retained lease after all awaits.
-      if (observations.length && observations.every((record) =>
-        record?.isCurrent() && sameFileVersion(record.identity, observations[0].identity)
-      )) {
+      if (
+        observations.length &&
+        observations.every(
+          (record) => record?.isCurrent() && sameFileVersion(record.identity, observations[0].identity)
+        )
+      ) {
         observations[0].publish(correction.meta);
       }
     }
     // Rich media/binary results have no line slices. Preserve their original
     // evidence, still under the producer's lease rather than the batch's.
     for (const task of tasks) {
-      if (hasRenderedLines(task.body) || task.body?.isError === true ||
-          (typeof task.body === 'string' && helpers.classifyResultKind(task.body) === 'error')) continue;
+      if (
+        hasRenderedLines(task.body) ||
+        task.body?.isError === true ||
+        (typeof task.body === 'string' && helpers.classifyResultKind(task.body) === 'error')
+      )
+        continue;
       for (const record of task.records) {
         if (!corrections.has(record.fullPath)) record.publish();
       }

package/src/runtime/agent/orchestrator/tools/builtin/read-tool/batch-snapshot.mjs

@@ -69,7 +69,12 @@ async function rawRangeHashes(fullPath, mergedRanges, { _hashText }) {
 
 export async function recordSlicedBatchSnapshots(orderedResults, workDir, readStateScope, helpers) {
   const { _mergeReadRanges, _recordReadSnapshot } = helpers;
-  const { exactRangesByPath, rangeHashesByPath } = deliveredRangesByPath(orderedResults, workDir, readStateScope, helpers);
+  const { exactRangesByPath, rangeHashesByPath } = deliveredRangesByPath(
+    orderedResults,
+    workDir,
+    readStateScope,
+    helpers
+  );
   for (const [fullPath, ranges] of exactRangesByPath) {
     const mergedRanges = _mergeReadRanges(ranges);
     let rangeHashes = rangeHashesByPath.get(fullPath) || [];

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

@@ -112,14 +112,7 @@ export async function executeReadTool(args, ...rest) {
   return `${out}\n[skipped ${skipped.length} more file(s) over the per-call limit: ${skipped.join(', ')} — read them in another call]`;
 }
 
-async function executeReadToolBody(
-  args,
-  workDir,
-  readStateScope,
-  executeChildBuiltinTool,
-  options = {},
-  helpers = {}
-) {
+async function executeReadToolBody(args, workDir, readStateScope, executeChildBuiltinTool, options = {}, helpers = {}) {
   const { normalizeInputPath, normaliseReadLineWindowArgs } = helpers;
   applyFilePathAlias(args);
   args.path = coerceReadFamilyPathArg(args.path);

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.34",
   "_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.34/mixdog-graph-darwin-arm64",
+      "sha256": "5bcf8c79135224d2e77eec70a57debd06d462bab01418ce1a6c1656a858eedad"
     },
     "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.34/mixdog-graph-darwin-x64",
+      "sha256": "2845ea2afa2802841589bd74c8785670cfe8c6b58b2ad5b258ac928afccbaa94"
     },
     "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.34/mixdog-graph-linux-arm64",
+      "sha256": "0364bc1c3741683fbdb45ed755f2baabb50a0556e2354c13a05f3d816bc1c461"
     },
     "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.34/mixdog-graph-linux-x64",
+      "sha256": "4f9091b2c5a89631efade89aae17e5411dda8bfec99e15ff64948906f9fa20d0"
     },
     "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.34/mixdog-graph-win32-arm64.exe",
+      "sha256": "03abef6f09b095b86c5cc32c6bead3f5d82f77961220c31221ab0b3f60974110"
     },
     "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.34/mixdog-graph-win32-x64.exe",
+      "sha256": "650cffe82ccbe9898e7ac8fc9b025c92098a810ad3ca95276c0bb8c19a328993"
     }
   }
 }

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',

package/src/runtime/agent/orchestrator/tools/lib/shell-warm-standby.mjs

@@ -55,8 +55,13 @@ function _disabled() {
   return process.env.MIXDOG_SHELL_WARM_STANDBY === '0';
 }
 
+// Per-session scratch variables: they differ between sessions by design, so
+// they stay out of the reuse signature and are set in the hand-off prelude.
+const SCRATCH_ENV_KEYS = Object.freeze(['TEMP', 'TMP', 'TMPDIR']);
+
 function envSignature(env) {
   const entries = Object.entries(env || {})
+    .filter(([key]) => !SCRATCH_ENV_KEYS.includes(key))
     .map(([key, value]) => `${key}=${value}`)
     .sort()
     .join('\n');
@@ -67,8 +72,16 @@ function _slotAlive(slot) {
   return Boolean(slot?.native?.child && slot.native.child.exitCode == null && !slot.native.child.killed);
 }
 
-function psQuote(value) {
-  return String(value).replace(/'/g, "''");
+// A PowerShell expression yielding `value` for any text. PowerShell quoting has
+// no safe form for typographic apostrophes and the like, so the value travels
+// as UTF-8 Base64 and is decoded inside the expression.
+function psStringExpr(value) {
+  return `[System.Text.Encoding]::UTF8.GetString([System.Convert]::FromBase64String('${Buffer.from(String(value), 'utf8').toString('base64')}'))`;
+}
+
+/** The parked standby slot, for tests. */
+export function _parkedShellStandbyForTest() {
+  return _slot;
 }
 
 /** Pre-spawn the next standby (fire-and-forget; a live one is kept). */
@@ -164,9 +177,18 @@ export function takeWarmShellStandby({ shell, env }) {
     // cwd prelude: the standby was spawned in the daemon cwd. Set-Location
     // fixes $PWD and native-child working dirs; Environment.CurrentDirectory
     // fixes .NET relative-path APIs.
-    const prelude = workDir
-      ? `Set-Location -LiteralPath '${psQuote(workDir)}'; [System.Environment]::CurrentDirectory = '${psQuote(workDir)}'; `
+    const cwdPrelude = workDir
+      ? `$__mixdogCwd = ${psStringExpr(workDir)}; Set-Location -LiteralPath $__mixdogCwd; [System.Environment]::CurrentDirectory = $__mixdogCwd; `
       : '';
+    // Scratch prelude: the standby was spawned for whichever session parked
+    // it. Set (or clear, when the request has none) the requested values
+    // before the command runs, so no other session's scratch path survives.
+    const scratchPrelude = SCRATCH_ENV_KEYS.map((key) =>
+      typeof env?.[key] === 'string'
+        ? `$env:${key} = ${psStringExpr(env[key])}; `
+        : `Remove-Item -LiteralPath 'Env:${key}' -ErrorAction SilentlyContinue; `
+    ).join('');
+    const prelude = scratchPrelude + cwdPrelude;
     // Single atomic write+EOF: a separate close message can race ahead
     // of the server's async write thread and feed an empty script.
     slot.native.child.writeStdin(prelude + String(commandText ?? ''), { close: true });

package/src/runtime/channels/lib/webhook/signature.mjs

@@ -46,7 +46,10 @@ function verifySignature(secret, rawBody, signatureValue, parser) {
     if (!vMatch || !tMatch) return false;
     const ts = Number(tMatch[1]);
     if (!Number.isFinite(ts) || Math.abs(Date.now() - ts * 1000) > STRIPE_TOLERANCE_MS) return false;
-    const expected = crypto.createHmac('sha256', secret).update(Buffer.concat([Buffer.from(`${tMatch[1]}.`), Buffer.from(rawBody)])).digest('hex');
+    const expected = crypto
+      .createHmac('sha256', secret)
+      .update(Buffer.concat([Buffer.from(`${tMatch[1]}.`), Buffer.from(rawBody)]))
+      .digest('hex');
     return hexDigestsEqual(vMatch[1], expected);
   }
   const expected = crypto.createHmac('sha256', secret).update(rawBody).digest('hex');

package/src/runtime/channels/lib/whisper-port.mjs

@@ -1,6 +1,7 @@
 import net from 'node:net';
 import path from 'node:path';
 import { execFile } from 'node:child_process';
+import { FETCH_BLOCKED_PORTS, FETCH_SAFE_ATTEMPTS } from '../../shared/fetch-safe-listen.mjs';
 
 // whisper.cpp cannot bind port 0 itself. Ask the OS for an available port,
 // release the reservation immediately before spawn, then verify the listener's
@@ -15,9 +16,17 @@ export function selectWhisperPort(host, preferred) {
         server.close((error) => (error ? reject(error) : resolve(selected)));
       });
     });
+  // The server is reached with fetch, which refuses a "bad port" the OS may assign.
+  const reserveFetchSafe = async () => {
+    for (let attempt = 0; attempt <= FETCH_SAFE_ATTEMPTS; attempt += 1) {
+      const port = await reserve(0);
+      if (!FETCH_BLOCKED_PORTS.has(port)) return port;
+    }
+    throw new Error('no fetch-safe loopback port was assigned');
+  };
   return reserve(preferred).catch((error) => {
     if (error.code !== 'EADDRINUSE' && error.code !== 'EACCES') throw error;
-    return reserve(0);
+    return reserveFetchSafe();
   });
 }
 

package/src/runtime/computer-bridge/action-schema.mjs

@@ -362,13 +362,13 @@ export const COMPUTER_ACTION_CONTRACTS = [
           type: 'string',
           minLength: 1,
           description:
-            "Fallback sign-in in the user's own browser; prefer its existing session/SSO or Browser Use's saved sign-in. Saved login (username or masked label; a miss lists the site's labels) written after host checks into the focused field of a Chrome/Edge HTTPS page. The site receives it. A password is kept from you and its browser's pixels are withheld this turn, but a page that redisplays it can expose it, and other programs of the same Windows user are outside this protection; a username is not hidden. On refusal hand the secret to the user (ask_user secret, surface computer).",
+            "Fallback sign-in in the user's own browser; prefer its existing session/SSO or Browser Use's saved sign-in. Saved login (username or masked label; a miss lists the site's labels) written after host checks into the focused field of a Chrome/Edge HTTPS page. The site receives it. A password is kept from you and its browser's pixels are withheld this turn, but a page that redisplays it can expose it, and other programs of the same Windows user are outside this protection; a username is not hidden. On refusal hand the secret to the user (handoff_user secret, surface computer).",
         },
         field: {
           type: 'string',
           enum: SAVED_LOGIN_FIELDS,
           description:
-            "username (text field) or password (password field). One-time codes, passkeys, security keys and app approvals are the user's step: ask_user takeover.",
+            "username (text field) or password (password field). One-time codes, passkeys, security keys and app approvals are the user's step: handoff_user takeover.",
         },
       },
       ['savedAccount', 'field']

package/src/runtime/computer-bridge/core-actions.mjs

@@ -74,13 +74,13 @@ export const COMPUTER_CORE_ACTION_SCHEMA = {
     text: {
       type: 'string',
       maxLength: 30_000,
-      description: `Literal text; foreground cap ${MAX_COMPUTER_FOREGROUND_TEXT_CHARS} UTF-16 code units per action. Never a password or one-time code, even one shown on screen: saved_login or ask_user.`,
+      description: `Literal text; foreground cap ${MAX_COMPUTER_FOREGROUND_TEXT_CHARS} UTF-16 code units per action. Never a password or one-time code, even one shown on screen: saved_login or handoff_user.`,
     },
     value: {
       type: 'string',
       maxLength: 30_000,
       description:
-        'set_value replacement for an element that advertises set_value; writes the control directly, without focus or keystrokes. Never a password or one-time code, even one shown on screen: saved_login or ask_user.',
+        'set_value replacement for an element that advertises set_value; writes the control directly, without focus or keystrokes. Never a password or one-time code, even one shown on screen: saved_login or handoff_user.',
     },
     keys: {
       type: 'string',

package/src/runtime/computer-bridge/error-recovery.mjs

@@ -31,8 +31,9 @@ const CLEANUP_CODES = new Set([
 const PIXEL_CODES = new Set(['pixel_unavailable', 'observation_unavailable']);
 // Saved-login refusals made before anything was written (host/saved-login.ts).
 const SAVED_LOGIN_REFUSAL_CODES = new Set(['saved_login_refused', 'saved_login_changed', 'saved_login_unavailable']);
-const SECRET_HANDOFF = 'hand the secret to the user with ask_user (kind "secret", surface "computer")';
-const STEP_HANDOFF = 'hand the step to the user with ask_user (kind "takeover", surface "computer", need "sign_in")';
+const SECRET_HANDOFF = 'hand the secret to the user with handoff_user (kind "secret", surface "computer")';
+const STEP_HANDOFF =
+  'hand the step to the user with handoff_user (kind "takeover", surface "computer", need "sign_in")';
 // Reads send no input, so their timeout is a provider budget, not an uncertain
 // mutation: the caller needs another read route, not a cleanup investigation.
 const READ_ONLY_ACTIONS = new Set(['capture', 'list', 'diagnose', 'verify']);
@@ -157,14 +158,14 @@ function recoveryForCode(code, args) {
   if (SAVED_LOGIN_REFUSAL_CODES.has(code)) {
     return {
       code,
-      next: 'ask_user',
+      next: 'handoff_user',
       guidance: `Nothing was written. If the refusal lists stored masked labels and the user's account is one of them, use that label; otherwise ${SECRET_HANDOFF}. Never type the secret yourself or try another window or field to get past the check.`,
     };
   }
   if (code === 'saved_login_unconfirmed') {
     return {
       code,
-      next: 'ask_user',
+      next: 'handoff_user',
       guidance: `The saved value may have been written. Do not call saved_login again for this field and do not type it yourself; ${STEP_HANDOFF} to check the field and finish signing in.`,
     };
   }

package/src/runtime/computer-bridge/linux-action-capabilities.mjs

@@ -14,15 +14,34 @@
 //   pointer/keyboard the input device (uinput on Wayland, XTest on X11).
 
 const WINDOW_ACTIONS = new Set([
-  'list_windows', 'window_snapshot', 'related_windows', 'window_bounds', 'window_capture',
-  'window_integrity', 'validate_background_input', 'list_apps', 'verify', 'focus_window',
-  'move_window', 'window_state', 'close_window', 'terminate_process',
+  'list_windows',
+  'window_snapshot',
+  'related_windows',
+  'window_bounds',
+  'window_capture',
+  'window_integrity',
+  'validate_background_input',
+  'list_apps',
+  'verify',
+  'focus_window',
+  'move_window',
+  'window_state',
+  'close_window',
+  'terminate_process',
 ]);
 const ACCESSIBILITY_ACTIONS = new Set(['snapshot', 'find', 'window_predicates', 'accessibility_probe']);
 const SEMANTIC_ACTIONS = new Set(['invoke', 'set_value', 'toggle', 'invoke_menu']);
 const POINTER_ACTIONS = new Set([
-  'click', 'double_click', 'right_click', 'middle_click', 'triple_click',
-  'mouse_down', 'mouse_up', 'mouse_move', 'drag', 'scroll',
+  'click',
+  'double_click',
+  'right_click',
+  'middle_click',
+  'triple_click',
+  'mouse_down',
+  'mouse_up',
+  'mouse_move',
+  'drag',
+  'scroll',
 ]);
 const KEYBOARD_ACTIONS = new Set(['type', 'key', 'key_down', 'key_up']);
 

package/src/runtime/computer-bridge/linux-readiness.d.mts

@@ -35,7 +35,10 @@ export interface LinuxComputerRefusal {
 export const MIN_WINDOW_HELPER_VERSION: number;
 export const CAPABILITY_UNAVAILABLE_CODE: 'computer_capability_unavailable';
 export function detectSession(env: Record<string, string | undefined>): 'wayland' | 'x11';
-export function detectDesktop(env: Record<string, string | undefined>, session: 'wayland' | 'x11'): LinuxComputerReadiness['desktop'];
+export function detectDesktop(
+  env: Record<string, string | undefined>,
+  session: 'wayland' | 'x11'
+): LinuxComputerReadiness['desktop'];
 export function checkLinuxComputerReadiness(options?: Record<string, unknown>): Promise<LinuxComputerReadiness>;
 export function getLinuxComputerReadiness(options?: Record<string, unknown>): Promise<LinuxComputerReadiness>;
 export function missingCapabilities(
@@ -47,4 +50,6 @@ export function resetLinuxComputerPreflightCache(): void;
 export const GNOME_EXTENSION_UUID: 'mixdog-windows@mixdog.io';
 export function gnomeExtensionDirs(env?: Record<string, string | undefined>): string[];
 export const CAPTURE_FALLBACK_NOTE: string;
-export function linuxCaptureFallback(options?: Record<string, unknown>): Promise<{ command: Record<string, unknown>; note: string } | null>;
+export function linuxCaptureFallback(
+  options?: Record<string, unknown>
+): Promise<{ command: Record<string, unknown>; note: string } | null>;

package/src/runtime/local-provider/server-process.mjs

@@ -4,13 +4,14 @@ import { setTimeout as delay } from 'node:timers/promises';
 import { redactedLog, spawnServerState } from './server-process/child-state.mjs';
 import { awaitServerReady } from './server-process/readiness.mjs';
 import { createSerialChain } from './serial-chain.mjs';
+import { listenOnFetchSafePort } from '../shared/fetch-safe-listen.mjs';
 
 async function freeLoopbackPort() {
   return new Promise((resolve, reject) => {
     const probe = createServer();
     probe.unref();
     probe.once('error', reject);
-    probe.listen(0, '127.0.0.1', () => {
+    listenOnFetchSafePort(probe, '127.0.0.1', () => {
       const port = probe.address().port;
       probe.close((error) => (error ? reject(error) : resolve(port)));
     });

package/src/runtime/media/adapters/gemini-video.mjs

@@ -120,7 +120,10 @@ async function generateViaVeo({ model, prompt, options, references = [], signal,
     // Veo reports no usage; it bills per generated second. The response does
     // not echo the length, so the requested one (default 8s) is the billed one.
     // A failed download still leaves the generated seconds billed.
-    const usage = { seconds: parameters.durationSeconds || VEO_DEFAULT_SECONDS, resolution: parameters.resolution || '720p' };
+    const usage = {
+      seconds: parameters.durationSeconds || VEO_DEFAULT_SECONDS,
+      resolution: parameters.resolution || '720p',
+    };
     // The download is part of the generation budget: unbounded, it held an
     // active job slot (and the upstream connection) open indefinitely after
     // the poll loop finished.

package/src/runtime/media/adapters/xai-media.mjs

@@ -120,7 +120,8 @@ export async function generateVideo({ lane, model, prompt, options = {}, referen
       // let the catalog's per-second rate price it otherwise.
       const seconds = Number(data?.video?.duration) || duration;
       const usage = { ...xaiUsage(data?.usage), seconds, resolution };
-      if (!url) throw withReportedUsage(mediaError('xAI video finished without a URL', 'MEDIA_EMPTY_RESULT', 502), usage);
+      if (!url)
+        throw withReportedUsage(mediaError('xAI video finished without a URL', 'MEDIA_EMPTY_RESULT', 502), usage);
       const bytes = await downloadPublicMedia(url, { signal, label: 'xAI video' }).catch((error) => {
         throw withReportedUsage(error, usage);
       });

package/src/runtime/memory/lib/embedding-worker.mjs

@@ -300,7 +300,11 @@ async function loadTokenizer() {
 async function createExtractor(device) {
   const ort = loadOrt();
   const encode = await loadTokenizer();
-  const graphPath = await ensureModelGraph(MODEL_CACHE_DIR, MODEL_ID, getEmbeddingModelGraphFile(MODEL_ID, configuredDtype));
+  const graphPath = await ensureModelGraph(
+    MODEL_CACHE_DIR,
+    MODEL_ID,
+    getEmbeddingModelGraphFile(MODEL_ID, configuredDtype)
+  );
   const session = await ort.InferenceSession.create(graphPath, {
     executionProviders: [device],
     intraOpNumThreads: INTRA_OP_THREADS,
@@ -397,8 +401,7 @@ async function loadExtractor() {
             } catch (e) {
               // Unprivileged processes cannot raise priority back (EACCES/EPERM);
               // on Linux that is expected, not a stuck state worth warning about.
-              const expectedOnLinux =
-                process.platform === 'linux' && /EACCES|EPERM/.test(`${e?.code} ${e?.message}`);
+              const expectedOnLinux = process.platform === 'linux' && /EACCES|EPERM/.test(`${e?.code} ${e?.message}`);
               if (!expectedOnLinux) {
                 __mixdogMemoryLog(
                   `[embed-worker] WARN: process priority stuck below normal (restore failed: ${e?.message || e})\n`

package/src/runtime/memory/lib/memory-action-handlers/cycle-backfill-action.mjs

@@ -6,13 +6,7 @@
 import { runFullBackfill } from '../memory-ops-policy.mjs';
 import { throwIfAborted } from '../memory-cycle-shared.mjs';
 
-export function createBackfillAction({
-  getDb,
-  dataDir,
-  awaitCycle1Run,
-  ingestTranscriptFile,
-  cwdFromTranscriptPath,
-}) {
+export function createBackfillAction({ getDb, dataDir, awaitCycle1Run, ingestTranscriptFile, cwdFromTranscriptPath }) {
   // Whole-action backfill mutex (transport-agnostic). memory-cycle1's
   // _runCycle1InFlight only protects cycle1; ingest workers
   // (memory-ops-policy.mjs) can still overlap if a second backfill

package/src/runtime/memory/lib/memory-chunk-quality.mjs

@@ -315,12 +315,7 @@ function createCycle1PacketGenerator({ callLlm, request, signal, inputTokenBudge
 
 export async function generateCycle1Chunks(
   rows,
-  {
-    callLlm,
-    request = {},
-    inputTokenBudget = CYCLE1_INPUT_TOKEN_BUDGET,
-    signal = request.signal,
-  } = {}
+  { callLlm, request = {}, inputTokenBudget = CYCLE1_INPUT_TOKEN_BUDGET, signal = request.signal } = {}
 ) {
   const startedAt = Date.now();
   const stats = { groupingCalls: 0, verificationCalls: 0, llmMs: 0, verificationMs: 0, retries: 0, fragments: 0 };

package/src/runtime/office/authoring/pdf-author-action.mjs

@@ -22,12 +22,7 @@ import {
 } from '../core/office-sessions.mjs';
 import { snapshotPdf } from '../pdf/pdf-adapter.mjs';
 import { inlineOfficeAudit } from '../quality/inline-audit.mjs';
-import {
-  factsGate,
-  parseAuthoringBrief,
-  reviewBriefPromises,
-  reviewSourceGrounding,
-} from './pptx-brief.mjs';
+import { factsGate, parseAuthoringBrief, reviewBriefPromises, reviewSourceGrounding } from './pptx-brief.mjs';
 import { editsReplacedByAuthor, markAuthoredFromHtml } from './html-source-drift.mjs';
 import { hasSlideSections, htmlBriefScript, runPptxHtmlAuthoring } from './pptx-html-runner.mjs';
 import {