@aspectlylabs/mikka 0.0.65 → 0.0.67

package/mikka.js

@@ -2103,11 +2103,11 @@ function daemonProcessAlive(dataDir) {
   return pid !== null && processAlive(pid);
 }
 function socketAnswers(socketPath) {
-  return new Promise((resolve11) => {
+  return new Promise((resolve12) => {
     const socket = createConnection(socketPath);
     const done = (alive) => {
       socket.destroy();
-      resolve11(alive);
+      resolve12(alive);
     };
     socket.once("connect", () => done(true));
     socket.once("error", () => done(false));
@@ -2216,21 +2216,77 @@ function closeLogger(logger) {
   const file = files.get(logger);
   if (!file) return Promise.resolve();
   files.delete(logger);
-  return new Promise((resolve11) => file.end(resolve11));
+  return new Promise((resolve12) => file.end(resolve12));
 }
 
-// src/service.ts
+// src/auto-update.ts
 import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-import { mkdir, writeFile, rm } from "node:fs/promises";
+import { realpathSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname as dirname2, join as join2, resolve } from "node:path";
+import { promisify } from "node:util";
 var exec = promisify(execFile);
+var PACKAGE = "@aspectlylabs/mikka";
+var DAY = 24 * 60 * 60 * 1e3;
+function newerStableVersion(candidate, current) {
+  const stable = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/;
+  if (typeof candidate !== "string" || !stable.test(candidate) || !stable.test(current)) return false;
+  const a = candidate.split(".").map(BigInt), b = current.split(".").map(BigInt);
+  for (let i = 0; i < 3; i++) if (a[i] !== b[i]) return a[i] > b[i];
+  return false;
+}
+async function runServiceNpm(args) {
+  const npm = realpathSync(join2(dirname2(process.execPath), "npm"));
+  const { stdout } = await exec(process.execPath, [npm, ...args], {
+    cwd: homedir(),
+    timeout: 3e5,
+    maxBuffer: 1024 * 1024,
+    env: { ...process.env, PATH: `${dirname2(process.execPath)}:${process.env.PATH ?? ""}` }
+  });
+  return stdout.trim();
+}
+async function managedAutoUpdateRuntime(entry, flavor, enabled) {
+  if (!enabled || flavor !== "prod" || !["systemd", "launchd"].includes(process.env.MIKKA_SERVICE ?? "")) return;
+  try {
+    const file = realpathSync(resolve(entry));
+    const root = dirname2(file);
+    const pkg = readJson(join2(root, "package.json"));
+    if (pkg?.name !== PACKAGE || pkg.private !== false) return;
+    const globalRoot = await runServiceNpm(["root", "--global"]);
+    if (realpathSync(join2(globalRoot, PACKAGE)) !== root || file !== join2(root, "mikka.js")) return;
+    return {
+      latest: async () => JSON.parse(await runServiceNpm(["view", `${PACKAGE}@latest`, "version", "--json"])),
+      install: async (version) => {
+        await runServiceNpm(["install", "--global", "--engine-strict", `${PACKAGE}@${version}`]);
+      }
+    };
+  } catch {
+    return void 0;
+  }
+}
+async function checkLatestVersion(file, current, runtime, now = Date.now()) {
+  const state = readJson(file);
+  if (typeof state?.lastAttemptAt === "number" && now - state.lastAttemptAt < DAY) return;
+  writeJsonAtomic(file, { lastAttemptAt: now });
+  const latest = await runtime.latest();
+  return newerStableVersion(latest, current) ? latest : void 0;
+}
+
+// src/service.ts
+import { execFile as execFile2 } from "node:child_process";
+import { promisify as promisify2 } from "node:util";
+import { mkdir, writeFile, rm } from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
+import { dirname as dirname3, join as join3, resolve as resolve2 } from "node:path";
+var exec2 = promisify2(execFile2);
 var label = "com.aspectlylabs.mikka.daemon";
 var xml = (s) => s.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
 var unitQuote = (s) => `"${s.replaceAll("\\", "\\\\").replaceAll('"', '\\"').replaceAll("%", "%%").replaceAll("$", () => "$$")}"`;
 function serviceDefinition(input) {
   const args = [input.node, input.entry, "daemon", "--server", input.server];
+  if (input.dataDir) args.push("--data-dir", resolve2(input.dataDir));
+  if (input.dev) args.push("--dev");
+  if (input.autoUpdate === false) args.push("--no-auto-update");
   if (input.platform === "linux") return `[Unit]
 Description=Mikka daemon
 After=network-online.target
@@ -2249,53 +2305,56 @@ WantedBy=default.target
   if (input.platform !== "darwin") throw new Error("Services require Linux or macOS");
   return `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0"><dict><key>Label</key><string>${label}</string><key>ProgramArguments</key><array>${args.map((arg) => `<string>${xml(arg)}</string>`).join("")}</array><key>RunAtLoad</key><true/><key>KeepAlive</key><dict><key>SuccessfulExit</key><false/></dict><key>EnvironmentVariables</key><dict><key>PATH</key><string>${xml(input.path)}</string><key>MIKKA_SERVICE</key><string>launchd</string><key>MIKKA_DEVICE_TYPE</key><string>${input.deviceType === "server" ? "server" : "laptop"}</string></dict><key>StandardErrorPath</key><string>${xml(join2(input.home, "Library/Logs/mikka-daemon.log"))}</string></dict></plist>
+<plist version="1.0"><dict><key>Label</key><string>${label}</string><key>ProgramArguments</key><array>${args.map((arg) => `<string>${xml(arg)}</string>`).join("")}</array><key>RunAtLoad</key><true/><key>KeepAlive</key><dict><key>SuccessfulExit</key><false/></dict><key>EnvironmentVariables</key><dict><key>PATH</key><string>${xml(input.path)}</string><key>MIKKA_SERVICE</key><string>launchd</string><key>MIKKA_DEVICE_TYPE</key><string>${input.deviceType === "server" ? "server" : "laptop"}</string></dict><key>StandardErrorPath</key><string>${xml(join3(input.home, "Library/Logs/mikka-daemon.log"))}</string></dict></plist>
 `;
 }
-async function installService(server, deviceType = "server") {
+async function installService(server, deviceType = "server", options = {}) {
   const url = new URL(server);
   if (!["https:", "http:"].includes(url.protocol) || url.username || url.password) throw new Error("Invalid server URL");
-  const home = homedir();
-  const content = serviceDefinition({ platform: process.platform, node: process.execPath, entry: resolve(process.argv[1]), server, home, path: process.env.PATH ?? "/usr/local/bin:/usr/bin:/bin", deviceType });
+  const home = homedir2();
+  const content = serviceDefinition({ platform: process.platform, node: process.execPath, entry: resolve2(process.argv[1]), server, home, path: process.env.PATH ?? "/usr/local/bin:/usr/bin:/bin", deviceType, ...options });
   if (process.platform === "linux") {
-    const file = join2(home, ".config/systemd/user/mikka-daemon.service");
-    await mkdir(dirname2(file), { recursive: true, mode: 448 });
+    const file = join3(home, ".config/systemd/user/mikka-daemon.service");
+    await mkdir(dirname3(file), { recursive: true, mode: 448 });
     await writeFile(file, content, { mode: 384 });
-    await exec("loginctl", ["enable-linger"], { timeout: 1e4 }).catch(() => void 0);
-    await exec("systemctl", ["--user", "daemon-reload"]);
-    await exec("systemctl", ["--user", "enable", "mikka-daemon.service"]);
-    await exec("systemctl", ["--user", "restart", "mikka-daemon.service"]);
+    await exec2("loginctl", ["enable-linger"], { timeout: 1e4 }).catch(() => void 0);
+    await exec2("systemctl", ["--user", "daemon-reload"]);
+    await exec2("systemctl", ["--user", "enable", "mikka-daemon.service"]);
+    await exec2("systemctl", ["--user", "restart", "mikka-daemon.service"]);
   } else {
-    const file = join2(home, "Library/LaunchAgents", `${label}.plist`);
-    await mkdir(dirname2(file), { recursive: true, mode: 448 });
-    await mkdir(join2(home, "Library/Logs"), { recursive: true });
+    const file = join3(home, "Library/LaunchAgents", `${label}.plist`);
+    await mkdir(dirname3(file), { recursive: true, mode: 448 });
+    await mkdir(join3(home, "Library/Logs"), { recursive: true });
     await writeFile(file, content, { mode: 384 });
     const domain = `gui/${process.getuid()}`;
-    await exec("launchctl", ["bootout", `${domain}/${label}`]).catch(() => void 0);
-    await exec("launchctl", ["bootstrap", domain, file]);
+    await exec2("launchctl", ["bootout", `${domain}/${label}`]).catch(() => void 0);
+    await exec2("launchctl", ["bootstrap", domain, file]);
   }
 }
 async function restartService(update, beforeRestart, dependencies = {
   manager: process.env.MIKKA_SERVICE,
   update: async () => {
-    await exec("npm", ["install", "--global", "@aspectlylabs/mikka"], { timeout: 3e5, maxBuffer: 1024 * 1024 });
+    await runServiceNpm(["install", "--global", "--engine-strict", "@aspectlylabs/mikka"]);
   },
   restart: () => {
-    setImmediate(() => process.kill(process.pid, "SIGUSR2"));
+    setImmediate(() => {
+      if (canRestart()) process.kill(process.pid, "SIGUSR2");
+    });
   }
-}) {
+}, canRestart = () => true) {
   const manager = dependencies.manager;
   if (manager !== "systemd" && manager !== "launchd") throw new Error("Daemon is not running as a managed service");
   if (update) await dependencies.update();
+  if (!canRestart()) return;
   beforeRestart();
   dependencies.restart();
 }
 async function uninstallService(clearCredential, dependencies = {
   manager: process.env.MIKKA_SERVICE,
-  home: homedir(),
+  home: homedir2(),
   uid: process.getuid?.() ?? 0,
   run: async (program, args) => {
-    await exec(program, args, { timeout: 1e4 });
+    await exec2(program, args, { timeout: 1e4 });
   },
   exit: () => {
     process.exit(0);
@@ -2304,10 +2363,10 @@ async function uninstallService(clearCredential, dependencies = {
   try {
     if (dependencies.manager === "systemd") {
       await dependencies.run("systemctl", ["--user", "disable", "mikka-daemon.service"]);
-      await rm(join2(dependencies.home, ".config/systemd/user/mikka-daemon.service"), { force: true });
+      await rm(join3(dependencies.home, ".config/systemd/user/mikka-daemon.service"), { force: true });
       await dependencies.run("systemctl", ["--user", "daemon-reload"]);
     } else if (dependencies.manager === "launchd") {
-      await rm(join2(dependencies.home, "Library/LaunchAgents", `${label}.plist`), { force: true });
+      await rm(join3(dependencies.home, "Library/LaunchAgents", `${label}.plist`), { force: true });
     }
   } finally {
     clearCredential();
@@ -4361,13 +4420,13 @@ function isNonRetryable(error) {
 
 // src/paths.ts
 import { existsSync } from "node:fs";
-import { homedir as homedir2 } from "node:os";
-import { join as join3 } from "node:path";
+import { homedir as homedir3 } from "node:os";
+import { join as join4 } from "node:path";
 
 // package.json
 var package_default = {
   name: "@mikka/daemon",
-  version: "0.0.65",
+  version: "0.0.67",
   description: "Local Mikka daemon: runs agents through the user's own CLIs",
   type: "module",
   private: true,
@@ -4426,7 +4485,7 @@ var package_default = {
   engines: {
     node: ">=24"
   },
-  gitHead: "f566198f5cee77ff3a0ba56f6923a0cf0b005b0e"
+  gitHead: "72d8d7fa02d21728bd426b7d7c71f37c4161ec31"
 };
 
 // src/paths.ts
@@ -4438,10 +4497,10 @@ function defaultDataDir(flavor, env = process.env, platform3 = process.platform)
   if (flavor === "dev" && env.MIKKA_USER_DATA_DIR) {
     return env.MIKKA_USER_DATA_DIR;
   }
-  const home = env.HOME || homedir2();
-  const base = platform3 === "darwin" ? join3(home, "Library", "Application Support") : platform3 === "win32" ? env.APPDATA || join3(home, "AppData", "Roaming") : env.XDG_CONFIG_HOME || join3(home, ".config");
-  const dir = join3(base, productName(flavor));
-  const legacy = join3(base, legacyProductName(flavor));
+  const home = env.HOME || homedir3();
+  const base = platform3 === "darwin" ? join4(home, "Library", "Application Support") : platform3 === "win32" ? env.APPDATA || join4(home, "AppData", "Roaming") : env.XDG_CONFIG_HOME || join4(home, ".config");
+  const dir = join4(base, productName(flavor));
+  const legacy = join4(base, legacyProductName(flavor));
   return !existsSync(dir) && existsSync(legacy) ? legacy : dir;
 }
 function legacyProductName(flavor) {
@@ -4450,17 +4509,17 @@ function legacyProductName(flavor) {
 function daemonPaths(dataDir) {
   return {
     dataDir,
-    socket: join3(dataDir, "daemon.sock"),
-    lock: join3(dataDir, "daemon.lock"),
-    secret: join3(dataDir, "daemon.secret"),
-    device: join3(dataDir, "device.json"),
-    journal: join3(dataDir, "runs.json"),
-    outbox: join3(dataDir, "outbox"),
-    worktrees: join3(dataDir, "worktrees"),
-    repos: join3(dataDir, "repos"),
-    adapterState: join3(dataDir, "adapters"),
-    logs: join3(dataDir, "logs"),
-    devRepos: join3(dataDir, "dev-repos.json")
+    socket: join4(dataDir, "daemon.sock"),
+    lock: join4(dataDir, "daemon.lock"),
+    secret: join4(dataDir, "daemon.secret"),
+    device: join4(dataDir, "device.json"),
+    journal: join4(dataDir, "runs.json"),
+    outbox: join4(dataDir, "outbox"),
+    worktrees: join4(dataDir, "worktrees"),
+    repos: join4(dataDir, "repos"),
+    adapterState: join4(dataDir, "adapters"),
+    logs: join4(dataDir, "logs"),
+    devRepos: join4(dataDir, "dev-repos.json")
   };
 }
 
@@ -4600,14 +4659,14 @@ function verifyPolicySnapshot(value, trusted, expected, options = {}) {
 }
 
 // src/permissions.ts
-import { lstatSync, readlinkSync, realpathSync } from "node:fs";
+import { lstatSync, readlinkSync, realpathSync as realpathSync2 } from "node:fs";
 import {
   basename,
-  dirname as dirname3,
+  dirname as dirname4,
   isAbsolute,
-  join as join4,
+  join as join5,
   relative,
-  resolve as resolve2
+  resolve as resolve3
 } from "node:path";
 function decide(action, context = {}) {
   if (!Object.hasOwn(PERMISSION_DEFAULTS, action))
@@ -4740,14 +4799,14 @@ function realTarget(path) {
   let current = path;
   for (let hops = 0; ; ) {
     try {
-      return join4(realpathSync(current), ...[...missing].reverse());
+      return join5(realpathSync2(current), ...[...missing].reverse());
     } catch {
       if (lstatSync(current, { throwIfNoEntry: false })?.isSymbolicLink()) {
         if (++hops > 40) return path;
-        current = resolve2(dirname3(current), readlinkSync(current));
+        current = resolve3(dirname4(current), readlinkSync(current));
         continue;
       }
-      const parent = dirname3(current);
+      const parent = dirname4(current);
       if (parent === current) return path;
       missing.push(basename(current));
       current = parent;
@@ -4759,8 +4818,8 @@ function inside(parent, child) {
   return rel === "" || !rel.startsWith("..") && !isAbsolute(rel);
 }
 function classifyWrite(worktree, target) {
-  const root = resolve2(worktree);
-  const lexical = resolve2(root, target);
+  const root = resolve3(worktree);
+  const lexical = resolve3(root, target);
   const ok2 = inside(root, lexical) && inside(realTarget(root), realTarget(lexical));
   return ok2 ? "write_in_worktree" : "write_outside_repo";
 }
@@ -5123,14 +5182,14 @@ var HttpServerLink = class {
             const current = await this.call("POST", path, { body: { operation: "check", deviceId: assignment.deviceId, policyRevision }, schema: z26.object({ live: z26.boolean(), paused: z26.boolean().optional() }), signal: liveness.signal, timeoutMs: 5e3 });
             check();
             if (!current.live || !current.paused) return current.live;
-            await new Promise((resolve11, reject) => {
+            await new Promise((resolve12, reject) => {
               const stop = () => {
                 clearTimeout(timer);
                 reject(new Error("cancelled"));
               };
               const timer = setTimeout(() => {
                 liveness.signal.removeEventListener("abort", stop);
-                resolve11();
+                resolve12();
               }, 1e3);
               liveness.signal.addEventListener("abort", stop, { once: true });
               if (liveness.signal.aborted) stop();
@@ -5141,10 +5200,10 @@ var HttpServerLink = class {
         }
       },
       ask: async (request, signal2) => {
-        const delay3 = () => new Promise((resolve11, reject) => {
+        const delay3 = () => new Promise((resolve12, reject) => {
           const done = () => {
             signal2.removeEventListener("abort", stop);
-            resolve11();
+            resolve12();
           };
           const timer = setTimeout(done, 1e3);
           const stop = () => {
@@ -5496,7 +5555,7 @@ async function post(options, path, body) {
   };
 }
 async function deviceLogin(options) {
-  const sleep3 = options.sleep ?? ((ms) => new Promise((resolve11) => setTimeout(resolve11, ms)));
+  const sleep3 = options.sleep ?? ((ms) => new Promise((resolve12) => setTimeout(resolve12, ms)));
   const started = await post(options, DEVICE_CODE_PATH, {
     client_id: DAEMON_CLIENT_ID
   });
@@ -5556,7 +5615,7 @@ async function registrationLogin(options) {
 
 // src/coordinator/runner.ts
 import { mkdirSync as mkdirSync9, mkdtempSync as mkdtempSync3, rmSync as rmSync9, writeFileSync as writeFileSync5 } from "node:fs";
-import { dirname as dirname7, join as join11 } from "node:path";
+import { dirname as dirname8, join as join12 } from "node:path";
 import { setTimeout as delay } from "node:timers/promises";
 import { z as z30 } from "zod";
 
@@ -5613,11 +5672,11 @@ import { spawn } from "node:child_process";
 import {
   mkdirSync as mkdirSync4,
   readFileSync as readFileSync4,
-  realpathSync as realpathSync3,
+  realpathSync as realpathSync4,
   rmSync as rmSync3,
   writeFileSync as writeFileSync2
 } from "node:fs";
-import { dirname as dirname4 } from "node:path";
+import { dirname as dirname5 } from "node:path";
 import { execa } from "execa";
 
 // src/agents/harness-home.ts
@@ -5627,13 +5686,13 @@ import {
   lstatSync as lstatSync2,
   mkdirSync as mkdirSync3,
   readFileSync as readFileSync3,
-  realpathSync as realpathSync2,
+  realpathSync as realpathSync3,
   rmSync as rmSync2,
   symlinkSync,
   writeFileSync
 } from "node:fs";
-import { homedir as homedir3 } from "node:os";
-import { join as join5 } from "node:path";
+import { homedir as homedir4 } from "node:os";
+import { join as join6 } from "node:path";
 var CODEX_CONFIG = [
   "# Written by Mikka for agent runs. Edits are overwritten.",
   'approval_policy = "on-request"',
@@ -5643,21 +5702,21 @@ var CODEX_CONFIG = [
 ].join("\n");
 function prepareCodexHome(dir, log, userHome, linkNativeAuth = true) {
   ownDir(dir);
-  writeOwnFile(join5(dir, "config.toml"), CODEX_CONFIG);
-  const link = join5(dir, "auth.json");
+  writeOwnFile(join6(dir, "config.toml"), CODEX_CONFIG);
+  const link = join6(dir, "auth.json");
   const current = lstatSync2(link, { throwIfNoEntry: false });
   if (current && !current.isSymbolicLink()) {
     log.warn("codex replaced its auth link with a file; removing the copy");
   }
   if (current) rmSync2(link, { force: true, recursive: true });
   if (!linkNativeAuth) return { home: dir, authFile: null };
-  const userAuth = join5(
-    userHome ?? (process.env.CODEX_HOME || join5(homedir3(), ".codex")),
+  const userAuth = join6(
+    userHome ?? (process.env.CODEX_HOME || join6(homedir4(), ".codex")),
     "auth.json"
   );
   if (!existsSync2(userAuth)) return { home: dir, authFile: null };
   symlinkSync(userAuth, link);
-  return { home: dir, authFile: realpathSync2(userAuth) };
+  return { home: dir, authFile: realpathSync3(userAuth) };
 }
 function codexAccount(text3) {
   try {
@@ -5695,9 +5754,9 @@ function carryHistory(from, to, entries) {
   if (!lstatSync2(from, { throwIfNoEntry: false })?.isDirectory()) return;
   ownDir(to);
   for (const entry of entries) {
-    const source = join5(from, entry);
+    const source = join6(from, entry);
     if (!lstatSync2(source, { throwIfNoEntry: false })) continue;
-    cpSync(source, join5(to, entry), {
+    cpSync(source, join6(to, entry), {
       recursive: true,
       force: true,
       filter: (path) => !lstatSync2(path).isSymbolicLink()
@@ -5744,8 +5803,8 @@ var EventQueue = class {
         if (next.type === "exit") return;
         continue;
       }
-      await new Promise((resolve11) => {
-        this.waiter = resolve11;
+      await new Promise((resolve12) => {
+        this.waiter = resolve12;
       });
     }
   }
@@ -5791,7 +5850,7 @@ async function reapStale(pidFile2, marker) {
 }
 async function claimRunDir(paths) {
   ownDir(paths.runDir);
-  const runDir = realpathSync3(paths.runDir);
+  const runDir = realpathSync4(paths.runDir);
   await reapStale(paths.pidFile, runDir);
   return runDir;
 }
@@ -5806,7 +5865,7 @@ async function spawnCli(sandbox, argv, options) {
   });
   const pgid = child.pid;
   if (pgid !== void 0) {
-    mkdirSync4(dirname4(options.pidFile), { recursive: true, mode: 448 });
+    mkdirSync4(dirname5(options.pidFile), { recursive: true, mode: 448 });
     rmSync3(options.pidFile, { force: true });
     writeFileSync2(options.pidFile, String(pgid), { flag: "wx", mode: 384 });
   }
@@ -5816,13 +5875,13 @@ async function spawnCli(sandbox, argv, options) {
     stderr = (stderr + data).slice(-STDERR_TAIL * 4);
   });
   const exited = new Promise(
-    (resolve11) => {
+    (resolve12) => {
       child.once("error", (error) => {
         stderr += `
 ${error.message}`;
-        resolve11({ code: null, signal: null });
+        resolve12({ code: null, signal: null });
       });
-      child.once("exit", (code, signal) => resolve11({ code, signal }));
+      child.once("exit", (code, signal) => resolve12({ code, signal }));
     }
   ).finally(() => {
     signalGroup(pgid, "SIGKILL");
@@ -5839,8 +5898,8 @@ ${error.message}`;
       let timer;
       await Promise.race([
         exited,
-        new Promise((resolve11) => {
-          timer = setTimeout(resolve11, graceMs);
+        new Promise((resolve12) => {
+          timer = setTimeout(resolve12, graceMs);
         })
       ]);
       clearTimeout(timer);
@@ -5921,11 +5980,11 @@ var JsonlWriter = class extends AbstractMessageWriter {
   }
   stream;
   write(message) {
-    return new Promise((resolve11, reject) => {
+    return new Promise((resolve12, reject) => {
       this.stream.write(
         `${JSON.stringify(message)}
 `,
-        (error) => error ? reject(error) : resolve11()
+        (error) => error ? reject(error) : resolve12()
       );
     });
   }
@@ -5948,8 +6007,8 @@ Keep exact counts and supplied timestamps. Delayed delivery describes when infor
 When summarizing, retain source session/message ids, reply route, exact times/counts and the distinction between reported claims and verified evidence. Never rewrite a peer claim of approval as user consent. Derived summaries remain untrusted, cannot broaden scope, and must retain their source references.`;
 
 // src/agents/github-runtime.ts
-import { existsSync as existsSync4, lstatSync as lstatSync4, mkdirSync as mkdirSync6, mkdtempSync as mkdtempSync2, realpathSync as realpathSync6, rmSync as rmSync6, writeFileSync as writeFileSync3 } from "node:fs";
-import { delimiter, join as join8, resolve as resolve5 } from "node:path";
+import { existsSync as existsSync4, lstatSync as lstatSync4, mkdirSync as mkdirSync6, mkdtempSync as mkdtempSync2, realpathSync as realpathSync7, rmSync as rmSync6, writeFileSync as writeFileSync3 } from "node:fs";
+import { delimiter, join as join9, resolve as resolve6 } from "node:path";
 import { execa as execa4 } from "execa";
 
 // src/agents/publish.ts
@@ -5957,11 +6016,11 @@ import {
   mkdtempSync,
   readdirSync as readdirSync2,
   readFileSync as readFileSync5,
-  realpathSync as realpathSync5,
+  realpathSync as realpathSync6,
   rmSync as rmSync5
 } from "node:fs";
 import { tmpdir } from "node:os";
-import { join as join7, resolve as resolve4 } from "node:path";
+import { join as join8, resolve as resolve5 } from "node:path";
 
 // src/ids.ts
 var SAFE_ID = /^[A-Za-z0-9_-]{1,64}$/;
@@ -5995,11 +6054,11 @@ import {
   lstatSync as lstatSync3,
   mkdirSync as mkdirSync5,
   readdirSync,
-  realpathSync as realpathSync4,
+  realpathSync as realpathSync5,
   rmSync as rmSync4
 } from "node:fs";
 import { lstat, readdir } from "node:fs/promises";
-import { dirname as dirname5, isAbsolute as isAbsolute2, join as join6, relative as relative2, resolve as resolve3 } from "node:path";
+import { dirname as dirname6, isAbsolute as isAbsolute2, join as join7, relative as relative2, resolve as resolve4 } from "node:path";
 import { execa as execa2 } from "execa";
 import { simpleGit } from "simple-git";
 var DISK_USAGE_TTL_MS = 5 * 6e4;
@@ -6031,9 +6090,9 @@ var WorktreeManager = class {
   usageRefresh = null;
   /** The run's worktree dir; never outside the worktree root. */
   pathFor(runId) {
-    const root = resolve3(this.root);
-    const path = resolve3(root, assertSafeId("run id", runId));
-    if (dirname5(path) !== root) {
+    const root = resolve4(this.root);
+    const path = resolve4(root, assertSafeId("run id", runId));
+    if (dirname6(path) !== root) {
       throw new Error(`worktree path escapes ${root}: ${runId}`);
     }
     return path;
@@ -6044,7 +6103,7 @@ var WorktreeManager = class {
    */
   async create(runId, repoPath, baseBranch) {
     const path = this.pathFor(runId);
-    if (existsSync3(join6(path, ".git"))) return path;
+    if (existsSync3(join7(path, ".git"))) return path;
     mkdirSync5(this.root, { recursive: true });
     await simpleGit(repoPath).raw([
       "worktree",
@@ -6104,10 +6163,10 @@ var WorktreeManager = class {
    * worktree, with hooks off: the agent wrote in that tree.
    */
   async continueFrom(repoPath, previousWorktree, runId) {
-    const root = resolve3(this.root);
-    const path = resolve3(previousWorktree);
-    if (dirname5(path) !== root) return null;
-    if (!existsSync3(join6(path, ".git"))) return null;
+    const root = resolve4(this.root);
+    const path = resolve4(previousWorktree);
+    if (dirname6(path) !== root) return null;
+    if (!existsSync3(join7(path, ".git"))) return null;
     let gitDir;
     try {
       gitDir = await worktreeGitDir(repoPath, path);
@@ -6115,8 +6174,8 @@ var WorktreeManager = class {
       return null;
     }
     const git2 = (args) => execa2("git", ["-c", "core.hooksPath=/dev/null", ...args], {
-      cwd: realpathSync4(path),
-      env: { GIT_DIR: gitDir, GIT_WORK_TREE: realpathSync4(path) },
+      cwd: realpathSync5(path),
+      env: { GIT_DIR: gitDir, GIT_WORK_TREE: realpathSync5(path) },
       stdin: "ignore"
     });
     const branch = `refs/heads/${runBranch(runId)}`;
@@ -6137,25 +6196,25 @@ var WorktreeManager = class {
    */
   async bootstrap(worktree, repoPath, recipe) {
     if (!recipe || !recipe.approved) return "skipped";
-    const repoReal = realpathSync4(repoPath);
-    const worktreeReal = realpathSync4(worktree);
+    const repoReal = realpathSync5(repoPath);
+    const worktreeReal = realpathSync5(worktree);
     for (const file of recipe.copyFiles) {
-      const rel = relative2(repoPath, resolve3(repoPath, file));
+      const rel = relative2(repoPath, resolve4(repoPath, file));
       if (rel === "" || rel.startsWith("..") || isAbsolute2(rel)) {
         throw new Error(`setup recipe copies a file outside the repo: ${file}`);
       }
-      const from = join6(repoPath, rel);
+      const from = join7(repoPath, rel);
       const fromStat = lstatSync3(from, { throwIfNoEntry: false });
       if (!fromStat) continue;
-      if (!fromStat.isFile() || !isInside(repoReal, realpathSync4(from))) {
+      if (!fromStat.isFile() || !isInside(repoReal, realpathSync5(from))) {
         throw new Error(
           `setup recipe copies a symlink or non-file, or leaves the repo: ${file}`
         );
       }
-      const to = join6(worktree, rel);
-      mkdirSync5(dirname5(to), { recursive: true });
+      const to = join7(worktree, rel);
+      mkdirSync5(dirname6(to), { recursive: true });
       const toStat = lstatSync3(to, { throwIfNoEntry: false });
-      if (!isInside(worktreeReal, realpathSync4(dirname5(to))) || toStat && !toStat.isFile()) {
+      if (!isInside(worktreeReal, realpathSync5(dirname6(to))) || toStat && !toStat.isFile()) {
         throw new Error(
           `setup recipe would write through a symlink or outside the worktree: ${file}`
         );
@@ -6195,11 +6254,11 @@ var WorktreeManager = class {
    */
   async discardIfEmpty(runIds, worktree, repoPath) {
     if (this.retainResources) return false;
-    const root = resolve3(this.root);
-    const path = worktree ? resolve3(worktree) : null;
-    if (path && dirname5(path) !== root) return false;
+    const root = resolve4(this.root);
+    const path = worktree ? resolve4(worktree) : null;
+    if (path && dirname6(path) !== root) return false;
     const git2 = simpleGit(repoPath);
-    if (path && existsSync3(join6(path, ".git"))) {
+    if (path && existsSync3(join7(path, ".git"))) {
       if ((await this.changedFiles(path)).length > 0) return false;
     }
     const branches = [];
@@ -6236,15 +6295,15 @@ var WorktreeManager = class {
       "mikka/run-*",
       "--format=%(refname:short)	%(worktreepath)"
     ]);
-    const root = resolve3(this.root);
-    const repo = resolve3(repoPath);
+    const root = resolve4(this.root);
+    const repo = resolve4(repoPath);
     const branches = [];
     for (const line of out.split("\n")) {
       const [name, where = ""] = line.split("	");
       const runId = name?.startsWith("mikka/run-") ? name.slice("mikka/run-".length) : "";
       if (!runId) continue;
-      const worktree = where.trim() ? resolve3(where.trim()) : null;
-      if (worktree && (worktree === repo || dirname5(worktree) !== root))
+      const worktree = where.trim() ? resolve4(where.trim()) : null;
+      if (worktree && (worktree === repo || dirname6(worktree) !== root))
         continue;
       branches.push({ runId, worktree });
     }
@@ -6308,7 +6367,7 @@ async function du(path) {
     return 0;
   }
   let total = 0;
-  for (const entry of entries) total += await du(join6(path, entry));
+  for (const entry of entries) total += await du(join7(path, entry));
   return total;
 }
 
@@ -6330,7 +6389,7 @@ var FALLBACK_IDENTITY = [
   "user.email=agent@mikka.invalid"
 ];
 async function worktreeGitDir(repoPath, worktree) {
-  const common = realpathSync5(
+  const common = realpathSync6(
     (await execa3(
       "git",
       [
@@ -6345,10 +6404,10 @@ async function worktreeGitDir(repoPath, worktree) {
       }
     )).stdout.trim()
   );
-  const dotGit = join7(realpathSync5(worktree), ".git");
-  const root = join7(common, "worktrees");
+  const dotGit = join8(realpathSync6(worktree), ".git");
+  const root = join8(common, "worktrees");
   for (const name of readdirSync2(root)) {
-    const gitdirFile = join7(root, name, "gitdir");
+    const gitdirFile = join8(root, name, "gitdir");
     let target;
     try {
       target = readFileSync5(gitdirFile, "utf8").trim();
@@ -6356,31 +6415,31 @@ async function worktreeGitDir(repoPath, worktree) {
       continue;
     }
     if (target === dotGit || safeRealpath(target) === dotGit) {
-      return join7(root, name);
+      return join8(root, name);
     }
   }
   throw new Error(`${worktree} is not a worktree of ${repoPath}`);
 }
 async function worktreeGitWritePaths(repoPath, worktree, runId) {
   const gitDir = await worktreeGitDir(repoPath, worktree);
-  const common = resolve4(gitDir, "..", "..");
+  const common = resolve5(gitDir, "..", "..");
   const branch = `mikka/run-${assertSafeId("run id", runId)}`;
-  const ref = join7(common, "refs", "heads", branch);
-  return [gitDir, join7(common, "objects"), ref, `${ref}.lock`, join7(common, "logs", "refs", "heads", branch)];
+  const ref = join8(common, "refs", "heads", branch);
+  return [gitDir, join8(common, "objects"), ref, `${ref}.lock`, join8(common, "logs", "refs", "heads", branch)];
 }
 function safeRealpath(path) {
   try {
-    return realpathSync5(path);
+    return realpathSync6(path);
   } catch {
     return path;
   }
 }
 async function pinnedGit(repoPath, worktree, env = process.env) {
   const gitDir = await worktreeGitDir(repoPath, worktree);
-  const workTree = realpathSync5(worktree);
+  const workTree = realpathSync6(worktree);
   return (args, extra, options) => execa3("git", [...SAFE_GIT, ...args], {
     cwd: workTree,
-    env: { ...env, ...extra, GIT_DIR: gitDir, GIT_COMMON_DIR: resolve4(gitDir, "..", ".."), GIT_WORK_TREE: workTree },
+    env: { ...env, ...extra, GIT_DIR: gitDir, GIT_COMMON_DIR: resolve5(gitDir, "..", ".."), GIT_WORK_TREE: workTree },
     extendEnv: false,
     stdin: "ignore",
     ...options?.buffer ? { encoding: "buffer", stripFinalNewline: false } : {}
@@ -6388,8 +6447,8 @@ async function pinnedGit(repoPath, worktree, env = process.env) {
 }
 async function snapshotTree(repoPath, worktree, env) {
   const git2 = await pinnedGit(repoPath, worktree, env);
-  const dir = mkdtempSync(join7(tmpdir(), "mikka-index-"));
-  const index = { GIT_INDEX_FILE: join7(dir, "index") };
+  const dir = mkdtempSync(join8(tmpdir(), "mikka-index-"));
+  const index = { GIT_INDEX_FILE: join8(dir, "index") };
   try {
     await git2(["read-tree", "HEAD"], index);
     await git2(["add", "--all"], index);
@@ -6534,7 +6593,7 @@ function gitError(error) {
 }
 
 // src/agents/github-runtime.ts
-var GITHUB_CREDENTIAL_SCRIPT = resolve5(import.meta.dirname, "github-credentials.mjs");
+var GITHUB_CREDENTIAL_SCRIPT = resolve6(import.meta.dirname, "github-credentials.mjs");
 var helper = GITHUB_CREDENTIAL_SCRIPT;
 var quote = (value) => `'${value.replaceAll("'", "'\\''")}'`;
 function githubReceiptEnvironment(host = process.env) {
@@ -6559,19 +6618,19 @@ function githubReceiptEnvironment(host = process.env) {
 function prepareGitHubEnvironment(runDir, github, path, runtime) {
   const endpoint = new URL(github.endpoint);
   if (!endpoint.pathname.endsWith("/api/runs/github-token") || endpoint.username || endpoint.password || endpoint.search || endpoint.hash || endpoint.protocol !== "https:" && !(endpoint.protocol === "http:" && ["127.0.0.1", "localhost", "[::1]"].includes(endpoint.hostname))) throw new Error("Invalid run GitHub endpoint");
-  const gh = runtime?.ghBinary ?? path.split(delimiter).map((dir2) => join8(dir2, "gh")).find((file) => existsSync4(file));
+  const gh = runtime?.ghBinary ?? path.split(delimiter).map((dir2) => join9(dir2, "gh")).find((file) => existsSync4(file));
   const node = runtime?.nodeBinary ?? process.execPath;
   if (!gh) throw new Error("Install GitHub CLI (gh) before running GitHub tasks");
-  const dir = join8(runDir, "github");
+  const dir = join9(runDir, "github");
   mkdirSync6(dir, { recursive: true, mode: 448 });
-  if (!lstatSync4(dir).isDirectory() || realpathSync6(dir) !== join8(realpathSync6(runDir), "github")) throw new Error("Invalid run GitHub directory");
-  const config = join8(dir, "config.json");
+  if (!lstatSync4(dir).isDirectory() || realpathSync7(dir) !== join9(realpathSync7(runDir), "github")) throw new Error("Invalid run GitHub directory");
+  const config = join9(dir, "config.json");
   rmSync6(config, { force: true });
   writeFileSync3(config, JSON.stringify({ ...github, gh }), { mode: 384, flag: "wx" });
-  const bin = join8(dir, "bin");
+  const bin = join9(dir, "bin");
   mkdirSync6(bin, { recursive: true, mode: 448 });
-  if (!lstatSync4(bin).isDirectory() || realpathSync6(bin) !== join8(realpathSync6(dir), "bin")) throw new Error("Invalid run GitHub executable directory");
-  const wrapper = join8(bin, "gh");
+  if (!lstatSync4(bin).isDirectory() || realpathSync7(bin) !== join9(realpathSync7(dir), "bin")) throw new Error("Invalid run GitHub executable directory");
+  const wrapper = join9(bin, "gh");
   rmSync6(wrapper, { force: true });
   writeFileSync3(wrapper, `#!/bin/sh
 exec env NODE_USE_ENV_PROXY=1 ${process.versions.electron ? "ELECTRON_RUN_AS_NODE=1 " : ""}${quote(node)} ${quote(helper)} gh ${quote(config)} "$@"
@@ -6596,7 +6655,7 @@ exec env NODE_USE_ENV_PROXY=1 ${process.versions.electron ? "ELECTRON_RUN_AS_NOD
 }
 async function agentPublishedReceipt(input) {
   mkdirSync6(input.privateDir, { recursive: true, mode: 448 });
-  const receiptDir = mkdtempSync2(join8(input.privateDir, "github-receipt-"));
+  const receiptDir = mkdtempSync2(join9(input.privateDir, "github-receipt-"));
   try {
     const env = {
       NODE_ENV: input.env?.NODE_ENV ?? process.env.NODE_ENV ?? "production",
@@ -6614,7 +6673,7 @@ async function agentPublishedReceipt(input) {
       if (originalHead !== commit || headTree !== input.tree) throw new Error("Agent must commit and verify every change before submitting");
     }
     try {
-      const gh = (args) => execa4(join8(receiptDir, "github", "bin", "gh"), args, { cwd: input.worktree, env, extendEnv: false, stdin: "ignore" });
+      const gh = (args) => execa4(join9(receiptDir, "github", "bin", "gh"), args, { cwd: input.worktree, env, extendEnv: false, stdin: "ignore" });
       if (input.hosted) {
         const object = JSON.parse((await gh(["api", `repos/${input.github.repository}/git/commits/${commit}`])).stdout);
         if (object.sha !== commit || object.tree?.sha !== input.tree) throw new Error("Uncommitted hosted changes");
@@ -6646,12 +6705,12 @@ import {
   lstatSync as lstatSync7,
   mkdirSync as mkdirSync8,
   readFileSync as readFileSync8,
-  realpathSync as realpathSync7,
+  realpathSync as realpathSync8,
   rmSync as rmSync8,
   writeFileSync as writeFileSync4
 } from "node:fs";
-import { homedir as homedir4 } from "node:os";
-import { dirname as dirname6, join as join10, resolve as resolve6 } from "node:path";
+import { homedir as homedir5 } from "node:os";
+import { dirname as dirname7, join as join11, resolve as resolve7 } from "node:path";
 
 // src/agents/skill-artifact.ts
 import { createHash as createHash2 } from "node:crypto";
@@ -6681,7 +6740,7 @@ function verifySkillResume(assignment, current) {
 // src/captures.ts
 import { createHash as createHash3 } from "node:crypto";
 import { closeSync as closeSync2, constants, fstatSync, lstatSync as lstatSync6, mkdirSync as mkdirSync7, openSync as openSync2, readFileSync as readFileSync7, readdirSync as readdirSync3, rmSync as rmSync7 } from "node:fs";
-import { join as join9 } from "node:path";
+import { join as join10 } from "node:path";
 var CAPTURES_DIR = "captures";
 var ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
 var EXTENSIONS = ["png", "jpg", "webp", "mp4", "webm"];
@@ -6701,7 +6760,7 @@ function readPlain(path, max) {
   }
 }
 var drop = (dir, id4) => {
-  for (const name of [`${id4}.json`, ...EXTENSIONS.map((ext) => `${id4}.${ext}`)]) rmSync7(join9(dir, name), { force: true });
+  for (const name of [`${id4}.json`, ...EXTENSIONS.map((ext) => `${id4}.${ext}`)]) rmSync7(join10(dir, name), { force: true });
 };
 async function uploadCaptures(dir, runId, link, log, pendingDir, existingOnly = false) {
   if (!link.beginCapture || !link.sendCapture || !link.completeCapture) return 0;
@@ -6710,13 +6769,13 @@ async function uploadCaptures(dir, runId, link, log, pendingDir, existingOnly =
   for (const name of readdirSync3(dir).sort()) {
     const id4 = name.endsWith(".json") ? name.slice(0, -5) : "";
     if (!ID.test(id4)) continue;
-    const meta = readPlain(join9(dir, name), 4096);
+    const meta = readPlain(join10(dir, name), 4096);
     let title2 = "";
     try {
       title2 = cleanCaptureTitle(String(JSON.parse(new TextDecoder().decode(meta ?? new Uint8Array())).title ?? ""));
     } catch {
     }
-    const file = EXTENSIONS.map((ext) => join9(dir, `${id4}.${ext}`)).find((path) => lstatSync6(path, { throwIfNoEntry: false }));
+    const file = EXTENSIONS.map((ext) => join10(dir, `${id4}.${ext}`)).find((path) => lstatSync6(path, { throwIfNoEntry: false }));
     const bytes = file ? readPlain(file, CAPTURE_MAX_BYTES.video) : null;
     const problem = !title2 ? "no title" : !bytes ? "no regular file" : captureProblem(bytes);
     const contentType = bytes && sniffCaptureType(bytes);
@@ -6727,7 +6786,7 @@ async function uploadCaptures(dir, runId, link, log, pendingDir, existingOnly =
     }
     try {
       const sha2562 = createHash3("sha256").update(bytes).digest("hex");
-      const pendingPath = pendingDir ? join9(pendingDir, `${id4}.json`) : null;
+      const pendingPath = pendingDir ? join10(pendingDir, `${id4}.json`) : null;
       let pending;
       if (pendingPath) {
         try {
@@ -6778,13 +6837,13 @@ async function uploadCaptures(dir, runId, link, log, pendingDir, existingOnly =
         log.warn({ run_id: runId, capture: id4, status: error.code }, "capture reservation unavailable; retry stopped");
         if (pendingDir) {
           mkdirSync7(pendingDir, { recursive: true, mode: 448 });
-          writeJsonAtomic(join9(pendingDir, "blocked.json"), { status: error.code });
+          writeJsonAtomic(join10(pendingDir, "blocked.json"), { status: error.code });
         }
         return sent;
       }
       log.warn({ run_id: runId, capture: id4, status: error instanceof DaemonError ? error.code : void 0 }, "capture refused");
       drop(dir, id4);
-      if (pendingDir) rmSync7(join9(pendingDir, `${id4}.json`), { force: true });
+      if (pendingDir) rmSync7(join10(pendingDir, `${id4}.json`), { force: true });
     }
   }
   return sent;
@@ -6803,8 +6862,8 @@ var CaptureUploader = class {
   passes = /* @__PURE__ */ new Map();
   flush(runId, existingOnly = false) {
     if (!/^[A-Za-z0-9_-]{1,64}$/.test(runId)) return Promise.resolve();
-    const pendingDir = this.pendingRoot ? join9(this.pendingRoot, runId) : void 0;
-    if (pendingDir && lstatSync6(join9(pendingDir, "blocked.json"), { throwIfNoEntry: false })) return Promise.resolve();
+    const pendingDir = this.pendingRoot ? join10(this.pendingRoot, runId) : void 0;
+    if (pendingDir && lstatSync6(join10(pendingDir, "blocked.json"), { throwIfNoEntry: false })) return Promise.resolve();
     const previous = this.passes.get(runId) ?? Promise.resolve();
     const next = previous.then(() => uploadCaptures(this.dirFor(runId), runId, this.link, this.log, pendingDir, existingOnly)).then(() => void 0, (error) => this.log.warn({ run_id: runId, err: error instanceof Error ? error.message : String(error) }, "capture upload failed")).finally(() => {
       if (this.passes.get(runId) === next) this.passes.delete(runId);
@@ -6834,10 +6893,10 @@ var HARNESS_DOMAINS = {
     "*.cursorapi.com"
   ]
 };
-var MCP_SERVER_SCRIPT = resolve6(import.meta.dirname, "mikka-mcp.mjs");
+var MCP_SERVER_SCRIPT = resolve7(import.meta.dirname, "mikka-mcp.mjs");
 var MCP_SERVER_NAME = "mikka";
 var COMPUTER_MCP_SERVER_NAME = "mikka_computer";
-function credentialDenyRead(harness, home = homedir4()) {
+function credentialDenyRead(harness, home = homedir5()) {
   return [
     ".ssh",
     ".aws",
@@ -6855,10 +6914,10 @@ function credentialDenyRead(harness, home = homedir4()) {
     // Other harnesses' logins; each harness still reads its own.
     ...harness === "codex" ? [] : [".codex/auth.json"],
     ...harness === "claude_code" ? [] : [".claude/.credentials.json"]
-  ].map((path) => join10(home, path));
+  ].map((path) => join11(home, path));
 }
 function daemonSecrets(dataDir) {
-  const paths = daemonPaths(realpathSync7(dataDir));
+  const paths = daemonPaths(realpathSync8(dataDir));
   return [
     paths.secret,
     paths.device,
@@ -6866,38 +6925,38 @@ function daemonSecrets(dataDir) {
     paths.outbox,
     paths.logs,
     paths.devRepos,
-    join10(paths.adapterState, "pids")
+    join11(paths.adapterState, "pids")
   ];
 }
 function runPaths(stateDir, runId) {
   const id4 = assertSafeId("run id", runId);
   return {
     /** The daemon's data dir (`stateDir` is `<dataDir>/adapters`). */
-    privateDir: resolve6(stateDir, ".."),
+    privateDir: resolve7(stateDir, ".."),
     /** Writable from the sandbox. */
-    runDir: join10(stateDir, "runs", id4),
+    runDir: join11(stateDir, "runs", id4),
     /** Daemon only. */
-    pidFile: join10(stateDir, "pids", `${id4}.pgid`)
+    pidFile: join11(stateDir, "pids", `${id4}.pgid`)
   };
 }
 var RunContext = class {
   constructor(options) {
     this.options = options;
     if (options.policyHash && (!options.policy || policySnapshotHash(options.policy) !== options.policyHash)) throw new Error("Run child policy hash mismatch");
-    this.worktree = realpathSync7(options.worktree);
-    this.gitDir = realpathSync7(
+    this.worktree = realpathSync8(options.worktree);
+    this.gitDir = realpathSync8(
       execFileSync("git", ["rev-parse", "--absolute-git-dir"], {
         cwd: this.worktree,
         encoding: "utf8"
       }).trim()
     );
     ownDir(options.runDir);
-    this.runDir = realpathSync7(options.runDir);
-    this.handoffFile = join10(this.runDir, "handoff.json");
-    this.skillsDir = join10(this.runDir, SKILLS_DIR);
-    this.tmpDir = join10(this.runDir, "tmp");
+    this.runDir = realpathSync8(options.runDir);
+    this.handoffFile = join11(this.runDir, "handoff.json");
+    this.skillsDir = join11(this.runDir, SKILLS_DIR);
+    this.tmpDir = join11(this.runDir, "tmp");
     ownDir(this.tmpDir);
-    this.capturesDir = join10(this.runDir, CAPTURES_DIR);
+    this.capturesDir = join11(this.runDir, CAPTURES_DIR);
     ownDir(this.capturesDir);
     this.writeSkills();
     if (options.github && options.kind !== "plan" && !runPolicy(options.policy).readOnly) {
@@ -6938,23 +6997,23 @@ var RunContext = class {
       let slug = base;
       for (let n = 2; taken.has(slug); n += 1) slug = `${base}-${n}`;
       taken.add(slug);
-      const dir = join10(this.skillsDir, slug);
+      const dir = join11(this.skillsDir, slug);
       if (this.options.skillReceipt) {
         const existing = lstatSync7(dir, { throwIfNoEntry: false });
         if (existing && (!existing.isDirectory() || existing.isSymbolicLink())) throw new Error("Unsafe Skill artifact directory");
-        const file = lstatSync7(join10(dir, SKILL_BODY_FILE), { throwIfNoEntry: false });
+        const file = lstatSync7(join11(dir, SKILL_BODY_FILE), { throwIfNoEntry: false });
         if (file && (!file.isFile() || file.isSymbolicLink() || file.nlink !== 1)) throw new Error("Unsafe Skill artifact file");
       }
       mkdirSync8(dir, { recursive: true });
-      const bodyFile = join10(dir, SKILL_BODY_FILE);
+      const bodyFile = join11(dir, SKILL_BODY_FILE);
       if (this.options.skillReceipt) {
         if (!lstatSync7(bodyFile, { throwIfNoEntry: false })) writeFileSync4(bodyFile, skillMarkdown(skill), { encoding: "utf8", flag: "wx", mode: 384 });
       } else writeFileSync4(bodyFile, skillMarkdown(skill), "utf8");
-      if (this.options.skillReceipt) verifyMountedSkill(join10(dir, SKILL_BODY_FILE), this.options.skillReceipt);
+      if (this.options.skillReceipt) verifyMountedSkill(join11(dir, SKILL_BODY_FILE), this.options.skillReceipt);
       for (const file of skill.files) {
-        const target = resolve6(dir, file.path);
+        const target = resolve7(dir, file.path);
         if (!target.startsWith(`${dir}/`)) continue;
-        mkdirSync8(dirname6(target), { recursive: true });
+        mkdirSync8(dirname7(target), { recursive: true });
         writeFileSync4(target, file.content, "utf8");
       }
     }
@@ -6974,10 +7033,10 @@ var RunContext = class {
       // says where the repo is) stays read-only. Only the daemon-validated
       // per-worktree administration and object/ref paths are writable.
       denyWrite: [
-        join10(this.worktree, ".git"),
-        join10(this.gitDir, "commondir"),
-        join10(this.gitDir, "gitdir"),
-        join10(this.gitDir, "config.worktree"),
+        join11(this.worktree, ".git"),
+        join11(this.gitDir, "commondir"),
+        join11(this.gitDir, "gitdir"),
+        join11(this.gitDir, "config.worktree"),
         ...readOnly ? [this.worktree, ...this.options.gitWritePaths ?? []] : []
       ],
       denyRead: [
@@ -7037,7 +7096,7 @@ var RunContext = class {
    * and zsh writes here-docs to `$TMPPREFIX` (default `/tmp/zsh`).
    */
   tempEnv() {
-    return { TMPDIR: this.tmpDir, TMPPREFIX: join10(this.tmpDir, "zsh"), ...this.githubEnv, ...this.options.policyHash ? { MIKKA_POLICY_HASH: this.options.policyHash } : {} };
+    return { TMPDIR: this.tmpDir, TMPPREFIX: join11(this.tmpDir, "zsh"), ...this.githubEnv, ...this.options.policyHash ? { MIKKA_POLICY_HASH: this.options.policyHash } : {} };
   }
   /** A hand-in from an earlier session would end this one at once. */
   clearHandoff() {
@@ -7331,8 +7390,8 @@ async function runCodexCoordinator(input, host) {
   const messages = /* @__PURE__ */ new Map();
   let resolveEnd;
   let rejectEnd;
-  const ended = new Promise((resolve11, reject) => {
-    resolveEnd = resolve11;
+  const ended = new Promise((resolve12, reject) => {
+    resolveEnd = resolve12;
     rejectEnd = reject;
   });
   void ended.catch(() => void 0);
@@ -7438,8 +7497,8 @@ async function runNativeCoordinatorJob(job, options) {
   const budget = Math.min(12e4, Date.parse(job.expiresAt) - Date.now());
   if (budget <= 0) throw new Error("coordinatorJobExpired");
   mkdirSync9(options.stateDir, { recursive: true, mode: 448 });
-  const dir = mkdtempSync3(join11(options.stateDir, "turn-"));
-  const cwd = join11(dir, "context");
+  const dir = mkdtempSync3(join12(options.stateDir, "turn-"));
+  const cwd = join12(dir, "context");
   mkdirSync9(cwd, { mode: 448 });
   try {
     const tools = job.tools.map((spec) => {
@@ -7463,8 +7522,8 @@ async function runNativeCoordinatorJob(job, options) {
     const input = { instructions: job.instructions, context: job.context, model: job.model, signal, timeoutMs: budget };
     const reply = job.harness === "claude_code" ? await runClaudeCoordinator(input, { cwd, tools, executable: options.claudeBinary }) : await runCodexCoordinator(input, { cwd, tools, connect: async (active) => {
       active.throwIfAborted();
-      const home = prepareCodexHome(join11(dir, "codex-home"), options.log);
-      writeFileSync5(join11(home.home, "config.toml"), `approval_policy = "${CODEX_COORDINATOR_APPROVAL_POLICY}"
+      const home = prepareCodexHome(join12(dir, "codex-home"), options.log);
+      writeFileSync5(join12(home.home, "config.toml"), `approval_policy = "${CODEX_COORDINATOR_APPROVAL_POLICY}"
 sandbox_mode = "read-only"
 `, { mode: 384 });
       const checkAuth = guardCodexAuth(home.authFile, options.log);
@@ -7473,10 +7532,10 @@ sandbox_mode = "read-only"
         env: { ...buildChildEnv(process.env), CODEX_HOME: home.home },
         policy: {
           allowWrite: [dir, ...home.authFile ? [home.authFile] : []],
-          denyRead: [...credentialDenyRead("codex"), ...daemonSecrets(dirname7(options.stateDir))],
+          denyRead: [...credentialDenyRead("codex"), ...daemonSecrets(dirname8(options.stateDir))],
           allowDomains: HARNESS_DOMAINS.codex
         },
-        pidFile: join11(dir, "private", "codex.pid"),
+        pidFile: join12(dir, "private", "codex.pid"),
         marker: dir
       });
       const rpc = jsonlConnection(child.process.stdout, child.process.stdin);
@@ -7513,10 +7572,10 @@ import {
   mkdirSync as mkdirSync16,
   readFileSync as readFileSync11,
   rmSync as rmSync17,
-  realpathSync as realpathSync12
+  realpathSync as realpathSync13
 } from "node:fs";
 import { arch, hostname, platform as platform2 } from "node:os";
-import { join as join27 } from "node:path";
+import { join as join28 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 
 // src/adapters/claude.ts
@@ -7540,9 +7599,9 @@ function computerSandboxPolicy(policy, spec) {
 
 // src/adapters/claude.ts
 import { randomUUID as randomUUID3 } from "node:crypto";
-import { realpathSync as realpathSync8 } from "node:fs";
-import { homedir as homedir5 } from "node:os";
-import { join as join13 } from "node:path";
+import { realpathSync as realpathSync9 } from "node:fs";
+import { homedir as homedir6 } from "node:os";
+import { join as join14 } from "node:path";
 import {
   query as query2,
   createSdkMcpServer as createSdkMcpServer2
@@ -7636,8 +7695,8 @@ function spawnRunSandbox(options) {
   let outcome;
   let hardStop;
   let settle;
-  const exited = new Promise((resolve11) => {
-    settle = resolve11;
+  const exited = new Promise((resolve12) => {
+    settle = resolve12;
   });
   function send(message) {
     if (!child.connected || gone) return;
@@ -7803,15 +7862,15 @@ function runNetworkApproval(runId, harness, gate, maximum, localComputerEndpoint
 // src/subscription-native-broker.ts
 import { chmodSync, mkdirSync as mkdirSync10, mkdtempSync as mkdtempSync4, rmSync as rmSync10 } from "node:fs";
 import { createServer } from "node:http";
-import { join as join12 } from "node:path";
+import { join as join13 } from "node:path";
 import { once } from "node:events";
 var NATIVE_AUTH_PLACEHOLDER = "mikka-native-broker-placeholder";
 async function createNativeSubscriptionBroker(host) {
   await host.check();
   mkdirSync10(host.root, { recursive: true, mode: 448 });
-  const dir = mkdtempSync4(join12(host.root, "native-broker-"));
+  const dir = mkdtempSync4(join13(host.root, "native-broker-"));
   chmodSync(dir, 448);
-  const socket = join12(dir, "broker.sock");
+  const socket = join13(dir, "broker.sock");
   const pending = /* @__PURE__ */ new Set();
   let halted = false;
   const server = createServer(async (request, response) => {
@@ -7881,9 +7940,9 @@ async function createNativeSubscriptionBroker(host) {
     }
   });
   try {
-    await new Promise((resolve11, reject) => {
+    await new Promise((resolve12, reject) => {
       server.once("error", reject);
-      server.listen(socket, resolve11);
+      server.listen(socket, resolve12);
     });
     chmodSync(socket, 384);
   } catch {
@@ -7896,7 +7955,7 @@ async function createNativeSubscriptionBroker(host) {
       halted = true;
       for (const abort of pending) abort.abort();
       server.closeAllConnections();
-      await new Promise((resolve11) => server.close(() => resolve11()));
+      await new Promise((resolve12) => server.close(() => resolve12()));
       rmSync10(dir, { recursive: true, force: true });
     }
   };
@@ -8060,8 +8119,8 @@ var PromptQueue = class {
         continue;
       }
       if (this.closed) return;
-      await new Promise((resolve11) => {
-        this.waiter = resolve11;
+      await new Promise((resolve12) => {
+        this.waiter = resolve12;
       });
     }
   }
@@ -8075,8 +8134,8 @@ async function untilSpoken(spoken) {
   try {
     return await Promise.race([
       spoken,
-      new Promise((resolve11) => {
-        timer = setTimeout(() => resolve11(true), CONTINUE_SILENCE_MS);
+      new Promise((resolve12) => {
+        timer = setTimeout(() => resolve12(true), CONTINUE_SILENCE_MS);
       })
     ]);
   } finally {
@@ -8162,8 +8221,8 @@ var ClaudeAdapter = class {
         throw new Error(SUBSCRIPTION_ERROR);
       }
     }
-    const nativeHome = externalAuth ? join13(runDir, "native-home") : void 0;
-    const configDir = nativeHome ? join13(nativeHome, ".claude") : this.options.configDir ?? join13(homedir5(), ".claude");
+    const nativeHome = externalAuth ? join14(runDir, "native-home") : void 0;
+    const configDir = nativeHome ? join14(nativeHome, ".claude") : this.options.configDir ?? join14(homedir6(), ".claude");
     if (nativeHome) ownDir(configDir);
     const ctx = new RunContext({
       github: options.github,
@@ -8183,11 +8242,11 @@ var ClaudeAdapter = class {
       privateDir: paths.privateDir,
       // Its session store, so `resume` works; keyed by the cwd it sees.
       extraWrite: [
-        join13(configDir, "projects", claudeProjectDirName(options.cwd)),
-        join13(
+        join14(configDir, "projects", claudeProjectDirName(options.cwd)),
+        join14(
           configDir,
           "projects",
-          claudeProjectDirName(realpathSync8(options.cwd))
+          claudeProjectDirName(realpathSync9(options.cwd))
         )
       ]
     });
@@ -8213,9 +8272,9 @@ var ClaudeAdapter = class {
     let stderr = "";
     const stderrTail = () => stderr.slice(-STDERR_TAIL2).trim() || "no output";
     let spoke = () => void 0;
-    const spoken = new Promise((resolve11) => spoke = resolve11);
+    const spoken = new Promise((resolve12) => spoke = resolve12);
     let finished = () => void 0;
-    const gone = new Promise((resolve11) => finished = resolve11);
+    const gone = new Promise((resolve12) => finished = resolve12);
     if (externalAuth && this.options.onHostedSession) {
       try {
         await this.options.onHostedSession(sessionId);
@@ -8428,7 +8487,7 @@ var ClaudeAdapter = class {
 };
 
 // src/adapters/codex.ts
-import { isAbsolute as isAbsolute4, join as join14, relative as relative3 } from "node:path";
+import { isAbsolute as isAbsolute4, join as join15, relative as relative3 } from "node:path";
 var SUBSCRIPTION_AUTH_ERROR = "Codex subscription authentication unavailable";
 var SUBSCRIPTION_EXECUTION_ERROR2 = "Codex subscription execution failed";
 function subscriptionTokens(value, accountId) {
@@ -8589,8 +8648,8 @@ var CodexAdapter = class {
           options.continueSession.runId
         ).runDir;
         carryHistory(
-          join14(earlier2, "codex-home"),
-          join14(runDir, "codex-home"),
+          join15(earlier2, "codex-home"),
+          join15(runDir, "codex-home"),
           CODEX_HISTORY
         );
       } catch (error) {
@@ -8602,7 +8661,7 @@ var CodexAdapter = class {
       }
     }
     const codexHome = prepareCodexHome(
-      join14(runDir, "codex-home"),
+      join15(runDir, "codex-home"),
       log,
       this.options.userHome,
       !externalAuth
@@ -9052,7 +9111,7 @@ var CodexAdapter = class {
 // src/adapters/cursor.ts
 import { Readable, Writable } from "node:stream";
 import * as acp from "@agentclientprotocol/sdk";
-import { join as join15 } from "node:path";
+import { join as join16 } from "node:path";
 function acpPermissionResponse(params, policy) {
   const pick = (kinds) => {
     for (const kind of kinds) {
@@ -9187,15 +9246,15 @@ var CursorAdapter = class {
           options.continueSession.runId
         ).runDir;
         carryHistory(
-          join15(earlier2, "cursor-home"),
-          join15(paths.runDir, "cursor-home"),
+          join16(earlier2, "cursor-home"),
+          join16(paths.runDir, "cursor-home"),
           CURSOR_HISTORY
         );
       } catch (error) {
         log.info({ err: error }, "could not copy the earlier cursor chats");
       }
     }
-    const configDir = prepareCursorHome(join15(paths.runDir, "cursor-home"));
+    const configDir = prepareCursorHome(join16(paths.runDir, "cursor-home"));
     const ctx = new RunContext({
       github: options.github,
       childPath: options.env.PATH,
@@ -9428,7 +9487,7 @@ ${firstMessage}` : firstMessage
 // src/adapters/mock.ts
 import { randomUUID as randomUUID4 } from "node:crypto";
 import { mkdirSync as mkdirSync11, readFileSync as readFileSync9, writeFileSync as writeFileSync6 } from "node:fs";
-import { dirname as dirname8, join as join16, resolve as resolve7 } from "node:path";
+import { dirname as dirname9, join as join17, resolve as resolve8 } from "node:path";
 import { setTimeout as sleep2 } from "node:timers/promises";
 import { execa as execa5 } from "execa";
 
@@ -9450,7 +9509,7 @@ function isRunChunk(value) {
 }
 
 // src/adapters/mock.ts
-var DEFAULT_FIXTURES_DIR = resolve7(
+var DEFAULT_FIXTURES_DIR = resolve8(
   import.meta.dirname,
   true ? "./fixtures" : "../../fixtures"
 );
@@ -9484,7 +9543,7 @@ var MockAdapter = class {
   fixturesDir;
   speed;
   stateFile(sessionId) {
-    return join16(
+    return join17(
       this.options.stateDir,
       `mock-${assertSafeId("session id", sessionId)}.json`
     );
@@ -9528,7 +9587,7 @@ var MockAdapter = class {
   open(sessionId, state, options) {
     const name = assertSafeId("fixture", state.fixture.replace(/\.jsonl$/, ""));
     const lines = parseFixture(
-      readFileSync9(join16(this.fixturesDir, `${name}.jsonl`), "utf8"),
+      readFileSync9(join17(this.fixturesDir, `${name}.jsonl`), "utf8"),
       name
     );
     const abort = new AbortController();
@@ -9566,7 +9625,7 @@ var MockAdapter = class {
         if (line.hang) {
           if (!abort.signal.aborted) {
             await new Promise(
-              (resolve11) => abort.signal.addEventListener("abort", resolve11, { once: true })
+              (resolve12) => abort.signal.addEventListener("abort", resolve12, { once: true })
             );
           }
           yield { type: "exit", outcome: "cancelled" };
@@ -9578,8 +9637,8 @@ var MockAdapter = class {
               `mock fixture writes outside the worktree: ${line.write.path}`
             );
           }
-          const target = resolve7(options.cwd, line.write.path);
-          mkdirSync11(dirname8(target), { recursive: true });
+          const target = resolve8(options.cwd, line.write.path);
+          mkdirSync11(dirname9(target), { recursive: true });
           writeFileSync6(target, line.write.content);
         }
         if (line.chunk) yield { type: "chunk", chunk: line.chunk };
@@ -9641,19 +9700,19 @@ var MockAdapter = class {
 };
 
 // src/agents/verify.ts
-import { mkdirSync as mkdirSync12, mkdtempSync as mkdtempSync5, realpathSync as realpathSync9, rmSync as rmSync11 } from "node:fs";
-import { join as join17 } from "node:path";
+import { mkdirSync as mkdirSync12, mkdtempSync as mkdtempSync5, realpathSync as realpathSync10, rmSync as rmSync11 } from "node:fs";
+import { join as join18 } from "node:path";
 var OUTPUT_TAIL = 4e3;
 async function runVerify(sandbox, options) {
   mkdirSync12(options.tmpRoot, { recursive: true, mode: 448 });
-  const tmpDir = mkdtempSync5(join17(realpathSync9(options.tmpRoot), "verify-"));
+  const tmpDir = mkdtempSync5(join18(realpathSync10(options.tmpRoot), "verify-"));
   const child = await spawnCli(sandbox, ["/bin/sh", "-c", options.command], {
     cwd: options.worktree,
     env: { ...options.env, TMPDIR: tmpDir },
     policy: {
       allowWrite: options.readOnly ? [tmpDir] : [options.worktree, tmpDir],
       denyWrite: [
-        join17(options.worktree, ".git"),
+        join18(options.worktree, ".git"),
         ...options.readOnly ? [options.worktree] : []
       ],
       denyRead: [
@@ -9664,7 +9723,7 @@ async function runVerify(sandbox, options) {
     },
     pidFile: options.pidFile,
     // Every verify of this run carries the temp root in its profile.
-    marker: realpathSync9(options.tmpRoot)
+    marker: realpathSync10(options.tmpRoot)
   });
   child.process.stdin.end();
   let output = "";
@@ -9821,12 +9880,12 @@ var SandboxRuntime = class _SandboxRuntime {
 import { SandboxManager as SandboxManager2 } from "@anthropic-ai/sandbox-runtime";
 
 // src/fs-browse.ts
-import { execFile as execFile2 } from "node:child_process";
+import { execFile as execFile3 } from "node:child_process";
 import { readdir as readdir2, realpath, stat } from "node:fs/promises";
-import { homedir as homedir6, platform } from "node:os";
-import { basename as basename2, dirname as dirname9, isAbsolute as isAbsolute5, join as join18, resolve as resolve8 } from "node:path";
-import { promisify as promisify2 } from "node:util";
-var run = promisify2(execFile2);
+import { homedir as homedir7, platform } from "node:os";
+import { basename as basename2, dirname as dirname10, isAbsolute as isAbsolute5, join as join19, resolve as resolve9 } from "node:path";
+import { promisify as promisify3 } from "node:util";
+var run = promisify3(execFile3);
 async function git(cwd, args) {
   try {
     const { stdout } = await run("git", ["-C", cwd, ...args], {
@@ -9862,7 +9921,7 @@ async function repoAround(path) {
   return { path: top, remoteUrl };
 }
 async function browseFolder(request) {
-  const home = homedir6();
+  const home = homedir7();
   const wanted = request.path ?? home;
   if (!isAbsolute5(wanted))
     return {
@@ -9870,7 +9929,7 @@ async function browseFolder(request) {
       code: "not_found",
       message: "Expected an absolute path."
     };
-  const path = resolve8(wanted);
+  const path = resolve9(wanted);
   if (!await exists(path))
     return { ok: false, code: "not_found", message: `${path} does not exist.` };
   if (!await isDir(path))
@@ -9894,7 +9953,7 @@ async function browseFolder(request) {
   let truncated = false;
   const dirs = names.filter((e) => e.isDirectory() || e.isSymbolicLink()).filter((e) => request.showHidden || !e.name.startsWith(".")).sort((a, b) => a.name.localeCompare(b.name));
   for (const entry of dirs) {
-    const full = join18(path, entry.name);
+    const full = join19(path, entry.name);
     if (entry.isSymbolicLink() && !await isDir(full)) continue;
     if (folders.length >= FS_MAX_ENTRIES) {
       truncated = true;
@@ -9903,10 +9962,10 @@ async function browseFolder(request) {
     folders.push({
       name: entry.name,
       path: full,
-      isRepo: await exists(join18(full, ".git"))
+      isRepo: await exists(join19(full, ".git"))
     });
   }
-  const parent = dirname9(path);
+  const parent = dirname10(path);
   return {
     ok: true,
     path,
@@ -10155,7 +10214,7 @@ import {
   rmSync as rmSync12,
   truncateSync
 } from "node:fs";
-import { join as join19 } from "node:path";
+import { join as join20 } from "node:path";
 var Outbox = class {
   constructor(dir, link, log, retryMs = 1e3, onUndeliverable = () => void 0, retainResources = false) {
     this.dir = dir;
@@ -10178,10 +10237,10 @@ var Outbox = class {
   /** Runs whose file was checked for a torn tail since this process started. */
   repaired = /* @__PURE__ */ new Set();
   file(runId) {
-    return join19(this.dir, `${assertSafeId("run id", runId)}.jsonl`);
+    return join20(this.dir, `${assertSafeId("run id", runId)}.jsonl`);
   }
   ackFile(runId) {
-    return join19(this.dir, `${assertSafeId("run id", runId)}.ack.json`);
+    return join20(this.dir, `${assertSafeId("run id", runId)}.ack.json`);
   }
   parse(runId) {
     let data;
@@ -10365,16 +10424,16 @@ var Outbox = class {
 };
 
 // src/quota/local-credentials.ts
-import { homedir as homedir7 } from "node:os";
-import { join as join21 } from "node:path";
+import { homedir as homedir8 } from "node:os";
+import { join as join22 } from "node:path";
 
 // src/quota/files.ts
-import { execFile as execFile3 } from "node:child_process";
+import { execFile as execFile4 } from "node:child_process";
 import { constants as constants2 } from "node:fs";
 import { lstat as lstat2, open } from "node:fs/promises";
-import { promisify as promisify3 } from "node:util";
+import { promisify as promisify4 } from "node:util";
 var NOFOLLOW = constants2.O_NOFOLLOW ?? 0;
-var execFileAsync = promisify3(execFile3);
+var execFileAsync = promisify4(execFile4);
 var KEYCHAIN_TIMEOUT_MS = 3e4;
 var MAX_CREDENTIAL_BYTES = 64 * 1024;
 function sanitizeError(error) {
@@ -10400,8 +10459,8 @@ function classifyKeychainError(error) {
 function safeAccount(account) {
   return /^[A-Za-z0-9._-]{1,64}$/.test(account);
 }
-async function readKeychainPassword(service, accounts = [null], exec4 = execFileAsync) {
-  if (process.platform !== "darwin" && exec4 === execFileAsync) {
+async function readKeychainPassword(service, accounts = [null], exec5 = execFileAsync) {
+  if (process.platform !== "darwin" && exec5 === execFileAsync) {
     return { status: "notFound" };
   }
   let denied = false;
@@ -10415,7 +10474,7 @@ async function readKeychainPassword(service, accounts = [null], exec4 = execFile
       "-w"
     ];
     try {
-      const { stdout } = await exec4("/usr/bin/security", args, {
+      const { stdout } = await exec5("/usr/bin/security", args, {
         timeout: KEYCHAIN_TIMEOUT_MS,
         maxBuffer: MAX_CREDENTIAL_BYTES
       });
@@ -10864,12 +10923,12 @@ async function readCodexQuota(options) {
 
 // src/quota/cursor.ts
 import { lstat as lstat3 } from "node:fs/promises";
-import { join as join20 } from "node:path";
+import { join as join21 } from "node:path";
 var ENDPOINT3 = "https://cursor.com/api/usage-summary";
 var ACCESS_TOKEN_KEY = "cursorAuth/accessToken";
 function cursorDatabasePath(platform3, home) {
   if (platform3 === "darwin") {
-    return join20(
+    return join21(
       home,
       "Library",
       "Application Support",
@@ -10880,7 +10939,7 @@ function cursorDatabasePath(platform3, home) {
     );
   }
   if (platform3 === "win32") {
-    return join20(
+    return join21(
       home,
       "AppData",
       "Roaming",
@@ -10890,7 +10949,7 @@ function cursorDatabasePath(platform3, home) {
       "state.vscdb"
     );
   }
-  return join20(home, ".config", "Cursor", "User", "globalStorage", "state.vscdb");
+  return join21(home, ".config", "Cursor", "User", "globalStorage", "state.vscdb");
 }
 var CURSOR_PLANS = {
   pro: "Pro",
@@ -11062,10 +11121,10 @@ async function readCursorQuota(options) {
 // src/quota/local-credentials.ts
 var KEYCHAIN_SERVICE = "Claude Code-credentials";
 function claudeCredentialPath(home) {
-  return join21(home, ".claude", ".credentials.json");
+  return join22(home, ".claude", ".credentials.json");
 }
 function codexAuthPath(home) {
-  return join21(home, ".codex", "auth.json");
+  return join22(home, ".codex", "auth.json");
 }
 function unknown2(vendor, observedAt) {
   return {
@@ -11084,7 +11143,7 @@ var LocalCredentialsSource = class {
   options;
   id = "local_credentials";
   async read(signal) {
-    const home = this.options.home ?? homedir7();
+    const home = this.options.home ?? homedir8();
     const platform3 = this.options.platform ?? process.platform;
     const fetchImpl = this.options.fetch ?? globalThis.fetch;
     const now = this.options.now ?? Date.now;
@@ -11260,9 +11319,9 @@ var RpcServer = class {
     const { socketPath } = this.options;
     rmSync13(socketPath, { force: true });
     const server = createServer2((socket) => this.accept(socket));
-    await new Promise((resolve11, reject) => {
+    await new Promise((resolve12, reject) => {
       server.once("error", reject);
-      server.listen(socketPath, () => resolve11());
+      server.listen(socketPath, () => resolve12());
     });
     chmodSync2(socketPath, 384);
     this.server = server;
@@ -11326,9 +11385,9 @@ var RpcServer = class {
   }
   async close() {
     for (const socket of this.sockets) socket.destroy();
-    await new Promise((resolve11) => {
-      if (!this.server) return resolve11();
-      this.server.close(() => resolve11());
+    await new Promise((resolve12) => {
+      if (!this.server) return resolve12();
+      this.server.close(() => resolve12());
     });
     this.server = null;
     rmSync13(this.options.socketPath, { force: true });
@@ -11554,13 +11613,13 @@ function createRunMasker(secrets) {
 
 // src/runs/supervisor.ts
 import { createHash as createHash4, randomUUID as randomUUID6 } from "node:crypto";
-import { join as join23, resolve as resolve9 } from "node:path";
+import { join as join24, resolve as resolve10 } from "node:path";
 import { execa as execa12 } from "execa";
 
 // src/agents/checkpoint.ts
 import { mkdtempSync as mkdtempSync6, rmSync as rmSync14, writeFileSync as writeFileSync7 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
-import { join as join22 } from "node:path";
+import { join as join23 } from "node:path";
 import { gunzipSync as gunzipSync2, gzipSync as gzipSync2 } from "node:zlib";
 import { execa as execa11 } from "execa";
 var CheckpointRecoveryError = class extends Error {
@@ -11607,8 +11666,8 @@ async function takeCheckpoint(options) {
 }
 async function applyCheckpoint(options) {
   const git2 = await pinnedGit(options.repoPath, options.worktree);
-  const dir = mkdtempSync6(join22(tmpdir2(), "mikka-checkpoint-"));
-  const file = join22(dir, "checkpoint.patch");
+  const dir = mkdtempSync6(join23(tmpdir2(), "mikka-checkpoint-"));
+  const file = join23(dir, "checkpoint.patch");
   try {
     const patch = gunzipSync2(Buffer.from(options.checkpoint.patch, "base64"));
     if (!patch.length && options.checkpoint.files === 0) return true;
@@ -11856,12 +11915,12 @@ var MemoryServer = class {
         this.check();
         let pending = this.pendingCommands(deviceId, skip);
         if (pending.length === 0 && waitSeconds > 0 && !signal?.aborted) {
-          await new Promise((resolve11) => {
-            const timer = setTimeout(resolve11, waitSeconds * 1e3);
-            signal?.addEventListener("abort", () => resolve11(), { once: true });
+          await new Promise((resolve12) => {
+            const timer = setTimeout(resolve12, waitSeconds * 1e3);
+            signal?.addEventListener("abort", () => resolve12(), { once: true });
             this.wakeCommands.push(() => {
               clearTimeout(timer);
-              resolve11();
+              resolve12();
             });
           });
           this.check();
@@ -12269,9 +12328,9 @@ var RunSupervisor = class {
       run2.abort.abort();
     }
     let timer;
-    const grace = new Promise((resolve11) => {
+    const grace = new Promise((resolve12) => {
       timer = setTimeout(
-        resolve11,
+        resolve12,
         this.deps.stopGraceMs ?? DEFAULT_STOP_GRACE_MS
       );
     });
@@ -12463,8 +12522,8 @@ var RunSupervisor = class {
     let timer;
     await Promise.race([
       this.deps.captures.flush(runId),
-      new Promise((resolve11) => {
-        timer = setTimeout(resolve11, 6e4);
+      new Promise((resolve12) => {
+        timer = setTimeout(resolve12, 6e4);
       })
     ]).finally(() => clearTimeout(timer));
   }
@@ -12798,7 +12857,7 @@ var RunSupervisor = class {
       mailbox
     };
     const resuming = entry.sessionId !== null && adapter.capabilities.supportsResume;
-    const inEarlierWorktree = continued !== null || entry.worktree !== null && resolve9(entry.worktree) !== resolve9(this.deps.worktrees.pathFor(runId));
+    const inEarlierWorktree = continued !== null || entry.worktree !== null && resolve10(entry.worktree) !== resolve10(this.deps.worktrees.pathFor(runId));
     const continueSession = !resuming && assignment.resumeSessionId && assignment.continuesRunId && inEarlierWorktree && adapter.capabilities.supportsResume ? {
       sessionId: assignment.resumeSessionId,
       runId: assignment.continuesRunId,
@@ -12845,7 +12904,7 @@ var RunSupervisor = class {
         if (!this.deps.adapterStateDir || assignment.harness === "mock" || !session.sessionId || resuming && session.sessionId !== entry.sessionId || assignment.requireSessionResume && session.sessionId !== assignment.resumeSessionId)
           throw new Error("Skill mount requires the actual original harness session");
         verifySkillAssignment(assignment);
-        const file = join23(
+        const file = join24(
           runPaths(this.deps.adapterStateDir, runId).runDir,
           SKILLS_DIR,
           skillSlug(assignment.skills[0].name),
@@ -13027,10 +13086,10 @@ function trackParts(open2, chunk) {
 }
 var ABORTED = /* @__PURE__ */ Symbol("aborted");
 function abortPromise(signal) {
-  return new Promise((resolve11) => {
-    if (signal.aborted) resolve11(ABORTED);
+  return new Promise((resolve12) => {
+    if (signal.aborted) resolve12(ABORTED);
     else
-      signal.addEventListener("abort", () => resolve11(ABORTED), { once: true });
+      signal.addEventListener("abort", () => resolve12(ABORTED), { once: true });
   });
 }
 function pickAgentReport(agent) {
@@ -13109,8 +13168,8 @@ function fixedCandidateCheck(assignment) {
 
 // src/repositories.ts
 import { createHash as createHash5, randomUUID as randomUUID7 } from "node:crypto";
-import { existsSync as existsSync5, lstatSync as lstatSync8, mkdirSync as mkdirSync14, readdirSync as readdirSync5, realpathSync as realpathSync10, renameSync as renameSync2, rmSync as rmSync15 } from "node:fs";
-import { dirname as dirname10, join as join24, resolve as resolve10 } from "node:path";
+import { existsSync as existsSync5, lstatSync as lstatSync8, mkdirSync as mkdirSync14, readdirSync as readdirSync5, realpathSync as realpathSync11, renameSync as renameSync2, rmSync as rmSync15 } from "node:fs";
+import { dirname as dirname11, join as join25, resolve as resolve11 } from "node:path";
 import { setTimeout as delay2 } from "node:timers/promises";
 import { execa as execa13 } from "execa";
 import lockfile2 from "proper-lockfile";
@@ -13125,8 +13184,8 @@ var RepositoryCache = class {
   retainResources;
   pathFor(remoteUrl) {
     const { key: key2 } = normalizeRepository(remoteUrl, { allowFile: this.allowFile });
-    const path = resolve10(this.root, "v2", createHash5("sha256").update(key2).digest("hex"));
-    if (!isInside(resolve10(this.root), path) || path === resolve10(this.root)) throw new Error("Invalid repository cache path");
+    const path = resolve11(this.root, "v2", createHash5("sha256").update(key2).digest("hex"));
+    if (!isInside(resolve11(this.root), path) || path === resolve11(this.root)) throw new Error("Invalid repository cache path");
     return path;
   }
   /** Serialize clone/fetch against the same cache, including other processes. */
@@ -13134,7 +13193,7 @@ var RepositoryCache = class {
     signal?.throwIfAborted();
     const { remoteUrl: remote } = normalizeRepository(remoteUrl, { allowFile: this.allowFile });
     const path = this.pathFor(remote);
-    this.ensureParents(dirname10(path));
+    this.ensureParents(dirname11(path));
     const release = await this.lock(path, signal);
     try {
       signal?.throwIfAborted();
@@ -13178,29 +13237,29 @@ var RepositoryCache = class {
   paths() {
     const visit = (path) => {
       if (!existsSync5(path) || lstatSync8(path).isSymbolicLink()) return [];
-      if (existsSync5(join24(path, ".git"))) {
+      if (existsSync5(join25(path, ".git"))) {
         this.assertClone(path);
         return [path];
       }
-      return readdirSync5(path, { withFileTypes: true }).flatMap((entry) => entry.isDirectory() && !entry.name.endsWith(".lock") && !entry.name.includes(".clone-") ? visit(join24(path, entry.name)) : []);
+      return readdirSync5(path, { withFileTypes: true }).flatMap((entry) => entry.isDirectory() && !entry.name.endsWith(".lock") && !entry.name.includes(".clone-") ? visit(join25(path, entry.name)) : []);
     };
-    return visit(resolve10(this.root));
+    return visit(resolve11(this.root));
   }
   ensureParents(path) {
     mkdirSync14(this.root, { recursive: true, mode: 448 });
     if (lstatSync8(this.root).isSymbolicLink()) throw new Error("Repository cache contains a symlink");
-    const root = realpathSync10(this.root);
-    let current = resolve10(this.root);
+    const root = realpathSync11(this.root);
+    let current = resolve11(this.root);
     for (const part of path.slice(current.length + 1).split("/").filter(Boolean)) {
-      current = join24(current, part);
+      current = join25(current, part);
       if (existsSync5(current) && lstatSync8(current).isSymbolicLink()) throw new Error("Repository cache contains a symlink");
       mkdirSync14(current, { recursive: true, mode: 448 });
-      if (!isInside(root, realpathSync10(current))) throw new Error("Repository cache escapes its directory");
+      if (!isInside(root, realpathSync11(current))) throw new Error("Repository cache escapes its directory");
     }
   }
   assertClone(path) {
-    if (lstatSync8(path).isSymbolicLink() || !lstatSync8(join24(path, ".git")).isDirectory() || lstatSync8(join24(path, ".git")).isSymbolicLink()) throw new Error("Repository cache is not a standard clone");
-    if (!isInside(realpathSync10(this.root), realpathSync10(path))) throw new Error("Repository cache escapes its directory");
+    if (lstatSync8(path).isSymbolicLink() || !lstatSync8(join25(path, ".git")).isDirectory() || lstatSync8(join25(path, ".git")).isSymbolicLink()) throw new Error("Repository cache is not a standard clone");
+    if (!isInside(realpathSync11(this.root), realpathSync11(path))) throw new Error("Repository cache escapes its directory");
   }
   async lock(path, signal) {
     const deadline = Date.now() + 12e4;
@@ -13217,7 +13276,7 @@ var RepositoryCache = class {
 };
 
 // src/subscription-hosted-runner.ts
-import { execFile as execFile4, spawn as spawn4 } from "node:child_process";
+import { execFile as execFile5, spawn as spawn4 } from "node:child_process";
 import { randomUUID as randomUUID8 } from "node:crypto";
 import {
   existsSync as existsSync6,
@@ -13225,13 +13284,13 @@ import {
   mkdirSync as mkdirSync15,
   mkdtempSync as mkdtempSync7,
   readdirSync as readdirSync6,
-  realpathSync as realpathSync11,
+  realpathSync as realpathSync12,
   rmSync as rmSync16
 } from "node:fs";
 import { createRequire } from "node:module";
-import { delimiter as delimiter2, dirname as dirname11, join as join26 } from "node:path";
+import { delimiter as delimiter2, dirname as dirname12, join as join27 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
-import { promisify as promisify4 } from "node:util";
+import { promisify as promisify5 } from "node:util";
 
 // src/agents/public-egress.ts
 import { lookup } from "node:dns/promises";
@@ -13239,7 +13298,7 @@ import { chmod, mkdtemp, rm as rm2 } from "node:fs/promises";
 import { createServer as createServer3, request as httpRequest } from "node:http";
 import { connect, isIP as isIP3 } from "node:net";
 import { tmpdir as tmpdir3 } from "node:os";
-import { join as join25 } from "node:path";
+import { join as join26 } from "node:path";
 
 // ../../lib/search/url-policy.ts
 import { BlockList, isIP as isIP2 } from "node:net";
@@ -13308,9 +13367,9 @@ function endToEndHeaders(input) {
 }
 async function startPublicEgress(options) {
   options.signal.throwIfAborted();
-  const directory = await mkdtemp(join25(tmpdir3(), "mikka-egress-"));
+  const directory = await mkdtemp(join26(tmpdir3(), "mikka-egress-"));
   await chmod(directory, 448);
-  const socketPath = join25(directory, "egress.sock");
+  const socketPath = join26(directory, "egress.sock");
   const lifetime = new AbortController();
   const signal = AbortSignal.any([options.signal, lifetime.signal]);
   const sockets = /* @__PURE__ */ new Set();
@@ -13415,9 +13474,9 @@ async function startPublicEgress(options) {
     if (closing) return closing;
     lifetime.abort();
     for (const socket of sockets) socket.destroy();
-    closing = new Promise((resolve11, reject) => server.close((error) => {
+    closing = new Promise((resolve12, reject) => server.close((error) => {
       options.signal.removeEventListener("abort", onAbort);
-      void rm2(directory, { recursive: true, force: true }).then(() => error && error.code !== "ERR_SERVER_NOT_RUNNING" ? reject(error) : resolve11(), reject);
+      void rm2(directory, { recursive: true, force: true }).then(() => error && error.code !== "ERR_SERVER_NOT_RUNNING" ? reject(error) : resolve12(), reject);
     }));
     return closing;
   };
@@ -13426,11 +13485,11 @@ async function startPublicEgress(options) {
   };
   options.signal.addEventListener("abort", onAbort, { once: true });
   try {
-    await new Promise((resolve11, reject) => {
+    await new Promise((resolve12, reject) => {
       server.once("error", reject);
       server.listen(socketPath, () => {
         server.removeListener("error", reject);
-        resolve11();
+        resolve12();
       });
     });
     await chmod(socketPath, 384);
@@ -13443,7 +13502,7 @@ async function startPublicEgress(options) {
 }
 
 // src/subscription-hosted-runner.ts
-var exec2 = promisify4(execFile4);
+var exec3 = promisify5(execFile5);
 var image = HOSTED_NATIVE_IMAGE;
 var bootstrap = fileURLToPath2(
   new URL("./agents/native-container.mjs", import.meta.url)
@@ -13461,20 +13520,20 @@ async function createHostedBotRunner(host) {
     throw unavailable2();
   if (host.dockerSocket !== void 0 && host.dockerSocket !== "unix:///run/mikka-container/docker.sock") throw unavailable2();
   const bareEnv = { PATH: process.env.PATH, LANG: "C.UTF-8", ...host.dockerSocket ? { DOCKER_HOST: host.dockerSocket } : {} };
-  await exec2("docker", ["image", "inspect", image, "--format", "{{.Id}}"], {
+  await exec3("docker", ["image", "inspect", image, "--format", "{{.Id}}"], {
     env: bareEnv,
     timeout: 1e4
   }).catch(() => {
     throw unavailable2();
   });
-  const resources = join26(host.stateDir, "native-resources");
+  const resources = join27(host.stateDir, "native-resources");
   mkdirSync15(resources, { recursive: true, mode: 448 });
   const removeResource = async (file, record) => {
     if (!/^mikka-native-(?:verify-)?[a-f0-9-]{36}$/.test(record.name) || !/^[a-f0-9-]{36}$/.test(record.nonce))
       throw unavailable2();
     let described;
     try {
-      described = await exec2(
+      described = await exec3(
         "docker",
         [
           "inspect",
@@ -13488,7 +13547,7 @@ async function createHostedBotRunner(host) {
       if (record.state === "created" && /No such (?:container|object)/i.test(
         String(error.stderr)
       )) {
-        if (record.assets?.startsWith(join26(host.stateDir, "native-verify-git-")))
+        if (record.assets?.startsWith(join27(host.stateDir, "native-verify-git-")))
           rmSync16(record.assets, { recursive: true, force: true });
         rmSync16(file, { force: true });
         return;
@@ -13498,14 +13557,14 @@ async function createHostedBotRunner(host) {
     const [id4, labels] = described.stdout.trim().split("|").map((part) => JSON.parse(part));
     if (labels?.["com.mikka.native.resource"] !== record.nonce || record.id && record.id !== id4)
       throw unavailable2();
-    await exec2("docker", ["rm", "-f", id4], { env: bareEnv, timeout: 3e4 });
-    if (record.assets?.startsWith(join26(host.stateDir, "native-verify-git-")))
+    await exec3("docker", ["rm", "-f", id4], { env: bareEnv, timeout: 3e4 });
+    if (record.assets?.startsWith(join27(host.stateDir, "native-verify-git-")))
       rmSync16(record.assets, { recursive: true, force: true });
     rmSync16(file, { force: true });
   };
   for (const name of readdirSync6(resources))
     if (name.endsWith(".json")) {
-      const file = join26(resources, name);
+      const file = join27(resources, name);
       const record = readJson(file);
       if (!record) throw unavailable2();
       await removeResource(file, record);
@@ -13516,8 +13575,8 @@ async function createHostedBotRunner(host) {
     const bundled = createRequire(
       require2.resolve("@anthropic-ai/claude-agent-sdk")
     );
-    claude ??= join26(
-      dirname11(
+    claude ??= join27(
+      dirname12(
         bundled.resolve(
           "@anthropic-ai/claude-agent-sdk-linux-x64/package.json"
         )
@@ -13526,12 +13585,12 @@ async function createHostedBotRunner(host) {
     );
   } catch {
   }
-  const codex = host.binaries?.codex ?? (process.env.PATH ?? "").split(delimiter2).map((dir) => join26(dir, "codex")).find((path) => existsSync6(path));
+  const codex = host.binaries?.codex ?? (process.env.PATH ?? "").split(delimiter2).map((dir) => join27(dir, "codex")).find((path) => existsSync6(path));
   const binaries = { codex, claude_code: claude };
   for (const kind of ["codex", "claude_code"])
     if (binaries[kind]) {
       try {
-        binaries[kind] = realpathSync11(binaries[kind]);
+        binaries[kind] = realpathSync12(binaries[kind]);
         if (!lstatSync9(binaries[kind]).isFile()) delete binaries[kind];
       } catch {
         delete binaries[kind];
@@ -13540,16 +13599,16 @@ async function createHostedBotRunner(host) {
   if (!binaries.codex && !binaries.claude_code) throw unavailable2();
   const command = async (worktree, script, readOnly, timeoutMs, signal) => {
     const name = `mikka-native-verify-${randomUUID8()}`;
-    const file = join26(resources, name + ".json");
+    const file = join27(resources, name + ".json");
     const resource = { name, nonce: randomUUID8(), state: "creating" };
     const timing = { createMs: 0, runMs: 0 };
     let phase = "create";
     let began = performance.now();
-    const gitCopy = mkdtempSync7(join26(host.stateDir, "native-verify-git-"));
+    const gitCopy = mkdtempSync7(join27(host.stateDir, "native-verify-git-"));
     resource.assets = gitCopy;
     try {
-      const cwd = realpathSync11(worktree);
-      await exec2(
+      const cwd = realpathSync12(worktree);
+      await exec3(
         "git",
         [
           "-c",
@@ -13561,7 +13620,7 @@ async function createHostedBotRunner(host) {
           "--no-checkout",
           "--",
           cwd,
-          join26(gitCopy, "repo")
+          join27(gitCopy, "repo")
         ],
         {
           env: {
@@ -13576,10 +13635,10 @@ async function createHostedBotRunner(host) {
           maxBuffer: 1024 * 1024
         }
       );
-      const safeGit = join26(gitCopy, "repo", ".git");
-      const protectedGit = lstatSync9(join26(cwd, ".git")).isFile() ? join26(cwd, ".git") : safeGit;
+      const safeGit = join27(gitCopy, "repo", ".git");
+      const protectedGit = lstatSync9(join27(cwd, ".git")).isFile() ? join27(cwd, ".git") : safeGit;
       writeJsonAtomic(file, resource);
-      const created = await exec2(
+      const created = await exec3(
         "docker",
         [
           "create",
@@ -13637,7 +13696,7 @@ async function createHostedBotRunner(host) {
       timing.createMs = Math.round(performance.now() - began);
       phase = "run";
       began = performance.now();
-      const result = await exec2("docker", ["start", "-a", resource.id], {
+      const result = await exec3("docker", ["start", "-a", resource.id], {
         env: bareEnv,
         timeout: timeoutMs,
         signal,
@@ -13681,7 +13740,7 @@ async function createHostedBotRunner(host) {
         throw unavailable2();
       const name = `mikka-native-${randomUUID8()}`;
       const nonce = randomUUID8();
-      const resourceFile = join26(resources, name + ".json");
+      const resourceFile = join27(resources, name + ".json");
       const resource = { name, nonce, state: "creating" };
       const lifetime = new AbortController();
       let closed = false;
@@ -13754,11 +13813,11 @@ async function createHostedBotRunner(host) {
         };
         const paths = runPaths(host.stateDir, assignment.runId);
         mkdirSync15(paths.runDir, { recursive: true, mode: 448 });
-        const shadow = join26(paths.runDir, "runtime-git");
-        const emptyHome = join26(paths.runDir, "git-bootstrap-home");
+        const shadow = join27(paths.runDir, "runtime-git");
+        const emptyHome = join27(paths.runDir, "git-bootstrap-home");
         mkdirSync15(emptyHome, { recursive: true, mode: 448 });
         if (!existsSync6(shadow))
-          await exec2(
+          await exec3(
             "git",
             [
               "-c",
@@ -13769,7 +13828,7 @@ async function createHostedBotRunner(host) {
               "--no-hardlinks",
               "--no-checkout",
               "--",
-              realpathSync11(options.cwd),
+              realpathSync12(options.cwd),
               shadow
             ],
             {
@@ -13786,9 +13845,9 @@ async function createHostedBotRunner(host) {
             }
           );
         await live();
-        if (!lstatSync9(shadow).isDirectory() || !lstatSync9(join26(shadow, ".git")).isDirectory() || !realpathSync11(shadow).startsWith(realpathSync11(paths.runDir) + "/"))
+        if (!lstatSync9(shadow).isDirectory() || !lstatSync9(join27(shadow, ".git")).isDirectory() || !realpathSync12(shadow).startsWith(realpathSync12(paths.runDir) + "/"))
           throw unavailable2();
-        const ledger = join26(
+        const ledger = join27(
           host.stateDir,
           "native-ledgers",
           assignment.runId + ".json"
@@ -13807,13 +13866,13 @@ async function createHostedBotRunner(host) {
         const previous = readJson(ledger);
         if (existsSync6(ledger) && (!previous || JSON.stringify(previous.scope) !== JSON.stringify(scope) || typeof previous.sessionId !== "string"))
           throw unavailable2();
-        mkdirSync15(dirname11(ledger), { recursive: true, mode: 448 });
+        mkdirSync15(dirname12(ledger), { recursive: true, mode: 448 });
         const record = async (sessionId) => {
           assertOpen();
           writeJsonAtomic(ledger, { scope, sessionId });
         };
         brokerStarting = createNativeSubscriptionBroker({
-          root: join26(host.stateDir, "native-brokers"),
+          root: join27(host.stateDir, "native-brokers"),
           revision,
           check,
           worker: {
@@ -13840,7 +13899,7 @@ async function createHostedBotRunner(host) {
         });
         const readyBroker = await brokerStarting;
         await live();
-        const githubCli = options.github ? (process.env.PATH ?? "").split(delimiter2).map((dir) => join26(dir, "gh")).find((file) => existsSync6(file)) : void 0;
+        const githubCli = options.github ? (process.env.PATH ?? "").split(delimiter2).map((dir) => join27(dir, "gh")).find((file) => existsSync6(file)) : void 0;
         if (options.github && !githubCli) throw new Error("Install GitHub CLI (gh) in the cloud worker image");
         const githubDomains = options.github ? ["github.com", "api.github.com", new URL(options.github.endpoint).host] : [];
         const egressMaximum = runDomains(runPolicy(options.policy), [...options.networkAllow ?? [], ...githubDomains]);
@@ -13855,10 +13914,10 @@ async function createHostedBotRunner(host) {
           await egressStarting;
           await live();
         }
-        const cwd = realpathSync11(options.cwd);
-        const runDir = realpathSync11(paths.runDir);
-        const protectedGit = lstatSync9(join26(cwd, ".git")).isFile() ? join26(cwd, ".git") : join26(shadow, ".git");
-        if (!lstatSync9(runDir).isDirectory() || !runDir.startsWith(realpathSync11(host.stateDir) + "/runs/")) {
+        const cwd = realpathSync12(options.cwd);
+        const runDir = realpathSync12(paths.runDir);
+        const protectedGit = lstatSync9(join27(cwd, ".git")).isFile() ? join27(cwd, ".git") : join27(shadow, ".git");
+        if (!lstatSync9(runDir).isDirectory() || !runDir.startsWith(realpathSync12(host.stateDir) + "/runs/")) {
           await close();
           throw unavailable2();
         }
@@ -13911,7 +13970,7 @@ async function createHostedBotRunner(host) {
           `${MCP_SERVER_SCRIPT}:${MCP_SERVER_SCRIPT}:ro`,
           ...githubCli ? ["-v", `${githubCli}:/usr/local/bin/mikka-gh:ro`, "-v", `${GITHUB_CREDENTIAL_SCRIPT}:${GITHUB_CREDENTIAL_SCRIPT}:ro`] : [],
           "-v",
-          `${join26(dirname11(MCP_SERVER_SCRIPT), "capture-copy.mjs")}:${join26(dirname11(MCP_SERVER_SCRIPT), "capture-copy.mjs")}:ro`,
+          `${join27(dirname12(MCP_SERVER_SCRIPT), "capture-copy.mjs")}:${join27(dirname12(MCP_SERVER_SCRIPT), "capture-copy.mjs")}:ro`,
           "-v",
           `${readyBroker.socket}:/run/mikka-native.sock:ro`,
           ...computerGrant ? [
@@ -13937,7 +13996,7 @@ async function createHostedBotRunner(host) {
         await live();
         writeJsonAtomic(resourceFile, resource);
         try {
-          creating = exec2("docker", containerArgs, {
+          creating = exec3("docker", containerArgs, {
             env: bareEnv,
             timeout: 3e4
           }).then((created) => {
@@ -13954,13 +14013,13 @@ async function createHostedBotRunner(host) {
         }
         const spawnHosted = (config) => {
           assertOpen();
-          const home = join26(runDir, "runtime-home");
+          const home = join27(runDir, "runtime-home");
           mkdirSync15(home, { recursive: true, mode: 448 });
           const env = {
             ...config.env,
             HOME: kind === "claude_code" ? config.env.HOME ?? home : home,
-            PATH: `${options.github ? join26(runDir, "github", "bin") + ":" : ""}/usr/local/bin:/usr/bin:/bin`,
-            GIT_DIR: join26(shadow, ".git"),
+            PATH: `${options.github ? join27(runDir, "github", "bin") + ":" : ""}/usr/local/bin:/usr/bin:/bin`,
+            GIT_DIR: join27(shadow, ".git"),
             GIT_WORK_TREE: cwd,
             GIT_CONFIG_GLOBAL: "/dev/null",
             GIT_CONFIG_SYSTEM: "/dev/null",
@@ -13979,7 +14038,7 @@ async function createHostedBotRunner(host) {
             signal: AbortSignal.any([lifetime.signal, ...config.signal ? [config.signal] : []])
           });
           child.stdin.write(
-            JSON.stringify({ kind, args: config.args, cwd, env: task.env, publicEgress: Boolean(egress), ...options.github ? { githubBin: join26(runDir, "github", "bin") } : {} }) + "\n"
+            JSON.stringify({ kind, args: config.args, cwd, env: task.env, publicEgress: Boolean(egress), ...options.github ? { githubBin: join27(runDir, "github", "bin") } : {} }) + "\n"
           );
           return child;
         };
@@ -13993,9 +14052,9 @@ async function createHostedBotRunner(host) {
             signal: new AbortController().signal
           });
           child.stderr?.resume();
-          const exited = new Promise((resolve11) => {
-            child.once("exit", (code, signal) => resolve11({ code, signal }));
-            child.once("error", () => resolve11({ code: null, signal: null }));
+          const exited = new Promise((resolve12) => {
+            child.once("exit", (code, signal) => resolve12({ code, signal }));
+            child.once("error", () => resolve12({ code: null, signal: null }));
           });
           return {
             process: child,
@@ -14119,19 +14178,19 @@ import { createServer as createServer4 } from "node:net";
 
 // src/computer/driver.mjs
 import { spawn as spawn5 } from "node:child_process";
-import { execFile as execFile5 } from "node:child_process";
-import { promisify as promisify5 } from "node:util";
+import { execFile as execFile6 } from "node:child_process";
+import { promisify as promisify6 } from "node:util";
 import { createHash as createHash6 } from "node:crypto";
 import { readFile as readFile2, realpath as realpath2 } from "node:fs/promises";
 import { createInterface } from "node:readline";
-var exec3 = promisify5(execFile5);
+var exec4 = promisify6(execFile6);
 async function detectComputerDriver(binary = "cua-driver") {
   try {
-    const { stdout: located } = await exec3("which", [binary], {
+    const { stdout: located } = await exec4("which", [binary], {
       timeout: 5e3
     });
     const path = await realpath2(located.trim());
-    const { stdout } = await exec3(path, ["--version"], { timeout: 5e3 });
+    const { stdout } = await exec4(path, ["--version"], { timeout: 5e3 });
     const version = stdout.trim().split("\n")[0];
     if (!/^cua-driver\s+0\.38\.0\b/.test(version)) return null;
     return {
@@ -14255,9 +14314,9 @@ async function executeDriver(driver, input, display, leaseGuard, assertLive = ()
       )
     )
   );
-  const request = (method, params) => new Promise((resolve11, reject) => {
+  const request = (method, params) => new Promise((resolve12, reject) => {
     const n = ++id4;
-    pending.set(n, { resolve: resolve11, reject });
+    pending.set(n, { resolve: resolve12, reject });
     child.stdin.write(
       JSON.stringify({ jsonrpc: "2.0", id: n, method, params }) + "\n"
     );
@@ -14358,10 +14417,10 @@ var ComputerBroker = class {
         })();
       });
     });
-    await new Promise((resolve11, reject) => {
+    await new Promise((resolve12, reject) => {
       this.server.once("error", reject);
-      if (this.transport === "tcp") this.server.listen({ host: "127.0.0.1", port: 0 }, resolve11);
-      else this.server.listen(this.socketPath, resolve11);
+      if (this.transport === "tcp") this.server.listen({ host: "127.0.0.1", port: 0 }, resolve12);
+      else this.server.listen(this.socketPath, resolve12);
     });
     if (this.transport === "tcp") this.socketPath = `tcp://127.0.0.1:${this.server.address().port}`;
     else chmodSync3(this.socketPath, 384);
@@ -14392,7 +14451,7 @@ var ComputerBroker = class {
       expiresAt: this.now() + this.ttl
     };
     const digest2 = createHash7("sha256").update(JSON.stringify(request)).digest("hex");
-    return new Promise((resolve11, reject) => {
+    return new Promise((resolve12, reject) => {
       const timer = setTimeout(() => {
         this.pending.delete(request.id);
         signal?.removeEventListener("abort", cancel);
@@ -14409,7 +14468,7 @@ var ComputerBroker = class {
         assertLive,
         cleanup: () => signal?.removeEventListener("abort", cancel),
         request: { ...request, digest: digest2 },
-        resolve: resolve11,
+        resolve: resolve12,
         reject,
         timer
       });
@@ -14486,7 +14545,7 @@ var ComputerBroker = class {
   async close() {
     this.suspend();
     for (const socket of this.sockets) socket.destroy();
-    if (this.server?.listening) await new Promise((resolve11) => this.server.close(resolve11));
+    if (this.server?.listening) await new Promise((resolve12) => this.server.close(resolve12));
   }
 };
 
@@ -14555,11 +14614,11 @@ async function pollWebComputerReviews(broker, deviceId, link, signal, intervalMs
     } catch {
     }
     if (signal.aborted) break;
-    await new Promise((resolve11) => {
+    await new Promise((resolve12) => {
       const done = () => {
         clearTimeout(timer);
         signal.removeEventListener("abort", done);
-        resolve11();
+        resolve12();
       };
       const timer = setTimeout(done, intervalMs);
       signal.addEventListener("abort", done, { once: true });
@@ -14610,6 +14669,11 @@ var Daemon = class {
   server = "unregistered";
   timer = null;
   tick = Promise.resolve();
+  updating = false;
+  claimsInFlight = 0;
+  updateCheck = null;
+  maintenance = null;
+  updateVersion;
   draining = false;
   stopped = false;
   stopPromise = null;
@@ -14668,7 +14732,7 @@ var Daemon = class {
     if (this.options.credential)
       this.saveDevice({ credential: this.options.credential });
     this.journal = new RunJournal(paths.journal);
-    this.captureUploader = new CaptureUploader((runId) => join27(runPaths(paths.adapterState, runId).runDir, CAPTURES_DIR), this.options.link, this.log, join27(paths.dataDir, "capture-pending"));
+    this.captureUploader = new CaptureUploader((runId) => join28(runPaths(paths.adapterState, runId).runDir, CAPTURES_DIR), this.options.link, this.log, join28(paths.dataDir, "capture-pending"));
     this.outbox = new Outbox(
       paths.outbox,
       this.options.link,
@@ -14685,7 +14749,7 @@ var Daemon = class {
     if (this.localComputerDriver && this.options.link.syncComputerReviews && this.options.link.localComputerAuthority) {
       this.localComputerBroker = new ComputerBroker({
         driver: this.localComputerDriver,
-        socketPath: join27(paths.dataDir, "local-computer.sock"),
+        socketPath: join28(paths.dataDir, "local-computer.sock"),
         transport: "tcp",
         permitted: (runId) => {
           const assignment = this.journal.get(runId)?.assignment;
@@ -14727,7 +14791,7 @@ var Daemon = class {
       };
       this.cloudComputerBroker = new ComputerBroker({
         driver,
-        socketPath: join27(paths.dataDir, "computer.sock"),
+        socketPath: join28(paths.dataDir, "computer.sock"),
         permitted: (runId) => {
           const entry = this.journal.get(runId);
           return Boolean(!this.stopped && this.registered && entry?.assignment.computer && this.supervisor?.computerRunAllowed(runId));
@@ -14850,7 +14914,7 @@ var Daemon = class {
           worktree,
           tree,
           github: { ...assignment.github, runToken: assignment.mcp.token, issueId: assignment.issueId },
-          privateDir: join27(paths.adapterState, "pids"),
+          privateDir: join28(paths.adapterState, "pids"),
           ...hosted ? { hosted: true } : {},
           env: githubReceiptEnvironment()
         }) : publishRun({
@@ -15028,12 +15092,12 @@ var Daemon = class {
   /** Waits `ms`, or less if the daemon stops or the device registers. */
   pauseCommands(ms, signal) {
     if (signal.aborted) return Promise.resolve();
-    return new Promise((resolve11) => {
+    return new Promise((resolve12) => {
       const done = () => {
         clearTimeout(timer);
         signal.removeEventListener("abort", done);
         this.wakeCommands = null;
-        resolve11();
+        resolve12();
       };
       const timer = setTimeout(done, ms);
       signal.addEventListener("abort", done, { once: true });
@@ -15133,12 +15197,12 @@ var Daemon = class {
       const paths = runPaths(this.paths.adapterState, runId);
       return runVerify(sandbox, {
         command,
-        worktree: realpathSync12(worktree),
-        tmpRoot: join27(this.paths.adapterState, "verify", runId),
+        worktree: realpathSync13(worktree),
+        tmpRoot: join28(this.paths.adapterState, "verify", runId),
         privateDir: paths.privateDir,
         pidFile: paths.pidFile.replace(/\.pgid$/, ".verify.pgid"),
         networkAllow: repo.networkAllow,
-        env: { ...buildChildEnv(), MIKKA_HANDOFF_FILE: join27(paths.runDir, "handoff.json") },
+        env: { ...buildChildEnv(), MIKKA_HANDOFF_FILE: join28(paths.runDir, "handoff.json") },
         timeoutMs,
         signal,
         readOnly
@@ -15250,6 +15314,8 @@ var Daemon = class {
     return pass;
   }
   async syncPass() {
+    if (this.stopped) return;
+    this.checkAutoUpdate();
     const { link } = this.options;
     const { credential, workspaceId } = this.device;
     if (!credential) {
@@ -15301,7 +15367,7 @@ var Daemon = class {
         return;
       }
       if (command && !this.device.completedDeviceCommands?.includes(command.id) && !this.device.failedDeviceCommands?.some((failure) => failure.id === command.id)) {
-        if (command.kind === "redetect" || this.supervisor.heartbeatRuns().length === 0) {
+        if (command.kind === "redetect" || this.maintenanceIdle()) {
           try {
             if (command.kind === "redetect") {
               const detected = await detectHarnesses();
@@ -15312,8 +15378,13 @@ var Daemon = class {
               this.saveDevice({ completedDeviceCommands: [command.id], failedDeviceCommands: [] });
               void this.syncWithServer().catch(() => void 0);
             } else {
-              await restartService(command.kind === "update", () => {
-                this.saveDevice({ completedDeviceCommands: [command.id], failedDeviceCommands: [] });
+              this.startMaintenance(async () => {
+                await restartService(command.kind === "update", () => {
+                  if (this.stopped) throw new Error("Daemon stopped during update");
+                  this.saveDevice({ completedDeviceCommands: [command.id], failedDeviceCommands: [] });
+                }, void 0, () => !this.stopped);
+              }, () => {
+                this.saveDevice({ completedDeviceCommands: [], failedDeviceCommands: [{ id: command.id, error: "Device command failed; check daemon service logs." }] });
               });
             }
           } catch {
@@ -15328,7 +15399,7 @@ var Daemon = class {
       this.server = "online";
       await this.outbox.flushAll();
       for (const entry of this.journal.all()) if (isTerminalRunState(entry.state)) void this.captureUploader.flush(entry.assignment.runId, true);
-      if (!this.draining) {
+      if (!this.draining && !this.updating && !this.stopped) {
         await this.supervisor.resumeAll(true);
         this.startCoordinatorPass(deviceId);
         for (const runId of await link.pendingRuns(deviceId)) {
@@ -15366,6 +15437,17 @@ var Daemon = class {
     this.log.warn("server refused the device session; sign in again");
   }
   async claimAndStart(runId) {
+    if (this.draining || this.updating || this.stopped) {
+      throw new DaemonError(DAEMON_RPC_ERRORS.draining, "Daemon is draining");
+    }
+    this.claimsInFlight++;
+    try {
+      return await this.claimAndStartInternal(runId);
+    } finally {
+      this.claimsInFlight--;
+    }
+  }
+  async claimAndStartInternal(runId) {
     if (this.draining) {
       throw new DaemonError(DAEMON_RPC_ERRORS.draining, "Daemon is draining");
     }
@@ -15399,7 +15481,7 @@ var Daemon = class {
       }
     }
     if (assignment.computer && (!this.cloudComputerBroker || !assignment.subscriptionBinding || assignment.computer.ownerId !== assignment.subscriptionBinding.ownerId)) throw new Error("Cloud computer runtime unavailable");
-    return this.supervisor.start(assignment);
+    return await this.supervisor.start(assignment);
   }
   /**
    * A run id that could escape the daemon's dirs never reaches the
@@ -15597,7 +15679,7 @@ var Daemon = class {
   startCoordinatorPass(deviceId) {
     const link = this.options.link;
     const sandbox = this.agentSandbox();
-    if (this.nativeCoordinator || !link.claimCoordinator || !sandbox || this.stopped || !this.harnesses.some((info) => info.coordinator)) return;
+    if (this.updating || this.draining || this.nativeCoordinator || !link.claimCoordinator || !sandbox || this.stopped || !this.harnesses.some((info) => info.coordinator)) return;
     const controller = new AbortController();
     this.nativeAbort = controller;
     this.nativeCoordinator = (async () => {
@@ -15605,7 +15687,7 @@ var Daemon = class {
       if (!job || controller.signal.aborted) return;
       await runNativeCoordinatorJob(job, {
         deviceId,
-        stateDir: join27(this.paths.dataDir, "coordinator"),
+        stateDir: join28(this.paths.dataDir, "coordinator"),
         link,
         signal: controller.signal,
         sandbox,
@@ -15620,6 +15702,43 @@ var Daemon = class {
       this.nativeAbort = null;
     });
   }
+  maintenanceIdle() {
+    return !this.stopped && !this.draining && !this.updating && !this.nativeCoordinator && this.claimsInFlight === 0 && this.supervisor.heartbeatRuns().length === 0;
+  }
+  startMaintenance(work, failed = () => {
+  }) {
+    if (!this.maintenanceIdle()) return;
+    this.updating = true;
+    this.maintenance = work().catch(() => {
+      this.updating = false;
+      failed();
+      this.log.warn("Daemon update or restart failed; check service installation and npm configuration");
+    }).finally(() => {
+      this.maintenance = null;
+    });
+  }
+  checkAutoUpdate() {
+    const runtime = this.options.autoUpdate;
+    if (!runtime || this.draining || this.updating) return;
+    if (this.updateVersion && this.maintenanceIdle()) {
+      const version = this.updateVersion;
+      this.updateVersion = void 0;
+      this.startMaintenance(async () => {
+        await runtime.install(version);
+        if (this.stopped) return;
+        await restartService(false, () => {
+        }, void 0, () => !this.stopped);
+      });
+    } else if (!this.updateCheck && !this.updateVersion) {
+      this.updateCheck = checkLatestVersion(join28(this.paths.dataDir, "auto-update.json"), DAEMON_VERSION, runtime).then((version) => {
+        this.updateVersion = version;
+      }).catch(() => {
+        this.log.warn("Daemon automatic update check failed");
+      }).finally(() => {
+        this.updateCheck = null;
+      });
+    }
+  }
   stop() {
     return this.stopPromise ??= this.stopInternal();
   }
@@ -15627,6 +15746,8 @@ var Daemon = class {
     this.stopped = true;
     this.localComputerBroker?.suspend();
     await this.starting?.catch(() => void 0);
+    await this.updateCheck;
+    await this.maintenance;
     this.nativeAbort?.abort();
     await this.nativeCoordinator;
     if (this.timer) clearTimeout(this.timer);
@@ -15684,7 +15805,7 @@ function isNoDaemon(error) {
 }
 async function connectDaemon(options) {
   const socket = connect2(options.socketPath);
-  await new Promise((resolve11, reject) => {
+  await new Promise((resolve12, reject) => {
     const timer = setTimeout(() => {
       socket.destroy();
       reject(
@@ -15695,7 +15816,7 @@ async function connectDaemon(options) {
     }, options.timeoutMs ?? 3e3);
     socket.once("connect", () => {
       clearTimeout(timer);
-      resolve11();
+      resolve12();
     });
     socket.once("error", (error) => {
       clearTimeout(timer);
@@ -15732,9 +15853,9 @@ async function connectDaemon(options) {
     if (isProtocolMismatch(error) && options.drainOnMismatch) {
       await Promise.race([
         connection.sendRequest("daemon.drain", {}).catch(() => void 0),
-        new Promise((resolve11) => {
-          connection.onClose(resolve11);
-          setTimeout(resolve11, 2e3).unref();
+        new Promise((resolve12) => {
+          connection.onClose(resolve12);
+          setTimeout(resolve12, 2e3).unref();
         })
       ]);
     }
@@ -15756,7 +15877,7 @@ function connectDaemonInDataDir(dataDir, client, extra = {}) {
 
 // src/cli.ts
 var USAGE = `Usage:
-  mikka daemon [--dev] [--data-dir <dir>] [--server <url>|memory] [--mock-speed <n>] [--fixtures-dir <dir>] [--stall-minutes <n>] [--hosted-subscriptions]
+  mikka daemon [--dev] [--no-auto-update] [--data-dir <dir>] [--server <url>|memory] [--mock-speed <n>] [--fixtures-dir <dir>] [--stall-minutes <n>] [--hosted-subscriptions]
   mikka daemon login [--server <url>] [--workspace <id>] [--token <device-token>] [--dev] [--data-dir <dir>]
   mikka daemon status [--dev] [--data-dir <dir>]`;
 var SERVER_URLS = {
@@ -15793,8 +15914,8 @@ async function connectStartingDaemon(dataDir) {
       }
       if (!daemonProcessAlive(dataDir)) return void 0;
       if (revision !== before) continue;
-      await new Promise((resolve11) => {
-        wake = resolve11;
+      await new Promise((resolve12) => {
+        wake = resolve12;
       });
       wake = void 0;
     }
@@ -15815,6 +15936,7 @@ async function runCli(argv, io = defaultIO, privateConfig) {
     allowPositionals: true,
     options: {
       dev: { type: "boolean", default: false },
+      "no-auto-update": { type: "boolean", default: false },
       "data-dir": { type: "string" },
       server: { type: "string" },
       "mock-speed": { type: "string" },
@@ -15839,7 +15961,7 @@ async function runCli(argv, io = defaultIO, privateConfig) {
   const flavor = values.dev ? "dev" : "prod";
   const dataDir = values["data-dir"] ?? defaultDataDir(flavor);
   if (sub === "service" && positionals[2] === "install") {
-    await installService(values.server ?? SERVER_URLS[flavor], values["device-type"]);
+    await installService(values.server ?? SERVER_URLS[flavor], values["device-type"], { dataDir, dev: values.dev, autoUpdate: !values["no-auto-update"] });
     io.out("Service installed.");
     return 0;
   }
@@ -15945,6 +16067,7 @@ async function runCli(argv, io = defaultIO, privateConfig) {
     const daemon = await startDaemon({
       dataDir,
       flavor,
+      autoUpdate: await managedAutoUpdateRuntime(process.argv[1] ?? "", flavor, !values["no-auto-update"] && !values["hosted-subscriptions"] && !values["e2b-container-runtime"] && !values["e2b-computer"]),
       link,
       memoryServer,
       credential,