mixdog 1.4.0 → 1.4.2

package/src/runtime/agent/orchestrator/tools/lib/shell-run-state.mjs

@@ -6,13 +6,31 @@
 import { randomUUID } from 'node:crypto';
 import { publishForegroundShellRecord, retireForegroundShellRecord } from '../builtin/shell-jobs.mjs';
 import { ShellTextDecoder, TaskOutput, treeKill } from '../shell-exec-output.mjs';
-import { createProcessTreeTracker, killAfterSnapshot } from './shell-descendants.mjs';
+import { createContainedTreeTracker, createProcessTreeTracker } from './shell-descendants.mjs';
 import { registerOwnedShellTree } from './owned-shell-trees.mjs';
 
+/** The tracker of the run's process tree, created once. A killed tree the
+ *  spawn server contains is gone on its verified-empty report alone; every
+ *  other tree (no containment, or a root that exited on its own and left
+ *  survivors) is observed through the process table. */
+export function runTreeTracker(run) {
+  run.terminationTracker =
+    run.terminationTracker ||
+    (run.killed === true && run.child.contained === true
+      ? createContainedTreeTracker({
+          outcome: () => run.child.treeOutcome,
+          // Survivors the server kept in the job: the kill, by request id.
+          cancel: () => treeKill(run.child),
+        })
+      : createProcessTreeTracker({ pid: run.child.pid, rootCreationTime: run.child.creationTime }));
+  return run.terminationTracker;
+}
+
 /** One pre-kill identity read of the run's tree (every kill path shares it):
- *  resolves true once the capture is complete, false when it failed. */
+ *  resolves true once the capture is complete, false when it failed. A
+ *  contained kill needs none: true at once, so the kill is never delayed. */
 export function capturePreKill(run) {
-  run.terminationTracker = run.terminationTracker || createProcessTreeTracker({ pid: run.child.pid });
+  if (runTreeTracker(run).contained) return true;
   const rootExited = run.child.exitCode != null || run.child.signalCode != null;
   return run.terminationTracker.capture({ rootExited }).catch(() => false);
 }
@@ -32,6 +50,7 @@ export function registerForegroundOwnedTree(run, ownerSessionId) {
       run.killCause = run.killCause || 'session-close';
       // Always a fresh read: an earlier one predates what the run started
       // since. Pending, the kill is sent at the snapshot bound regardless.
+      // A contained tree answers true at once: its cancel is sent at once.
       return capturePreKill(run);
     },
   };
