@ai-development-environment/control-agent 0.0.53 → 0.0.55

package/dist/control-agent.js

@@ -1,4 +1,6 @@
 #!/usr/bin/env node
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -3728,15 +3730,15 @@ var require_windows = __commonJS({
       }
       return false;
     }
-    function checkStat(stat9, path, options) {
-      if (!stat9.isSymbolicLink() && !stat9.isFile()) {
+    function checkStat(stat10, path, options) {
+      if (!stat10.isSymbolicLink() && !stat10.isFile()) {
         return false;
       }
       return checkPathExt(path, options);
     }
     function isexe(path, options, cb2) {
-      fs.stat(path, function(er2, stat9) {
-        cb2(er2, er2 ? false : checkStat(stat9, path, options));
+      fs.stat(path, function(er2, stat10) {
+        cb2(er2, er2 ? false : checkStat(stat10, path, options));
       });
     }
     function sync(path, options) {
@@ -3752,20 +3754,20 @@ var require_mode = __commonJS({
     isexe.sync = sync;
     var fs = __require("fs");
     function isexe(path, options, cb2) {
-      fs.stat(path, function(er2, stat9) {
-        cb2(er2, er2 ? false : checkStat(stat9, options));
+      fs.stat(path, function(er2, stat10) {
+        cb2(er2, er2 ? false : checkStat(stat10, options));
       });
     }
     function sync(path, options) {
       return checkStat(fs.statSync(path), options);
     }
-    function checkStat(stat9, options) {
-      return stat9.isFile() && checkMode(stat9, options);
+    function checkStat(stat10, options) {
+      return stat10.isFile() && checkMode(stat10, options);
     }
-    function checkMode(stat9, options) {
-      var mod = stat9.mode;
-      var uid = stat9.uid;
-      var gid = stat9.gid;
+    function checkMode(stat10, options) {
+      var mod = stat10.mode;
+      var uid = stat10.uid;
+      var gid = stat10.gid;
       var myUid = options.uid !== void 0 ? options.uid : process.getuid && process.getuid();
       var myGid = options.gid !== void 0 ? options.gid : process.getgid && process.getgid();
       var u = parseInt("100", 8);
@@ -4182,7 +4184,7 @@ var require_cross_spawn = __commonJS({
     var cp3 = __require("child_process");
     var parse2 = require_parse();
     var enoent = require_enoent();
-    function spawn7(command3, args, options) {
+    function spawn8(command3, args, options) {
       const parsed = parse2(command3, args, options);
       const spawned = cp3.spawn(parsed.command, parsed.args, parsed.options);
       enoent.hookChildProcess(spawned, parsed);
@@ -4194,18 +4196,14 @@ var require_cross_spawn = __commonJS({
       result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
       return result;
     }
-    module.exports = spawn7;
-    module.exports.spawn = spawn7;
+    module.exports = spawn8;
+    module.exports.spawn = spawn8;
     module.exports.sync = spawnSync2;
     module.exports._parse = parse2;
     module.exports._enoent = enoent;
   }
 });
 
-// src/index.ts
-import { execFile as execFile5 } from "node:child_process";
-import { promisify as promisify5 } from "node:util";
-
 // src/config.ts
 import { chmod, mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
@@ -4252,8 +4250,6 @@ async function saveConfig(config, path = configPath()) {
 }
 
 // ../agent-contract/src/index.ts
-var TUNNEL_NAME_PATTERN = "[A-Za-z0-9][A-Za-z0-9_-]{0,127}";
-var TUNNEL_NAME_REGEX = new RegExp(`^${TUNNEL_NAME_PATTERN}$`);
 var CCUSAGE_REPORT_JOB_KIND = "ccusage.report";
 var DEFAULT_AGENT_HEARTBEAT_INTERVAL_SECONDS = 15;
 var MIN_AGENT_HEARTBEAT_INTERVAL_SECONDS = 5;
@@ -5170,6 +5166,24 @@ var AgentGraphQLClient = class {
       }
     );
   }
+  async diskSpaceConfiguration() {
+    const data = await this.request(`query AgentDiskSpaceConfiguration {
+      agentDiskSpaceConfiguration {
+        enabled pollIntervalSeconds baseRepoDirectory
+        derivedDataLocationMode derivedDataPath
+        worktrees { id folder }
+      }
+    }`);
+    return data.agentDiskSpaceConfiguration;
+  }
+  reportDiskSpace(input) {
+    return this.request(
+      `mutation ReportAgentDiskSpace($input: AgentDiskSpaceReportInput!) {
+        reportAgentDiskSpace(input: $input)
+      }`,
+      { input }
+    );
+  }
   async pendingJobs(agentId) {
     const data = await this.request(
       `query PendingJobs($agentId: ID!) {
@@ -5180,7 +5194,7 @@ var AgentGraphQLClient = class {
       { agentId }
     );
     return data.agentJobs.filter(
-      (job) => job.status === "QUEUED" || job.status === "RUNNING" || job.status === "CANCELLED"
+      (job) => job.status === "QUEUED" || job.status === "RUNNING" || job.status === "CANCELLING" || job.status === "CANCELLED"
     );
   }
   async cadenceSettings(agentId) {
@@ -5236,6 +5250,14 @@ var AgentGraphQLClient = class {
       { jobId, logs: [log] }
     );
   }
+  appendCommandOutput(jobId, attemptId, chunks) {
+    return this.request(
+      `mutation AppendCommandRunOutput($jobId: ID!, $attemptId: ID!, $chunks: [CommandRunOutputInput!]!) {
+        appendCommandRunOutput(jobId: $jobId, attemptId: $attemptId, chunks: $chunks) { id }
+      }`,
+      { jobId, attemptId, chunks }
+    );
+  }
   reportBuildProgress(input) {
     return this.request(
       `mutation ReportBuildProgress($input: BuildProgressInput!) {
@@ -5244,12 +5266,12 @@ var AgentGraphQLClient = class {
       { input }
     );
   }
-  appendBuildLogs(buildId, events) {
+  appendBuildLogChunks(buildId, chunks) {
     return this.request(
-      `mutation AppendBuildLogs($buildId: ID!, $events: [BuildLogEventInput!]!) {
-        appendBuildLogEvents(buildId: $buildId, events: $events) { id }
+      `mutation AppendBuildLogChunks($buildId: ID!, $chunks: [BuildLogChunkInput!]!) {
+        appendBuildLogChunks(buildId: $buildId, chunks: $chunks) { id }
       }`,
-      { buildId, events }
+      { buildId, chunks }
     );
   }
   async uploadBuildArtifact(input) {
@@ -5590,6 +5612,10 @@ function nullableString(value, name) {
   if (value === null) return null;
   return stringValue2(value, name);
 }
+function optionalNullableString(value, name) {
+  if (value === void 0 || value === null) return null;
+  return stringValue2(value, name);
+}
 function exactKeys(value, allowed, name) {
   const unexpected = Object.keys(value).find((key) => !allowed.includes(key));
   if (unexpected) throw new Error(`Unexpected ${name} field: ${unexpected}`);
@@ -5619,6 +5645,44 @@ function target(value, index) {
     )
   };
 }
+function deleteTarget(value, index) {
+  const item = objectValue2(value, `build data delete targets[${index}]`);
+  exactKeys(
+    item,
+    ["path", "rootPath", "name", "kind", "worktreeId", "worktreePath"],
+    "build data delete target"
+  );
+  const kind = item.kind;
+  if (kind !== void 0 && !["PROJECT", "PENDING", "SHARED_CACHE", "DEVICE_SUPPORT"].includes(kind)) {
+    throw new Error(`build data delete targets[${index}].kind is invalid`);
+  }
+  return {
+    path: stringValue2(item.path, `build data delete targets[${index}].path`),
+    rootPath: stringValue2(
+      item.rootPath,
+      `build data delete targets[${index}].rootPath`
+    ),
+    ...item.name === void 0 ? {} : {
+      name: stringValue2(
+        item.name,
+        `build data delete targets[${index}].name`
+      )
+    },
+    ...kind === void 0 ? {} : { kind },
+    ...item.worktreeId === void 0 ? {} : {
+      worktreeId: optionalNullableString(
+        item.worktreeId,
+        `build data delete targets[${index}].worktreeId`
+      )
+    },
+    ...item.worktreePath === void 0 ? {} : {
+      worktreePath: optionalNullableString(
+        item.worktreePath,
+        `build data delete targets[${index}].worktreePath`
+      )
+    }
+  };
+}
 function buildDataScanPayload(value) {
   const payload = objectValue2(value, "build data scan payload");
   exactKeys(payload, ["mode", "path", "worktrees"], "build data scan payload");
@@ -5649,6 +5713,23 @@ function buildDataTargetsPayload(value) {
   }
   return { targets: payload.targets.map(target) };
 }
+function buildDataDeletePayload(value) {
+  const payload = objectValue2(value, "build data delete payload");
+  exactKeys(payload, ["targets", "source"], "build data delete payload");
+  if (!Array.isArray(payload.targets) || payload.targets.length > 1e4) {
+    throw new Error(
+      "build data delete targets must be an array of at most 10,000 items"
+    );
+  }
+  const source = payload.source ?? "USER";
+  if (source !== "USER" && source !== "AUTOMATIC") {
+    throw new Error("build data delete source is invalid");
+  }
+  return {
+    targets: payload.targets.map(deleteTarget),
+    source
+  };
+}
 
 // ../agent-contract/src/codebases.ts
 var CODEBASE_BROWSE_JOB_KIND = "codebase.browse";
@@ -7782,10 +7863,58 @@ function parseWorkflowGitCheckpointPayload(value) {
   };
 }
 
+// ../agent-contract/src/commands.ts
+var COMMAND_RUN_JOB_KIND = "command.run";
+function objectValue10(value, name) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`${name} must be an object`);
+  }
+  return value;
+}
+function stringValue10(value, name, maximum) {
+  if (typeof value !== "string" || !value.length || value.length > maximum) {
+    throw new Error(
+      `${name} must be a non-empty string of at most ${maximum} characters`
+    );
+  }
+  return value;
+}
+function parseCommandRunPayload(value) {
+  const payload = objectValue10(value, "command run payload");
+  const targetKind = stringValue10(payload.targetKind, "targetKind", 20);
+  if (targetKind !== "AGENT_HOME" && targetKind !== "WORKTREE") {
+    throw new Error("targetKind must be AGENT_HOME or WORKTREE");
+  }
+  const cwd = payload.cwd === null || payload.cwd === void 0 ? null : stringValue10(payload.cwd, "cwd", 1e4);
+  if (targetKind === "WORKTREE" && !cwd) {
+    throw new Error("Worktree commands require cwd");
+  }
+  if (targetKind === "AGENT_HOME" && cwd !== null) {
+    throw new Error("Agent-home commands cannot provide cwd");
+  }
+  const allowed = /* @__PURE__ */ new Set([
+    "commandRunId",
+    "attemptId",
+    "targetKind",
+    "cwd",
+    "script"
+  ]);
+  const unexpected = Object.keys(payload).find((key) => !allowed.has(key));
+  if (unexpected)
+    throw new Error(`Unsupported command payload field: ${unexpected}`);
+  return {
+    commandRunId: stringValue10(payload.commandRunId, "commandRunId", 200),
+    attemptId: stringValue10(payload.attemptId, "attemptId", 200),
+    targetKind,
+    cwd,
+    script: stringValue10(payload.script, "script", 1e6)
+  };
+}
+
 // src/inventory.ts
 var AGENT_VERSION = "0.1.0";
 var AGENT_CAPABILITIES = [
-  "cloudflared.runTunnel",
+  COMMAND_RUN_JOB_KIND,
   CCUSAGE_REPORT_JOB_KIND,
   ...BUILD_DATA_JOB_KINDS,
   ...CODEBASE_JOB_KINDS,
@@ -7817,148 +7946,186 @@ function collectInventory() {
   };
 }
 
-// src/process-runner.ts
+// src/handlers/commands.ts
 import { spawn } from "node:child_process";
-async function runProcess(options) {
-  return new Promise((resolve7, reject) => {
-    let sequence = 0;
-    let timedOut = false;
-    let cancelled = false;
-    let settled = false;
-    let logChain = Promise.resolve();
-    const detached = process.platform !== "win32";
-    const child = spawn(options.command, options.args, {
-      shell: false,
-      stdio: ["ignore", "pipe", "pipe"],
-      cwd: options.cwd,
-      env: options.env ?? process.env,
-      // A separate process group lets cancellation terminate scripts and all
-      // descendants instead of leaving a child holding stdout/stderr open.
-      detached
-    });
-    const emit = (stream, message) => {
-      const log = {
-        sequence: sequence++,
-        stream,
-        message,
-        createdAt: (/* @__PURE__ */ new Date()).toISOString()
-      };
-      logChain = logChain.then(async () => {
+import { chmod as chmod2, mkdtemp, realpath, rm as rm2, writeFile as writeFile2 } from "node:fs/promises";
+import { homedir as homedir2, tmpdir } from "node:os";
+import { join as join2 } from "node:path";
+var MAX_BATCH_BYTES = 128 * 1024;
+var FLUSH_DELAY_MS = 25;
+var runCommand = async (rawPayload, _timeoutMs, signal, _onLog, context) => {
+  const payload = parseCommandRunPayload(rawPayload);
+  if (!context?.appendCommandOutput) {
+    throw new Error("Command output uploader is unavailable");
+  }
+  const directory = await mkdtemp(join2(tmpdir(), "aide-command-"));
+  const scriptPath = join2(directory, "command.sh");
+  await writeFile2(scriptPath, payload.script, {
+    encoding: "utf8",
+    mode: 384
+  });
+  await chmod2(scriptPath, 384);
+  const cwd = payload.targetKind === "AGENT_HOME" ? homedir2() : await realpath(payload.cwd);
+  let sequence = 0;
+  let queuedBytes = 0;
+  let pending = [];
+  let timer;
+  let uploadChain = Promise.resolve();
+  const upload = (chunks) => {
+    if (!chunks.length) return;
+    const bytes = chunks.reduce((total, chunk) => total + chunk.byteLength, 0);
+    uploadChain = uploadChain.then(async () => {
+      let retry = 0;
+      while (true) {
         try {
-          await options.onLog(log);
+          await context.appendCommandOutput?.(payload.attemptId, chunks);
+          queuedBytes -= bytes;
+          return;
         } catch (error) {
+          if (signal.aborted) return;
+          const delay = Math.min(3e4, 500 * 2 ** Math.min(retry++, 6));
           console.error(
-            `Could not append process log ${log.sequence}:`,
+            `Could not append command output; retrying in ${delay}ms:`,
             error instanceof Error ? error.message : error
           );
+          await new Promise((resolve7) => {
+            const onAbort = () => {
+              clearTimeout(retryTimer);
+              resolve7();
+            };
+            const retryTimer = setTimeout(() => {
+              signal.removeEventListener("abort", onAbort);
+              resolve7();
+            }, delay);
+            retryTimer.unref();
+            signal.addEventListener("abort", onAbort, { once: true });
+            if (signal.aborted) onAbort();
+          });
+          if (signal.aborted) return;
         }
-      });
+      }
+    });
+  };
+  const flush = () => {
+    if (timer) clearTimeout(timer);
+    timer = void 0;
+    const batch = pending;
+    pending = [];
+    upload(batch);
+  };
+  const enqueue = (stream, bytes) => {
+    const chunk = {
+      sequence: sequence++,
+      stream,
+      dataBase64: bytes.toString("base64"),
+      byteLength: bytes.length,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
     };
-    const attach = (stream, kind) => {
-      let remainder = "";
-      stream.setEncoding("utf8");
-      stream.on("data", (chunk) => {
-        const parts = `${remainder}${chunk}`.split(/\r?\n/);
-        remainder = parts.pop() ?? "";
-        for (const line of parts) emit(kind, line);
+    pending.push(chunk);
+    queuedBytes += bytes.length;
+    if (pending.reduce((total, item) => total + item.byteLength, 0) >= MAX_BATCH_BYTES) {
+      flush();
+    } else if (!timer) {
+      timer = setTimeout(flush, FLUSH_DELAY_MS);
+      timer.unref();
+    }
+  };
+  try {
+    return await new Promise((resolve7, reject) => {
+      let cancelled = false;
+      let settled = false;
+      const child = spawn(process.env.SHELL || "/bin/sh", ["-l", scriptPath], {
+        cwd,
+        detached: process.platform !== "win32",
+        env: {
+          ...process.env,
+          TERM: "xterm-256color",
+          COLORTERM: "truecolor",
+          FORCE_COLOR: "1",
+          CLICOLOR_FORCE: "1"
+        },
+        shell: false,
+        stdio: ["ignore", "pipe", "pipe"]
       });
-      stream.on("end", () => {
-        if (remainder) emit(kind, remainder);
+      const pauseForPressure = () => {
+        if (queuedBytes < 4 * 1024 * 1024) return;
+        child.stdout.pause();
+        child.stderr.pause();
+        void uploadChain.finally(() => {
+          child.stdout.resume();
+          child.stderr.resume();
+        });
+      };
+      child.stdout.on("data", (bytes) => {
+        enqueue("STDOUT", bytes);
+        pauseForPressure();
       });
-    };
-    attach(child.stdout, "STDOUT");
-    attach(child.stderr, "STDERR");
-    const sendSignal = (signal) => {
-      if (detached && child.pid) {
+      child.stderr.on("data", (bytes) => {
+        enqueue("STDERR", bytes);
+        pauseForPressure();
+      });
+      const sendSignal = (name) => {
+        if (child.exitCode !== null) return;
         try {
-          process.kill(-child.pid, signal);
-          return;
+          if (process.platform !== "win32" && child.pid)
+            process.kill(-child.pid, name);
+          else child.kill(name);
         } catch (error) {
           if (!(error instanceof Error) || !("code" in error) || error.code !== "ESRCH") {
             throw error;
           }
         }
-      }
-      child.kill(signal);
-    };
-    const terminate = () => {
-      if (child.exitCode !== null || child.killed) return;
-      sendSignal("SIGTERM");
-      const killTimer = setTimeout(() => sendSignal("SIGKILL"), 5e3);
-      killTimer.unref();
-    };
-    const timeout = setTimeout(() => {
-      timedOut = true;
-      emit(
-        "SYSTEM",
-        `Process exceeded its ${Math.round(options.timeoutMs / 1e3)} second timeout`
-      );
-      terminate();
-    }, options.timeoutMs);
-    timeout.unref();
-    const abort = () => {
-      cancelled = true;
-      emit("SYSTEM", "Cancellation requested");
-      terminate();
-    };
-    options.signal.addEventListener("abort", abort, { once: true });
-    child.once("error", (error) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timeout);
-      options.signal.removeEventListener("abort", abort);
-      reject(error);
-    });
-    child.once("close", (exitCode, signal) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timeout);
-      options.signal.removeEventListener("abort", abort);
-      void logChain.then(
-        () => resolve7({ exitCode, signal, timedOut, cancelled })
-      );
+      };
+      const abort = () => {
+        if (cancelled) return;
+        cancelled = true;
+        enqueue("SYSTEM", Buffer.from("\r\nCancellation requested\r\n"));
+        sendSignal("SIGTERM");
+        const killTimer = setTimeout(() => sendSignal("SIGKILL"), 5e3);
+        killTimer.unref();
+      };
+      signal.addEventListener("abort", abort, { once: true });
+      if (signal.aborted) abort();
+      child.once("error", (error) => {
+        if (settled) return;
+        settled = true;
+        signal.removeEventListener("abort", abort);
+        reject(error);
+      });
+      child.once("close", (exitCode, closeSignal) => {
+        if (settled) return;
+        settled = true;
+        signal.removeEventListener("abort", abort);
+        flush();
+        void uploadChain.then(
+          () => resolve7({
+            exitCode,
+            signal: closeSignal,
+            timedOut: false,
+            cancelled
+          })
+        );
+      });
     });
-  });
-}
-
-// src/handlers/cloudflared.ts
-function validateCloudflaredPayload(payload) {
-  if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
-    throw new Error("Cloudflared payload must be an object");
-  }
-  const value = payload;
-  if (typeof value.tunnelName !== "string" || !TUNNEL_NAME_REGEX.test(value.tunnelName)) {
-    throw new Error("Invalid Cloudflared tunnel name");
-  }
-  if (Object.keys(value).some((key) => key !== "tunnelName")) {
-    throw new Error("Cloudflared payload contains an unsupported field");
+  } finally {
+    if (timer) clearTimeout(timer);
+    await rm2(directory, { force: true, recursive: true });
   }
-  return { tunnelName: value.tunnelName };
-}
-function runCloudflared(payload, timeoutMs, signal, onLog) {
-  const { tunnelName } = validateCloudflaredPayload(payload);
-  return runProcess({
-    command: "cloudflared",
-    args: ["tunnel", "run", tunnelName],
-    timeoutMs,
-    signal,
-    onLog
-  });
-}
+};
 
 // src/handlers/signing.ts
 import { createHash as createHash3, randomUUID, X509Certificate } from "node:crypto";
 import {
   mkdir as mkdir2,
-  mkdtemp,
+  mkdtemp as mkdtemp2,
   readFile as readFile2,
   readdir,
-  rm as rm2,
+  rm as rm3,
   stat as stat2,
-  writeFile as writeFile2
+  writeFile as writeFile3
 } from "node:fs/promises";
-import { homedir as homedir2, tmpdir } from "node:os";
-import { basename, join as join2, relative, sep } from "node:path";
+import { homedir as homedir3, tmpdir as tmpdir2 } from "node:os";
+import { basename, join as join3, relative, sep } from "node:path";
 
 // ../agent-contract/src/plist.ts
 function xmlEscape(value) {
@@ -8193,15 +8360,15 @@ function captureCommand(options) {
 
 // src/handlers/signing.ts
 var PROFILE_DIRECTORIES = [
-  join2(
-    homedir2(),
+  join3(
+    homedir3(),
     "Library",
     "Developer",
     "Xcode",
     "UserData",
     "Provisioning Profiles"
   ),
-  join2(homedir2(), "Library", "MobileDevice", "Provisioning Profiles")
+  join3(homedir3(), "Library", "MobileDevice", "Provisioning Profiles")
 ];
 var PROFILE_EXTENSIONS = [".mobileprovision", ".provisionprofile"];
 function text(value) {
@@ -8294,7 +8461,7 @@ async function readProfiles(timeoutMs, signal) {
         continue;
       signal.throwIfAborted();
       const raw = await decodeProfile(
-        join2(directory, entry),
+        join3(directory, entry),
         timeoutMs,
         signal
       );
@@ -8328,7 +8495,7 @@ async function decodedProfiles(timeoutMs, signal, strict = false) {
         continue;
       }
       signal.throwIfAborted();
-      const path = join2(directory, entry);
+      const path = join3(directory, entry);
       const raw = await decodeProfile(path, timeoutMs, signal, strict);
       if (!raw) continue;
       let content;
@@ -8484,7 +8651,7 @@ async function readCertificates(timeoutMs, signal, strict = false) {
   );
 }
 async function readArchiveBundles(archivePath, timeoutMs, signal) {
-  const products = join2(archivePath, "Products");
+  const products = join3(archivePath, "Products");
   const bundles = [];
   const queue = [products];
   while (queue.length) {
@@ -8498,7 +8665,7 @@ async function readArchiveBundles(archivePath, timeoutMs, signal) {
     }
     for (const entry of entries) {
       if (entry.isSymbolicLink() || !entry.isDirectory()) continue;
-      const path = join2(current, entry.name);
+      const path = join3(current, entry.name);
       const signable = /\.(app|appex)$/.test(entry.name);
       if (!signable) {
         if (!/\.[A-Za-z0-9]+$/.test(entry.name)) queue.push(path);
@@ -8530,7 +8697,7 @@ async function bundleIdentifier(bundlePath, timeoutMs, signal) {
         "raw",
         "-o",
         "-",
-        join2(bundlePath, "Info.plist")
+        join3(bundlePath, "Info.plist")
       ],
       timeoutMs: Math.min(timeoutMs, 5e3),
       signal
@@ -8546,7 +8713,7 @@ async function embeddedProfile(bundlePath, timeoutMs, signal) {
     "embedded.mobileprovision",
     "embedded.provisionprofile"
   ]) {
-    const path = join2(bundlePath, name);
+    const path = join3(bundlePath, name);
     try {
       await stat2(path);
     } catch {
@@ -8593,7 +8760,7 @@ async function inspectSigningAssets(archivePath, timeoutMs, signal) {
 }
 var inspectIosSigning = async (payload, timeoutMs, signal) => {
   const input = parseBuildSigningInspectPayload(payload);
-  const archivePath = join2(input.artifactDirectory, input.archiveRelativePath);
+  const archivePath = join3(input.artifactDirectory, input.archiveRelativePath);
   const inspection = await inspectSigningAssets(archivePath, timeoutMs, signal);
   return {
     exitCode: 0,
@@ -8655,21 +8822,21 @@ var installSigningProfile = async (payload, timeoutMs, signal) => {
   const { contentBase64 } = signingProfileInstallPayload(payload);
   const content = Buffer.from(contentBase64, "base64");
   if (!content.length) throw new Error("Provisioning profile is empty");
-  const temporaryRoot = await mkdtemp(join2(tmpdir(), "ade-profile-"));
-  const temporaryPath = join2(temporaryRoot, `${randomUUID()}.mobileprovision`);
+  const temporaryRoot = await mkdtemp2(join3(tmpdir2(), "ade-profile-"));
+  const temporaryPath = join3(temporaryRoot, `${randomUUID()}.mobileprovision`);
   try {
-    await writeFile2(temporaryPath, content, { mode: 384 });
+    await writeFile3(temporaryPath, content, { mode: 384 });
     const raw = await decodeProfile(temporaryPath, timeoutMs, signal);
     if (!raw) throw new Error("Provisioning profile is invalid or unsigned");
     const uuid = text(raw.UUID);
     if (!uuid) throw new Error("Provisioning profile UUID is missing");
     const directory = PROFILE_DIRECTORIES[0];
     await mkdir2(directory, { recursive: true, mode: 448 });
-    const destination = join2(directory, `${uuid}.mobileprovision`);
-    await writeFile2(destination, content, { mode: 384 });
+    const destination = join3(directory, `${uuid}.mobileprovision`);
+    await writeFile3(destination, content, { mode: 384 });
     return { ...successfulProcess, uuid };
   } finally {
-    await rm2(temporaryRoot, { recursive: true, force: true });
+    await rm3(temporaryRoot, { recursive: true, force: true });
   }
 };
 var deleteSigningProfile = async (payload, timeoutMs, signal) => {
@@ -8679,7 +8846,7 @@ var deleteSigningProfile = async (payload, timeoutMs, signal) => {
   );
   for (const profile of matches) {
     signal.throwIfAborted();
-    await rm2(profile.path, { force: false });
+    await rm3(profile.path, { force: false });
   }
   return { ...successfulProcess, uuid, deleted: matches.length };
 };
@@ -8693,10 +8860,10 @@ var importSigningIdentity = async (payload, timeoutMs, signal, _onLog, context)
   const hash = createHash3("sha256").update(p12).digest("hex").toUpperCase();
   if (hash !== input.sha256)
     throw new Error("Signing identity transfer changed");
-  const temporaryRoot = await mkdtemp(join2(tmpdir(), "ade-identity-"));
-  const path = join2(temporaryRoot, "identity.p12");
+  const temporaryRoot = await mkdtemp2(join3(tmpdir2(), "ade-identity-"));
+  const path = join3(temporaryRoot, "identity.p12");
   try {
-    await writeFile2(path, p12, { mode: 384 });
+    await writeFile3(path, p12, { mode: 384 });
     const result = await captureCommand({
       command: "/usr/bin/security",
       args: [
@@ -8719,7 +8886,7 @@ var importSigningIdentity = async (payload, timeoutMs, signal, _onLog, context)
     }
     return { ...successfulProcess, sha256: input.sha256 };
   } finally {
-    await rm2(temporaryRoot, { recursive: true, force: true });
+    await rm3(temporaryRoot, { recursive: true, force: true });
   }
 };
 var deleteSigningIdentity = async (payload, timeoutMs, signal) => {
@@ -8740,6 +8907,112 @@ var deleteSigningIdentity = async (payload, timeoutMs, signal) => {
 
 // src/handlers/ccusage.ts
 import { Buffer as Buffer2 } from "node:buffer";
+
+// src/process-runner.ts
+import { spawn as spawn3 } from "node:child_process";
+async function runProcess(options) {
+  return new Promise((resolve7, reject) => {
+    let sequence = 0;
+    let timedOut = false;
+    let cancelled = false;
+    let settled = false;
+    let logChain = Promise.resolve();
+    const detached = process.platform !== "win32";
+    const child = spawn3(options.command, options.args, {
+      shell: false,
+      stdio: ["ignore", "pipe", "pipe"],
+      cwd: options.cwd,
+      env: options.env ?? process.env,
+      // A separate process group lets cancellation terminate scripts and all
+      // descendants instead of leaving a child holding stdout/stderr open.
+      detached
+    });
+    const emit = (stream, message) => {
+      const log = {
+        sequence: sequence++,
+        stream,
+        message,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      logChain = logChain.then(async () => {
+        try {
+          await options.onLog(log);
+        } catch (error) {
+          console.error(
+            `Could not append process log ${log.sequence}:`,
+            error instanceof Error ? error.message : error
+          );
+        }
+      });
+    };
+    const attach = (stream, kind) => {
+      let remainder = "";
+      stream.setEncoding("utf8");
+      stream.on("data", (chunk) => {
+        const parts = `${remainder}${chunk}`.split(/\r?\n/);
+        remainder = parts.pop() ?? "";
+        for (const line of parts) emit(kind, line);
+      });
+      stream.on("end", () => {
+        if (remainder) emit(kind, remainder);
+      });
+    };
+    attach(child.stdout, "STDOUT");
+    attach(child.stderr, "STDERR");
+    const sendSignal = (signal) => {
+      if (detached && child.pid) {
+        try {
+          process.kill(-child.pid, signal);
+          return;
+        } catch (error) {
+          if (!(error instanceof Error) || !("code" in error) || error.code !== "ESRCH") {
+            throw error;
+          }
+        }
+      }
+      child.kill(signal);
+    };
+    const terminate = () => {
+      if (child.exitCode !== null || child.killed) return;
+      sendSignal("SIGTERM");
+      const killTimer = setTimeout(() => sendSignal("SIGKILL"), 5e3);
+      killTimer.unref();
+    };
+    const timeout = setTimeout(() => {
+      timedOut = true;
+      emit(
+        "SYSTEM",
+        `Process exceeded its ${Math.round(options.timeoutMs / 1e3)} second timeout`
+      );
+      terminate();
+    }, options.timeoutMs);
+    timeout.unref();
+    const abort = () => {
+      cancelled = true;
+      emit("SYSTEM", "Cancellation requested");
+      terminate();
+    };
+    options.signal.addEventListener("abort", abort, { once: true });
+    child.once("error", (error) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+      options.signal.removeEventListener("abort", abort);
+      reject(error);
+    });
+    child.once("close", (exitCode, signal) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+      options.signal.removeEventListener("abort", abort);
+      void logChain.then(
+        () => resolve7({ exitCode, signal, timedOut, cancelled })
+      );
+    });
+  });
+}
+
+// src/handlers/ccusage.ts
 var MAX_CCUSAGE_STDOUT_BYTES = 16 * 1024 * 1024;
 function validateCcusagePayload(payload) {
   if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
@@ -8793,9 +9066,17 @@ async function runCcusage(payload, timeoutMs, signal, onLog) {
 }
 
 // src/handlers/build-data.ts
-import { lstat, opendir, readdir as readdir2, realpath, rm as rm3 } from "node:fs/promises";
-import { homedir as homedir3 } from "node:os";
-import { basename as basename2, dirname as dirname2, isAbsolute, join as join3, resolve } from "node:path";
+import {
+  lstat,
+  opendir,
+  readdir as readdir2,
+  realpath as realpath2,
+  rm as rm4,
+  stat as stat3,
+  statfs
+} from "node:fs/promises";
+import { homedir as homedir4 } from "node:os";
+import { basename as basename2, dirname as dirname2, isAbsolute, join as join4, resolve } from "node:path";
 var successfulProcess2 = {
   exitCode: 0,
   signal: null,
@@ -8812,7 +9093,7 @@ function safeRelativePath3(value) {
 }
 async function configuredRoots(payload) {
   if (payload.mode === "DEFAULT") {
-    return [join3(homedir3(), "Library", "Developer", "Xcode", "DerivedData")];
+    return [join4(homedir4(), "Library", "Developer", "Xcode", "DerivedData")];
   }
   if (payload.mode === "ABSOLUTE") {
     if (!payload.path || !isAbsolute(payload.path)) {
@@ -8849,7 +9130,7 @@ async function scanRoot(configuredRoot, timeoutMs, signal) {
   signal.throwIfAborted();
   let rootPath2;
   try {
-    rootPath2 = await realpath(configuredRoot);
+    rootPath2 = await realpath2(configuredRoot);
   } catch (error) {
     if (error.code === "ENOENT") {
       return { entries: [], warning: null };
@@ -8869,12 +9150,15 @@ async function scanRoot(configuredRoot, timeoutMs, signal) {
     };
   }
   const entries = [];
+  const rootStats = await stat3(rootPath2);
+  const volumeId = String(rootStats.dev);
   for (const child of children) {
     signal.throwIfAborted();
     if (!child.isDirectory()) continue;
-    const path = join3(rootPath2, child.name);
+    const path = join4(rootPath2, child.name);
+    const information = await lstat(path);
     const projectPath = await workspacePath(
-      join3(path, "info.plist"),
+      join4(path, "info.plist"),
       timeoutMs,
       signal
     );
@@ -8883,21 +9167,23 @@ async function scanRoot(configuredRoot, timeoutMs, signal) {
       rootPath: rootPath2,
       name: child.name,
       kind: projectPath ? "PROJECT" : child.name.toLocaleLowerCase().endsWith(".noindex") ? "SHARED_CACHE" : "PENDING",
-      workspacePath: projectPath
+      workspacePath: projectPath,
+      modifiedAt: information.mtime.toISOString(),
+      volumeId
     });
   }
   entries.sort((first, second) => first.name.localeCompare(second.name));
   return { entries, warning: null };
 }
 async function scanDeviceSupport(signal) {
-  const configuredRoot = join3(
-    process.env.ADE_IOS_DEVICE_SUPPORT_DIRECTORY ?? homedir3(),
+  const configuredRoot = join4(
+    process.env.ADE_IOS_DEVICE_SUPPORT_DIRECTORY ?? homedir4(),
     ...process.env.ADE_IOS_DEVICE_SUPPORT_DIRECTORY ? [] : ["Library", "Developer", "Xcode", "iOS DeviceSupport"]
   );
   signal.throwIfAborted();
   let rootPath2;
   try {
-    rootPath2 = await realpath(configuredRoot);
+    rootPath2 = await realpath2(configuredRoot);
   } catch (error) {
     if (error.code === "ENOENT") {
       return { entries: [], warning: null };
@@ -8911,11 +9197,13 @@ async function scanDeviceSupport(signal) {
     const children = await readdir2(rootPath2, { withFileTypes: true });
     return {
       entries: children.filter((child) => child.isDirectory() && !child.isSymbolicLink()).map((child) => ({
-        path: join3(rootPath2, child.name),
+        path: join4(rootPath2, child.name),
         rootPath: rootPath2,
         name: child.name,
         kind: "DEVICE_SUPPORT",
-        workspacePath: null
+        workspacePath: null,
+        modifiedAt: null,
+        volumeId: null
       })).sort((first, second) => first.name.localeCompare(second.name)),
       warning: null
     };
@@ -8936,7 +9224,7 @@ var scanBuildData = async (rawPayload, timeoutMs, signal) => {
     signal.throwIfAborted();
     let canonical = root;
     try {
-      canonical = await realpath(root);
+      canonical = await realpath2(root);
     } catch {
     }
     if (canonicalRoots.has(canonical)) continue;
@@ -8970,7 +9258,7 @@ async function allocatedBytes(path, signal) {
   try {
     for await (const entry of directory) {
       signal.throwIfAborted();
-      total += await allocatedBytes(join3(path, entry.name), signal);
+      total += await allocatedBytes(join4(path, entry.name), signal);
     }
   } finally {
     await directory.close().catch(() => void 0);
@@ -8984,7 +9272,7 @@ var sizeBuildData = async (rawPayload, _timeoutMs, signal) => {
     signal.throwIfAborted();
     try {
       assertDirectChild(target2.rootPath, target2.path);
-      const rootPath2 = await realpath(target2.rootPath);
+      const rootPath2 = await realpath2(target2.rootPath);
       if (rootPath2 !== resolve(target2.rootPath) || dirname2(resolve(target2.path)) !== rootPath2) {
         throw new Error("Build Data root changed since the scan");
       }
@@ -9009,13 +9297,13 @@ var sizeBuildData = async (rawPayload, _timeoutMs, signal) => {
   return { ...successfulProcess2, sizes };
 };
 var deleteBuildData = async (rawPayload, _timeoutMs, signal) => {
-  const payload = buildDataTargetsPayload(rawPayload);
+  const payload = buildDataDeletePayload(rawPayload);
   const deleted = [];
   for (const target2 of payload.targets) {
     signal.throwIfAborted();
     try {
       assertDirectChild(target2.rootPath, target2.path);
-      const rootPath2 = await realpath(target2.rootPath);
+      const rootPath2 = await realpath2(target2.rootPath);
       if (rootPath2 !== resolve(target2.rootPath) || dirname2(resolve(target2.path)) !== rootPath2) {
         throw new Error("Build Data root changed since the scan");
       }
@@ -9023,7 +9311,7 @@ var deleteBuildData = async (rawPayload, _timeoutMs, signal) => {
       if (!stats.isDirectory() || stats.isSymbolicLink()) {
         throw new Error("Build Data target is not a directory");
       }
-      await rm3(target2.path, { recursive: true, force: false, maxRetries: 3 });
+      await rm4(target2.path, { recursive: true, force: false, maxRetries: 3 });
       deleted.push({ path: target2.path, deleted: true, error: null });
     } catch (error) {
       signal.throwIfAborted();
@@ -9036,11 +9324,122 @@ var deleteBuildData = async (rawPayload, _timeoutMs, signal) => {
   }
   return { ...successfulProcess2, deleted };
 };
+async function sharedCapacityId(canonicalPath, volumeId, signal) {
+  try {
+    const result = await captureCommand({
+      command: "/usr/sbin/diskutil",
+      args: ["info", "-plist", canonicalPath],
+      timeoutMs: 5e3,
+      signal
+    });
+    signal.throwIfAborted();
+    if (result.exitCode !== 0) return volumeId;
+    const information = parsePlist(result.stdout);
+    if (!information || typeof information !== "object") return volumeId;
+    const container = information.APFSContainerReference;
+    return typeof container === "string" && container.trim() ? `apfs:${container.trim()}` : volumeId;
+  } catch {
+    signal.throwIfAborted();
+    return volumeId;
+  }
+}
+async function inspectVolume(configuredPath, role, signal) {
+  signal.throwIfAborted();
+  const canonicalPath = await realpath2(configuredPath);
+  const [information, filesystem] = await Promise.all([
+    stat3(canonicalPath),
+    statfs(canonicalPath, { bigint: true })
+  ]);
+  const id2 = String(information.dev);
+  return {
+    canonicalPath,
+    volume: {
+      id: id2,
+      capacityId: id2,
+      totalBytes: Number(filesystem.blocks * filesystem.bsize),
+      freeBytes: Number(filesystem.bavail * filesystem.bsize),
+      roles: /* @__PURE__ */ new Set([role]),
+      paths: /* @__PURE__ */ new Set([canonicalPath])
+    }
+  };
+}
+async function collectAgentDiskSpace(configuration, signal) {
+  const scanPayload = buildDataScanPayload({
+    mode: configuration.derivedDataLocationMode,
+    path: configuration.derivedDataPath,
+    worktrees: configuration.worktrees
+  });
+  const roots = await configuredRoots(scanPayload);
+  const requested = [
+    { path: "/", role: "MAIN" },
+    ...configuration.baseRepoDirectory ? [{ path: configuration.baseRepoDirectory, role: "BASE_REPO" }] : [],
+    ...roots.map((path) => ({ path, role: "DERIVED_DATA" }))
+  ];
+  const warnings = [];
+  const volumes = /* @__PURE__ */ new Map();
+  for (const request of requested) {
+    signal.throwIfAborted();
+    try {
+      const inspected = await inspectVolume(request.path, request.role, signal);
+      const existing = volumes.get(inspected.volume.id);
+      if (existing) {
+        existing.roles.add(request.role);
+        existing.paths.add(inspected.canonicalPath);
+        existing.totalBytes = inspected.volume.totalBytes;
+        existing.freeBytes = inspected.volume.freeBytes;
+      } else {
+        inspected.volume.capacityId = await sharedCapacityId(
+          inspected.canonicalPath,
+          inspected.volume.id,
+          signal
+        );
+        volumes.set(inspected.volume.id, inspected.volume);
+      }
+    } catch (error) {
+      warnings.push(`${request.path}: ${errorMessage(error)}`);
+    }
+  }
+  const entries = [];
+  const scannedRoots = /* @__PURE__ */ new Set();
+  for (const root of roots) {
+    signal.throwIfAborted();
+    let canonical = root;
+    try {
+      canonical = await realpath2(root);
+    } catch {
+    }
+    if (scannedRoots.has(canonical)) continue;
+    scannedRoots.add(canonical);
+    const result = await scanRoot(root, 45e3, signal);
+    if (result.warning) warnings.push(result.warning);
+    for (const entry of result.entries) {
+      if (!entry.modifiedAt || !entry.volumeId) continue;
+      entries.push({
+        ...entry,
+        modifiedAt: entry.modifiedAt,
+        volumeId: entry.volumeId
+      });
+    }
+  }
+  return {
+    observedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    volumes: [...volumes.values()].map((volume) => ({
+      id: volume.id,
+      capacityId: volume.capacityId,
+      totalBytes: volume.totalBytes,
+      freeBytes: volume.freeBytes,
+      roles: [...volume.roles],
+      paths: [...volume.paths]
+    })),
+    entries,
+    warnings: [...new Set(warnings)]
+  };
+}
 
 // src/handlers/codebases.ts
-import { readdir as readdir3, realpath as realpath2, stat as stat3 } from "node:fs/promises";
-import { homedir as homedir4 } from "node:os";
-import { dirname as dirname3, join as join4, resolve as resolve2 } from "node:path";
+import { readdir as readdir3, realpath as realpath3, stat as stat4 } from "node:fs/promises";
+import { homedir as homedir5 } from "node:os";
+import { dirname as dirname3, join as join5, resolve as resolve2 } from "node:path";
 var successfulProcess3 = {
   exitCode: 0,
   signal: null,
@@ -9117,7 +9516,7 @@ function baseSnapshot(folder) {
 }
 async function fetchedAt(commonDirectory) {
   try {
-    return (await stat3(join4(commonDirectory, "FETCH_HEAD"))).mtime.toISOString();
+    return (await stat4(join5(commonDirectory, "FETCH_HEAD"))).mtime.toISOString();
   } catch {
     return null;
   }
@@ -9127,8 +9526,8 @@ async function inspectCodebaseProcess(selectedFolder, timeoutMs, signal, expecte
   const base = baseSnapshot(fallbackFolder);
   let selected;
   try {
-    selected = await realpath2(fallbackFolder);
-    if (!(await stat3(selected)).isDirectory())
+    selected = await realpath3(fallbackFolder);
+    if (!(await stat4(selected)).isDirectory())
       throw new Error("Folder is not a directory");
   } catch (error) {
     return {
@@ -9160,7 +9559,7 @@ async function inspectCodebaseProcess(selectedFolder, timeoutMs, signal, expecte
         }
       };
     }
-    const folder = await realpath2(rootResult.stdout.trim());
+    const folder = await realpath3(rootResult.stdout.trim());
     const bare = await git(
       folder,
       ["rev-parse", "--is-bare-repository"],
@@ -9211,8 +9610,8 @@ async function inspectCodebaseProcess(selectedFolder, timeoutMs, signal, expecte
       };
     }
     const origin2 = normalizeGitOrigin(originResult.stdout.trim());
-    const gitDirectory2 = await realpath2(gitDirectoryResult.stdout.trim());
-    const commonDirectory = await realpath2(commonDirectoryResult.stdout.trim());
+    const gitDirectory2 = await realpath3(gitDirectoryResult.stdout.trim());
+    const commonDirectory = await realpath3(commonDirectoryResult.stdout.trim());
     const linkedWorktree = gitDirectory2 !== commonDirectory;
     const branchResult = await git(
       folder,
@@ -9296,9 +9695,9 @@ async function inspectCodebase(selectedFolder, timeoutMs, signal, expectedOrigin
 }
 var browseCodebaseDirectories = async (payload) => {
   const input = codebaseBrowsePayload(payload);
-  const homePath = await realpath2(homedir4());
-  const path = await realpath2(input.path ? resolve2(input.path) : homePath);
-  if (!(await stat3(path)).isDirectory())
+  const homePath = await realpath3(homedir5());
+  const path = await realpath3(input.path ? resolve2(input.path) : homePath);
+  if (!(await stat4(path)).isDirectory())
     throw new Error("Path is not a directory");
   const candidates = await readdir3(path, { withFileTypes: true });
   const entries = [];
@@ -9306,13 +9705,13 @@ var browseCodebaseDirectories = async (payload) => {
     if (candidate.isDirectory()) {
       entries.push({
         name: candidate.name,
-        path: join4(path, candidate.name),
+        path: join5(path, candidate.name),
         hidden: candidate.name.startsWith(".")
       });
     } else if (candidate.isSymbolicLink()) {
       try {
-        const target2 = join4(path, candidate.name);
-        if ((await stat3(target2)).isDirectory()) {
+        const target2 = join5(path, candidate.name);
+        if ((await stat4(target2)).isDirectory()) {
           entries.push({
             name: candidate.name,
             path: target2,
@@ -9913,19 +10312,19 @@ import { execFile } from "node:child_process";
 import { randomUUID as randomUUID2 } from "node:crypto";
 import {
   access,
-  chmod as chmod2,
+  chmod as chmod3,
   lstat as lstat2,
   mkdir as mkdir3,
   readFile as readFile3,
-  realpath as realpath3,
+  realpath as realpath4,
   readdir as readdir4,
   rename as rename2,
-  rm as rm4,
-  stat as stat4,
-  writeFile as writeFile3
+  rm as rm5,
+  stat as stat5,
+  writeFile as writeFile4
 } from "node:fs/promises";
-import { homedir as homedir5 } from "node:os";
-import { dirname as dirname4, isAbsolute as isAbsolute2, join as join5, relative as relative2, resolve as resolve3, sep as sep2 } from "node:path";
+import { homedir as homedir6 } from "node:os";
+import { dirname as dirname4, isAbsolute as isAbsolute2, join as join6, relative as relative2, resolve as resolve3, sep as sep2 } from "node:path";
 import { promisify } from "node:util";
 var executeFile = promisify(execFile);
 var successfulProcess4 = {
@@ -9980,23 +10379,23 @@ var PROJECT_ROOTS = {
 };
 async function directoryExists(path) {
   try {
-    return (await stat4(path)).isDirectory();
+    return (await stat5(path)).isDirectory();
   } catch {
     return false;
   }
 }
 async function configuredTools(tools) {
-  const homePath = homedir5();
+  const homePath = homedir6();
   return Promise.all(
     AI_TOOLS.filter((tool) => tools.includes(tool)).map(async (tool) => ({
       tool,
-      configured: await directoryExists(join5(homePath, ...CONFIG_PATHS[tool])),
+      configured: await directoryExists(join6(homePath, ...CONFIG_PATHS[tool])),
       homePath
     }))
   );
 }
 function rootPath(location) {
-  const base = location.scope === "GLOBAL" ? homedir5() : location.folder;
+  const base = location.scope === "GLOBAL" ? homedir6() : location.folder;
   const parts = location.scope === "GLOBAL" ? GLOBAL_ROOTS[location.rootKind] : PROJECT_ROOTS[location.rootKind];
   const path = resolve3(base, ...parts);
   const normalizedBase = resolve3(base);
@@ -10013,7 +10412,7 @@ async function listPackageFiles(skillDirectory) {
   let totalBytes = 0;
   const visit = async (directory) => {
     for (const entry of await readdir4(directory, { withFileTypes: true })) {
-      const path = join5(directory, entry.name);
+      const path = join6(directory, entry.name);
       const metadata = await lstat2(path);
       if (metadata.isSymbolicLink()) {
         throw new Error(
@@ -10049,7 +10448,7 @@ async function readPackage(directory) {
   const metadata = await lstat2(directory);
   let resolvedDirectory = directory;
   if (metadata.isSymbolicLink()) {
-    resolvedDirectory = await realpath3(directory);
+    resolvedDirectory = await realpath4(directory);
   } else if (!metadata.isDirectory()) {
     throw new Error("Skill path is not a directory");
   }
@@ -10102,7 +10501,7 @@ async function scanRoot2(location, configured, targets, warnings) {
   const installations = [];
   for (const entry of await readdir4(root, { withFileTypes: true })) {
     if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
-    const directory = join5(root, entry.name);
+    const directory = join6(root, entry.name);
     try {
       const skillPackage = await readPackage(directory);
       const relativeDirectory = location.folder ? relative2(location.folder, directory).split(sep2).join("/") : "";
@@ -10181,7 +10580,7 @@ var readSkills = async (payload) => {
     }
     packages.push({
       ...request,
-      package: await readPackage(join5(root, request.skillName))
+      package: await readPackage(join6(root, request.skillName))
     });
   }
   return { ...successfulProcess4, packages };
@@ -10222,7 +10621,7 @@ async function updateManagedExclude(folder, relativeSkillPath, present) {
   const block = managed.size ? `${MANAGED_EXCLUDE_START}
 ${[...managed].sort().join("\n")}
 ${MANAGED_EXCLUDE_END}` : "";
-  await writeFile3(
+  await writeFile4(
     excludePath,
     `${[before, block, after].filter(Boolean).join("\n\n")}
 `,
@@ -10243,11 +10642,11 @@ async function writePackage(location, skillPackage) {
     throw new Error("New skill copies may only be written to shared roots");
   }
   const root = rootPath(location);
-  const destination = join5(root, skillPackage.name);
+  const destination = join6(root, skillPackage.name);
   await assertUntracked(location, destination);
   await mkdir3(root, { recursive: true });
-  const temporary = join5(root, `.${skillPackage.name}.${randomUUID2()}.tmp`);
-  const backup = join5(root, `.${skillPackage.name}.${randomUUID2()}.bak`);
+  const temporary = join6(root, `.${skillPackage.name}.${randomUUID2()}.tmp`);
+  const backup = join6(root, `.${skillPackage.name}.${randomUUID2()}.bak`);
   await mkdir3(temporary, { recursive: true });
   try {
     for (const file of skillPackage.files) {
@@ -10255,8 +10654,8 @@ async function writePackage(location, skillPackage) {
       if (!path.startsWith(`${temporary}${sep2}`))
         throw new Error("Skill file escaped temporary directory");
       await mkdir3(dirname4(path), { recursive: true });
-      await writeFile3(path, Buffer.from(file.contentsBase64, "base64"));
-      await chmod2(path, file.executable ? 493 : 420);
+      await writeFile4(path, Buffer.from(file.contentsBase64, "base64"));
+      await chmod3(path, file.executable ? 493 : 420);
     }
     let hadDestination = false;
     try {
@@ -10268,14 +10667,14 @@ async function writePackage(location, skillPackage) {
     }
     try {
       await rename2(temporary, destination);
-      if (hadDestination) await rm4(backup, { recursive: true, force: true });
+      if (hadDestination) await rm5(backup, { recursive: true, force: true });
     } catch (error) {
       if (hadDestination) await rename2(backup, destination);
       throw error;
     }
   } finally {
-    await rm4(temporary, { recursive: true, force: true });
-    await rm4(backup, { recursive: true, force: true });
+    await rm5(temporary, { recursive: true, force: true });
+    await rm5(backup, { recursive: true, force: true });
   }
   return destination;
 }
@@ -10285,7 +10684,7 @@ var applySkills = async (payload) => {
   for (const operation of operations) {
     const root = rootPath(operation);
     const skillName = operation.kind === "WRITE" ? operation.package.name : operation.skillName;
-    const destination = join5(root, skillName);
+    const destination = join6(root, skillName);
     await assertUntracked(operation, destination);
     if (operation.kind === "WRITE") {
       await writePackage(operation, operation.package);
@@ -10295,7 +10694,7 @@ var applySkills = async (payload) => {
         packageHash: operation.package.packageHash
       });
     } else {
-      await rm4(destination, { recursive: true, force: true });
+      await rm5(destination, { recursive: true, force: true });
       results.push({
         kind: operation.kind,
         path: destination,
@@ -10314,9 +10713,9 @@ var applySkills = async (payload) => {
 };
 
 // src/handlers/runs.ts
-import { readFile as readFile4, readdir as readdir5, stat as stat5 } from "node:fs/promises";
-import { homedir as homedir6 } from "node:os";
-import { join as join6 } from "node:path";
+import { readFile as readFile4, readdir as readdir5, stat as stat6 } from "node:fs/promises";
+import { homedir as homedir7 } from "node:os";
+import { join as join7 } from "node:path";
 var successfulProcess5 = {
   exitCode: 0,
   signal: null,
@@ -10325,13 +10724,13 @@ var successfulProcess5 = {
 };
 async function fileExists(path) {
   try {
-    return (await stat5(path)).isFile();
+    return (await stat6(path)).isFile();
   } catch {
     return false;
   }
 }
 async function findClaudeSessionFile(nativeId, home) {
-  const projectsDir = join6(home, ".claude", "projects");
+  const projectsDir = join7(home, ".claude", "projects");
   let entries;
   try {
     entries = await readdir5(projectsDir, { withFileTypes: true });
@@ -10341,13 +10740,13 @@ async function findClaudeSessionFile(nativeId, home) {
   const target2 = `${nativeId}.jsonl`;
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const candidate = join6(projectsDir, entry.name, target2);
+    const candidate = join7(projectsDir, entry.name, target2);
     if (await fileExists(candidate)) return candidate;
   }
   return null;
 }
 async function findCodexSessionFile(nativeId, home) {
-  const sessionsDir = join6(home, ".codex", "sessions");
+  const sessionsDir = join7(home, ".codex", "sessions");
   const suffix = `-${nativeId}.jsonl`;
   const walk = async (dir) => {
     let entries;
@@ -10357,7 +10756,7 @@ async function findCodexSessionFile(nativeId, home) {
       return null;
     }
     for (const entry of entries) {
-      const path = join6(dir, entry.name);
+      const path = join7(dir, entry.name);
       if (entry.isDirectory()) {
         const found = await walk(path);
         if (found) return found;
@@ -10374,13 +10773,13 @@ async function locateSessionFile(payload, home) {
 }
 var readRunSession = async (payload) => {
   const input = parseRunSessionReadPayload(payload);
-  const path = await locateSessionFile(input, homedir6());
+  const path = await locateSessionFile(input, homedir7());
   if (!path) {
     throw new Error(
       `No ${input.provider === "CLAUDE" ? "Claude" : "Codex"} session file found for this run on this agent`
     );
   }
-  const { size } = await stat5(path);
+  const { size } = await stat6(path);
   if (size > MAX_RUN_SESSION_FILE_BYTES) {
     throw new Error(
       `Session file is too large to export (${size} bytes exceeds the ${MAX_RUN_SESSION_FILE_BYTES} byte limit)`
@@ -10396,21 +10795,21 @@ var readRunSession = async (payload) => {
 
 // src/handlers/workflows.ts
 import {
-  mkdtemp as mkdtemp4,
+  mkdtemp as mkdtemp5,
   readFile as readFile6,
-  realpath as realpath5,
-  rm as rm7,
-  stat as stat7,
-  writeFile as writeFile5
+  realpath as realpath6,
+  rm as rm8,
+  stat as stat8,
+  writeFile as writeFile6
 } from "node:fs/promises";
-import { tmpdir as tmpdir4 } from "node:os";
-import { join as join9 } from "node:path";
+import { tmpdir as tmpdir5 } from "node:os";
+import { join as join10 } from "node:path";
 
 // src/runs/git-checkpoint.ts
 import { execFile as execFile2 } from "node:child_process";
-import { copyFile, mkdtemp as mkdtemp2, rm as rm5 } from "node:fs/promises";
-import { tmpdir as tmpdir2 } from "node:os";
-import { join as join7 } from "node:path";
+import { copyFile, mkdtemp as mkdtemp3, rm as rm6 } from "node:fs/promises";
+import { tmpdir as tmpdir3 } from "node:os";
+import { join as join8 } from "node:path";
 import { promisify as promisify2 } from "node:util";
 var execFileAsync = promisify2(execFile2);
 async function git2(cwd, args, env) {
@@ -10525,12 +10924,12 @@ async function captureGitCheckpoint(cwd, runId, kind) {
   const manifest = await optionalGit(cwd, ["status", "--porcelain=v2", "-z"]);
   const staged = await optionalGit(cwd, ["diff", "--cached", "--stat", "HEAD"]);
   const unstaged = await optionalGit(cwd, ["diff", "--stat", "HEAD"]);
-  const directory = await mkdtemp2(join7(tmpdir2(), "aide-run-index-"));
+  const directory = await mkdtemp3(join8(tmpdir3(), "aide-run-index-"));
   let worktreeTree = null;
   let refName = null;
   try {
     const actualIndex = await git2(cwd, ["rev-parse", "--git-path", "index"]);
-    const temporaryIndex = join7(directory, "index");
+    const temporaryIndex = join8(directory, "index");
     try {
       await copyFile(actualIndex, temporaryIndex);
     } catch {
@@ -10562,7 +10961,7 @@ async function captureGitCheckpoint(cwd, runId, kind) {
     refName = `refs/aide/runs/${runId}/${Date.now()}-${kind.toLowerCase()}`;
     await git2(cwd, ["update-ref", refName, checkpointCommit]);
   } finally {
-    await rm5(directory, { recursive: true, force: true });
+    await rm6(directory, { recursive: true, force: true });
   }
   return {
     kind,
@@ -10591,36 +10990,37 @@ import { createHash as createHash5, randomUUID as randomUUID3 } from "node:crypt
 import {
   cp,
   mkdir as mkdir4,
-  mkdtemp as mkdtemp3,
+  mkdtemp as mkdtemp4,
   open,
   readdir as readdir6,
   readFile as readFile5,
-  realpath as realpath4,
+  realpath as realpath5,
   rename as rename3,
-  rm as rm6,
-  stat as stat6,
-  writeFile as writeFile4
+  rm as rm7,
+  stat as stat7,
+  writeFile as writeFile5
 } from "node:fs/promises";
 import { createReadStream as createReadStream3, createWriteStream } from "node:fs";
-import { tmpdir as tmpdir3 } from "node:os";
+import { tmpdir as tmpdir4 } from "node:os";
 import { pipeline } from "node:stream/promises";
+import { StringDecoder } from "node:string_decoder";
 import {
   basename as basename3,
   dirname as dirname5,
   isAbsolute as isAbsolute4,
-  join as join8,
+  join as join9,
   relative as relative4,
   resolve as resolve5,
   sep as sep4
 } from "node:path";
-import { spawn as spawn4 } from "node:child_process";
+import { spawn as spawn5 } from "node:child_process";
 
 // src/git-code-state.ts
 import { createHash as createHash4 } from "node:crypto";
 import { createReadStream as createReadStream2 } from "node:fs";
 import { lstat as lstat3, readlink } from "node:fs/promises";
 import { isAbsolute as isAbsolute3, relative as relative3, resolve as resolve4, sep as sep3 } from "node:path";
-import { spawn as spawn3 } from "node:child_process";
+import { spawn as spawn4 } from "node:child_process";
 function gitEnvironment() {
   return {
     ...process.env,
@@ -10643,7 +11043,7 @@ function hashGitDiff(hash, folder, timeoutMs, signal) {
   return new Promise((resolveResult, reject) => {
     let settled = false;
     let timedOut = false;
-    const child = spawn3(
+    const child = spawn4(
       "git",
       [
         "-C",
@@ -10862,8 +11262,8 @@ function requireSuccess2(result, fallback) {
   return result;
 }
 async function validateWorktree(input, timeoutMs, signal) {
-  const folder = await realpath4(input.folder);
-  if (!(await stat6(folder)).isDirectory())
+  const folder = await realpath5(input.folder);
+  if (!(await stat7(folder)).isDirectory())
     throw new Error("Worktree is missing");
   const gitDirectory2 = requireSuccess2(
     await command(
@@ -10876,7 +11276,7 @@ async function validateWorktree(input, timeoutMs, signal) {
     ),
     "Could not resolve the worktree Git directory"
   ).stdout.trim();
-  if (await realpath4(gitDirectory2) !== input.gitDirectory) {
+  if (await realpath5(gitDirectory2) !== input.gitDirectory) {
     throw new Error("Worktree identity changed; refresh the page");
   }
   const origin2 = requireSuccess2(
@@ -10905,12 +11305,12 @@ function containedPath2(root, relativePath) {
 }
 async function validateSource(root, source) {
   const target2 = containedPath2(root, source.relativePath);
-  const resolved = await realpath4(target2);
+  const resolved = await realpath5(target2);
   const difference = relative4(root, resolved);
   if (difference === ".." || difference.startsWith(`..${sep4}`) || isAbsolute4(difference)) {
     throw new Error("Build source resolves outside the worktree");
   }
-  const information = await stat6(resolved);
+  const information = await stat7(resolved);
   if (source.kind === "PACKAGE" && !information.isFile()) {
     throw new Error("Package.swift is missing");
   }
@@ -10926,7 +11326,7 @@ async function discoverSourcesInFolder(folder) {
     const current = queue.shift();
     for (const entry of await readdir6(current, { withFileTypes: true })) {
       if (entry.isSymbolicLink()) continue;
-      const absolute = join8(current, entry.name);
+      const absolute = join9(current, entry.name);
       const path = relative4(folder, absolute).split(sep4).join("/");
       if (entry.isDirectory()) {
         if (entry.name.endsWith(".xcodeproj")) {
@@ -10997,7 +11397,7 @@ function metadataFromList(value) {
   };
 }
 async function workspaceProjectPaths(workspacePath2, folder) {
-  const contentsPath = join8(workspacePath2, "contents.xcworkspacedata");
+  const contentsPath = join9(workspacePath2, "contents.xcworkspacedata");
   let contents;
   try {
     contents = await readFile5(contentsPath, "utf8");
@@ -11024,9 +11424,9 @@ async function workspaceProjectPaths(workspacePath2, folder) {
       continue;
     }
     try {
-      const resolved = await realpath4(candidate);
+      const resolved = await realpath5(candidate);
       const resolvedDifference = relative4(folder, resolved);
-      if (resolvedDifference === ".." || resolvedDifference.startsWith(`..${sep4}`) || isAbsolute4(resolvedDifference) || !(await stat6(resolved)).isDirectory()) {
+      if (resolvedDifference === ".." || resolvedDifference.startsWith(`..${sep4}`) || isAbsolute4(resolvedDifference) || !(await stat7(resolved)).isDirectory()) {
         continue;
       }
       projects.push(resolved);
@@ -11217,7 +11617,7 @@ async function dependentSigningRequirements(source, absolutePath, folder, rootTa
   for (const project of projects.slice(0, 50)) {
     const converted = await command(
       "plutil",
-      ["-convert", "json", "-o", "-", join8(project, "project.pbxproj")],
+      ["-convert", "json", "-o", "-", join9(project, "project.pbxproj")],
       Math.min(timeoutMs, 15e3),
       signal,
       folder
@@ -11454,8 +11854,8 @@ function genericBuildDestinations(action) {
   ];
 }
 async function listPhysicalDevices(timeoutMs, signal) {
-  const directory = await mkdtemp3(join8(tmpdir3(), "ade-devices-"));
-  const output = join8(directory, "devices.json");
+  const directory = await mkdtemp4(join9(tmpdir4(), "ade-devices-"));
+  const output = join9(directory, "devices.json");
   try {
     const result = await command(
       "xcrun",
@@ -11475,7 +11875,7 @@ async function listPhysicalDevices(timeoutMs, signal) {
     if (result.exitCode !== 0) return [];
     return physicalDestinations(JSON.parse(await readFile5(output, "utf8")));
   } finally {
-    await rm6(directory, { recursive: true, force: true });
+    await rm7(directory, { recursive: true, force: true });
   }
 }
 var inspectBuildDestinations = async (payload, timeoutMs, signal) => {
@@ -11562,7 +11962,7 @@ function createRedactor(env) {
     );
   };
 }
-var BuildLogger = class {
+var BuildLogger = class _BuildLogger {
   constructor(buildId, context, rawLogPath, env) {
     this.buildId = buildId;
     this.context = context;
@@ -11571,51 +11971,67 @@ var BuildLogger = class {
   }
   buildId;
   context;
+  static MAX_CHUNK_BYTES = 128 * 1024;
+  static MAX_BATCH_BYTES = 128 * 1024;
   stream;
   redact;
   sequence = 0;
   pending = [];
+  pendingBytes = 0;
   flushChain = Promise.resolve();
   timer = null;
   closePromise = null;
   redactingPrivateKey = false;
   emit(phase, stream, message, scope = "BUILD", scopeId = this.buildId, extraStream) {
+    this.write(phase, stream, `${message}\r
+`, scope, scopeId, extraStream);
+  }
+  write(phase, stream, output, scope = "BUILD", scopeId = this.buildId, extraStream) {
+    const ending = output.match(/(?:\r\n|\r|\n)$/)?.[0] ?? "";
+    const message = ending ? output.slice(0, -ending.length) : output;
     const startsPrivateKey = /-----BEGIN [^-]*PRIVATE KEY-----/i.test(message);
     const endsPrivateKey = /-----END [^-]*PRIVATE KEY-----/i.test(message);
     if (startsPrivateKey) this.redactingPrivateKey = true;
     const sanitized = this.redactingPrivateKey ? "[REDACTED PRIVATE KEY]" : this.redact(message);
     if (endsPrivateKey) this.redactingPrivateKey = false;
     const createdAt = (/* @__PURE__ */ new Date()).toISOString();
-    const line = `[${createdAt}] [${phase}] [${stream}] ${sanitized}
-`;
+    const terminalOutput = `${sanitized}${ending}`;
+    const line = `[${createdAt}] [${phase}] [${stream}] ${sanitized}${ending || "\n"}`;
     this.stream.write(line);
     extraStream?.write(line);
-    this.pending.push({
-      scope,
-      scopeId,
-      sequence: this.sequence++,
-      phase,
-      level: stream === "STDERR" || /\berror\b/i.test(sanitized) ? "ERROR" : /\bwarning\b/i.test(sanitized) ? "WARNING" : "INFO",
-      stream,
-      message: sanitized,
-      createdAt
-    });
-    if (this.pending.length >= 100) this.flush();
-    else if (!this.timer) {
-      this.timer = setTimeout(() => this.flush(), 250);
+    for (const data of splitUtf8(terminalOutput, _BuildLogger.MAX_CHUNK_BYTES)) {
+      const bytes = Buffer.from(data, "utf8");
+      this.pending.push({
+        scope,
+        scopeId,
+        sequence: this.sequence++,
+        phase,
+        stream,
+        dataBase64: bytes.toString("base64"),
+        byteLength: bytes.byteLength,
+        createdAt
+      });
+      this.pendingBytes += bytes.byteLength;
+      if (this.pending.length >= 200 || this.pendingBytes >= _BuildLogger.MAX_BATCH_BYTES) {
+        this.flush();
+      }
+    }
+    if (this.pending.length && !this.timer) {
+      this.timer = setTimeout(() => this.flush(), 25);
       this.timer.unref();
     }
   }
   flush() {
     if (this.timer) clearTimeout(this.timer);
     this.timer = null;
-    const events = this.pending.splice(0);
-    if (!events.length || !this.context?.appendBuildLogs) return;
+    const chunks = this.pending.splice(0);
+    this.pendingBytes = 0;
+    if (!chunks.length || !this.context?.appendBuildLogChunks) return;
     this.flushChain = this.flushChain.then(async () => {
       try {
-        await this.context.appendBuildLogs(this.buildId, events);
+        await this.context.appendBuildLogChunks(this.buildId, chunks);
       } catch (error) {
-        console.error("Could not append build logs:", cleanError2(error));
+        console.error("Could not append build log chunks:", cleanError2(error));
       }
     });
   }
@@ -11628,6 +12044,24 @@ var BuildLogger = class {
     return this.closePromise;
   }
 };
+function splitUtf8(value, maximumBytes) {
+  if (!value) return [];
+  const parts = [];
+  let part = "";
+  let byteLength = 0;
+  for (const character of value) {
+    const characterBytes = Buffer.byteLength(character, "utf8");
+    if (part && byteLength + characterBytes > maximumBytes) {
+      parts.push(part);
+      part = "";
+      byteLength = 0;
+    }
+    part += character;
+    byteLength += characterBytes;
+  }
+  if (part) parts.push(part);
+  return parts;
+}
 function terminateProcess(child) {
   if (child.exitCode !== null || child.killed) return null;
   try {
@@ -11661,9 +12095,15 @@ function runLoggedCommand(options) {
         mode: 384
       });
     }
-    const child = spawn4(options.command, options.args, {
+    const child = spawn5(options.command, options.args, {
       cwd: options.cwd,
-      env: options.env,
+      env: {
+        ...options.env,
+        TERM: "xterm-256color",
+        COLORTERM: "truecolor",
+        FORCE_COLOR: "1",
+        CLICOLOR_FORCE: "1"
+      },
       shell: false,
       detached: true,
       stdio: ["ignore", "pipe", "pipe"]
@@ -11677,36 +12117,36 @@ function runLoggedCommand(options) {
       extraStream
     );
     const attach = (stream, kind) => {
+      const decoder = new StringDecoder("utf8");
       let remainder = "";
-      stream.setEncoding("utf8");
-      stream.on("data", (chunk) => {
-        const parts = `${remainder}${chunk}`.split(/\r?\n/);
-        remainder = parts.pop() ?? "";
-        for (const line of parts) {
-          output = `${output}${line}
-`.slice(-64e3);
-          options.logger.emit(
+      const drain = (final = false) => {
+        while (remainder) {
+          const delimiter = remainder.search(/[\r\n]/);
+          if (delimiter < 0 && !final) return;
+          let end = delimiter < 0 ? remainder.length : delimiter + 1;
+          if (remainder[delimiter] === "\r" && remainder[delimiter + 1] === "\n") {
+            end += 1;
+          }
+          const record = remainder.slice(0, end);
+          remainder = remainder.slice(end);
+          output = `${output}${record}`.slice(-64e3);
+          options.logger.write(
             options.phase,
             kind,
-            line,
+            record,
             options.scope,
             options.scopeId,
             extraStream
           );
         }
+      };
+      stream.on("data", (chunk) => {
+        remainder += decoder.write(chunk);
+        drain();
       });
       stream.on("end", () => {
-        if (remainder) {
-          output = `${output}${remainder}`.slice(-64e3);
-          options.logger.emit(
-            options.phase,
-            kind,
-            remainder,
-            options.scope,
-            options.scopeId,
-            extraStream
-          );
-        }
+        remainder += decoder.end();
+        drain(true);
       });
     };
     attach(child.stdout, "STDOUT");
@@ -11853,7 +12293,7 @@ function actionArgument(action) {
   }[action];
 }
 function xcodeBuildArguments(input) {
-  const resultBundle = join8(input.artifactDirectory, "result.xcresult");
+  const resultBundle = join9(input.artifactDirectory, "result.xcresult");
   const sourcePath = containedPath2(input.folder, input.source.relativePath);
   const usesCapturedTestProducts = input.action === "TEST_WITHOUT_BUILDING";
   const args = [
@@ -11875,13 +12315,13 @@ function xcodeBuildArguments(input) {
   if (input.action === "ARCHIVE") {
     args.push(
       "-archivePath",
-      join8(input.artifactDirectory, "archive.xcarchive")
+      join9(input.artifactDirectory, "archive.xcarchive")
     );
   }
   if (input.action === "BUILD_FOR_TESTING") {
     args.push(
       "-testProductsPath",
-      join8(input.artifactDirectory, "test-products.xctestproducts")
+      join9(input.artifactDirectory, "test-products.xctestproducts")
     );
   }
   if (input.action === "TEST_WITHOUT_BUILDING" && input.advancedSettings.priorTestProductsPath) {
@@ -11944,27 +12384,27 @@ function classifyFailure(output) {
 }
 async function runHook(options) {
   const phaseDirectory = options.phase === "PRE_BUILD" ? "pre" : "post";
-  const directory = join8(
+  const directory = join9(
     options.input.artifactDirectory,
     "hooks",
     phaseDirectory
   );
   const prefix = `${String(options.script.position).padStart(3, "0")}-${options.script.id}`;
-  const file = join8(directory, `${prefix}.mjs`);
-  const runner = join8(directory, `${prefix}.runner.mjs`);
-  const log = join8(directory, `${prefix}.log`);
+  const file = join9(directory, `${prefix}.mjs`);
+  const runner = join9(directory, `${prefix}.runner.mjs`);
+  const log = join9(directory, `${prefix}.log`);
   const started = Date.now();
   try {
     await mkdir4(directory, { recursive: true, mode: 448 });
-    await writeFile4(file, `${options.source}
+    await writeFile5(file, `${options.source}
 `, { mode: 384 });
-    await writeFile4(
+    await writeFile5(
       options.contextPath,
       `${JSON.stringify(options.hookContext, null, 2)}
 `,
       { mode: 384 }
     );
-    await writeFile4(
+    await writeFile5(
       runner,
       `import { readFile } from "node:fs/promises";
 const hookModule = await import(${JSON.stringify(`./${basename3(file)}`)});
@@ -12037,26 +12477,26 @@ if (typeof hookModule.default === "function") {
 }
 async function pathExists(path) {
   try {
-    await stat6(path);
+    await stat7(path);
     return true;
   } catch {
     return false;
   }
 }
 async function pathSize(path) {
-  const information = await stat6(path);
+  const information = await stat7(path);
   if (information.isFile()) return information.size;
   if (!information.isDirectory()) return 0;
   let size = 0;
   for (const entry of await readdir6(path, { withFileTypes: true })) {
     if (entry.isSymbolicLink()) continue;
-    size += await pathSize(join8(path, entry.name));
+    size += await pathSize(join9(path, entry.name));
   }
   return size;
 }
 async function fileChecksum(path) {
   try {
-    const information = await stat6(path);
+    const information = await stat7(path);
     if (!information.isFile()) return null;
     const hash = createHash5("sha256");
     await pipeline(createReadStream3(path), hash);
@@ -12080,7 +12520,7 @@ async function plistString(plistPath, keyPath, timeoutMs, signal) {
   }
 }
 async function archiveApplicationProperties(archivePath, timeoutMs, signal) {
-  const plistPath = join8(archivePath, "Info.plist");
+  const plistPath = join9(archivePath, "Info.plist");
   const read = (key) => plistString(plistPath, `ApplicationProperties.${key}`, timeoutMs, signal);
   const [bundleIdentifier2, bundleShortVersion, bundleVersion, applicationPath] = await Promise.all([
     read("CFBundleIdentifier"),
@@ -12239,9 +12679,9 @@ function normalizeCoverage(value) {
   };
 }
 async function writeJsonReport(input, kind, timeoutMs, signal) {
-  const resultBundle = join8(input.artifactDirectory, "result.xcresult");
+  const resultBundle = join9(input.artifactDirectory, "result.xcresult");
   const filename = kind === "TEST_RESULTS" ? "test-results.json" : "code-coverage.json";
-  const destination = join8(input.artifactDirectory, filename);
+  const destination = join9(input.artifactDirectory, filename);
   const temporary = `${destination}.tmp-${randomUUID3()}`;
   try {
     if (!await pathExists(resultBundle)) {
@@ -12285,7 +12725,7 @@ async function writeJsonReport(input, kind, timeoutMs, signal) {
       error: null
     };
   } catch (error) {
-    await rm6(temporary, { force: true });
+    await rm7(temporary, { force: true });
     return {
       kind,
       status: "FAILED",
@@ -12376,7 +12816,7 @@ async function snapshotCoverageChanges(input, folder, timeoutMs, signal) {
   const types = changeTypesFromStatus(status2.stdout);
   for (const path of untracked.stdout.split("\0").filter(Boolean)) {
     try {
-      const contents = await readFile5(join8(folder, path));
+      const contents = await readFile5(join9(folder, path));
       if (contents.includes(0)) continue;
       const lineCount = contents.length ? contents.toString("utf8").split("\n").length - (contents.toString("utf8").endsWith("\n") ? 1 : 0) : 0;
       lines.set(
@@ -12410,7 +12850,7 @@ async function addChangedCoverage(report, changes, input, folder, timeoutMs, sig
     let covered = 0;
     let executable = 0;
     if (coveragePath && change.lines.length) {
-      const temporary2 = join8(
+      const temporary2 = join9(
         input.artifactDirectory,
         `.changed-coverage-${randomUUID3()}.json`
       );
@@ -12451,7 +12891,7 @@ async function addChangedCoverage(report, changes, input, folder, timeoutMs, sig
           }
         }
       } finally {
-        await rm6(temporary2, { force: true });
+        await rm7(temporary2, { force: true });
       }
     }
     changedCoveredLines += covered;
@@ -12471,9 +12911,9 @@ async function addChangedCoverage(report, changes, input, folder, timeoutMs, sig
     changedLineCoverage: changedExecutableLines ? changedCoveredLines / changedExecutableLines : null
   };
   const data = { ...report.data, changedFiles };
-  const destination = join8(input.artifactDirectory, "worktree-coverage.json");
+  const destination = join9(input.artifactDirectory, "worktree-coverage.json");
   const temporary = `${destination}.tmp-${randomUUID3()}`;
-  await writeFile4(temporary, JSON.stringify({ summary, data }, null, 2), {
+  await writeFile5(temporary, JSON.stringify({ summary, data }, null, 2), {
     mode: 384
   });
   await rename3(temporary, destination);
@@ -12525,7 +12965,7 @@ async function findFiles(root, predicate, limit = 20) {
     }
     for (const entry of entries) {
       if (entry.isSymbolicLink()) continue;
-      const path = join8(current, entry.name);
+      const path = join9(current, entry.name);
       if (entry.isDirectory()) queue.push(path);
       else if (entry.isFile() && predicate(entry.name)) results.push(path);
       if (results.length >= limit) break;
@@ -12535,7 +12975,7 @@ async function findFiles(root, predicate, limit = 20) {
 }
 async function captureArtifacts(input, folder, signal, includeProducts = true) {
   const artifacts = [];
-  const resultBundle = join8(input.artifactDirectory, "result.xcresult");
+  const resultBundle = join9(input.artifactDirectory, "result.xcresult");
   if (await pathExists(resultBundle)) {
     const coverageProbe = await command(
       "xcrun",
@@ -12562,7 +13002,7 @@ async function captureArtifacts(input, folder, signal, includeProducts = true) {
     );
   }
   if (!includeProducts) return artifacts;
-  const archivePath = join8(input.artifactDirectory, "archive.xcarchive");
+  const archivePath = join9(input.artifactDirectory, "archive.xcarchive");
   if (await pathExists(archivePath)) {
     artifacts.push(
       await artifact(input.artifactDirectory, "ARCHIVE", archivePath)
@@ -12585,12 +13025,12 @@ async function captureArtifacts(input, folder, signal, includeProducts = true) {
   if (apps.length === 1) {
     const settings = apps[0].buildSettings;
     const productName = settings.FULL_PRODUCT_NAME ?? settings.WRAPPER_NAME;
-    const source = settings.TARGET_BUILD_DIR && productName ? join8(settings.TARGET_BUILD_DIR, productName) : null;
+    const source = settings.TARGET_BUILD_DIR && productName ? join9(settings.TARGET_BUILD_DIR, productName) : null;
     if (source && await pathExists(source)) {
-      const productDirectory = join8(input.artifactDirectory, "products");
-      const destination = join8(productDirectory, basename3(source));
+      const productDirectory = join9(input.artifactDirectory, "products");
+      const destination = join9(productDirectory, basename3(source));
       await mkdir4(productDirectory, { recursive: true, mode: 448 });
-      await rm6(destination, { recursive: true, force: true });
+      await rm7(destination, { recursive: true, force: true });
       await cp(source, destination, {
         recursive: true,
         preserveTimestamps: true
@@ -12605,7 +13045,7 @@ async function captureArtifacts(input, folder, signal, includeProducts = true) {
     }
   }
   if (input.action === "BUILD_FOR_TESTING") {
-    const testDirectory = join8(
+    const testDirectory = join9(
       input.artifactDirectory,
       "test-products.xctestproducts"
     );
@@ -12640,10 +13080,10 @@ var runIosBuild = async (payload, timeoutMs, signal, onLog, context) => {
     const testProductsPath = input.advancedSettings.priorTestProductsPath;
     const xctestrunPath = input.advancedSettings.priorXctestrunPath;
     if (testProductsPath) {
-      if (!testProductsPath.endsWith(".xctestproducts") || !await pathExists(testProductsPath) || !(await stat6(testProductsPath)).isDirectory()) {
+      if (!testProductsPath.endsWith(".xctestproducts") || !await pathExists(testProductsPath) || !(await stat7(testProductsPath)).isDirectory()) {
         throw new Error("The captured test-products artifact is unavailable");
       }
-    } else if (!xctestrunPath?.endsWith(".xctestrun") || !await pathExists(xctestrunPath) || !(await stat6(xctestrunPath)).isFile()) {
+    } else if (!xctestrunPath?.endsWith(".xctestrun") || !await pathExists(xctestrunPath) || !(await stat7(xctestrunPath)).isFile()) {
       throw new Error("The captured .xctestrun artifact is unavailable");
     }
   }
@@ -12656,11 +13096,11 @@ var runIosBuild = async (payload, timeoutMs, signal, onLog, context) => {
     signal
   );
   await mkdir4(input.artifactDirectory, { recursive: true, mode: 448 });
-  const rawLog = join8(input.artifactDirectory, "build.log");
+  const rawLog = join9(input.artifactDirectory, "build.log");
   const logger = new BuildLogger(input.buildId, context, rawLog, process.env);
   try {
     const scriptExecutions = [];
-    const contextPath = join8(input.artifactDirectory, "context.json");
+    const contextPath = join9(input.artifactDirectory, "context.json");
     const baseHookContext = {
       buildId: input.buildId,
       branch: input.branch ?? null,
@@ -12919,7 +13359,7 @@ var generateIosBuildReport = async (payload, timeoutMs, signal, onLog) => {
 var deleteIosBuild = async (payload, _timeoutMs, signal, onLog) => {
   const input = parseBuildDeletePayload(payload);
   if (signal.aborted) return { ...successfulProcess6, cancelled: true };
-  await rm6(input.artifactDirectory, { recursive: true, force: true });
+  await rm7(input.artifactDirectory, { recursive: true, force: true });
   await onLog({
     sequence: 0,
     stream: "SYSTEM",
@@ -12933,23 +13373,23 @@ var downloadIosBuildArtifact = async (payload, timeoutMs, signal, onLog, context
   if (!context?.uploadBuildArtifact) {
     throw new Error("This agent cannot upload build artifacts");
   }
-  const root = await realpath4(input.artifactDirectory);
-  const target2 = await realpath4(
+  const root = await realpath5(input.artifactDirectory);
+  const target2 = await realpath5(
     containedPath2(root, input.artifactRelativePath)
   );
   const difference = relative4(root, target2);
   if (!difference || difference === ".." || difference.startsWith(`..${sep4}`) || isAbsolute4(difference)) {
     throw new Error("Build artifact resolves outside the build folder");
   }
-  const information = await stat6(target2);
+  const information = await stat7(target2);
   let uploadPath = target2;
   let filename = basename3(target2);
   let contentType = "application/octet-stream";
   let temporaryArchive = null;
   try {
     if (information.isDirectory()) {
-      temporaryArchive = join8(
-        tmpdir3(),
+      temporaryArchive = join9(
+        tmpdir4(),
         `ade-build-artifact-${randomUUID3()}.tar.gz`
       );
       requireSuccess2(
@@ -12982,7 +13422,7 @@ var downloadIosBuildArtifact = async (payload, timeoutMs, signal, onLog, context
     return successfulProcess6;
   } finally {
     if (temporaryArchive) {
-      await rm6(temporaryArchive, { force: true });
+      await rm7(temporaryArchive, { force: true });
     }
   }
 };
@@ -13018,24 +13458,24 @@ var deployIosBuild = async (payload, timeoutMs, signal, _onLog, context) => {
   if (!await pathExists(appPath) || !appPath.endsWith(".app")) {
     throw new Error("Runnable app artifact is missing");
   }
-  const deploymentsDirectory = join8(input.artifactDirectory, "deployments");
+  const deploymentsDirectory = join9(input.artifactDirectory, "deployments");
   await mkdir4(deploymentsDirectory, { recursive: true, mode: 448 });
   const logger = new BuildLogger(
     input.buildId,
     context,
-    join8(deploymentsDirectory, "deployments.log"),
+    join9(deploymentsDirectory, "deployments.log"),
     process.env
   );
   try {
     const outcomes = [];
     for (const deployment of input.deployments) {
-      const directory = join8(
+      const directory = join9(
         input.artifactDirectory,
         "deployments",
         deployment.id
       );
       await mkdir4(directory, { recursive: true, mode: 448 });
-      const logPath = join8(directory, "deployment.log");
+      const logPath = join9(directory, "deployment.log");
       const started = Date.now();
       let failure = null;
       try {
@@ -13250,15 +13690,15 @@ var exportIosArchive = async (payload, timeoutMs, signal, _onLog, context) => {
   if (!await pathExists(archivePath) || !archivePath.endsWith(".xcarchive")) {
     throw new Error("Archive artifact is missing");
   }
-  const exportDirectory = join8(
+  const exportDirectory = join9(
     input.artifactDirectory,
     "exports",
     input.exportId
   );
   await mkdir4(exportDirectory, { recursive: true, mode: 448 });
-  const plistPath = join8(exportDirectory, "ExportOptions.plist");
-  const logPath = join8(exportDirectory, "export.log");
-  await writeFile4(plistPath, exportPlist(input.settings), { mode: 384 });
+  const plistPath = join9(exportDirectory, "ExportOptions.plist");
+  const logPath = join9(exportDirectory, "export.log");
+  await writeFile5(plistPath, exportPlist(input.settings), { mode: 384 });
   const logger = new BuildLogger(input.buildId, context, logPath, process.env);
   try {
     const result = await runLoggedCommand({
@@ -13324,18 +13764,18 @@ var success = {
 };
 var runWorkflowTerminal = async (payloadValue, timeoutMs, signal, onLog, context) => {
   const payload = parseWorkflowTerminalPayload(payloadValue);
-  const cwd = await realpath5(payload.cwd);
-  const information = await stat7(cwd);
+  const cwd = await realpath6(payload.cwd);
+  const information = await stat8(cwd);
   if (!information.isDirectory())
     throw new Error("Workflow working directory is not a directory");
-  const directory = await mkdtemp4(join9(tmpdir4(), "aide-workflow-"));
+  const directory = await mkdtemp5(join10(tmpdir5(), "aide-workflow-"));
   const extension2 = payload.interpreter === "NODE" ? "mjs" : "sh";
-  const scriptPath = join9(directory, `step.${extension2}`);
-  const sessionPath = join9(directory, "session.json");
+  const scriptPath = join10(directory, `step.${extension2}`);
+  const sessionPath = join10(directory, "session.json");
   try {
-    await writeFile5(scriptPath, `${payload.script}
+    await writeFile6(scriptPath, `${payload.script}
 `, { mode: 384 });
-    await writeFile5(
+    await writeFile6(
       sessionPath,
       `${JSON.stringify(payload.sessionData, null, 2)}
 `,
@@ -13379,13 +13819,13 @@ var runWorkflowTerminal = async (payloadValue, timeoutMs, signal, onLog, context
     }
     return { ...result, sessionData };
   } finally {
-    await rm7(directory, { recursive: true, force: true });
+    await rm8(directory, { recursive: true, force: true });
   }
 };
 var runWorkflowGitCheckpoint = async (payloadValue, _timeoutMs, signal) => {
   const payload = parseWorkflowGitCheckpointPayload(payloadValue);
   if (signal.aborted) return { ...success, exitCode: null, cancelled: true };
-  const cwd = await realpath5(payload.cwd);
+  const cwd = await realpath6(payload.cwd);
   if (payload.operation === "CAPTURE") {
     const checkpoint2 = await captureGitCheckpoint(
       cwd,
@@ -13422,10 +13862,10 @@ var runWorkflowGitCheckpoint = async (payloadValue, _timeoutMs, signal) => {
 
 // src/handlers/worktrees.ts
 import { createWriteStream as createWriteStream2, watch } from "node:fs";
-import { mkdtemp as mkdtemp5, open as open2, readFile as readFile7, realpath as realpath6, rm as rm8, stat as stat8 } from "node:fs/promises";
-import { tmpdir as tmpdir5 } from "node:os";
-import { basename as basename4, dirname as dirname6, isAbsolute as isAbsolute5, join as join10, relative as relative5 } from "node:path";
-import { spawn as spawn5 } from "node:child_process";
+import { mkdtemp as mkdtemp6, open as open2, readFile as readFile7, realpath as realpath7, rm as rm9, stat as stat9 } from "node:fs/promises";
+import { tmpdir as tmpdir6 } from "node:os";
+import { basename as basename4, dirname as dirname6, isAbsolute as isAbsolute5, join as join11, relative as relative5 } from "node:path";
+import { spawn as spawn6 } from "node:child_process";
 var successfulProcess7 = {
   exitCode: 0,
   signal: null,
@@ -13479,7 +13919,7 @@ async function rebaseInProgress(folder, timeoutMs, signal) {
     const candidate = pathResult.stdout.trim();
     if (!candidate) continue;
     try {
-      await stat8(isAbsolute5(candidate) ? candidate : join10(folder, candidate));
+      await stat9(isAbsolute5(candidate) ? candidate : join11(folder, candidate));
       return true;
     } catch {
     }
@@ -13499,7 +13939,7 @@ async function rebaseBranch(folder, timeoutMs, signal) {
     if (!candidate) continue;
     try {
       const headName = (await readFile7(
-        isAbsolute5(candidate) ? candidate : join10(folder, candidate),
+        isAbsolute5(candidate) ? candidate : join11(folder, candidate),
         "utf8"
       )).trim();
       if (headName.startsWith("refs/heads/")) {
@@ -13682,7 +14122,7 @@ async function gitDirectory(folder, timeoutMs, signal) {
     ),
     "Could not resolve the worktree Git directory"
   );
-  return realpath6(result.stdout.trim());
+  return realpath7(result.stdout.trim());
 }
 async function origin(folder, timeoutMs, signal) {
   const result = requireSuccess3(
@@ -13692,8 +14132,8 @@ async function origin(folder, timeoutMs, signal) {
   return normalizeGitOrigin(result.stdout.trim()).canonicalOrigin;
 }
 async function validateWorktree2(input, timeoutMs, signal) {
-  const folder = await realpath6(input.folder);
-  if (!(await stat8(folder)).isDirectory())
+  const folder = await realpath7(input.folder);
+  if (!(await stat9(folder)).isDirectory())
     throw new Error("Worktree is missing");
   const observedGitDirectory = await gitDirectory(folder, timeoutMs, signal);
   if (observedGitDirectory !== input.gitDirectory) {
@@ -13739,7 +14179,7 @@ async function worktreePushStatus(folder, branch, changes, timeoutMs, signal) {
 async function inspectWorktreeItem(folderValue2, rootFolder, baseBranch, primary, timeoutMs, signal) {
   const checkedAt = (/* @__PURE__ */ new Date()).toISOString();
   try {
-    const folder = await realpath6(folderValue2);
+    const folder = await realpath7(folderValue2);
     const [gitDir, branchResult, headResult, statusResult, rebasing] = await Promise.all([
       gitDirectory(folder, timeoutMs, signal),
       git3(
@@ -13839,7 +14279,7 @@ async function inspectWorktreeItem(folderValue2, rootFolder, baseBranch, primary
   }
 }
 async function discoverWorktrees(rootFolderValue, baseOverrides, knownDefaultBranch, timeoutMs, signal) {
-  const rootFolder = await realpath6(rootFolderValue);
+  const rootFolder = await realpath7(rootFolderValue);
   const list = requireSuccess3(
     await git3(
       rootFolder,
@@ -13934,7 +14374,7 @@ function parseNumstat(value) {
 }
 async function untrackedLines(folder, path) {
   try {
-    const file = await stat8(`${folder}/${path}`);
+    const file = await stat9(`${folder}/${path}`);
     if (!file.isFile() || file.size > 1024 * 1024) return null;
     const contents = await readFile7(`${folder}/${path}`);
     if (contents.includes(0)) return null;
@@ -14145,7 +14585,7 @@ async function comparisonSides(input, folder, timeoutMs, signal) {
   if (!input.path) return { before: null, after: null };
   const path = input.path;
   const previousPath = input.previousPath ?? path;
-  const currentPath = join10(folder, path);
+  const currentPath = join11(folder, path);
   if (input.scope === "UNTRACKED") {
     return { before: null, after: { kind: "FILE", path: currentPath } };
   }
@@ -14228,9 +14668,9 @@ async function availableSide(side, folder, timeoutMs, signal) {
     return gitObjectExists(folder, side.specification, timeoutMs, signal);
   }
   try {
-    const resolved = await realpath6(side.path);
+    const resolved = await realpath7(side.path);
     const difference = relative5(folder, resolved);
-    return difference !== ".." && !difference.startsWith("../") && (await stat8(resolved)).isFile();
+    return difference !== ".." && !difference.startsWith("../") && (await stat9(resolved)).isFile();
   } catch {
     return false;
   }
@@ -14301,7 +14741,7 @@ async function inspectRequestedDiff(input, folder, timeoutMs, signal) {
   let patch;
   if (input.scope === "UNTRACKED") {
     const bounded = await readBoundedFile(
-      join10(folder, input.path),
+      join11(folder, input.path),
       MAX_DIFF_BYTES
     );
     const contents = bounded.contents;
@@ -14405,7 +14845,7 @@ function imageContentType(path) {
 }
 async function writeGitObject(folder, specification, destination, timeoutMs, signal) {
   await new Promise((resolvePromise, rejectPromise) => {
-    const child = spawn5(
+    const child = spawn6(
       "git",
       ["-C", folder, "cat-file", "blob", specification],
       { stdio: ["ignore", "pipe", "pipe"] }
@@ -14471,7 +14911,7 @@ var downloadWorktreeDiffAsset = async (payload, timeoutMs, signal, _onLog, conte
   let temporaryDirectory = null;
   try {
     if (selected.kind === "FILE") {
-      uploadPath = await realpath6(selected.path);
+      uploadPath = await realpath7(selected.path);
       const difference = relative5(folder, uploadPath);
       if (difference === ".." || difference.startsWith("../")) {
         throw new Error("Diff image resolves outside the worktree");
@@ -14489,8 +14929,8 @@ var downloadWorktreeDiffAsset = async (payload, timeoutMs, signal, _onLog, conte
       if (!/^\d+$/.test(size) || Number(size) > 20 * 1024 * 1024) {
         throw new Error("Diff image exceeds the 20 MiB limit");
       }
-      temporaryDirectory = await mkdtemp5(join10(tmpdir5(), "ade-diff-image-"));
-      uploadPath = join10(temporaryDirectory, basename4(input.path));
+      temporaryDirectory = await mkdtemp6(join11(tmpdir6(), "ade-diff-image-"));
+      uploadPath = join11(temporaryDirectory, basename4(input.path));
       await writeGitObject(
         folder,
         selected.specification,
@@ -14499,7 +14939,7 @@ var downloadWorktreeDiffAsset = async (payload, timeoutMs, signal, _onLog, conte
         signal
       );
     }
-    const information = await stat8(uploadPath);
+    const information = await stat9(uploadPath);
     if (!information.isFile() || information.size > 20 * 1024 * 1024) {
       throw new Error("Diff image exceeds the 20 MiB limit");
     }
@@ -14512,7 +14952,7 @@ var downloadWorktreeDiffAsset = async (payload, timeoutMs, signal, _onLog, conte
     return successfulProcess7;
   } finally {
     if (temporaryDirectory) {
-      await rm8(temporaryDirectory, { recursive: true, force: true });
+      await rm9(temporaryDirectory, { recursive: true, force: true });
     }
   }
 };
@@ -14689,8 +15129,8 @@ async function chooseNewBranch(folder, candidates, allowedCurrentBranch, timeout
   throw new Error("Every generated ticket branch name is already taken");
 }
 async function validateBranchRoot(input, timeoutMs, signal) {
-  const rootFolder = await realpath6(input.rootFolder);
-  if (!(await stat8(rootFolder)).isDirectory()) {
+  const rootFolder = await realpath7(input.rootFolder);
+  if (!(await stat9(rootFolder)).isDirectory()) {
     throw new Error("Base repository is missing");
   }
   if (await origin(rootFolder, timeoutMs, signal) !== input.expectedOrigin) {
@@ -14753,13 +15193,13 @@ var branchWorktree = async (payload, timeoutMs, signal) => {
     timeoutMs,
     signal
   ) : input.candidates[0];
-  const targetFolder = input.action === "CREATE" ? join10(
+  const targetFolder = input.action === "CREATE" ? join11(
     dirname6(rootFolder),
     `${basename4(rootFolder)}-${branch.replaceAll("/", "-")}`
   ) : changeFolder;
   if (input.action === "CREATE") {
     try {
-      await stat8(targetFolder);
+      await stat9(targetFolder);
       throw new Error(`Worktree folder already exists: ${targetFolder}`);
     } catch (error) {
       if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT") {
@@ -14993,12 +15433,12 @@ var checkoutMovedWorktree = async (payload, timeoutMs, signal) => {
         `Branch ${input.branch} is already checked out in ${occupiedFolder}`
       );
     }
-    targetFolder = join10(
+    targetFolder = join11(
       dirname6(rootFolder),
       `${basename4(rootFolder)}-${input.branch.replaceAll("/", "-")}`
     );
     try {
-      await stat8(targetFolder);
+      await stat9(targetFolder);
       throw new Error(`Worktree folder already exists: ${targetFolder}`);
     } catch (error) {
       if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT") {
@@ -15044,7 +15484,7 @@ var checkoutMovedWorktree = async (payload, timeoutMs, signal) => {
     const targetBranch = await currentBranch(targetFolder, timeoutMs, signal);
     const targetChanges = await statusState(targetFolder, timeoutMs, signal);
     if (occupiedFolder) {
-      const occupied = await realpath6(occupiedFolder);
+      const occupied = await realpath7(occupiedFolder);
       if (occupied !== targetFolder) {
         throw new Error(
           `Branch ${input.branch} is checked out in another destination worktree`
@@ -15158,8 +15598,8 @@ var checkoutMovedWorktree = async (payload, timeoutMs, signal) => {
 };
 var deleteWorktree = async (payload, timeoutMs, signal) => {
   const input = worktreeDeleteJobPayload(payload);
-  const rootFolder = await realpath6(input.rootFolder);
-  if (!(await stat8(rootFolder)).isDirectory()) {
+  const rootFolder = await realpath7(input.rootFolder);
+  if (!(await stat9(rootFolder)).isDirectory()) {
     throw new Error("Base repository is missing");
   }
   if (await origin(rootFolder, timeoutMs, signal) !== input.expectedOrigin) {
@@ -15401,7 +15841,7 @@ var operateWorktree = async (payload, timeoutMs, signal) => {
 
 // src/handlers/index.ts
 var handlers = {
-  "cloudflared.runTunnel": runCloudflared,
+  [COMMAND_RUN_JOB_KIND]: runCommand,
   [CCUSAGE_REPORT_JOB_KIND]: runCcusage,
   [BUILD_DATA_SCAN_JOB_KIND]: scanBuildData,
   [BUILD_DATA_SIZE_JOB_KIND]: sizeBuildData,
@@ -15489,7 +15929,9 @@ var JobExecutor = class {
     this.running.set(job.id, { controller, task });
   }
   cancel(jobId) {
-    this.running.get(jobId)?.controller.abort();
+    const running = this.running.get(jobId);
+    running?.controller.abort();
+    return Boolean(running);
   }
   async cancelAll() {
     this.stopping = true;
@@ -15524,10 +15966,11 @@ var JobExecutor = class {
         {
           reportWorktreeActivity: (input) => this.client.reportWorktreeActivity(input),
           reportBuildProgress: (input) => this.client.reportBuildProgress(input),
-          appendBuildLogs: (buildId, events) => this.client.appendBuildLogs(buildId, events),
+          appendBuildLogChunks: (buildId, chunks) => this.client.appendBuildLogChunks(buildId, chunks),
           uploadBuildArtifact: (input) => this.client.uploadBuildArtifact(input),
           claimSigningSecretTransfer: (transferId) => this.client.claimSigningSecretTransfer(transferId),
-          claimWorkflowJobSecrets: () => this.client.claimWorkflowJobSecrets(claimed.id)
+          claimWorkflowJobSecrets: () => this.client.claimWorkflowJobSecrets(claimed.id),
+          appendCommandOutput: (attemptId, chunks) => this.client.appendCommandOutput(claimed.id, attemptId, chunks)
         }
       );
       const codebaseId = claimed.payload && typeof claimed.payload === "object" && !Array.isArray(claimed.payload) && typeof claimed.payload.codebaseId === "string" ? String(claimed.payload.codebaseId) : null;
@@ -15703,8 +16146,8 @@ var CodebaseMonitor = class {
 
 // src/runs/run-manager.ts
 import { execFile as execFile4 } from "node:child_process";
-import { mkdir as mkdir6, rm as rm12 } from "node:fs/promises";
-import { dirname as dirname8, join as join14 } from "node:path";
+import { mkdir as mkdir6, rm as rm13 } from "node:fs/promises";
+import { dirname as dirname8, join as join15 } from "node:path";
 import { promisify as promisify4 } from "node:util";
 
 // src/runs/journal.ts
@@ -15714,10 +16157,10 @@ import {
   mkdir as mkdir5,
   readFile as readFile8,
   rename as rename4,
-  rm as rm9,
-  writeFile as writeFile6
+  rm as rm10,
+  writeFile as writeFile7
 } from "node:fs/promises";
-import { dirname as dirname7, join as join11 } from "node:path";
+import { dirname as dirname7, join as join12 } from "node:path";
 var RunJournal = class {
   constructor(runId, attemptId) {
     this.runId = runId;
@@ -15736,13 +16179,13 @@ var RunJournal = class {
     this.attemptId = attemptId;
   }
   get directory() {
-    return join11(dirname7(configPath()), "runs", this.runId);
+    return join12(dirname7(configPath()), "runs", this.runId);
   }
   get eventsPath() {
-    return join11(this.directory, "events.jsonl");
+    return join12(this.directory, "events.jsonl");
   }
   get statePath() {
-    return join11(this.directory, "state.json");
+    return join12(this.directory, "state.json");
   }
   async load() {
     if (this.loaded) return;
@@ -15843,10 +16286,10 @@ var RunJournal = class {
     const operation = this.saving.then(async () => {
       const temporary = `${this.statePath}.${process.pid}.${randomUUID4()}.tmp`;
       try {
-        await writeFile6(temporary, contents, { mode: 384 });
+        await writeFile7(temporary, contents, { mode: 384 });
         await rename4(temporary, this.statePath);
       } catch (error) {
-        await rm9(temporary, { force: true }).catch(() => void 0);
+        await rm10(temporary, { force: true }).catch(() => void 0);
         throw error;
       }
     });
@@ -25020,7 +25463,7 @@ function Yy(e) {
 var l = {};
 lt(l, { xid: () => u9, void: () => I9, uuidv7: () => n9, uuidv6: () => r9, uuidv4: () => t9, uuid: () => e9, url: () => o9, uppercase: () => Fl, unknown: () => Ke, union: () => $e, undefined: () => C9, ulid: () => l9, uint64: () => A9, uint32: () => w9, tuple: () => L9, trim: () => Wl, treeifyError: () => Yd, transform: () => jv, toUpperCase: () => Zl, toLowerCase: () => Kl, toJSONSchema: () => Js, templateLiteral: () => q9, symbol: () => O9, superRefine: () => ER, success: () => B9, stringbool: () => W9, stringFormat: () => x9, string: () => k, strictObject: () => N9, startsWith: () => Hl, size: () => $l, setErrorMap: () => J9, set: () => $9, safeParseAsync: () => gv, safeParse: () => mv, registry: () => hl, regexes: () => wo, regex: () => jl, refine: () => SR, record: () => je, readonly: () => hR, property: () => iv, promise: () => G9, prettifyError: () => Xd, preprocess: () => Km, prefault: () => lR, positive: () => tv, pipe: () => Fm, partialRecord: () => M9, parseAsync: () => fv, parse: () => dv, overwrite: () => Vn, optional: () => Ve, object: () => G, number: () => Ce, nullish: () => F9, nullable: () => zm, null: () => Bm, normalize: () => Vl, nonpositive: () => nv, nonoptional: () => uR, nonnegative: () => ov, never: () => Hm, negative: () => rv, nativeEnum: () => j9, nanoid: () => s9, nan: () => H9, multipleOf: () => wi, minSize: () => Ti, minLength: () => Ao, mime: () => Gl, maxSize: () => Ws, maxLength: () => Ks, map: () => U9, lte: () => Ur, lt: () => qn, lowercase: () => zl, looseObject: () => Bt, locales: () => Gs, literal: () => Z, length: () => Zs, lazy: () => bR, ksuid: () => p9, keyof: () => D9, jwt: () => b9, json: () => K9, iso: () => Ys, ipv6: () => f9, ipv4: () => d9, intersection: () => ru, int64: () => k9, int32: () => E9, int: () => hv, instanceof: () => V9, includes: () => Bl, guid: () => QZ, gte: () => ar, gt: () => Gn, globalRegistry: () => sr, getErrorMap: () => Y9, function: () => Dm, formatError: () => js, float64: () => S9, float32: () => v9, flattenError: () => $s, file: () => z9, enum: () => Jt, endsWith: () => ql, emoji: () => i9, email: () => XZ, e164: () => y9, discriminatedUnion: () => Vm, date: () => P9, custom: () => Hv, cuid2: () => c9, cuid: () => a9, core: () => Qr, config: () => ut, coerce: () => qv, clone: () => Ft, cidrv6: () => g9, cidrv4: () => m9, check: () => vR, catch: () => fR, boolean: () => ht, bigint: () => T9, base64url: () => _9, base64: () => h9, array: () => he, any: () => R9, _default: () => aR, _ZodString: () => _v, ZodXID: () => Tv, ZodVoid: () => JC, ZodUnknown: () => KC, ZodUnion: () => Mv, ZodUndefined: () => GC, ZodUUID: () => Wn, ZodURL: () => bv, ZodULID: () => wv, ZodType: () => de, ZodTuple: () => eR, ZodTransform: () => $v, ZodTemplateLiteral: () => _R, ZodSymbol: () => qC, ZodSuccess: () => pR, ZodStringFormat: () => Ge, ZodString: () => Xl, ZodSet: () => rR, ZodRecord: () => Uv, ZodRealError: () => Xs, ZodReadonly: () => gR, ZodPromise: () => xR, ZodPrefault: () => cR, ZodPipe: () => Bv, ZodOptional: () => zv, ZodObject: () => Gm, ZodNumberFormat: () => Qs, ZodNumber: () => Ql, ZodNullable: () => iR, ZodNull: () => VC, ZodNonOptional: () => Fv, ZodNever: () => ZC, ZodNanoID: () => vv, ZodNaN: () => mR, ZodMap: () => tR, ZodLiteral: () => nR, ZodLazy: () => yR, ZodKSUID: () => kv, ZodJWT: () => Nv, ZodIssueCode: () => Z9, ZodIntersection: () => QC, ZodISOTime: () => Um, ZodISODuration: () => $m, ZodISODateTime: () => Lm, ZodISODate: () => Mm, ZodIPv6: () => Ov, ZodIPv4: () => Av, ZodGUID: () => jm, ZodFile: () => oR, ZodError: () => JZ, ZodEnum: () => Yl, ZodEmoji: () => xv, ZodEmail: () => yv, ZodE164: () => Dv, ZodDiscriminatedUnion: () => XC, ZodDefault: () => sR, ZodDate: () => qm, ZodCustomStringFormat: () => HC, ZodCustom: () => Wm, ZodCatch: () => dR, ZodCUID2: () => Ev, ZodCUID: () => Sv, ZodCIDRv6: () => Rv, ZodCIDRv4: () => Cv, ZodBoolean: () => eu, ZodBigIntFormat: () => Lv, ZodBigInt: () => tu, ZodBase64URL: () => Pv, ZodBase64: () => Iv, ZodArray: () => YC, ZodAny: () => WC, TimePrecision: () => lm, NEVER: () => Kd, $output: () => sm, $input: () => am, $brand: () => Zd });
 var Qr = {};
-lt(Qr, { version: () => tx, util: () => M, treeifyError: () => Yd, toJSONSchema: () => Js, toDotPath: () => yC, safeParseAsync: () => Eo, safeParse: () => So, registry: () => hl, regexes: () => wo, prettifyError: () => Xd, parseAsync: () => xi, parse: () => bi, locales: () => Gs, isValidJWT: () => MC, isValidBase64URL: () => LC, isValidBase64: () => ax, globalRegistry: () => sr, globalConfig: () => tl, function: () => Dm, formatError: () => js, flattenError: () => $s, config: () => ut, clone: () => Ft, _xid: () => Ol, _void: () => Tm, _uuidv7: () => vl, _uuidv6: () => xl, _uuidv4: () => bl, _uuid: () => yl, _url: () => Sl, _uppercase: () => Fl, _unknown: () => Ei, _union: () => OZ, _undefined: () => vm, _ulid: () => Al, _uint64: () => bm, _uint32: () => gm, _tuple: () => sv, _trim: () => Wl, _transform: () => UZ, _toUpperCase: () => Zl, _toLowerCase: () => Kl, _templateLiteral: () => VZ, _symbol: () => xm, _success: () => BZ, _stringbool: () => Im, _stringFormat: () => Pm, _string: () => cm, _startsWith: () => Hl, _size: () => $l, _set: () => DZ, _safeParseAsync: () => rf, _safeParse: () => tf, _regex: () => jl, _refine: () => Rm, _record: () => IZ, _readonly: () => GZ, _property: () => iv, _promise: () => KZ, _positive: () => tv, _pipe: () => qZ, _parseAsync: () => ef, _parse: () => Qd, _overwrite: () => Vn, _optional: () => $Z, _number: () => um, _nullable: () => jZ, _null: () => Sm, _normalize: () => Vl, _nonpositive: () => nv, _nonoptional: () => FZ, _nonnegative: () => ov, _never: () => wm, _negative: () => rv, _nativeEnum: () => LZ, _nanoid: () => wl, _nan: () => Am, _multipleOf: () => wi, _minSize: () => Ti, _minLength: () => Ao, _min: () => ar, _mime: () => Gl, _maxSize: () => Ws, _maxLength: () => Ks, _max: () => Ur, _map: () => PZ, _lte: () => Ur, _lt: () => qn, _lowercase: () => zl, _literal: () => MZ, _length: () => Zs, _lazy: () => WZ, _ksuid: () => Cl, _jwt: () => Ul, _isoTime: () => Zx, _isoDuration: () => Jx, _isoDateTime: () => Wx, _isoDate: () => Kx, _ipv6: () => Il, _ipv4: () => Rl, _intersection: () => RZ, _int64: () => ym, _int32: () => mm, _int: () => pm, _includes: () => Bl, _guid: () => Vs, _gte: () => ar, _gt: () => Gn, _float64: () => fm, _float32: () => dm, _file: () => Om, _enum: () => NZ, _endsWith: () => ql, _emoji: () => El, _email: () => _l, _e164: () => Ml, _discriminatedUnion: () => CZ, _default: () => zZ, _date: () => km, _custom: () => Cm, _cuid2: () => kl, _cuid: () => Tl, _coercedString: () => Vx, _coercedNumber: () => Yx, _coercedDate: () => ev, _coercedBoolean: () => Xx, _coercedBigint: () => Qx, _cidrv6: () => Dl, _cidrv4: () => Pl, _catch: () => HZ, _boolean: () => hm, _bigint: () => _m, _base64url: () => Ll, _base64: () => Nl, _array: () => Jl, _any: () => Em, TimePrecision: () => lm, NEVER: () => Kd, JSONSchemaGenerator: () => Nm, JSONSchema: () => zC, Doc: () => af, $output: () => sm, $input: () => am, $constructor: () => S, $brand: () => Zd, $ZodXID: () => bf, $ZodVoid: () => Uf, $ZodUnknown: () => Si, $ZodUnion: () => fl, $ZodUndefined: () => Df, $ZodUUID: () => pf, $ZodURL: () => ff, $ZodULID: () => yf, $ZodType: () => ie, $ZodTuple: () => ko, $ZodTransform: () => Hs, $ZodTemplateLiteral: () => rm10, $ZodSymbol: () => Pf, $ZodSuccess: () => Xf, $ZodStringFormat: () => Ue, $ZodString: () => To, $ZodSet: () => Hf, $ZodRegistry: () => gl, $ZodRecord: () => Ff, $ZodRealError: () => Us, $ZodReadonly: () => tm, $ZodPromise: () => nm, $ZodPrefault: () => Jf, $ZodPipe: () => qs, $ZodOptional: () => Wf, $ZodObject: () => dl, $ZodNumberFormat: () => Rf, $ZodNumber: () => ul, $ZodNullable: () => Kf, $ZodNull: () => Nf, $ZodNonOptional: () => Yf, $ZodNever: () => Mf, $ZodNanoID: () => gf, $ZodNaN: () => em, $ZodMap: () => Bf, $ZodLiteral: () => Gf, $ZodLazy: () => om, $ZodKSUID: () => xf, $ZodJWT: () => Of, $ZodIntersection: () => zf, $ZodISOTime: () => ix, $ZodISODuration: () => sx, $ZodISODateTime: () => nx, $ZodISODate: () => ox, $ZodIPv6: () => Sf, $ZodIPv4: () => vf, $ZodGUID: () => uf, $ZodFunction: () => av, $ZodFile: () => Vf, $ZodError: () => ll, $ZodEnum: () => qf, $ZodEmoji: () => mf, $ZodEmail: () => df, $ZodE164: () => Af, $ZodDiscriminatedUnion: () => jf, $ZodDefault: () => Zf, $ZodDate: () => $f, $ZodCustomStringFormat: () => Cf, $ZodCustom: () => im, $ZodCheckUpperCase: () => Kb, $ZodCheckStringFormat: () => zs, $ZodCheckStartsWith: () => Jb, $ZodCheckSizeEquals: () => Bb, $ZodCheckRegex: () => Vb, $ZodCheckProperty: () => Xb, $ZodCheckOverwrite: () => ex, $ZodCheckNumberFormat: () => $b, $ZodCheckMultipleOf: () => Ub, $ZodCheckMinSize: () => Fb, $ZodCheckMinLength: () => qb, $ZodCheckMimeType: () => Qb, $ZodCheckMaxSize: () => zb, $ZodCheckMaxLength: () => Hb, $ZodCheckLowerCase: () => Wb, $ZodCheckLessThan: () => of, $ZodCheckLengthEquals: () => Gb, $ZodCheckIncludes: () => Zb, $ZodCheckGreaterThan: () => sf, $ZodCheckEndsWith: () => Yb, $ZodCheckBigIntFormat: () => jb, $ZodCheck: () => Xe, $ZodCatch: () => Qf, $ZodCUID2: () => _f, $ZodCUID: () => hf, $ZodCIDRv6: () => wf, $ZodCIDRv4: () => Ef, $ZodBoolean: () => Fs, $ZodBigIntFormat: () => If, $ZodBigInt: () => pl, $ZodBase64URL: () => kf, $ZodBase64: () => Tf, $ZodAsyncError: () => Bn, $ZodArray: () => Bs, $ZodAny: () => Lf });
+lt(Qr, { version: () => tx, util: () => M, treeifyError: () => Yd, toJSONSchema: () => Js, toDotPath: () => yC, safeParseAsync: () => Eo, safeParse: () => So, registry: () => hl, regexes: () => wo, prettifyError: () => Xd, parseAsync: () => xi, parse: () => bi, locales: () => Gs, isValidJWT: () => MC, isValidBase64URL: () => LC, isValidBase64: () => ax, globalRegistry: () => sr, globalConfig: () => tl, function: () => Dm, formatError: () => js, flattenError: () => $s, config: () => ut, clone: () => Ft, _xid: () => Ol, _void: () => Tm, _uuidv7: () => vl, _uuidv6: () => xl, _uuidv4: () => bl, _uuid: () => yl, _url: () => Sl, _uppercase: () => Fl, _unknown: () => Ei, _union: () => OZ, _undefined: () => vm, _ulid: () => Al, _uint64: () => bm, _uint32: () => gm, _tuple: () => sv, _trim: () => Wl, _transform: () => UZ, _toUpperCase: () => Zl, _toLowerCase: () => Kl, _templateLiteral: () => VZ, _symbol: () => xm, _success: () => BZ, _stringbool: () => Im, _stringFormat: () => Pm, _string: () => cm, _startsWith: () => Hl, _size: () => $l, _set: () => DZ, _safeParseAsync: () => rf, _safeParse: () => tf, _regex: () => jl, _refine: () => Rm, _record: () => IZ, _readonly: () => GZ, _property: () => iv, _promise: () => KZ, _positive: () => tv, _pipe: () => qZ, _parseAsync: () => ef, _parse: () => Qd, _overwrite: () => Vn, _optional: () => $Z, _number: () => um, _nullable: () => jZ, _null: () => Sm, _normalize: () => Vl, _nonpositive: () => nv, _nonoptional: () => FZ, _nonnegative: () => ov, _never: () => wm, _negative: () => rv, _nativeEnum: () => LZ, _nanoid: () => wl, _nan: () => Am, _multipleOf: () => wi, _minSize: () => Ti, _minLength: () => Ao, _min: () => ar, _mime: () => Gl, _maxSize: () => Ws, _maxLength: () => Ks, _max: () => Ur, _map: () => PZ, _lte: () => Ur, _lt: () => qn, _lowercase: () => zl, _literal: () => MZ, _length: () => Zs, _lazy: () => WZ, _ksuid: () => Cl, _jwt: () => Ul, _isoTime: () => Zx, _isoDuration: () => Jx, _isoDateTime: () => Wx, _isoDate: () => Kx, _ipv6: () => Il, _ipv4: () => Rl, _intersection: () => RZ, _int64: () => ym, _int32: () => mm, _int: () => pm, _includes: () => Bl, _guid: () => Vs, _gte: () => ar, _gt: () => Gn, _float64: () => fm, _float32: () => dm, _file: () => Om, _enum: () => NZ, _endsWith: () => ql, _emoji: () => El, _email: () => _l, _e164: () => Ml, _discriminatedUnion: () => CZ, _default: () => zZ, _date: () => km, _custom: () => Cm, _cuid2: () => kl, _cuid: () => Tl, _coercedString: () => Vx, _coercedNumber: () => Yx, _coercedDate: () => ev, _coercedBoolean: () => Xx, _coercedBigint: () => Qx, _cidrv6: () => Dl, _cidrv4: () => Pl, _catch: () => HZ, _boolean: () => hm, _bigint: () => _m, _base64url: () => Ll, _base64: () => Nl, _array: () => Jl, _any: () => Em, TimePrecision: () => lm, NEVER: () => Kd, JSONSchemaGenerator: () => Nm, JSONSchema: () => zC, Doc: () => af, $output: () => sm, $input: () => am, $constructor: () => S, $brand: () => Zd, $ZodXID: () => bf, $ZodVoid: () => Uf, $ZodUnknown: () => Si, $ZodUnion: () => fl, $ZodUndefined: () => Df, $ZodUUID: () => pf, $ZodURL: () => ff, $ZodULID: () => yf, $ZodType: () => ie, $ZodTuple: () => ko, $ZodTransform: () => Hs, $ZodTemplateLiteral: () => rm11, $ZodSymbol: () => Pf, $ZodSuccess: () => Xf, $ZodStringFormat: () => Ue, $ZodString: () => To, $ZodSet: () => Hf, $ZodRegistry: () => gl, $ZodRecord: () => Ff, $ZodRealError: () => Us, $ZodReadonly: () => tm, $ZodPromise: () => nm, $ZodPrefault: () => Jf, $ZodPipe: () => qs, $ZodOptional: () => Wf, $ZodObject: () => dl, $ZodNumberFormat: () => Rf, $ZodNumber: () => ul, $ZodNullable: () => Kf, $ZodNull: () => Nf, $ZodNonOptional: () => Yf, $ZodNever: () => Mf, $ZodNanoID: () => gf, $ZodNaN: () => em, $ZodMap: () => Bf, $ZodLiteral: () => Gf, $ZodLazy: () => om, $ZodKSUID: () => xf, $ZodJWT: () => Of, $ZodIntersection: () => zf, $ZodISOTime: () => ix, $ZodISODuration: () => sx, $ZodISODateTime: () => nx, $ZodISODate: () => ox, $ZodIPv6: () => Sf, $ZodIPv4: () => vf, $ZodGUID: () => uf, $ZodFunction: () => av, $ZodFile: () => Vf, $ZodError: () => ll, $ZodEnum: () => qf, $ZodEmoji: () => mf, $ZodEmail: () => df, $ZodE164: () => Af, $ZodDiscriminatedUnion: () => jf, $ZodDefault: () => Zf, $ZodDate: () => $f, $ZodCustomStringFormat: () => Cf, $ZodCustom: () => im, $ZodCheckUpperCase: () => Kb, $ZodCheckStringFormat: () => zs, $ZodCheckStartsWith: () => Jb, $ZodCheckSizeEquals: () => Bb, $ZodCheckRegex: () => Vb, $ZodCheckProperty: () => Xb, $ZodCheckOverwrite: () => ex, $ZodCheckNumberFormat: () => $b, $ZodCheckMultipleOf: () => Ub, $ZodCheckMinSize: () => Fb, $ZodCheckMinLength: () => qb, $ZodCheckMimeType: () => Qb, $ZodCheckMaxSize: () => zb, $ZodCheckMaxLength: () => Hb, $ZodCheckLowerCase: () => Wb, $ZodCheckLessThan: () => of, $ZodCheckLengthEquals: () => Gb, $ZodCheckIncludes: () => Zb, $ZodCheckGreaterThan: () => sf, $ZodCheckEndsWith: () => Yb, $ZodCheckBigIntFormat: () => jb, $ZodCheck: () => Xe, $ZodCatch: () => Qf, $ZodCUID2: () => _f, $ZodCUID: () => hf, $ZodCIDRv6: () => wf, $ZodCIDRv4: () => Ef, $ZodBoolean: () => Fs, $ZodBigIntFormat: () => If, $ZodBigInt: () => pl, $ZodBase64URL: () => kf, $ZodBase64: () => Tf, $ZodAsyncError: () => Bn, $ZodArray: () => Bs, $ZodAny: () => Lf });
 var Kd = Object.freeze({ status: "aborted" });
 function S(e, t, r) {
   function n(a, c) {
@@ -26568,7 +27011,7 @@ var tm = S("$ZodReadonly", (e, t) => {
 function DC(e) {
   return e.value = Object.freeze(e.value), e;
 }
-var rm10 = S("$ZodTemplateLiteral", (e, t) => {
+var rm11 = S("$ZodTemplateLiteral", (e, t) => {
   ie.init(e, t);
   let r = [];
   for (let n of t.parts) if (n instanceof ie) {
@@ -30375,7 +30818,7 @@ function hR(e) {
   return new gR({ type: "readonly", innerType: e });
 }
 var _R = S("ZodTemplateLiteral", (e, t) => {
-  rm10.init(e, t), de.init(e, t);
+  rm11.init(e, t), de.init(e, t);
 });
 function q9(e, t) {
   return new _R({ type: "template_literal", parts: e, ...M.normalizeParams(t) });
@@ -41994,11 +42437,11 @@ var ClaudeAdapter = class {
 // src/runs/codex-adapter.ts
 import {
   execFile as execFile3,
-  spawn as spawn6
+  spawn as spawn7
 } from "node:child_process";
-import { mkdtemp as mkdtemp6, rm as rm11, writeFile as writeFile7 } from "node:fs/promises";
-import { tmpdir as tmpdir6 } from "node:os";
-import { join as join13 } from "node:path";
+import { mkdtemp as mkdtemp7, rm as rm12, writeFile as writeFile8 } from "node:fs/promises";
+import { tmpdir as tmpdir7 } from "node:os";
+import { join as join14 } from "node:path";
 import { createInterface } from "node:readline";
 import { promisify as promisify3 } from "node:util";
 var SUPPORTED_CODEX_APP_SERVER_MINORS = ["0.144", "0.145"];
@@ -42056,7 +42499,7 @@ var CodexAppServer = class {
   async start() {
     const modelCatalogPath = await this.createBundledModelCatalog();
     const modelCatalogDirectory = this.modelCatalogDirectory;
-    const child = spawn6("codex", codexAppServerArgs(modelCatalogPath), {
+    const child = spawn7("codex", codexAppServerArgs(modelCatalogPath), {
       stdio: ["pipe", "pipe", "pipe"],
       env: process.env
     });
@@ -42125,7 +42568,7 @@ var CodexAppServer = class {
     }
   }
   async createBundledModelCatalog() {
-    const directory = await mkdtemp6(join13(tmpdir6(), "aide-codex-models-"));
+    const directory = await mkdtemp7(join14(tmpdir7(), "aide-codex-models-"));
     try {
       const { stdout } = await execFileAsync2(
         "codex",
@@ -42135,12 +42578,12 @@ var CodexAppServer = class {
           maxBuffer: 16 * 1024 * 1024
         }
       );
-      const catalogPath = join13(directory, "models.json");
-      await writeFile7(catalogPath, stdout, "utf8");
+      const catalogPath = join14(directory, "models.json");
+      await writeFile8(catalogPath, stdout, "utf8");
       this.modelCatalogDirectory = directory;
       return catalogPath;
     } catch (error) {
-      await rm11(directory, { recursive: true, force: true }).catch(
+      await rm12(directory, { recursive: true, force: true }).catch(
         () => void 0
       );
       throw error;
@@ -42151,7 +42594,7 @@ var CodexAppServer = class {
     if (this.modelCatalogDirectory === directory) {
       this.modelCatalogDirectory = void 0;
     }
-    await rm11(directory, { recursive: true, force: true }).catch(
+    await rm12(directory, { recursive: true, force: true }).catch(
       () => void 0
     );
   }
@@ -48829,7 +49272,7 @@ var RunManager = class {
         5
       );
       await this.completeCommand(command3.id, "SUCCEEDED");
-      await rm12(join14(dirname8(configPath()), "runs", run.id, "attachments"), {
+      await rm13(join15(dirname8(configPath()), "runs", run.id, "attachments"), {
         recursive: true,
         force: true
       }).catch(() => void 0);
@@ -49010,7 +49453,7 @@ var RunManager = class {
         this.active.delete(run.id);
       this.interruptionRequests.delete(run.id);
       this.executingCommands.delete(command3.id);
-      await rm12(join14(dirname8(configPath()), "runs", run.id, "attachments"), {
+      await rm13(join15(dirname8(configPath()), "runs", run.id, "attachments"), {
         recursive: true,
         force: true
       }).catch(() => void 0);
@@ -49238,11 +49681,11 @@ var RunManager = class {
   }
   async stageAttachments(runId, attachments) {
     if (!attachments.length) return [];
-    const directory = join14(dirname8(configPath()), "runs", runId, "attachments");
+    const directory = join15(dirname8(configPath()), "runs", runId, "attachments");
     await mkdir6(directory, { recursive: true, mode: 448 });
     return Promise.all(
       attachments.map(async (attachment) => {
-        const path = join14(
+        const path = join15(
           directory,
           `${attachment.id}-${safeFilename(attachment.filename)}`
         );
@@ -49358,6 +49801,10 @@ var RunManager = class {
   }
 };
 
+// ../agent-contract/src/disk-space.ts
+var DISK_SPACE_POLL_INTERVAL_SECONDS = 60;
+var DISK_SPACE_STALE_AFTER_SECONDS = DISK_SPACE_POLL_INTERVAL_SECONDS * 2;
+
 // src/agent-runtime.ts
 function configuredIntervalMs(value, fallbackSeconds, minSeconds, maxSeconds) {
   return (Number.isInteger(value) && value >= minSeconds && value <= maxSeconds ? value : fallbackSeconds) * 1e3;
@@ -49380,6 +49827,9 @@ async function runAgent(config, signal) {
   let heartbeatTimer;
   let jobReconciliationTimer;
   let codebaseTimer;
+  let diskSpaceTimer;
+  let diskSpaceRunning = false;
+  let diskSpaceIntervalMs = DISK_SPACE_POLL_INTERVAL_SECONDS * 1e3;
   let startupRecoveryPending = true;
   const interruptedJobs = /* @__PURE__ */ new Set();
   const reconcileJobs = async (recoverInterrupted) => {
@@ -49399,6 +49849,12 @@ async function runAgent(config, signal) {
           executor.cancel(job.id);
           return;
         }
+        if (job.status === "CANCELLING") {
+          if (!executor.cancel(job.id)) {
+            await client2.completeJob(job.id, "CANCELLED");
+          }
+          return;
+        }
         if (job.status !== "RUNNING" || !recoverInterrupted && !interruptedJobs.has(job.id)) {
           executor.execute(job);
           return;
@@ -49527,11 +49983,48 @@ async function runAgent(config, signal) {
     codebaseTimer = void 0;
     void reconcileCodebases();
   };
+  const scheduleDiskSpacePoll = () => {
+    if (diskSpaceTimer) clearTimeout(diskSpaceTimer);
+    if (!signal.aborted) {
+      diskSpaceTimer = setTimeout(
+        () => void runDiskSpacePoll(),
+        diskSpaceIntervalMs
+      );
+    }
+  };
+  const runDiskSpacePoll = async () => {
+    if (diskSpaceRunning || signal.aborted) return;
+    diskSpaceRunning = true;
+    if (diskSpaceTimer) clearTimeout(diskSpaceTimer);
+    diskSpaceTimer = void 0;
+    try {
+      const configuration = await client2.diskSpaceConfiguration();
+      diskSpaceIntervalMs = Math.max(
+        1e3,
+        configuration.pollIntervalSeconds * 1e3
+      );
+      if (configuration.enabled) {
+        const report = await collectAgentDiskSpace(configuration, signal);
+        await client2.reportDiskSpace(report);
+      }
+    } catch (error) {
+      if (!signal.aborted) {
+        console.error(
+          "Disk space poll failed:",
+          error instanceof Error ? error.message : error
+        );
+      }
+    } finally {
+      diskSpaceRunning = false;
+      scheduleDiskSpacePoll();
+    }
+  };
   await refreshCadence();
   await heartbeat();
   await runJobReconciliation();
   await runManager.start();
   void reconcileCodebases();
+  void runDiskSpacePoll();
   const subscriptionClient = createAgentSubscriptionClient(config);
   const unsubscribe = subscribeToAgentEvents(
     subscriptionClient,
@@ -49544,11 +50037,14 @@ async function runAgent(config, signal) {
         requestCodebaseReconcile();
       } else if (event.type === "RUN_COMMAND_AVAILABLE") {
         runManager.execute(event.runCommand);
+      } else if (event.type === "DISK_SPACE_POLL_REQUESTED") {
+        void runDiskSpacePoll();
       } else {
         void refreshCadence().then(() => {
           scheduleHeartbeat();
           scheduleJobReconciliation();
           requestCodebaseReconcile();
+          void runDiskSpacePoll();
         });
       }
     }
@@ -49560,6 +50056,7 @@ async function runAgent(config, signal) {
   if (heartbeatTimer) clearTimeout(heartbeatTimer);
   if (jobReconciliationTimer) clearTimeout(jobReconciliationTimer);
   if (codebaseTimer) clearTimeout(codebaseTimer);
+  if (diskSpaceTimer) clearTimeout(diskSpaceTimer);
   unsubscribe();
   await subscriptionClient.dispose();
   await executor.cancelAll();
@@ -49699,7 +50196,6 @@ function redactedRequestHeaders(headers) {
 }
 
 // src/index.ts
-var execFileAsync4 = promisify5(execFile5);
 function flags(args) {
   const result = {};
   const headerValues = [];
@@ -49802,22 +50298,6 @@ async function doctor() {
       detail: error instanceof Error ? error.message : String(error)
     });
   }
-  try {
-    const { stdout, stderr } = await execFileAsync4("cloudflared", [
-      "--version"
-    ]);
-    checks.push({
-      check: "cloudflared",
-      ok: true,
-      detail: (stdout || stderr).trim()
-    });
-  } catch (error) {
-    checks.push({
-      check: "cloudflared",
-      ok: false,
-      detail: error instanceof Error ? error.message : String(error)
-    });
-  }
   for (const check of checks)
     console.log(
       `${check.ok ? "PASS" : "FAIL"} ${check.check}: ${check.detail}`
@@ -49835,21 +50315,26 @@ async function main() {
   if (command3 === "doctor") return doctor();
   if (command3 === "run" || command3 === "dev") {
     const controller = new AbortController();
-    process.once("SIGINT", () => controller.abort());
-    process.once("SIGTERM", () => controller.abort());
-    if (command3 === "dev") {
-      const options = flags(args).values;
-      const server = options.server ?? process.env.CONTROL_AGENT_DEV_SERVER ?? `http://127.0.0.1:${process.env.PORT ?? "3000"}`;
-      return runDevelopmentAgent(
-        {
-          server,
-          websocketServer: options["websocket-server"] ?? process.env.CONTROL_AGENT_DEV_WEBSOCKET_SERVER ?? process.env.NEXT_PUBLIC_AGENT_WS_URL,
-          name: options.name
-        },
-        controller.signal
-      );
+    const stop2 = () => controller.abort();
+    const shutdownSignals = ["SIGINT", "SIGTERM", "SIGHUP"];
+    for (const signal of shutdownSignals) process.once(signal, stop2);
+    try {
+      if (command3 === "dev") {
+        const options = flags(args).values;
+        const server = options.server ?? process.env.CONTROL_AGENT_DEV_SERVER ?? `http://127.0.0.1:${process.env.PORT ?? "3000"}`;
+        return await runDevelopmentAgent(
+          {
+            server,
+            websocketServer: options["websocket-server"] ?? process.env.CONTROL_AGENT_DEV_WEBSOCKET_SERVER ?? process.env.NEXT_PUBLIC_AGENT_WS_URL,
+            name: options.name
+          },
+          controller.signal
+        );
+      }
+      return await runAgent(await loadConfig(), controller.signal);
+    } finally {
+      for (const signal of shutdownSignals) process.off(signal, stop2);
     }
-    return runAgent(await loadConfig(), controller.signal);
   }
   throw new Error(`Unknown command: ${command3}`);
 }