@@ -219,18 +238,23 @@ export function keepTerminationUnconfirmedRecord(run) {
 // Record the tree's identities while the root is still alive, THEN kill: once
 // an intermediate dies its children's parent links dangle and a snapshot taken
 // afterwards can no longer find them.
-// The kill waits for the snapshot at most PROCESS_TABLE_READ_BOUND_MS and is
-// sent whether the snapshot succeeded, failed or is still pending (a late
-// snapshot is still absorbed; a missing one leaves the outcome unknown, so the
-// workspace stays held under the observation loop). The confirmation deadline
-// starts once the kill is actually issued.
+// The kill waits until the snapshot succeeded or failed, never just for a
+// while: a read still in flight takes its table after a kill sent beside it,
+// finds the root gone, and the tree could never be confirmed terminated (the
+// workspace then stays held until a force-release). A healthy table read takes
+// seconds on a loaded host; a stuck one ends at its enumeration deadline
+// (ENUMERATION_DEADLINE_MS), and the kill is sent then, the outcome unknown.
+// A tree the spawn server contains is killed at once instead: its job holds
+// every descendant, and the server reports when that job is empty.
+// The confirmation deadline starts once the kill is actually issued.
 function snapshotThenKill(run, afterKill) {
-  if (!run.child?.pid) {
+  const snapshot = run.child?.pid ? capturePreKill(run) : true;
+  if (snapshot === true) {
     treeKill(run.child);
     afterKill();
     return;
   }
-  void killAfterSnapshot(capturePreKill(run), () => {
+  void snapshot.then(() => {
     treeKill(run.child);
     afterKill();
   });

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). */
@@ -89,6 +102,8 @@ function ensureWarmShellStandby({ shell, env }) {
         outputLimit: SHELL_OUTPUT_DISK_CAP,
         rawOutput: true,
         stdinPipe: true,
+        // The command it is fed runs contained, like a fresh spawn's.
+        contain: true,
         shellType: 'powershell',
         command: '(warm shell standby)',
       },
@@ -164,9 +179,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/agent/orchestrator/tools/lib/wait-until-fixture.mjs

@@ -0,0 +1,26 @@
+// Test support: wait for a real condition on a wall-clock budget. A fixed
+// number of event-loop turns is load-dependent (async record writes and
+// process-table reads take more turns on a busy machine); elapsed time is not.
+// Polls on a short real timer (never a busy loop). The real setTimeout is
+// captured at load, before any test enables mock timers, so a mocked clock
+// cannot freeze the wait.
+import assert from 'node:assert/strict';
+
+const realSetTimeout = setTimeout;
+const POLL_MS = 5;
+const tick = () => new Promise((resolve) => realSetTimeout(resolve, POLL_MS));
+
+/** Resolves with the first truthy `read()` (sync or async); fails with `what`
+ *  once `timeoutMs` has passed without one. */
+export async function waitUntil(
+  read,
+  { timeoutMs = 10_000, what = String(read).replace(/\s+/g, ' ').slice(0, 160) } = {}
+) {
+  const deadline = Date.now() + timeoutMs;
+  for (;;) {
+    const value = await read();
+    if (value) return value;
+    if (Date.now() >= deadline) assert.fail(`condition not reached within ${timeoutMs}ms: ${what}`);
+    await tick();
+  }
+}

package/src/runtime/agent/orchestrator/tools/shell-command.mjs

@@ -432,7 +432,7 @@ function attachChildExit(run, releasePromotedCapture) {
   // child termination regardless — give 'close' a 3 s grace then
   // settle anyway. The grace outlives the spawn server's own 2 s drain
   // deadline, so the real exit status normally still arrives first.
-  child.once('exit', (code, signal) => {
+  const onExit = (code, signal) => {
     if (!run.rootExitAtMs) run.rootExitAtMs = Date.now();
     const grace = setTimeout(() => {
       if (run.settled || run.promotionClose) return;
@@ -449,7 +449,12 @@ function attachChildExit(run, releasePromotedCapture) {
       run.settle(code == null ? 1 : code, signal);
     }, 3000);
     if (grace.unref) grace.unref();
-  });
+  };
+  // The spawn awaits the command's workspace lease before these listeners
+  // exist; a root that exited meanwhile ('close' is replayed, 'exit' is not)
+  // starts its grace now.
+  if (child.exitCode != null || child.signalCode != null) onExit(child.exitCode, child.signalCode);
+  else child.once('exit', onExit);
 }
 
 // Live-progress heartbeat: every 2 s while the foreground command runs, emit

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

@@ -1,30 +1,30 @@
 {
-  "version": "0.1.11",
+  "version": "0.1.12",
   "_comment": "Synced from immutable spawn-v release assets.",
   "assets": {
     "darwin-arm64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/spawn-v0.1.11/mixdog-spawn-darwin-arm64",
-      "sha256": "6f1a7e6597dcc8785d12c5a13c42388110d9f4a2e5378ca2773172adbf50de60"
+      "url": "https://github.com/tribgames/mixdog/releases/download/spawn-v0.1.12/mixdog-spawn-darwin-arm64",
+      "sha256": "bc2307b1c089e07f829a8a1daf4dfdfc128e3221d8f70609ffbdcc3f8b596806"
     },
     "darwin-x64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/spawn-v0.1.11/mixdog-spawn-darwin-x64",
-      "sha256": "ff755eb9848cb3ce90f3df24136bb84a52f9ff6c67002c4d764beb6d7906e6b2"
+      "url": "https://github.com/tribgames/mixdog/releases/download/spawn-v0.1.12/mixdog-spawn-darwin-x64",
+      "sha256": "4b1d221a29128046c417cfae5617e2898e1b7bc564dca686b2608b6cb14bf3af"
     },
     "linux-arm64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/spawn-v0.1.11/mixdog-spawn-linux-arm64",
-      "sha256": "3bc0fccde46537046d498a2b953aa92ef4afacc95c96c563ce1d6fb92d74e593"
+      "url": "https://github.com/tribgames/mixdog/releases/download/spawn-v0.1.12/mixdog-spawn-linux-arm64",
+      "sha256": "2f577f54693726db0d285a16c3af2ad25b73fd705fd2fd4ac5c18ce795f657a9"
     },
     "linux-x64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/spawn-v0.1.11/mixdog-spawn-linux-x64",
-      "sha256": "16dc4e3bf6636335c1325c88bbb5245529731525953466e761d363897b59aac7"
+      "url": "https://github.com/tribgames/mixdog/releases/download/spawn-v0.1.12/mixdog-spawn-linux-x64",
+      "sha256": "83b52edfe2b810d5cf6544b03ab263eedcf7b2ef3c73107a45a33f6f7871e59e"
     },
     "win32-arm64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/spawn-v0.1.11/mixdog-spawn-win32-arm64.exe",
-      "sha256": "c2fb5499d3d44405e27c79f8db65694299d61ddf029f466df68549fc2f2c5f5c"
+      "url": "https://github.com/tribgames/mixdog/releases/download/spawn-v0.1.12/mixdog-spawn-win32-arm64.exe",
+      "sha256": "33872113fc0ca3cd2a2f6cf36c33430431388a5e36f254c8a0c6a44932057009"
     },
     "win32-x64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/spawn-v0.1.11/mixdog-spawn-win32-x64.exe",
-      "sha256": "50531a9f033dc22eff3ec5b2a9d10441ffdfac0e50d9acf9047e4f302e5d70d9"
+      "url": "https://github.com/tribgames/mixdog/releases/download/spawn-v0.1.12/mixdog-spawn-win32-x64.exe",
+      "sha256": "0070823fa03a50819077d60a407f4f8e26becafe3541ecdfabe522fc5e05a8cb"
     }
   }
 }

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();
   });
 }
 
@@ -39,22 +48,31 @@ function runOwnershipQuery(command, args) {
   });
 }
 
+// Get-NetTCPConnection prints one OwningProcess number per line: no localized words.
+export function listenerPidsInclude(stdout, pid) {
+  return stdout.split(/\r?\n/).some((line) => line.trim() === String(pid));
+}
+
 export async function whisperListenerOwned(host, port, pid) {
   if (!Number.isInteger(pid) || pid <= 0 || !Number.isInteger(port)) return false;
   try {
     if (process.platform === 'win32') {
       const root = process.env.SystemRoot || 'C:\\Windows';
-      const stdout = await runOwnershipQuery(path.join(root, 'System32', 'netstat.exe'), ['-ano', '-p', 'tcp']);
+      // netstat omits listeners when the TCP table is large; the CIM-backed cmdlet does not.
+      // The State filter is skipped (it can report an unknown state for live listeners);
+      // a listening row is the one with no remote endpoint (RemotePort 0).
+      if (!/^[0-9a-fA-F:.]+$/.test(host)) return false;
+      const stdout = await runOwnershipQuery(
+        path.join(root, 'System32', 'WindowsPowerShell', 'v1.0', 'powershell.exe'),
+        [
+          '-NoProfile',
+          '-NonInteractive',
+          '-Command',
+          `(Get-NetTCPConnection -LocalAddress '${host}' -LocalPort ${port} -ErrorAction SilentlyContinue | Where-Object RemotePort -eq 0).OwningProcess`,
+        ]
+      );
       if (stdout === null) return false;
-      return stdout.split(/\r?\n/).some((line) => {
-        const fields = line.trim().split(/\s+/);
-        return (
-          fields[0] === 'TCP' &&
-          fields[1] === `${host}:${port}` &&
-          fields[3] === 'LISTENING' &&
-          fields[4] === String(pid)
-        );
-      });
+      return listenerPidsInclude(stdout, pid);
     }
     if (process.platform === 'linux') {
       const stdout = await runOwnershipQuery('ss', ['-H', '-ltnp', `sport = :${port}`]);

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

@@ -80,6 +80,9 @@ const mgr = {
   child: null, // ChildProcess handle (non-detached)
   port: null, // selected port; must belong to the current child
   host: null,
+  // Ownership proven for this child+port. A live child keeps its bound port, so
+  // no other process can take it; cleared whenever the child goes away.
+  proof: null, // { child, port }
   runtimeKey: null, // exact contract fingerprint
   contract: null, // { serverCmd, modelPath, threadCount, host }
   startPromise: null, // in-flight ensureReady() start
@@ -330,6 +333,7 @@ async function teardown(reason) {
     }
   }
   mgr.child = null;
+  mgr.proof = null;
   mgr.port = null;
   mgr.host = null;
   mgr.runtimeKey = null;
@@ -357,6 +361,7 @@ function wireChildExit() {
     detachChildHandlers();
     clearPidMeta();
     mgr.child = null;
+    mgr.proof = null;
     mgr.port = null;
     mgr.runtimeKey = null;
     mgr.contract = null;
@@ -435,6 +440,7 @@ async function startServer(contract) {
       mgr.state === STATE.STARTING
     ) {
       mgr.port = port;
+      mgr.proof = { child, port };
       mgr.state = STATE.READY;
       return;
     }
@@ -509,7 +515,10 @@ export async function transcribe(wavPath, { language } = {}) {
   try {
     const [data, owned] = await Promise.all([
       fs.promises.readFile(wavPath),
-      whisperListenerOwned(host, port, child.pid),
+      // Proven at readiness for this live child; re-prove only without that proof.
+      mgr.proof?.child === child && mgr.proof.port === port && child.exitCode === null
+        ? true
+        : whisperListenerOwned(host, port, child.pid),
     ]);
     // Re-check after the awaits: a replacement listener (or child) must never
     // receive audio. Nothing awaits between this check and the request.

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>;