@ai-development-environment/control-agent 0.0.106 → 0.0.108

package/dist/control-agent.js

@@ -3730,15 +3730,15 @@ var require_windows = __commonJS({
       }
       return false;
     }
-    function checkStat(stat12, path, options) {
-      if (!stat12.isSymbolicLink() && !stat12.isFile()) {
+    function checkStat(stat13, path, options) {
+      if (!stat13.isSymbolicLink() && !stat13.isFile()) {
         return false;
       }
       return checkPathExt(path, options);
     }
     function isexe(path, options, cb) {
-      fs2.stat(path, function(er2, stat12) {
-        cb(er2, er2 ? false : checkStat(stat12, path, options));
+      fs2.stat(path, function(er2, stat13) {
+        cb(er2, er2 ? false : checkStat(stat13, path, options));
       });
     }
     function sync(path, options) {
@@ -3754,20 +3754,20 @@ var require_mode = __commonJS({
     isexe.sync = sync;
     var fs2 = __require("fs");
     function isexe(path, options, cb) {
-      fs2.stat(path, function(er2, stat12) {
-        cb(er2, er2 ? false : checkStat(stat12, options));
+      fs2.stat(path, function(er2, stat13) {
+        cb(er2, er2 ? false : checkStat(stat13, options));
       });
     }
     function sync(path, options) {
       return checkStat(fs2.statSync(path), options);
     }
-    function checkStat(stat12, options) {
-      return stat12.isFile() && checkMode(stat12, options);
+    function checkStat(stat13, options) {
+      return stat13.isFile() && checkMode(stat13, options);
     }
-    function checkMode(stat12, options) {
-      var mod = stat12.mode;
-      var uid = stat12.uid;
-      var gid = stat12.gid;
+    function checkMode(stat13, options) {
+      var mod = stat13.mode;
+      var uid = stat13.uid;
+      var gid = stat13.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);
@@ -4205,7 +4205,7 @@ var require_cross_spawn = __commonJS({
 });
 
 // src/index.ts
-import { rm as rm16 } from "node:fs/promises";
+import { rm as rm17 } from "node:fs/promises";
 
 // src/config.ts
 import { chmod, mkdir, readFile, rename, writeFile } from "node:fs/promises";
@@ -5236,12 +5236,12 @@ var AgentGraphQLClient = class {
     );
     return data.workflowJobSecrets;
   }
-  appendLog(jobId, log) {
+  appendLog(jobId, log2) {
     return this.request(
       `mutation AppendLog($jobId: ID!, $logs: [AgentJobLogInput!]!) {
         appendAgentJobLogs(jobId: $jobId, logs: $logs) { id }
       }`,
-      { jobId, logs: [log] }
+      { jobId, logs: [log2] }
     );
   }
   appendCommandOutput(jobId, attemptId, chunks) {
@@ -5489,6 +5489,85 @@ var AgentGraphQLClient = class {
       checksum: metadata.checksum
     };
   }
+  /**
+   * Downloads a dSYM's DWARF file for crash symbolication in 16 MiB ranges,
+   * resuming a partial file and retrying each range, then checks the sha256
+   * the job payload promised.
+   */
+  async downloadDsymDwarf(input) {
+    if (!input.downloadPath.startsWith("/api/agent/dsyms/")) {
+      throw new Error("dSYM download path is not an agent route");
+    }
+    const url = `${this.server}${input.downloadPath}`;
+    let offset = 0;
+    try {
+      offset = (await stat(input.path)).size;
+    } catch {
+    }
+    if (offset > input.sizeBytes) {
+      await rm(input.path, { force: true });
+      offset = 0;
+    }
+    const handle = await open(input.path, offset === 0 ? "w" : "r+");
+    try {
+      while (offset < input.sizeBytes) {
+        const end = Math.min(
+          input.sizeBytes - 1,
+          offset + 16 * 1024 * 1024 - 1
+        );
+        let bytes = null;
+        let attempt = 0;
+        while (!bytes) {
+          let failure = new Error("dSYM range download failed");
+          try {
+            const response = await fetch(url, {
+              headers: this.artifactTransferHeaders({
+                range: `bytes=${offset}-${end}`
+              }),
+              signal: input.signal
+            });
+            if (response.status !== 206 && response.status !== 200) {
+              failure = new Error(
+                `dSYM download failed: HTTP ${response.status} ${await response.text()}`
+              );
+              if (response.status === 401 || response.status === 403) {
+                throw failure;
+              }
+            } else {
+              const received = Buffer.from(await response.arrayBuffer());
+              const expected = end - offset + 1;
+              if (response.status === 200 && offset === 0) {
+                bytes = received.subarray(0, expected);
+              } else if (received.length === expected) {
+                bytes = received;
+              } else {
+                failure = new Error("dSYM range length did not match");
+              }
+            }
+          } catch (error) {
+            if (input.signal.aborted) throw error;
+            if (error === failure) throw error;
+            failure = error instanceof Error ? error : new Error(String(error));
+          }
+          if (bytes) break;
+          if (++attempt >= 5) throw failure;
+          await artifactTransferRetryDelay(attempt, input.signal);
+        }
+        await writeArtifactTransferBytes(handle, bytes, offset);
+        offset += bytes.length;
+      }
+      await handle.sync();
+    } finally {
+      await handle.close();
+    }
+    const digest = createHash("sha256");
+    for await (const chunk of createReadStream(input.path))
+      digest.update(chunk);
+    if (digest.digest("hex") !== input.sha256) {
+      await rm(input.path, { force: true });
+      throw new Error("Downloaded dSYM checksum did not match");
+    }
+  }
   completeJob(jobId, status2, result, error) {
     return this.request(
       `mutation CompleteJob($jobId: ID!, $status: AgentJobStatus!, $result: JSON, $error: String) {
@@ -7754,6 +7833,7 @@ var DEFAULT_BUILD_ADVANCED_SETTINGS = {
   parseTestResults: true,
   parallelTesting: null,
   parallelTestingWorkers: null,
+  collectDsyms: null,
   onlyTesting: [],
   skipTesting: [],
   buildSettingOverrides: {},
@@ -7761,6 +7841,11 @@ var DEFAULT_BUILD_ADVANCED_SETTINGS = {
   priorTestProductsPath: null,
   priorXctestrunPath: null
 };
+var DSYMS_ARTIFACT_KIND = "DSYMS";
+var DSYMS_ARTIFACT_FILENAME = "dSYMs.zip";
+function resolveCollectDsyms(settings, action) {
+  return settings.collectDsyms ?? action === "ARCHIVE";
+}
 var BUILD_REPORT_KINDS = ["TEST_RESULTS", "CODE_COVERAGE"];
 function objectValue7(value, name) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
@@ -7895,6 +7980,10 @@ function parseBuildAdvancedSettings(value) {
   if (parallel !== null && typeof parallel !== "boolean") {
     throw new Error("parallelTesting must be a boolean or null");
   }
+  const collectDsyms = input.collectDsyms ?? null;
+  if (collectDsyms !== null && typeof collectDsyms !== "boolean") {
+    throw new Error("collectDsyms must be a boolean or null");
+  }
   return {
     packageResolution: enumValue3(
       input.packageResolution,
@@ -7950,6 +8039,7 @@ function parseBuildAdvancedSettings(value) {
     ),
     parallelTesting: parallel,
     parallelTestingWorkers: workers ?? null,
+    collectDsyms,
     onlyTesting: stringArray2(
       input.onlyTesting,
       "advanced settings.onlyTesting"
@@ -8851,12 +8941,189 @@ function buildCoverageReportPayload(input) {
   };
 }
 
+// ../agent-contract/src/crashes.ts
+var CRASH_SYMBOLICATE_JOB_KIND = "ios.crash.symbolicate";
+var CRASH_JOB_KINDS = [CRASH_SYMBOLICATE_JOB_KIND];
+var ATOS_BATCH_SIZE = 500;
+var ATOS_GROUP_DELIMITER = "<|aide-atos|>";
+var MAX_LOOKUPS = 200;
+var MAX_OFFSETS = 1e4;
+function objectValue12(value, name) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`${name} must be an object`);
+  }
+  return value;
+}
+function stringValue12(value, name, maximum = 4e3) {
+  if (typeof value !== "string" || !value.trim() || value.length > maximum) {
+    throw new Error(
+      `${name} must be a non-empty string of at most ${maximum} characters`
+    );
+  }
+  return value;
+}
+function arrayValue(value, name, maximum) {
+  if (!Array.isArray(value)) throw new Error(`${name} must be an array`);
+  if (value.length > maximum) {
+    throw new Error(`${name} may hold at most ${maximum} entries`);
+  }
+  return value;
+}
+function hexOffset(value, name) {
+  const text2 = stringValue12(value, name, 32);
+  if (!/^0x[0-9a-f]+$/i.test(text2)) {
+    throw new Error(`${name} must be a 0x hexadecimal offset`);
+  }
+  return `0x${text2.slice(2).toLowerCase()}`;
+}
+function normalizeUuid(value) {
+  const compact = value.replaceAll("-", "").replace(/^<|>$/g, "").trim();
+  if (!/^[0-9a-f]{32}$/i.test(compact)) {
+    throw new Error(`${value} is not a binary image UUID`);
+  }
+  return compact.toUpperCase();
+}
+function safeFileName(value, name) {
+  const text2 = stringValue12(value, name, 255);
+  if (text2.includes("/") || text2.includes("\\") || text2 === "..") {
+    throw new Error(`${name} must be a plain file name`);
+  }
+  return text2;
+}
+function parseCrashSymbolicationPayload(value) {
+  const payload = objectValue12(value, "crash symbolication payload");
+  const dsyms = arrayValue(payload.dsyms, "dsyms", MAX_LOOKUPS).map(
+    (entry, index) => {
+      const dsym = objectValue12(entry, `dsyms[${index}]`);
+      const sha256 = stringValue12(dsym.sha256, `dsyms[${index}].sha256`, 64);
+      if (!/^[0-9a-f]{64}$/.test(sha256)) {
+        throw new Error(`dsyms[${index}].sha256 must be a sha256 digest`);
+      }
+      const size = dsym.sizeBytes;
+      if (typeof size !== "number" || !Number.isSafeInteger(size) || size < 1) {
+        throw new Error(`dsyms[${index}].sizeBytes must be a positive integer`);
+      }
+      const downloadPath = stringValue12(
+        dsym.downloadPath,
+        `dsyms[${index}].downloadPath`
+      );
+      if (!downloadPath.startsWith("/api/agent/dsyms/")) {
+        throw new Error(`dsyms[${index}].downloadPath is not an agent route`);
+      }
+      return {
+        dsymId: stringValue12(dsym.dsymId, `dsyms[${index}].dsymId`, 200),
+        sha256,
+        sizeBytes: size,
+        binaryName: safeFileName(dsym.binaryName, `dsyms[${index}].binaryName`),
+        downloadPath
+      };
+    }
+  );
+  const known = new Set(dsyms.map((dsym) => dsym.dsymId));
+  let offsetCount = 0;
+  const lookups = arrayValue(payload.lookups, "lookups", MAX_LOOKUPS).map(
+    (entry, index) => {
+      const lookup = objectValue12(entry, `lookups[${index}]`);
+      const dsymId = stringValue12(lookup.dsymId, `lookups[${index}].dsymId`);
+      if (!known.has(dsymId)) {
+        throw new Error(`lookups[${index}].dsymId is not listed in dsyms`);
+      }
+      const arch2 = stringValue12(lookup.arch, `lookups[${index}].arch`, 32);
+      if (!/^[a-z0-9_]+$/i.test(arch2)) {
+        throw new Error(`lookups[${index}].arch is invalid`);
+      }
+      const offsets = arrayValue(
+        lookup.offsets,
+        `lookups[${index}].offsets`,
+        MAX_OFFSETS
+      ).map(
+        (offset, position) => hexOffset(offset, `lookups[${index}].offsets[${position}]`)
+      );
+      offsetCount += offsets.length;
+      if (offsetCount > MAX_OFFSETS) {
+        throw new Error(`A crash may request at most ${MAX_OFFSETS} offsets`);
+      }
+      return {
+        dsymId,
+        uuid: normalizeUuid(
+          stringValue12(lookup.uuid, `lookups[${index}].uuid`, 64)
+        ),
+        arch: arch2,
+        offsets
+      };
+    }
+  );
+  return {
+    crashId: stringValue12(payload.crashId, "crashId", 200),
+    dsyms,
+    lookups
+  };
+}
+function atosArguments(input) {
+  return [
+    "atos",
+    "-arch",
+    input.arch,
+    "-o",
+    input.dwarfPath,
+    "--offset",
+    "-i",
+    "--fullPath",
+    "-d",
+    ATOS_GROUP_DELIMITER,
+    "-f",
+    input.offsetsFile
+  ];
+}
+var ATOS_LINE = /^(.+?) \(in ([^)]+)\)(?: \((.+):(\d+)\))?(?: \+ (\d+))?$/;
+function parseAtosLine(line) {
+  const text2 = line.trim();
+  if (!text2 || /^0x[0-9a-f]+$/i.test(text2)) return null;
+  const match = ATOS_LINE.exec(text2);
+  if (!match) {
+    return {
+      symbol: text2,
+      image: null,
+      file: null,
+      line: null,
+      symbolOffset: null
+    };
+  }
+  const [, symbol, image, file, lineNumber, offset] = match;
+  return {
+    symbol,
+    image: image ?? null,
+    file: file ?? null,
+    line: lineNumber ? Number(lineNumber) : null,
+    symbolOffset: offset ? Number(offset) : null
+  };
+}
+function parseAtosOutput(stdout, offsets) {
+  const groups = [[]];
+  for (const line of stdout.split(/\r?\n/)) {
+    if (line.trim() === ATOS_GROUP_DELIMITER) groups.push([]);
+    else if (line.trim()) groups[groups.length - 1].push(line);
+  }
+  if (!groups[groups.length - 1].length) groups.pop();
+  if (groups.length !== offsets.length) {
+    throw new Error(
+      `atos answered ${groups.length} addresses but ${offsets.length} were requested`
+    );
+  }
+  return offsets.map((offset, index) => ({
+    offset,
+    frames: groups[index].map(parseAtosLine).filter(
+      (frame) => frame !== null
+    )
+  }));
+}
+
 // ../agent-contract/src/cli-health.ts
 var CLI_HEALTH_JOB_KIND = "cli.health";
 var CLI_HEALTH_MAX_CHECKS = 27;
 var CLI_HEALTH_MAX_OUTPUT_BYTES = 32 * 1024;
 var CLI_HEALTH_CHECK_TIMEOUT_MS = 15e3;
-function objectValue12(value, name) {
+function objectValue13(value, name) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     throw new Error(`${name} must be an object`);
   }
@@ -8864,7 +9131,7 @@ function objectValue12(value, name) {
 }
 function checkDefinition(value, index) {
   const name = `cli.health checks[${index}]`;
-  const check = objectValue12(value, name);
+  const check = objectValue13(value, name);
   const allowed = /* @__PURE__ */ new Set(["id", "name", "command", "builtIn"]);
   const unexpected = Object.keys(check).find((key) => !allowed.has(key));
   if (unexpected) throw new Error(`Unexpected ${name} field: ${unexpected}`);
@@ -8886,7 +9153,7 @@ function checkDefinition(value, index) {
   return check;
 }
 function parseCliHealthJobPayload(value) {
-  const payload = objectValue12(value, "cli.health payload");
+  const payload = objectValue13(value, "cli.health payload");
   const unexpected = Object.keys(payload).find((key) => key !== "checks");
   if (unexpected)
     throw new Error(`Unexpected cli.health payload field: ${unexpected}`);
@@ -8927,7 +9194,7 @@ var TAILSCALE_DESTINATION_PROTOCOLS = [
   "TCP"
 ];
 var TAILSCALE_PROXY_PROTOCOLS = ["NONE", "V1", "V2"];
-function objectValue13(value, name) {
+function objectValue14(value, name) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     throw new Error(`${name} must be an object`);
   }
@@ -8994,7 +9261,7 @@ function appCapabilities(value) {
   ].sort();
 }
 function parseTailscaleServeRoute(value) {
-  const route = objectValue13(value, "Tailscale Serve route");
+  const route = objectValue14(value, "Tailscale Serve route");
   exactKeys3(
     route,
     [
@@ -9014,7 +9281,7 @@ function parseTailscaleServeRoute(value) {
     "Tailscale Serve protocol"
   );
   const listenPort = integerPort(route.listenPort, "Tailscale listen port");
-  const destination = objectValue13(
+  const destination = objectValue14(
     route.destination,
     "Tailscale Serve destination"
   );
@@ -9075,12 +9342,12 @@ function parseTailscaleServeRoute(value) {
   };
 }
 function tailscaleServeInspectPayload(value) {
-  const payload = objectValue13(value, "Tailscale Serve inspect payload");
+  const payload = objectValue14(value, "Tailscale Serve inspect payload");
   exactKeys3(payload, ["operationId"], "Tailscale Serve inspect payload");
   return { operationId: requiredString(payload.operationId, "operationId") };
 }
 function mutationPayload(value, allowPrevious) {
-  const payload = objectValue13(value, "Tailscale Serve mutation payload");
+  const payload = objectValue14(value, "Tailscale Serve mutation payload");
   exactKeys3(
     payload,
     [
@@ -9135,7 +9402,9 @@ var PORTABLE_AGENT_CAPABILITIES = [
 var MACOS_AGENT_CAPABILITIES = [
   ...BUILD_DATA_JOB_KINDS,
   ...IOS_BUILD_JOB_KINDS,
-  ...SIGNING_ASSET_JOB_KINDS
+  ...SIGNING_ASSET_JOB_KINDS,
+  // `atos` ships with Xcode, so only a Mac can name crash frames.
+  ...CRASH_JOB_KINDS
 ];
 var UNIX_AGENT_CAPABILITIES = [...TAILSCALE_SERVE_JOB_KINDS];
 function capabilitiesForPlatform(targetPlatform) {
@@ -10951,7 +11220,7 @@ function testArguments(settings) {
   for (const test of settings.skipTesting) args.push(`-skip-testing:${test}`);
   return args;
 }
-function advancedArguments(settings) {
+function advancedArguments(settings, action) {
   const args = [];
   if (settings.packageResolution === "RESOLVED_ONLY") {
     args.push("-onlyUsePackageVersionsFromResolvedFile");
@@ -10985,6 +11254,9 @@ function advancedArguments(settings) {
     args.push("-allowProvisioningDeviceRegistration");
   }
   args.push(...testArguments(settings));
+  if (resolveCollectDsyms(settings, action) && !settings.buildSettingOverrides.DEBUG_INFORMATION_FORMAT) {
+    args.push("DEBUG_INFORMATION_FORMAT=dwarf-with-dsym");
+  }
   for (const [key, value] of Object.entries(settings.buildSettingOverrides)) {
     args.push(`${key}=${value}`);
   }
@@ -11024,7 +11296,7 @@ function xcodeBuildArguments(input) {
     "-hideShellScriptEnvironment",
     "-resultBundlePath",
     resultBundle,
-    ...usesCapturedTestProducts ? testArguments(input.advancedSettings) : advancedArguments(input.advancedSettings)
+    ...usesCapturedTestProducts ? testArguments(input.advancedSettings) : advancedArguments(input.advancedSettings, input.action)
   ];
   if (input.action === "ARCHIVE") {
     args.push(
@@ -11063,7 +11335,7 @@ function xcodeBuildSettingsArguments(input, folder = input.folder) {
     input.configuration,
     "-destination",
     destinationArgument(input.destination),
-    ...advancedArguments(input.advancedSettings),
+    ...advancedArguments(input.advancedSettings, input.action),
     "-showBuildSettings",
     "-json"
   ];
@@ -11106,7 +11378,7 @@ async function runHook(options) {
   const prefix = `${String(options.script.position).padStart(3, "0")}-${options.script.id}`;
   const file = join3(directory, `${prefix}.mjs`);
   const runner = join3(directory, `${prefix}.runner.mjs`);
-  const log = join3(directory, `${prefix}.log`);
+  const log2 = join3(directory, `${prefix}.log`);
   const started = Date.now();
   try {
     await mkdir2(directory, { recursive: true, mode: 448 });
@@ -11161,7 +11433,7 @@ if (typeof hookModule.default === "function") {
       phase: options.phase,
       scope: "BUILD",
       scopeId: options.input.buildId,
-      additionalLogPath: log
+      additionalLogPath: log2
     });
     const failed = result.exitCode !== 0 || result.timedOut;
     return {
@@ -11171,7 +11443,7 @@ if (typeof hookModule.default === "function") {
       exitCode: result.exitCode,
       durationMs: Date.now() - started,
       causedBuildFailure: failed && options.script.failureBehavior === "FAIL_BUILD",
-      outputRelativePath: relative3(options.input.artifactDirectory, log),
+      outputRelativePath: relative3(options.input.artifactDirectory, log2),
       error: failed ? cleanError(result.output || "Build hook failed") : null
     };
   } catch (hookError) {
@@ -11184,7 +11456,7 @@ if (typeof hookModule.default === "function") {
       exitCode: null,
       durationMs: Date.now() - started,
       causedBuildFailure: !options.signal.aborted && options.script.failureBehavior === "FAIL_BUILD",
-      outputRelativePath: relative3(options.input.artifactDirectory, log),
+      outputRelativePath: relative3(options.input.artifactDirectory, log2),
       error
     };
   }
@@ -11706,6 +11978,110 @@ async function findFiles(root, predicate, limit = 20) {
   }
   return results;
 }
+function parseDwarfdumpUuids(output) {
+  const found = [];
+  for (const line of output.split(/\r?\n/)) {
+    const match = /^UUID:\s+([0-9A-Fa-f-]{36})\s+\(([^)]+)\)\s+(.+)$/.exec(
+      line.trim()
+    );
+    if (match) {
+      found.push({
+        uuid: match[1].toUpperCase(),
+        arch: match[2],
+        name: basename2(match[3])
+      });
+    }
+  }
+  return found;
+}
+async function dwarfdumpUuids(paths, signal) {
+  if (!paths.length) return [];
+  const result = await command(
+    "xcrun",
+    ["dwarfdump", "--uuid", ...paths],
+    6e4,
+    signal,
+    void 0,
+    xcodeEnvironment()
+  );
+  return parseDwarfdumpUuids(result.stdout);
+}
+async function captureDsyms(input, entries, signal) {
+  const sources = [];
+  const archiveDsyms = join3(
+    input.artifactDirectory,
+    "archive.xcarchive",
+    "dSYMs"
+  );
+  if (input.action === "ARCHIVE" && await pathExists(archiveDsyms)) {
+    for (const name of await readdir(archiveDsyms)) {
+      if (name.endsWith(".dSYM")) sources.push(join3(archiveDsyms, name));
+    }
+  } else {
+    const binaries = entries.map(
+      ({ buildSettings: settings }) => settings.TARGET_BUILD_DIR && settings.EXECUTABLE_PATH ? join3(settings.TARGET_BUILD_DIR, settings.EXECUTABLE_PATH) : null
+    ).filter((path) => Boolean(path));
+    const existing = [];
+    for (const binary of new Set(binaries)) {
+      if (await pathExists(binary)) existing.push(binary);
+    }
+    const built = new Set(
+      (await dwarfdumpUuids(existing, signal)).map((entry) => entry.uuid)
+    );
+    const folders = new Set(
+      entries.map(({ buildSettings: settings }) => settings.DWARF_DSYM_FOLDER_PATH).filter((path) => Boolean(path))
+    );
+    for (const folder of folders) {
+      if (!await pathExists(folder)) continue;
+      for (const name of await readdir(folder)) {
+        if (!name.endsWith(".dSYM")) continue;
+        const bundle = join3(folder, name);
+        const uuids = await dwarfdumpUuids([bundle], signal);
+        if (uuids.some((entry) => built.has(entry.uuid))) sources.push(bundle);
+      }
+    }
+  }
+  if (!sources.length) return null;
+  const staging = join3(input.artifactDirectory, "dSYMs");
+  const zipPath = join3(input.artifactDirectory, DSYMS_ARTIFACT_FILENAME);
+  await rm3(staging, { recursive: true, force: true });
+  await rm3(zipPath, { force: true });
+  await mkdir2(staging, { recursive: true, mode: 448 });
+  try {
+    for (const source of sources) {
+      await cp(source, join3(staging, basename2(source)), {
+        recursive: true,
+        preserveTimestamps: true
+      });
+    }
+    const zipped = await command(
+      "/usr/bin/ditto",
+      ["-c", "-k", "--norsrc", "--noextattr", "--keepParent", staging, zipPath],
+      10 * 6e4,
+      signal
+    );
+    if (zipped.exitCode !== 0) {
+      throw new Error(
+        `Could not zip dSYMs: ${zipped.stderr.trim() || `ditto exited with ${zipped.exitCode}`}`
+      );
+    }
+    const uuids = await dwarfdumpUuids(
+      sources.map((source) => join3(staging, basename2(source))),
+      signal
+    );
+    return await artifact(
+      input.artifactDirectory,
+      DSYMS_ARTIFACT_KIND,
+      zipPath,
+      {
+        count: sources.length,
+        uuids
+      }
+    );
+  } finally {
+    await rm3(staging, { recursive: true, force: true });
+  }
+}
 async function captureArtifacts(input, folder, signal, includeProducts = true) {
   const artifacts = [];
   const resultBundle = join3(input.artifactDirectory, "result.xcresult");
@@ -11749,8 +12125,22 @@ async function captureArtifacts(input, folder, signal, includeProducts = true) {
     folder,
     xcodeEnvironment()
   );
-  if (settingsResult.exitCode !== 0) return artifacts;
+  const collectDsyms = resolveCollectDsyms(
+    input.advancedSettings,
+    input.action
+  );
+  if (settingsResult.exitCode !== 0) {
+    if (collectDsyms) {
+      const dsyms = await captureDsyms(input, [], signal);
+      if (dsyms) artifacts.push(dsyms);
+    }
+    return artifacts;
+  }
   const entries = parseBuildSettings(settingsResult.stdout);
+  if (collectDsyms) {
+    const dsyms = await captureDsyms(input, entries, signal);
+    if (dsyms) artifacts.push(dsyms);
+  }
   const apps = entries.filter((entry) => {
     const settings = entry.buildSettings;
     return settings.WRAPPER_EXTENSION === "app" || settings.FULL_PRODUCT_NAME?.endsWith(".app");
@@ -12734,9 +13124,220 @@ var importCoverageReport = async (payloadValue, timeoutMs, signal, onLog) => {
   };
 };
 
+// src/handlers/crashes.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+import {
+  mkdir as mkdir3,
+  readdir as readdir2,
+  rename as rename3,
+  rm as rm4,
+  stat as stat4,
+  utimes,
+  writeFile as writeFile4
+} from "node:fs/promises";
+import { homedir as homedir3, tmpdir as tmpdir3 } from "node:os";
+import { join as join5 } from "node:path";
+var CACHE_LIMIT_BYTES = 10 * 1024 ** 3;
+var ATOS_OUTPUT_LIMIT_BYTES = 16 * 1024 * 1024;
+var successfulProcess3 = {
+  exitCode: 0,
+  signal: null,
+  timedOut: false,
+  cancelled: false
+};
+function dsymCacheDirectory() {
+  if (process.env.CONTROL_AGENT_DSYM_CACHE) {
+    return process.env.CONTROL_AGENT_DSYM_CACHE;
+  }
+  return process.platform === "darwin" ? join5(homedir3(), "Library", "Caches", "control-agent", "dsym-cache") : join5(homedir3(), ".cache", "control-agent", "dsym-cache");
+}
+async function log(onLog, sequence, message, stream = "SYSTEM") {
+  await onLog({
+    sequence,
+    stream,
+    message,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+}
+async function cachedDwarf(dsym, cache, download, signal) {
+  const folder = join5(cache, dsym.sha256);
+  const path = join5(folder, dsym.binaryName);
+  try {
+    const existing = await stat4(path);
+    if (existing.size === dsym.sizeBytes) {
+      const now = /* @__PURE__ */ new Date();
+      await utimes(folder, now, now).catch(() => void 0);
+      return { path, downloaded: false };
+    }
+  } catch {
+  }
+  await mkdir3(folder, { recursive: true, mode: 448 });
+  const partial = join5(folder, `.${dsym.binaryName}.${randomUUID2()}.partial`);
+  try {
+    await download({
+      downloadPath: dsym.downloadPath,
+      path: partial,
+      sizeBytes: dsym.sizeBytes,
+      sha256: dsym.sha256,
+      signal
+    });
+    await rename3(partial, path);
+  } finally {
+    await rm4(partial, { force: true });
+  }
+  return { path, downloaded: true };
+}
+async function trimDsymCache(cache, keep, limit = CACHE_LIMIT_BYTES) {
+  let entries;
+  try {
+    entries = await readdir2(cache);
+  } catch {
+    return;
+  }
+  const folders = [];
+  for (const name of entries) {
+    const folder = join5(cache, name);
+    try {
+      const information = await stat4(folder);
+      if (!information.isDirectory()) continue;
+      let size = 0;
+      for (const file of await readdir2(folder)) {
+        size += (await stat4(join5(folder, file))).size;
+      }
+      folders.push({ name, size, used: information.mtimeMs });
+    } catch {
+    }
+  }
+  let total = folders.reduce((sum, folder) => sum + folder.size, 0);
+  for (const folder of folders.sort((left, right) => left.used - right.used)) {
+    if (total <= limit) break;
+    if (keep.has(folder.name)) continue;
+    await rm4(join5(cache, folder.name), { recursive: true, force: true });
+    total -= folder.size;
+  }
+}
+async function xcodeVersion(signal) {
+  const result = await captureCommand({
+    command: "xcrun",
+    args: ["xcodebuild", "-version"],
+    timeoutMs: 3e4,
+    signal
+  }).catch(() => null);
+  if (!result || result.exitCode !== 0) return null;
+  return result.stdout.trim().split(/\r?\n/).join(" ") || null;
+}
+var symbolicateCrash = async (payloadValue, timeoutMs, signal, onLog, context) => {
+  const payload = parseCrashSymbolicationPayload(payloadValue);
+  if (!context?.downloadDsymDwarf) {
+    throw new Error("This agent cannot download dSYMs");
+  }
+  const deadline = Date.now() + timeoutMs;
+  const remaining = () => Math.max(0, deadline - Date.now());
+  const cache = dsymCacheDirectory();
+  let sequence = 0;
+  const dwarfPaths = /* @__PURE__ */ new Map();
+  const downloadErrors = /* @__PURE__ */ new Map();
+  for (const dsym of payload.dsyms) {
+    if (signal.aborted) return { ...successfulProcess3, cancelled: true };
+    try {
+      const { path, downloaded } = await cachedDwarf(
+        dsym,
+        cache,
+        context.downloadDsymDwarf,
+        signal
+      );
+      dwarfPaths.set(dsym.dsymId, path);
+      await log(
+        onLog,
+        sequence++,
+        `${downloaded ? "Downloaded" : "Using cached"} ${dsym.binaryName} (${dsym.sha256.slice(0, 12)})`
+      );
+    } catch (error) {
+      if (signal.aborted) return { ...successfulProcess3, cancelled: true };
+      const message = error instanceof Error ? error.message : String(error);
+      downloadErrors.set(dsym.dsymId, message);
+      await log(
+        onLog,
+        sequence++,
+        `Could not download ${dsym.binaryName}: ${message}`,
+        "STDERR"
+      );
+    }
+  }
+  const workFolder = join5(tmpdir3(), `control-agent-atos-${randomUUID2()}`);
+  await mkdir3(workFolder, { recursive: true, mode: 448 });
+  const lookups = [];
+  try {
+    for (const lookup of payload.lookups) {
+      const dwarfPath = dwarfPaths.get(lookup.dsymId);
+      const result = {
+        dsymId: lookup.dsymId,
+        uuid: lookup.uuid,
+        results: [],
+        error: dwarfPath ? null : downloadErrors.get(lookup.dsymId) ?? "The dSYM is unavailable"
+      };
+      lookups.push(result);
+      if (!dwarfPath) continue;
+      for (let start = 0; start < lookup.offsets.length; start += ATOS_BATCH_SIZE) {
+        const batch = lookup.offsets.slice(start, start + ATOS_BATCH_SIZE);
+        const offsetsFile = join5(workFolder, `${lookup.uuid}-${start}.txt`);
+        await writeFile4(offsetsFile, `${batch.join("\n")}
+`, { mode: 384 });
+        const run = await captureCommand({
+          command: "xcrun",
+          args: atosArguments({ arch: lookup.arch, dwarfPath, offsetsFile }),
+          timeoutMs: remaining(),
+          signal,
+          maxOutputBytes: ATOS_OUTPUT_LIMIT_BYTES
+        });
+        if (run.cancelled || run.timedOut) {
+          return {
+            exitCode: run.exitCode,
+            signal: run.signal,
+            timedOut: run.timedOut,
+            cancelled: run.cancelled
+          };
+        }
+        if (run.exitCode !== 0) {
+          result.error = run.stderr.trim().slice(0, 1e3) || `atos exited with code ${run.exitCode}`;
+          break;
+        }
+        if (run.outputTruncated) {
+          result.error = "atos printed more output than the agent keeps";
+          break;
+        }
+        try {
+          result.results.push(...parseAtosOutput(run.stdout, batch));
+        } catch (error) {
+          result.error = error instanceof Error ? error.message : String(error);
+          break;
+        }
+      }
+      const named = result.results.filter((entry) => entry.frames.length);
+      await log(
+        onLog,
+        sequence++,
+        `${lookup.uuid} (${lookup.arch}): named ${named.length} of ${lookup.offsets.length} addresses${result.error ? `; ${result.error}` : ""}`,
+        result.error ? "STDERR" : "SYSTEM"
+      );
+    }
+  } finally {
+    await rm4(workFolder, { recursive: true, force: true });
+  }
+  await trimDsymCache(
+    cache,
+    new Set(payload.dsyms.map((dsym) => dsym.sha256))
+  ).catch(() => void 0);
+  return {
+    ...successfulProcess3,
+    lookups,
+    xcodeVersion: await xcodeVersion(signal)
+  };
+};
+
 // src/handlers/cli-health.ts
 import { Buffer as Buffer2 } from "node:buffer";
-import { homedir as homedir3 } from "node:os";
+import { homedir as homedir4 } from "node:os";
 var CONCURRENCY = 4;
 var ANSI_PATTERN = /\u001B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g;
 var CONTROL_PATTERN = /[\u0000-\u0008\u000B\u000C\u000E-\u001A\u001C-\u001F\u007F]/g;
@@ -12807,7 +13408,7 @@ async function runCliHealthCheck(check, signal, onLog, options = {}) {
     const result = await captureCommand({
       command: shell,
       args: ["-lc", check.command],
-      cwd: options.cwd || homedir3(),
+      cwd: options.cwd || homedir4(),
       timeoutMs,
       signal,
       maxOutputBytes: CLI_HEALTH_MAX_OUTPUT_BYTES
@@ -12862,8 +13463,8 @@ async function runCliHealth(payload, _timeoutMs, signal, onLog) {
   let next = 0;
   let logSequence = 0;
   let logChain = Promise.resolve();
-  const appendSweepLog = (log) => {
-    const sequenced = { ...log, sequence: logSequence++ };
+  const appendSweepLog = (log2) => {
+    const sequenced = { ...log2, sequence: logSequence++ };
     const task = logChain.then(() => onLog(sequenced));
     logChain = task.catch(() => void 0);
     return task;
@@ -12893,28 +13494,28 @@ async function runCliHealth(payload, _timeoutMs, signal, onLog) {
 }
 
 // src/handlers/signing.ts
-import { createHash as createHash6, randomUUID as randomUUID2, X509Certificate } from "node:crypto";
+import { createHash as createHash6, randomUUID as randomUUID3, X509Certificate } from "node:crypto";
 import {
-  mkdir as mkdir3,
+  mkdir as mkdir4,
   mkdtemp as mkdtemp3,
   readFile as readFile4,
-  readdir as readdir2,
-  rm as rm4,
-  stat as stat4,
-  writeFile as writeFile4
+  readdir as readdir3,
+  rm as rm5,
+  stat as stat5,
+  writeFile as writeFile5
 } from "node:fs/promises";
-import { homedir as homedir4, tmpdir as tmpdir3 } from "node:os";
-import { basename as basename3, join as join5, relative as relative5, sep as sep5 } from "node:path";
+import { homedir as homedir5, tmpdir as tmpdir4 } from "node:os";
+import { basename as basename3, join as join6, relative as relative5, sep as sep5 } from "node:path";
 var PROFILE_DIRECTORIES = [
-  join5(
-    homedir4(),
+  join6(
+    homedir5(),
     "Library",
     "Developer",
     "Xcode",
     "UserData",
     "Provisioning Profiles"
   ),
-  join5(homedir4(), "Library", "MobileDevice", "Provisioning Profiles")
+  join6(homedir5(), "Library", "MobileDevice", "Provisioning Profiles")
 ];
 var PROFILE_EXTENSIONS = [".mobileprovision", ".provisionprofile"];
 function text(value) {
@@ -12998,7 +13599,7 @@ async function readProfiles(timeoutMs, signal) {
   for (const directory of PROFILE_DIRECTORIES) {
     let entries;
     try {
-      entries = await readdir2(directory);
+      entries = await readdir3(directory);
     } catch {
       continue;
     }
@@ -13007,7 +13608,7 @@ async function readProfiles(timeoutMs, signal) {
         continue;
       signal.throwIfAborted();
       const raw = await decodeProfile(
-        join5(directory, entry),
+        join6(directory, entry),
         timeoutMs,
         signal
       );
@@ -13029,7 +13630,7 @@ async function decodedProfiles(timeoutMs, signal, strict = false) {
   for (const directory of PROFILE_DIRECTORIES) {
     let entries;
     try {
-      entries = await readdir2(directory);
+      entries = await readdir3(directory);
     } catch (error) {
       if (strict && error.code !== "ENOENT") {
         throw error;
@@ -13041,7 +13642,7 @@ async function decodedProfiles(timeoutMs, signal, strict = false) {
         continue;
       }
       signal.throwIfAborted();
-      const path = join5(directory, entry);
+      const path = join6(directory, entry);
       const raw = await decodeProfile(path, timeoutMs, signal, strict);
       if (!raw) continue;
       let content;
@@ -13197,7 +13798,7 @@ async function readCertificates(timeoutMs, signal, strict = false) {
   );
 }
 async function readArchiveBundles(archivePath, timeoutMs, signal) {
-  const products = join5(archivePath, "Products");
+  const products = join6(archivePath, "Products");
   const bundles = [];
   const queue = [products];
   while (queue.length) {
@@ -13205,13 +13806,13 @@ async function readArchiveBundles(archivePath, timeoutMs, signal) {
     const current = queue.shift();
     let entries;
     try {
-      entries = await readdir2(current, { withFileTypes: true });
+      entries = await readdir3(current, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const entry of entries) {
       if (entry.isSymbolicLink() || !entry.isDirectory()) continue;
-      const path = join5(current, entry.name);
+      const path = join6(current, entry.name);
       const signable = /\.(app|appex)$/.test(entry.name);
       if (!signable) {
         if (!/\.[A-Za-z0-9]+$/.test(entry.name)) queue.push(path);
@@ -13243,7 +13844,7 @@ async function bundleIdentifier(bundlePath, timeoutMs, signal) {
         "raw",
         "-o",
         "-",
-        join5(bundlePath, "Info.plist")
+        join6(bundlePath, "Info.plist")
       ],
       timeoutMs: Math.min(timeoutMs, 5e3),
       signal
@@ -13259,9 +13860,9 @@ async function embeddedProfile(bundlePath, timeoutMs, signal) {
     "embedded.mobileprovision",
     "embedded.provisionprofile"
   ]) {
-    const path = join5(bundlePath, name);
+    const path = join6(bundlePath, name);
     try {
-      await stat4(path);
+      await stat5(path);
     } catch {
       continue;
     }
@@ -13306,7 +13907,7 @@ async function inspectSigningAssets(archivePath, timeoutMs, signal) {
 }
 var inspectIosSigning = async (payload, timeoutMs, signal) => {
   const input = parseBuildSigningInspectPayload(payload);
-  const archivePath = join5(input.artifactDirectory, input.archiveRelativePath);
+  const archivePath = join6(input.artifactDirectory, input.archiveRelativePath);
   const inspection = await inspectSigningAssets(archivePath, timeoutMs, signal);
   return {
     exitCode: 0,
@@ -13316,7 +13917,7 @@ var inspectIosSigning = async (payload, timeoutMs, signal) => {
     ...inspection
   };
 };
-var successfulProcess3 = {
+var successfulProcess4 = {
   exitCode: 0,
   signal: null,
   timedOut: false,
@@ -13339,7 +13940,7 @@ var scanSigningAssets = async (payload, timeoutMs, signal) => {
     }
   }
   return {
-    ...successfulProcess3,
+    ...successfulProcess4,
     profiles: [...byUuid.values()].sort(
       (left, right) => left.name.localeCompare(right.name)
     ),
@@ -13358,7 +13959,7 @@ var readSigningProfile = async (payload, timeoutMs, signal) => {
   const { uuid } = signingProfileKeyPayload(payload);
   const profile = await findDecodedProfile(uuid, timeoutMs, signal);
   return {
-    ...successfulProcess3,
+    ...successfulProcess4,
     uuid,
     contentBase64: profile.content.toString("base64"),
     sha256: createHash6("sha256").update(profile.content).digest("hex").toUpperCase()
@@ -13368,21 +13969,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 mkdtemp3(join5(tmpdir3(), "ade-profile-"));
-  const temporaryPath = join5(temporaryRoot, `${randomUUID2()}.mobileprovision`);
+  const temporaryRoot = await mkdtemp3(join6(tmpdir4(), "ade-profile-"));
+  const temporaryPath = join6(temporaryRoot, `${randomUUID3()}.mobileprovision`);
   try {
-    await writeFile4(temporaryPath, content, { mode: 384 });
+    await writeFile5(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 mkdir3(directory, { recursive: true, mode: 448 });
-    const destination = join5(directory, `${uuid}.mobileprovision`);
-    await writeFile4(destination, content, { mode: 384 });
-    return { ...successfulProcess3, uuid };
+    await mkdir4(directory, { recursive: true, mode: 448 });
+    const destination = join6(directory, `${uuid}.mobileprovision`);
+    await writeFile5(destination, content, { mode: 384 });
+    return { ...successfulProcess4, uuid };
   } finally {
-    await rm4(temporaryRoot, { recursive: true, force: true });
+    await rm5(temporaryRoot, { recursive: true, force: true });
   }
 };
 var deleteSigningProfile = async (payload, timeoutMs, signal) => {
@@ -13392,9 +13993,9 @@ var deleteSigningProfile = async (payload, timeoutMs, signal) => {
   );
   for (const profile of matches) {
     signal.throwIfAborted();
-    await rm4(profile.path, { force: false });
+    await rm5(profile.path, { force: false });
   }
-  return { ...successfulProcess3, uuid, deleted: matches.length };
+  return { ...successfulProcess4, uuid, deleted: matches.length };
 };
 var importSigningIdentity = async (payload, timeoutMs, signal, _onLog, context) => {
   const input = signingIdentityImportPayload(payload);
@@ -13406,10 +14007,10 @@ var importSigningIdentity = async (payload, timeoutMs, signal, _onLog, context)
   const hash = createHash6("sha256").update(p12).digest("hex").toUpperCase();
   if (hash !== input.sha256)
     throw new Error("Signing identity transfer changed");
-  const temporaryRoot = await mkdtemp3(join5(tmpdir3(), "ade-identity-"));
-  const path = join5(temporaryRoot, "identity.p12");
+  const temporaryRoot = await mkdtemp3(join6(tmpdir4(), "ade-identity-"));
+  const path = join6(temporaryRoot, "identity.p12");
   try {
-    await writeFile4(path, p12, { mode: 384 });
+    await writeFile5(path, p12, { mode: 384 });
     const result = await captureCommand({
       command: "/usr/bin/security",
       args: [
@@ -13430,9 +14031,9 @@ var importSigningIdentity = async (payload, timeoutMs, signal, _onLog, context)
         result.stderr.trim() || "Could not import signing identity"
       );
     }
-    return { ...successfulProcess3, sha256: input.sha256 };
+    return { ...successfulProcess4, sha256: input.sha256 };
   } finally {
-    await rm4(temporaryRoot, { recursive: true, force: true });
+    await rm5(temporaryRoot, { recursive: true, force: true });
   }
 };
 var deleteSigningIdentity = async (payload, timeoutMs, signal) => {
@@ -13448,7 +14049,7 @@ var deleteSigningIdentity = async (payload, timeoutMs, signal) => {
       result.stderr.trim() || "Could not delete signing identity"
     );
   }
-  return { ...successfulProcess3, sha1 };
+  return { ...successfulProcess4, sha1 };
 };
 
 // src/handlers/ccusage.ts
@@ -13456,8 +14057,8 @@ import { Buffer as Buffer3 } from "node:buffer";
 
 // src/executable-lookup.ts
 import { accessSync, constants } from "node:fs";
-import { homedir as homedir5 } from "node:os";
-import { delimiter, dirname as dirname3, join as join6 } from "node:path";
+import { homedir as homedir6 } from "node:os";
+import { delimiter, dirname as dirname3, join as join7 } from "node:path";
 function isExecutable(path) {
   try {
     accessSync(path, constants.X_OK);
@@ -13467,14 +14068,14 @@ function isExecutable(path) {
   }
 }
 function toolDirectories(options = {}) {
-  const home = options.home ?? homedir5();
+  const home = options.home ?? homedir6();
   const platform2 = options.platform ?? process.platform;
   return [
-    join6(home, ".local", "bin"),
-    join6(home, ".bun", "bin"),
-    join6(home, ".npm-global", "bin"),
+    join7(home, ".local", "bin"),
+    join7(home, ".bun", "bin"),
+    join7(home, ".npm-global", "bin"),
     // Where the opencode.ai install script puts its binary.
-    join6(home, ".opencode", "bin"),
+    join7(home, ".opencode", "bin"),
     // Global npm installs land next to the node binary running this agent.
     options.nodeDirectory ?? dirname3(process.execPath),
     ...platform2 === "darwin" ? ["/opt/homebrew/bin", "/usr/local/bin"] : []
@@ -13491,7 +14092,7 @@ function findExecutable(name, options = {}) {
   const override = options.overrideVariable ? env[options.overrideVariable]?.trim() : void 0;
   const candidates = [
     ...override ? [override] : [],
-    ...directories.map((directory) => join6(directory, executable))
+    ...directories.map((directory) => join7(directory, executable))
   ];
   const canExecute = options.isExecutable ?? isExecutable;
   return [...new Set(candidates)].find(canExecute);
@@ -13537,7 +14138,7 @@ async function runProcess(options) {
       detached
     });
     const emit = (stream, message) => {
-      const log = {
+      const log2 = {
         sequence: sequence++,
         stream,
         message,
@@ -13545,10 +14146,10 @@ async function runProcess(options) {
       };
       logChain = logChain.then(async () => {
         try {
-          await options.onLog(log);
+          await options.onLog(log2);
         } catch (error) {
           console.error(
-            `Could not append process log ${log.sequence}:`,
+            `Could not append process log ${log2.sequence}:`,
             error instanceof Error ? error.message : error
           );
         }
@@ -13651,18 +14252,18 @@ async function runCcusage(payload, timeoutMs, signal, onLog) {
     args: ["--json"],
     timeoutMs,
     signal,
-    onLog: async (log) => {
-      if (log.stream !== "STDOUT") {
-        await onLog(log);
+    onLog: async (log2) => {
+      if (log2.stream !== "STDOUT") {
+        await onLog(log2);
         return;
       }
-      const lineBytes = Buffer3.byteLength(log.message, "utf8") + 1;
+      const lineBytes = Buffer3.byteLength(log2.message, "utf8") + 1;
       if (stdoutBytes + lineBytes > MAX_CCUSAGE_STDOUT_BYTES) {
         exceededLimit = true;
         return;
       }
       stdoutBytes += lineBytes;
-      stdout.push(log.message);
+      stdout.push(log2.message);
     }
   });
   if (result.exitCode !== 0 || result.cancelled || result.timedOut || result.signal !== null) {
@@ -13686,15 +14287,15 @@ async function runCcusage(payload, timeoutMs, signal, onLog) {
 import {
   lstat as lstat2,
   opendir,
-  readdir as readdir3,
+  readdir as readdir4,
   realpath as realpath4,
-  rm as rm5,
-  stat as stat5,
+  rm as rm6,
+  stat as stat6,
   statfs
 } from "node:fs/promises";
-import { homedir as homedir6 } from "node:os";
-import { basename as basename4, dirname as dirname4, isAbsolute as isAbsolute4, join as join7, resolve as resolve4 } from "node:path";
-var successfulProcess4 = {
+import { homedir as homedir7 } from "node:os";
+import { basename as basename4, dirname as dirname4, isAbsolute as isAbsolute4, join as join8, resolve as resolve4 } from "node:path";
+var successfulProcess5 = {
   exitCode: 0,
   signal: null,
   timedOut: false,
@@ -13710,7 +14311,7 @@ function safeRelativePath3(value) {
 }
 async function configuredRoots(payload) {
   if (payload.mode === "DEFAULT") {
-    return [join7(homedir6(), "Library", "Developer", "Xcode", "DerivedData")];
+    return [join8(homedir7(), "Library", "Developer", "Xcode", "DerivedData")];
   }
   if (payload.mode === "ABSOLUTE") {
     if (!payload.path || !isAbsolute4(payload.path)) {
@@ -13759,7 +14360,7 @@ async function scanRoot(configuredRoot, timeoutMs, signal) {
   }
   let children;
   try {
-    children = await readdir3(rootPath2, { withFileTypes: true });
+    children = await readdir4(rootPath2, { withFileTypes: true });
   } catch (error) {
     return {
       entries: [],
@@ -13767,15 +14368,15 @@ async function scanRoot(configuredRoot, timeoutMs, signal) {
     };
   }
   const entries = [];
-  const rootStats = await stat5(rootPath2);
+  const rootStats = await stat6(rootPath2);
   const volumeId = String(rootStats.dev);
   for (const child of children) {
     signal.throwIfAborted();
     if (!child.isDirectory()) continue;
-    const path = join7(rootPath2, child.name);
+    const path = join8(rootPath2, child.name);
     const information = await lstat2(path);
     const projectPath = await workspacePath(
-      join7(path, "info.plist"),
+      join8(path, "info.plist"),
       timeoutMs,
       signal
     );
@@ -13793,8 +14394,8 @@ async function scanRoot(configuredRoot, timeoutMs, signal) {
   return { entries, warning: null };
 }
 async function scanDeviceSupport(signal) {
-  const configuredRoot = join7(
-    process.env.ADE_IOS_DEVICE_SUPPORT_DIRECTORY ?? homedir6(),
+  const configuredRoot = join8(
+    process.env.ADE_IOS_DEVICE_SUPPORT_DIRECTORY ?? homedir7(),
     ...process.env.ADE_IOS_DEVICE_SUPPORT_DIRECTORY ? [] : ["Library", "Developer", "Xcode", "iOS DeviceSupport"]
   );
   signal.throwIfAborted();
@@ -13811,10 +14412,10 @@ async function scanDeviceSupport(signal) {
     };
   }
   try {
-    const children = await readdir3(rootPath2, { withFileTypes: true });
+    const children = await readdir4(rootPath2, { withFileTypes: true });
     return {
       entries: children.filter((child) => child.isDirectory() && !child.isSymbolicLink()).map((child) => ({
-        path: join7(rootPath2, child.name),
+        path: join8(rootPath2, child.name),
         rootPath: rootPath2,
         name: child.name,
         kind: "DEVICE_SUPPORT",
@@ -13853,7 +14454,7 @@ var scanBuildData = async (rawPayload, timeoutMs, signal) => {
   const deviceSupport = await scanDeviceSupport(signal);
   entries.push(...deviceSupport.entries);
   if (deviceSupport.warning) warnings.push(deviceSupport.warning);
-  return { ...successfulProcess4, entries, warnings };
+  return { ...successfulProcess5, entries, warnings };
 };
 function assertDirectChild(rootPath2, path) {
   if (!isAbsolute4(rootPath2) || !isAbsolute4(path)) {
@@ -13875,7 +14476,7 @@ async function allocatedBytes(path, signal) {
   try {
     for await (const entry of directory) {
       signal.throwIfAborted();
-      total += await allocatedBytes(join7(path, entry.name), signal);
+      total += await allocatedBytes(join8(path, entry.name), signal);
     }
   } finally {
     await directory.close().catch(() => void 0);
@@ -13911,7 +14512,7 @@ var sizeBuildData = async (rawPayload, _timeoutMs, signal) => {
       });
     }
   }
-  return { ...successfulProcess4, sizes };
+  return { ...successfulProcess5, sizes };
 };
 var deleteBuildData = async (rawPayload, _timeoutMs, signal) => {
   const payload = buildDataDeletePayload(rawPayload);
@@ -13928,7 +14529,7 @@ var deleteBuildData = async (rawPayload, _timeoutMs, signal) => {
       if (!stats.isDirectory() || stats.isSymbolicLink()) {
         throw new Error("Build Data target is not a directory");
       }
-      await rm5(target2.path, { recursive: true, force: false, maxRetries: 3 });
+      await rm6(target2.path, { recursive: true, force: false, maxRetries: 3 });
       deleted.push({ path: target2.path, deleted: true, error: null });
     } catch (error) {
       signal.throwIfAborted();
@@ -13939,7 +14540,7 @@ var deleteBuildData = async (rawPayload, _timeoutMs, signal) => {
       });
     }
   }
-  return { ...successfulProcess4, deleted };
+  return { ...successfulProcess5, deleted };
 };
 async function sharedCapacityId(canonicalPath, volumeId, signal) {
   try {
@@ -13981,7 +14582,7 @@ async function inspectVolume(configuredPath, role, signal, allowMissing) {
       candidate = parent;
       try {
         inspectionPath = await realpath4(candidate);
-        canonicalPath = join7(inspectionPath, ...missingSegments);
+        canonicalPath = join8(inspectionPath, ...missingSegments);
         break;
       } catch (parentError) {
         if (parentError.code !== "ENOENT") {
@@ -13991,7 +14592,7 @@ async function inspectVolume(configuredPath, role, signal, allowMissing) {
     }
   }
   const [information, filesystem] = await Promise.all([
-    stat5(inspectionPath),
+    stat6(inspectionPath),
     statfs(inspectionPath, { bigint: true })
   ]);
   const id = String(information.dev);
@@ -14087,10 +14688,10 @@ async function collectAgentDiskSpace(configuration, signal) {
 }
 
 // src/handlers/codebases.ts
-import { readdir as readdir4, realpath as realpath5, stat as stat6 } from "node:fs/promises";
-import { homedir as homedir7 } from "node:os";
-import { dirname as dirname5, join as join8, resolve as resolve5 } from "node:path";
-var successfulProcess5 = {
+import { readdir as readdir5, realpath as realpath5, stat as stat7 } from "node:fs/promises";
+import { homedir as homedir8 } from "node:os";
+import { dirname as dirname5, join as join9, resolve as resolve5 } from "node:path";
+var successfulProcess6 = {
   exitCode: 0,
   signal: null,
   timedOut: false,
@@ -14166,7 +14767,7 @@ function baseSnapshot(folder) {
 }
 async function fetchedAt(commonDirectory) {
   try {
-    return (await stat6(join8(commonDirectory, "FETCH_HEAD"))).mtime.toISOString();
+    return (await stat7(join9(commonDirectory, "FETCH_HEAD"))).mtime.toISOString();
   } catch {
     return null;
   }
@@ -14177,11 +14778,11 @@ async function inspectCodebaseProcess(selectedFolder, timeoutMs, signal, expecte
   let selected;
   try {
     selected = await realpath5(fallbackFolder);
-    if (!(await stat6(selected)).isDirectory())
+    if (!(await stat7(selected)).isDirectory())
       throw new Error("Folder is not a directory");
   } catch (error) {
     return {
-      ...successfulProcess5,
+      ...successfulProcess6,
       snapshot: {
         ...base,
         availability: "MISSING",
@@ -14198,7 +14799,7 @@ async function inspectCodebaseProcess(selectedFolder, timeoutMs, signal, expecte
     );
     if (rootResult.exitCode !== 0) {
       return {
-        ...successfulProcess5,
+        ...successfulProcess6,
         snapshot: {
           ...base,
           folder: selected,
@@ -14218,7 +14819,7 @@ async function inspectCodebaseProcess(selectedFolder, timeoutMs, signal, expecte
     );
     if (bare.stdout.trim() === "true") {
       return {
-        ...successfulProcess5,
+        ...successfulProcess6,
         snapshot: {
           ...base,
           folder,
@@ -14250,7 +14851,7 @@ async function inspectCodebaseProcess(selectedFolder, timeoutMs, signal, expecte
     ]);
     if (originResult.exitCode !== 0) {
       return {
-        ...successfulProcess5,
+        ...successfulProcess6,
         snapshot: {
           ...base,
           folder,
@@ -14297,7 +14898,7 @@ async function inspectCodebaseProcess(selectedFolder, timeoutMs, signal, expecte
     const syncState = !branch ? "DETACHED" : !upstream ? "NO_UPSTREAM" : ahead === null || behind === null ? "UNKNOWN" : ahead > 0 && behind > 0 ? "DIVERGED" : ahead > 0 ? "AHEAD" : behind > 0 ? "BEHIND" : "IN_SYNC";
     const mismatch = expectedOrigin !== void 0 && origin2.canonicalOrigin !== expectedOrigin;
     return {
-      ...successfulProcess5,
+      ...successfulProcess6,
       snapshot: {
         folder,
         observedOrigin: origin2.sanitizedOrigin,
@@ -14319,7 +14920,7 @@ async function inspectCodebaseProcess(selectedFolder, timeoutMs, signal, expecte
   } catch (error) {
     if (error instanceof InterruptedGitInspection) return error.result;
     return {
-      ...successfulProcess5,
+      ...successfulProcess6,
       snapshot: {
         ...base,
         folder: selected,
@@ -14345,23 +14946,23 @@ async function inspectCodebase(selectedFolder, timeoutMs, signal, expectedOrigin
 }
 var browseCodebaseDirectories = async (payload) => {
   const input = codebaseBrowsePayload(payload);
-  const homePath = await realpath5(homedir7());
+  const homePath = await realpath5(homedir8());
   const path = await realpath5(input.path ? resolve5(input.path) : homePath);
-  if (!(await stat6(path)).isDirectory())
+  if (!(await stat7(path)).isDirectory())
     throw new Error("Path is not a directory");
-  const candidates = await readdir4(path, { withFileTypes: true });
+  const candidates = await readdir5(path, { withFileTypes: true });
   const entries = [];
   for (const candidate of candidates) {
     if (candidate.isDirectory()) {
       entries.push({
         name: candidate.name,
-        path: join8(path, candidate.name),
+        path: join9(path, candidate.name),
         hidden: candidate.name.startsWith(".")
       });
     } else if (candidate.isSymbolicLink()) {
       try {
-        const target2 = join8(path, candidate.name);
-        if ((await stat6(target2)).isDirectory()) {
+        const target2 = join9(path, candidate.name);
+        if ((await stat7(target2)).isDirectory()) {
           entries.push({
             name: candidate.name,
             path: target2,
@@ -14380,7 +14981,7 @@ var browseCodebaseDirectories = async (payload) => {
     entries: entries.slice(0, 1e3),
     truncated: entries.length > 1e3
   };
-  return { ...successfulProcess5, listing };
+  return { ...successfulProcess6, listing };
 };
 var inspectCodebaseFolder = async (payload, timeoutMs, signal) => {
   const input = codebaseJobPayload(payload);
@@ -14458,7 +15059,7 @@ async function updateBaseBranchAfterFetch(folder, baseBranch, timeoutMs, signal)
 var fetchCodebase = async (payload, timeoutMs, signal, onLog, context) => {
   const input = codebaseJobPayload(payload);
   let sequence = 0;
-  const log = async (message) => {
+  const log2 = async (message) => {
     try {
       await onLog({
         sequence: sequence++,
@@ -14470,7 +15071,7 @@ var fetchCodebase = async (payload, timeoutMs, signal, onLog, context) => {
       console.error("Could not report fetch progress:", cleanError2(error));
     }
   };
-  await log("Checking repository before fetching");
+  await log2("Checking repository before fetching");
   const beforeResult = await inspectCodebaseProcess(
     input.folder,
     Math.min(timeoutMs, 3e4),
@@ -14480,11 +15081,11 @@ var fetchCodebase = async (payload, timeoutMs, signal, onLog, context) => {
   if (!("snapshot" in beforeResult)) return beforeResult;
   const before = beforeResult.snapshot;
   if (before.availability !== "AVAILABLE") {
-    return { ...successfulProcess5, exitCode: 1, snapshot: before };
+    return { ...successfulProcess6, exitCode: 1, snapshot: before };
   }
   let result;
   const fetchAttemptedAt = (/* @__PURE__ */ new Date()).toISOString();
-  await log("Fetching remote branches from origin");
+  await log2("Fetching remote branches from origin");
   try {
     result = await git(input.folder, ["fetch", "origin"], timeoutMs, signal);
   } catch (error) {
@@ -14492,14 +15093,14 @@ var fetchCodebase = async (payload, timeoutMs, signal, onLog, context) => {
     throw error;
   }
   if (result.exitCode === 0 && input.keepBaseBranchUpToDate && input.baseBranch) {
-    await log("Updating the base branch where it can be fast-forwarded");
+    await log2("Updating the base branch where it can be fast-forwarded");
     const updated = await updateBaseBranchAfterFetch(
       input.folder,
       input.baseBranch,
       timeoutMs,
       signal
     );
-    await log(
+    await log2(
       updated ? "Base branch updated" : "Base branch left unchanged because it could not be safely fast-forwarded"
     );
   }
@@ -14517,12 +15118,12 @@ var fetchCodebase = async (payload, timeoutMs, signal, onLog, context) => {
     snapshot.fetchedAt = (/* @__PURE__ */ new Date()).toISOString();
   }
   if (result.exitCode !== 0) {
-    await log(snapshot.error || "Git fetch failed");
+    await log2(snapshot.error || "Git fetch failed");
   }
   let worktreesRefreshedAt;
   let worktreeRefreshError;
   if (input.codebaseId && context?.refreshFetchedCodebase) {
-    await log("Refreshing worktree branches and status");
+    await log2("Refreshing worktree branches and status");
     try {
       worktreesRefreshedAt = await context.refreshFetchedCodebase({
         codebaseId: input.codebaseId,
@@ -14530,10 +15131,10 @@ var fetchCodebase = async (payload, timeoutMs, signal, onLog, context) => {
         fetchAttemptedAt,
         fetchError: result.exitCode === 0 ? null : snapshot.error
       });
-      await log("Worktree branches and status refreshed");
+      await log2("Worktree branches and status refreshed");
     } catch (error) {
       worktreeRefreshError = cleanError2(error);
-      await log(`Could not refresh worktrees: ${worktreeRefreshError}`);
+      await log2(`Could not refresh worktrees: ${worktreeRefreshError}`);
     }
   }
   return {
@@ -14756,12 +15357,12 @@ var inspectCodebaseGit = async (payload, timeoutMs, signal) => {
   );
   if (input.action === "STATE") {
     return {
-      ...successfulProcess5,
+      ...successfulProcess6,
       state: await inspectCodebaseGitState(folder, timeoutMs, signal)
     };
   }
   return {
-    ...successfulProcess5,
+    ...successfulProcess6,
     diff: await inspectCodebaseStashDiff(
       folder,
       input.stashOid,
@@ -14984,7 +15585,7 @@ var operateCodebaseGit = async (payload, timeoutMs, signal) => {
   );
   await runCodebaseGitOperation(folder, input, timeoutMs, signal);
   return {
-    ...successfulProcess5,
+    ...successfulProcess6,
     snapshot: await inspectCodebase(
       folder,
       Math.min(timeoutMs, 3e4),
@@ -15001,25 +15602,25 @@ var operateCodebaseGit = async (payload, timeoutMs, signal) => {
 
 // src/handlers/skills.ts
 import { execFile } from "node:child_process";
-import { randomUUID as randomUUID3 } from "node:crypto";
+import { randomUUID as randomUUID4 } from "node:crypto";
 import {
   access,
   chmod as chmod3,
   lstat as lstat3,
-  mkdir as mkdir4,
+  mkdir as mkdir5,
   readFile as readFile5,
   realpath as realpath6,
-  readdir as readdir5,
-  rename as rename3,
-  rm as rm6,
-  stat as stat7,
-  writeFile as writeFile5
+  readdir as readdir6,
+  rename as rename4,
+  rm as rm7,
+  stat as stat8,
+  writeFile as writeFile6
 } from "node:fs/promises";
-import { homedir as homedir8 } from "node:os";
-import { dirname as dirname6, isAbsolute as isAbsolute5, join as join9, relative as relative6, resolve as resolve6, sep as sep6 } from "node:path";
+import { homedir as homedir9 } from "node:os";
+import { dirname as dirname6, isAbsolute as isAbsolute5, join as join10, relative as relative6, resolve as resolve6, sep as sep6 } from "node:path";
 import { promisify } from "node:util";
 var executeFile = promisify(execFile);
-var successfulProcess6 = {
+var successfulProcess7 = {
   exitCode: 0,
   signal: null,
   timedOut: false,
@@ -15071,23 +15672,23 @@ var PROJECT_ROOTS = {
 };
 async function directoryExists(path) {
   try {
-    return (await stat7(path)).isDirectory();
+    return (await stat8(path)).isDirectory();
   } catch {
     return false;
   }
 }
 async function configuredTools(tools) {
-  const homePath = homedir8();
+  const homePath = homedir9();
   return Promise.all(
     AI_TOOLS.filter((tool) => tools.includes(tool)).map(async (tool) => ({
       tool,
-      configured: await directoryExists(join9(homePath, ...CONFIG_PATHS[tool])),
+      configured: await directoryExists(join10(homePath, ...CONFIG_PATHS[tool])),
       homePath
     }))
   );
 }
 function rootPath(location) {
-  const base = location.scope === "GLOBAL" ? homedir8() : location.folder;
+  const base = location.scope === "GLOBAL" ? homedir9() : location.folder;
   const parts = location.scope === "GLOBAL" ? GLOBAL_ROOTS[location.rootKind] : PROJECT_ROOTS[location.rootKind];
   const path = resolve6(base, ...parts);
   const normalizedBase = resolve6(base);
@@ -15117,8 +15718,8 @@ async function listPackageFiles(skillDirectory) {
   const files = [];
   let totalBytes = 0;
   const visit = async (directory) => {
-    for (const entry of await readdir5(directory, { withFileTypes: true })) {
-      const path = join9(directory, entry.name);
+    for (const entry of await readdir6(directory, { withFileTypes: true })) {
+      const path = join10(directory, entry.name);
       const metadata = await lstat3(path);
       if (metadata.isSymbolicLink()) {
         throw new Error(
@@ -15215,9 +15816,9 @@ async function scanRoot2(location, configured, targets, warnings) {
   if (!consumers.length) return [];
   const target2 = targetForFolder(targets, location.folder);
   const installations = [];
-  for (const entry of await readdir5(root, { withFileTypes: true })) {
+  for (const entry of await readdir6(root, { withFileTypes: true })) {
     if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
-    const directory = join9(root, entry.name);
+    const directory = join10(root, entry.name);
     try {
       const skillPackage = await readPackage(directory, resolvedRoot);
       const relativeDirectory = location.folder ? relative6(location.folder, directory).split(sep6).join("/") : "";
@@ -15274,7 +15875,7 @@ var scanSkills = async (payload) => {
     )
   )).flat();
   return {
-    ...successfulProcess6,
+    ...successfulProcess7,
     configuredTools: observations,
     installations,
     warnings: warnings.slice(0, 500)
@@ -15297,10 +15898,10 @@ var readSkills = async (payload) => {
     const { resolvedRoot } = await resolvedSkillRoot(request);
     packages.push({
       ...request,
-      package: await readPackage(join9(root, request.skillName), resolvedRoot)
+      package: await readPackage(join10(root, request.skillName), resolvedRoot)
     });
   }
-  return { ...successfulProcess6, packages };
+  return { ...successfulProcess7, packages };
 };
 async function gitExcludePath(folder) {
   const result = await executeFile("git", [
@@ -15315,7 +15916,7 @@ async function gitExcludePath(folder) {
 }
 async function updateManagedExclude(folder, relativeSkillPath, present) {
   const excludePath = await gitExcludePath(folder);
-  await mkdir4(dirname6(excludePath), { recursive: true });
+  await mkdir5(dirname6(excludePath), { recursive: true });
   let existing = "";
   try {
     existing = await readFile5(excludePath, "utf8");
@@ -15338,7 +15939,7 @@ async function updateManagedExclude(folder, relativeSkillPath, present) {
   const block = managed.size ? `${MANAGED_EXCLUDE_START}
 ${[...managed].sort().join("\n")}
 ${MANAGED_EXCLUDE_END}` : "";
-  await writeFile5(
+  await writeFile6(
     excludePath,
     `${[before, block, after].filter(Boolean).join("\n\n")}
 `,
@@ -15359,39 +15960,39 @@ async function writePackage(location, skillPackage) {
     throw new Error("New skill copies may only be written to shared roots");
   }
   const root = rootPath(location);
-  const destination = join9(root, skillPackage.name);
+  const destination = join10(root, skillPackage.name);
   await assertUntracked(location, destination);
-  await mkdir4(root, { recursive: true });
-  const temporary = join9(root, `.${skillPackage.name}.${randomUUID3()}.tmp`);
-  const backup = join9(root, `.${skillPackage.name}.${randomUUID3()}.bak`);
-  await mkdir4(temporary, { recursive: true });
+  await mkdir5(root, { recursive: true });
+  const temporary = join10(root, `.${skillPackage.name}.${randomUUID4()}.tmp`);
+  const backup = join10(root, `.${skillPackage.name}.${randomUUID4()}.bak`);
+  await mkdir5(temporary, { recursive: true });
   try {
     for (const file of skillPackage.files) {
       const path = resolve6(temporary, ...file.path.split("/"));
       if (!path.startsWith(`${temporary}${sep6}`))
         throw new Error("Skill file escaped temporary directory");
-      await mkdir4(dirname6(path), { recursive: true });
-      await writeFile5(path, Buffer.from(file.contentsBase64, "base64"));
+      await mkdir5(dirname6(path), { recursive: true });
+      await writeFile6(path, Buffer.from(file.contentsBase64, "base64"));
       await chmod3(path, file.executable ? 493 : 420);
     }
     let hadDestination = false;
     try {
       await access(destination);
       hadDestination = true;
-      await rename3(destination, backup);
+      await rename4(destination, backup);
     } catch {
       hadDestination = false;
     }
     try {
-      await rename3(temporary, destination);
-      if (hadDestination) await rm6(backup, { recursive: true, force: true });
+      await rename4(temporary, destination);
+      if (hadDestination) await rm7(backup, { recursive: true, force: true });
     } catch (error) {
-      if (hadDestination) await rename3(backup, destination);
+      if (hadDestination) await rename4(backup, destination);
       throw error;
     }
   } finally {
-    await rm6(temporary, { recursive: true, force: true });
-    await rm6(backup, { recursive: true, force: true });
+    await rm7(temporary, { recursive: true, force: true });
+    await rm7(backup, { recursive: true, force: true });
   }
   return destination;
 }
@@ -15401,7 +16002,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 = join9(root, skillName);
+    const destination = join10(root, skillName);
     await assertUntracked(operation, destination);
     if (operation.kind === "WRITE") {
       await writePackage(operation, operation.package);
@@ -15411,7 +16012,7 @@ var applySkills = async (payload) => {
         packageHash: operation.package.packageHash
       });
     } else {
-      await rm6(destination, { recursive: true, force: true });
+      await rm7(destination, { recursive: true, force: true });
       results.push({
         kind: operation.kind,
         path: destination,
@@ -15426,14 +16027,14 @@ var applySkills = async (payload) => {
       );
     }
   }
-  return { ...successfulProcess6, results };
+  return { ...successfulProcess7, results };
 };
 
 // src/handlers/runs.ts
-import { readFile as readFile6, readdir as readdir6, stat as stat8 } from "node:fs/promises";
-import { homedir as homedir9 } from "node:os";
-import { join as join10 } from "node:path";
-var successfulProcess7 = {
+import { readFile as readFile6, readdir as readdir7, stat as stat9 } from "node:fs/promises";
+import { homedir as homedir10 } from "node:os";
+import { join as join11 } from "node:path";
+var successfulProcess8 = {
   exitCode: 0,
   signal: null,
   timedOut: false,
@@ -15441,39 +16042,39 @@ var successfulProcess7 = {
 };
 async function fileExists(path) {
   try {
-    return (await stat8(path)).isFile();
+    return (await stat9(path)).isFile();
   } catch {
     return false;
   }
 }
 async function findClaudeSessionFile(nativeId, home) {
-  const projectsDir = join10(home, ".claude", "projects");
+  const projectsDir = join11(home, ".claude", "projects");
   let entries;
   try {
-    entries = await readdir6(projectsDir, { withFileTypes: true });
+    entries = await readdir7(projectsDir, { withFileTypes: true });
   } catch {
     return null;
   }
   const target2 = `${nativeId}.jsonl`;
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const candidate = join10(projectsDir, entry.name, target2);
+    const candidate = join11(projectsDir, entry.name, target2);
     if (await fileExists(candidate)) return candidate;
   }
   return null;
 }
 async function findCodexSessionFile(nativeId, home) {
-  const sessionsDir = join10(home, ".codex", "sessions");
+  const sessionsDir = join11(home, ".codex", "sessions");
   const suffix = `-${nativeId}.jsonl`;
   const walk = async (dir) => {
     let entries;
     try {
-      entries = await readdir6(dir, { withFileTypes: true });
+      entries = await readdir7(dir, { withFileTypes: true });
     } catch {
       return null;
     }
     for (const entry of entries) {
-      const path = join10(dir, entry.name);
+      const path = join11(dir, entry.name);
       if (entry.isDirectory()) {
         const found = await walk(path);
         if (found) return found;
@@ -15490,13 +16091,13 @@ async function locateSessionFile(payload, home) {
 }
 var readRunSession = async (payload) => {
   const input = parseRunSessionReadPayload(payload);
-  const path = await locateSessionFile(input, homedir9());
+  const path = await locateSessionFile(input, homedir10());
   if (!path) {
     throw new Error(
       `No ${input.provider === "CLAUDE" ? "Claude" : "Codex"} session file found for this run on this agent`
     );
   }
-  const { size } = await stat8(path);
+  const { size } = await stat9(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)`
@@ -15504,7 +16105,7 @@ var readRunSession = async (payload) => {
   }
   const contents = await readFile6(path);
   return {
-    ...successfulProcess7,
+    ...successfulProcess8,
     filename: path.split("/").at(-1) ?? `${input.nativeId}.jsonl`,
     contentBase64: contents.toString("base64")
   };
@@ -15515,18 +16116,18 @@ import {
   mkdtemp as mkdtemp5,
   readFile as readFile7,
   realpath as realpath7,
-  rm as rm8,
-  stat as stat9,
-  writeFile as writeFile6
+  rm as rm9,
+  stat as stat10,
+  writeFile as writeFile7
 } from "node:fs/promises";
-import { tmpdir as tmpdir5 } from "node:os";
-import { join as join12 } from "node:path";
+import { tmpdir as tmpdir6 } from "node:os";
+import { join as join13 } from "node:path";
 
 // src/runs/git-checkpoint.ts
 import { execFile as execFile2, spawn as spawn6 } from "node:child_process";
-import { copyFile, mkdtemp as mkdtemp4, rm as rm7 } from "node:fs/promises";
-import { tmpdir as tmpdir4 } from "node:os";
-import { join as join11 } from "node:path";
+import { copyFile, mkdtemp as mkdtemp4, rm as rm8 } from "node:fs/promises";
+import { tmpdir as tmpdir5 } from "node:os";
+import { join as join12 } from "node:path";
 import { promisify as promisify2 } from "node:util";
 var execFileAsync = promisify2(execFile2);
 var PATCH_LIMIT = 2e6;
@@ -15744,12 +16345,12 @@ async function captureGitCheckpoint(cwd, runId, kind) {
     ["diff", "--stat", "HEAD"],
     SUMMARY_LIMIT
   );
-  const directory = await mkdtemp4(join11(tmpdir4(), "aide-run-index-"));
+  const directory = await mkdtemp4(join12(tmpdir5(), "aide-run-index-"));
   let worktreeTree = null;
   let refName = null;
   try {
     const actualIndex = await git2(cwd, ["rev-parse", "--git-path", "index"]);
-    const temporaryIndex = join11(directory, "index");
+    const temporaryIndex = join12(directory, "index");
     try {
       await copyFile(actualIndex, temporaryIndex);
     } catch {
@@ -15781,7 +16382,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 rm7(directory, { recursive: true, force: true });
+    await rm8(directory, { recursive: true, force: true });
   }
   return {
     kind,
@@ -15814,17 +16415,17 @@ var success = {
 var runWorkflowTerminal = async (payloadValue, timeoutMs, signal, onLog, context) => {
   const payload = parseWorkflowTerminalPayload(payloadValue);
   const cwd = await realpath7(payload.cwd);
-  const information = await stat9(cwd);
+  const information = await stat10(cwd);
   if (!information.isDirectory())
     throw new Error("Workflow working directory is not a directory");
-  const directory = await mkdtemp5(join12(tmpdir5(), "aide-workflow-"));
+  const directory = await mkdtemp5(join13(tmpdir6(), "aide-workflow-"));
   const extension2 = payload.interpreter === "NODE" ? "mjs" : "sh";
-  const scriptPath = join12(directory, `step.${extension2}`);
-  const sessionPath = join12(directory, "session.json");
+  const scriptPath = join13(directory, `step.${extension2}`);
+  const sessionPath = join13(directory, "session.json");
   try {
-    await writeFile6(scriptPath, `${payload.script}
+    await writeFile7(scriptPath, `${payload.script}
 `, { mode: 384 });
-    await writeFile6(
+    await writeFile7(
       sessionPath,
       `${JSON.stringify(payload.sessionData, null, 2)}
 `,
@@ -15854,7 +16455,7 @@ var runWorkflowTerminal = async (payloadValue, timeoutMs, signal, onLog, context
       env,
       timeoutMs,
       signal,
-      onLog: (log) => onLog({ ...log, message: redact(log.message) })
+      onLog: (log2) => onLog({ ...log2, message: redact(log2.message) })
     });
     const sessionFile = await readFile7(sessionPath);
     if (sessionFile.byteLength > MAX_SESSION_BYTES) {
@@ -15868,7 +16469,7 @@ var runWorkflowTerminal = async (payloadValue, timeoutMs, signal, onLog, context
     }
     return { ...result, sessionData };
   } finally {
-    await rm8(directory, { recursive: true, force: true });
+    await rm9(directory, { recursive: true, force: true });
   }
 };
 var runWorkflowGitCheckpoint = async (payloadValue, _timeoutMs, signal) => {
@@ -15911,9 +16512,9 @@ var runWorkflowGitCheckpoint = async (payloadValue, _timeoutMs, signal) => {
 
 // src/handlers/worktrees.ts
 import { createWriteStream as createWriteStream2, watch } from "node:fs";
-import { mkdtemp as mkdtemp6, open as open3, readFile as readFile9, realpath as realpath9, rm as rm10, stat as stat10 } from "node:fs/promises";
-import { tmpdir as tmpdir6 } from "node:os";
-import { basename as basename5, dirname as dirname8, isAbsolute as isAbsolute7, join as join14, relative as relative8 } from "node:path";
+import { mkdtemp as mkdtemp6, open as open3, readFile as readFile9, realpath as realpath9, rm as rm11, stat as stat11 } from "node:fs/promises";
+import { tmpdir as tmpdir7 } from "node:os";
+import { basename as basename5, dirname as dirname8, isAbsolute as isAbsolute7, join as join15, relative as relative8 } from "node:path";
 import { spawn as spawn7 } from "node:child_process";
 
 // src/handlers/worktree-preparations.ts
@@ -15921,13 +16522,13 @@ import { createHash as createHash7 } from "node:crypto";
 import {
   chmod as chmod4,
   lstat as lstat4,
-  mkdir as mkdir5,
+  mkdir as mkdir6,
   readFile as readFile8,
   realpath as realpath8,
-  rm as rm9,
-  writeFile as writeFile7
+  rm as rm10,
+  writeFile as writeFile8
 } from "node:fs/promises";
-import { dirname as dirname7, isAbsolute as isAbsolute6, join as join13, relative as relative7, resolve as resolve7 } from "node:path";
+import { dirname as dirname7, isAbsolute as isAbsolute6, join as join14, relative as relative7, resolve as resolve7 } from "node:path";
 var EXCLUDE_BEGIN = "# BEGIN AIDE PREPARATIONS";
 var EXCLUDE_END = "# END AIDE PREPARATIONS";
 function cleanError3(value) {
@@ -15978,7 +16579,7 @@ async function safeTarget(folder, path) {
   let current = root;
   const segments = fromRoot.split(/[\\/]/);
   for (const segment of segments.slice(0, -1)) {
-    current = join13(current, segment);
+    current = join14(current, segment);
     try {
       const info = await lstat4(current);
       if (info.isSymbolicLink()) {
@@ -16094,8 +16695,8 @@ async function reconcileExcludeFile(folder, definitions, timeoutMs, signal) {
   const entries = definitions.filter((definition) => definition.kind === "WRITE").map((definition) => excludeEntry(definition.path)).sort((left, right) => left.localeCompare(right));
   const block = entries.length ? [EXCLUDE_BEGIN, ...entries, EXCLUDE_END].join("\n") : "";
   const next = [base, block].filter(Boolean).join("\n\n");
-  await mkdir5(dirname7(path), { recursive: true });
-  await writeFile7(path, next ? `${next}
+  await mkdir6(dirname7(path), { recursive: true });
+  await writeFile8(path, next ? `${next}
 ` : "", "utf8");
 }
 function decodeContents(definition) {
@@ -16117,7 +16718,7 @@ async function removeTarget(target2, path) {
     if (info.isDirectory() && !info.isSymbolicLink()) {
       throw new Error(`Preparation path is a directory: ${path}`);
     }
-    await rm9(target2, { force: true });
+    await rm10(target2, { force: true });
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT") {
       return;
@@ -16172,15 +16773,15 @@ async function applyOne(folder, definition, timeoutMs, signal) {
         throw new Error(`Preparation path is a directory: ${definition.path}`);
       }
       executable = info.isFile() && (info.mode & 73) !== 0;
-      if (info.isSymbolicLink()) await rm9(target2, { force: true });
+      if (info.isSymbolicLink()) await rm10(target2, { force: true });
     } catch (error) {
       if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT") {
         throw error;
       }
     }
-    await mkdir5(dirname7(target2), { recursive: true, mode: 493 });
+    await mkdir6(dirname7(target2), { recursive: true, mode: 493 });
     await safeTarget(folder, definition.path);
-    await writeFile7(target2, contents, { mode: executable ? 493 : 420 });
+    await writeFile8(target2, contents, { mode: executable ? 493 : 420 });
     if (executable) await chmod4(target2, 493);
   }
   if (tracked) {
@@ -16399,7 +17000,7 @@ async function preparationConflictPaths(folder, definitions, remoteBase, timeout
 }
 
 // src/handlers/worktrees.ts
-var successfulProcess8 = {
+var successfulProcess9 = {
   exitCode: 0,
   signal: null,
   timedOut: false,
@@ -16452,7 +17053,7 @@ async function rebaseInProgress(folder, timeoutMs, signal) {
     const candidate = pathResult.stdout.trim();
     if (!candidate) continue;
     try {
-      await stat10(isAbsolute7(candidate) ? candidate : join14(folder, candidate));
+      await stat11(isAbsolute7(candidate) ? candidate : join15(folder, candidate));
       return true;
     } catch {
     }
@@ -16472,7 +17073,7 @@ async function rebaseBranch(folder, timeoutMs, signal) {
     if (!candidate) continue;
     try {
       const headName = (await readFile9(
-        isAbsolute7(candidate) ? candidate : join14(folder, candidate),
+        isAbsolute7(candidate) ? candidate : join15(folder, candidate),
         "utf8"
       )).trim();
       if (headName.startsWith("refs/heads/")) {
@@ -16666,7 +17267,7 @@ async function origin(folder, timeoutMs, signal) {
 }
 async function validateWorktree2(input, timeoutMs, signal) {
   const folder = await realpath9(input.folder);
-  if (!(await stat10(folder)).isDirectory())
+  if (!(await stat11(folder)).isDirectory())
     throw new Error("Worktree is missing");
   const observedGitDirectory = await gitDirectory(folder, timeoutMs, signal);
   if (observedGitDirectory !== input.gitDirectory) {
@@ -16907,7 +17508,7 @@ function parseNumstat(value) {
 }
 async function untrackedLines(folder, path) {
   try {
-    const file = await stat10(`${folder}/${path}`);
+    const file = await stat11(`${folder}/${path}`);
     if (!file.isFile() || file.size > 1024 * 1024) return null;
     const contents = await readFile9(`${folder}/${path}`);
     if (contents.includes(0)) return null;
@@ -17030,7 +17631,7 @@ async function inspectCommits(folder, baseBranch, timeoutMs, signal) {
       [
         "log",
         "--max-count=101",
-        "--format=%x1e%H%x1f%s%x1f%an%x1f%aI",
+        "--format=%x1e%H%x1f%s%x1f%an%x1f%aI%x1f%B%x00",
         "--numstat",
         `refs/remotes/origin/${baseBranch}..HEAD`
       ],
@@ -17040,16 +17641,31 @@ async function inspectCommits(folder, baseBranch, timeoutMs, signal) {
     "Could not inspect base-relative commits"
   );
   const commits = result.stdout.split("").filter(Boolean).map((block) => {
-    const lines = block.trim().split("\n");
-    const [sha = "", subject = "", authorName = "", authoredAt = ""] = (lines.shift() ?? "").split("");
+    const [header = "", stats = ""] = block.split("\0");
+    const [
+      sha = "",
+      subject = "",
+      authorName = "",
+      authoredAt = "",
+      ...messageParts
+    ] = header.split("");
+    const message = messageParts.join("").replace(/\n$/, "");
     let additions = 0;
     let deletions = 0;
-    for (const line of lines) {
+    for (const line of stats.trim().split("\n")) {
       const [added, deleted] = line.split("	");
       if (/^\d+$/.test(added ?? "")) additions += Number(added);
       if (/^\d+$/.test(deleted ?? "")) deletions += Number(deleted);
     }
-    return { sha, subject, authorName, authoredAt, additions, deletions };
+    return {
+      sha,
+      subject,
+      message,
+      authorName,
+      authoredAt,
+      additions,
+      deletions
+    };
   });
   return { commits: commits.slice(0, 100), truncated: commits.length > 100 };
 }
@@ -17125,7 +17741,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 = join14(folder, path);
+  const currentPath = join15(folder, path);
   if (input.scope === "UNTRACKED") {
     return { before: null, after: { kind: "FILE", path: currentPath } };
   }
@@ -17229,7 +17845,7 @@ async function availableSide(side, folder, timeoutMs, signal) {
   try {
     const resolved = await realpath9(side.path);
     const difference = relative8(folder, resolved);
-    return difference !== ".." && !difference.startsWith("../") && (await stat10(resolved)).isFile();
+    return difference !== ".." && !difference.startsWith("../") && (await stat11(resolved)).isFile();
   } catch {
     return false;
   }
@@ -17300,7 +17916,7 @@ async function inspectRequestedDiff(input, folder, timeoutMs, signal) {
   let patch;
   if (input.scope === "UNTRACKED") {
     const bounded = await readBoundedFile(
-      join14(folder, input.path),
+      join15(folder, input.path),
       MAX_DIFF_BYTES
     );
     const contents = bounded.contents;
@@ -17380,7 +17996,7 @@ var inspectWorktreeDiff = async (payload, timeoutMs, signal) => {
   const input = worktreeDiffPayload(payload);
   const folder = await validateWorktree2(input, timeoutMs, signal);
   return {
-    ...successfulProcess8,
+    ...successfulProcess9,
     diff: await inspectRequestedDiff(input, folder, timeoutMs, signal)
   };
 };
@@ -17482,8 +18098,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 mkdtemp6(join14(tmpdir6(), "ade-diff-image-"));
-      uploadPath = join14(temporaryDirectory, basename5(input.path));
+      temporaryDirectory = await mkdtemp6(join15(tmpdir7(), "ade-diff-image-"));
+      uploadPath = join15(temporaryDirectory, basename5(input.path));
       await writeGitObject(
         folder,
         selected.specification,
@@ -17492,7 +18108,7 @@ var downloadWorktreeDiffAsset = async (payload, timeoutMs, signal, _onLog, conte
         signal
       );
     }
-    const information = await stat10(uploadPath);
+    const information = await stat11(uploadPath);
     if (!information.isFile() || information.size > 20 * 1024 * 1024) {
       throw new Error("Diff image exceeds the 20 MiB limit");
     }
@@ -17502,10 +18118,10 @@ var downloadWorktreeDiffAsset = async (payload, timeoutMs, signal, _onLog, conte
       filename: basename5(input.path),
       contentType: imageContentType(input.path)
     });
-    return successfulProcess8;
+    return successfulProcess9;
   } finally {
     if (temporaryDirectory) {
-      await rm10(temporaryDirectory, { recursive: true, force: true });
+      await rm11(temporaryDirectory, { recursive: true, force: true });
     }
   }
 };
@@ -17517,11 +18133,11 @@ var watchWorktree = async (payload, timeoutMs, signal, _onLog, context) => {
       closeWorktreeWatch(current);
       activeWorktreeWatches.delete(input.gitDirectory);
     }
-    return successfulProcess8;
+    return successfulProcess9;
   }
   if (!context) throw new Error("Worktree activity reporting is unavailable");
   const folder = await validateWorktree2(input, timeoutMs, signal);
-  if (current?.watchId === input.watchId) return successfulProcess8;
+  if (current?.watchId === input.watchId) return successfulProcess9;
   if (current) {
     closeWorktreeWatch(current);
     activeWorktreeWatches.delete(input.gitDirectory);
@@ -17563,14 +18179,14 @@ var watchWorktree = async (payload, timeoutMs, signal, _onLog, context) => {
     activeWorktreeWatches.delete(input.gitDirectory);
     throw error;
   }
-  return successfulProcess8;
+  return successfulProcess9;
 };
 var inspectWorktree = async (payload, timeoutMs, signal) => {
   const input = worktreeJobPayload(payload);
   const folder = await validateWorktree2(input, timeoutMs, signal);
   if (!input.baseBranch) throw new Error("A base branch is required");
   return {
-    ...successfulProcess8,
+    ...successfulProcess9,
     detail: await inspectWorktreeDetail(
       folder,
       input.baseBranch,
@@ -17584,12 +18200,12 @@ var inspectWorktreeGit = async (payload, timeoutMs, signal) => {
   const folder = await validateWorktree2(input, timeoutMs, signal);
   if (input.action === "STATE") {
     return {
-      ...successfulProcess8,
+      ...successfulProcess9,
       state: await inspectCodebaseGitState(folder, timeoutMs, signal)
     };
   }
   return {
-    ...successfulProcess8,
+    ...successfulProcess9,
     diff: await inspectCodebaseStashDiff(
       folder,
       input.stashOid,
@@ -17673,7 +18289,7 @@ var commitWorktree = async (payload, timeoutMs, signal) => {
   );
   const [shaResult, subjectResult] = await Promise.all([sha, subject]);
   return {
-    ...successfulProcess8,
+    ...successfulProcess9,
     commit: {
       sha: shaResult.stdout.trim(),
       subject: subjectResult.stdout.trim(),
@@ -17694,7 +18310,7 @@ var operateWorktreeGit = async (payload, timeoutMs, signal) => {
   const folder = await validateWorktree2(input, timeoutMs, signal);
   await runCodebaseGitOperation(folder, input, timeoutMs, signal);
   return {
-    ...successfulProcess8,
+    ...successfulProcess9,
     worktree: await inspectWorktreeItem(
       folder,
       folder,
@@ -17774,7 +18390,7 @@ async function chooseNewBranch(folder, candidates, allowedCurrentBranch, timeout
 }
 async function validateBranchRoot(input, timeoutMs, signal) {
   const rootFolder = await realpath9(input.rootFolder);
-  if (!(await stat10(rootFolder)).isDirectory()) {
+  if (!(await stat11(rootFolder)).isDirectory()) {
     throw new Error("Base repository is missing");
   }
   if (await origin(rootFolder, timeoutMs, signal) !== input.expectedOrigin) {
@@ -17837,13 +18453,13 @@ var branchWorktree = async (payload, timeoutMs, signal) => {
     timeoutMs,
     signal
   ) : input.candidates[0];
-  const targetFolder = input.action === "CREATE" ? join14(
+  const targetFolder = input.action === "CREATE" ? join15(
     dirname8(rootFolder),
     `${basename5(rootFolder)}-${branch.replaceAll("/", "-")}`
   ) : changeFolder;
   if (input.action === "CREATE") {
     try {
-      await stat10(targetFolder);
+      await stat11(targetFolder);
       throw new Error(`Worktree folder already exists: ${targetFolder}`);
     } catch (error) {
       if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT") {
@@ -17981,7 +18597,7 @@ var branchWorktree = async (payload, timeoutMs, signal) => {
     throw new Error(worktree.error || "Could not inspect the updated worktree");
   }
   return {
-    ...successfulProcess8,
+    ...successfulProcess9,
     worktree,
     branch,
     baseBranch: input.baseBranch,
@@ -18038,7 +18654,7 @@ var pushMovedWorktree = async (payload, timeoutMs, signal) => {
     throw new Error("The source branch changed while it was being pushed");
   }
   return {
-    ...successfulProcess8,
+    ...successfulProcess9,
     moveId: input.moveId,
     branch,
     headSha: pushedHeadSha
@@ -18129,12 +18745,12 @@ var checkoutMovedWorktree = async (payload, timeoutMs, signal) => {
         `Branch ${input.branch} is already checked out in ${occupiedFolder}`
       );
     }
-    targetFolder = join14(
+    targetFolder = join15(
       dirname8(rootFolder),
       `${basename5(rootFolder)}-${input.branch.replaceAll("/", "-")}`
     );
     try {
-      await stat10(targetFolder);
+      await stat11(targetFolder);
       throw new Error(`Worktree folder already exists: ${targetFolder}`);
     } catch (error) {
       if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT") {
@@ -18240,7 +18856,7 @@ var checkoutMovedWorktree = async (payload, timeoutMs, signal) => {
     if (switched.exitCode !== 0) {
       if (!input.stashOnFailure && hasChanges(targetChanges)) {
         return {
-          ...successfulProcess8,
+          ...successfulProcess9,
           moveId: input.moveId,
           outcome: "NEEDS_STASH",
           message: cleanError4(
@@ -18309,7 +18925,7 @@ var checkoutMovedWorktree = async (payload, timeoutMs, signal) => {
     );
   }
   return {
-    ...successfulProcess8,
+    ...successfulProcess9,
     moveId: input.moveId,
     outcome: "CHECKED_OUT",
     worktree,
@@ -18361,7 +18977,7 @@ var prepareWorktree = async (payload, timeoutMs, signal) => {
         });
       }
     }
-    return { ...successfulProcess8, worktrees };
+    return { ...successfulProcess9, worktrees };
   }
   const folder = await validateWorktree2(input, timeoutMs, signal);
   const preparations = await executeWorktreePreparations(
@@ -18372,7 +18988,7 @@ var prepareWorktree = async (payload, timeoutMs, signal) => {
     signal
   );
   return {
-    ...successfulProcess8,
+    ...successfulProcess9,
     checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
     preparations
   };
@@ -18380,7 +18996,7 @@ var prepareWorktree = async (payload, timeoutMs, signal) => {
 var deleteWorktree = async (payload, timeoutMs, signal) => {
   const input = worktreeDeleteJobPayload(payload);
   const rootFolder = await realpath9(input.rootFolder);
-  if (!(await stat10(rootFolder)).isDirectory()) {
+  if (!(await stat11(rootFolder)).isDirectory()) {
     throw new Error("Base repository is missing");
   }
   if (await origin(rootFolder, timeoutMs, signal) !== input.expectedOrigin) {
@@ -18467,7 +19083,7 @@ var deleteWorktree = async (payload, timeoutMs, signal) => {
     );
   }
   return {
-    ...successfulProcess8,
+    ...successfulProcess9,
     moveId: input.moveId,
     deleted: true,
     branch,
@@ -18568,7 +19184,7 @@ var operateWorktree = async (payload, timeoutMs, signal) => {
           operationOutcome = "PREPARATION_CONFLICT";
           preparationResults = await inspectPreparations();
           return {
-            ...successfulProcess8,
+            ...successfulProcess9,
             outcome: operationOutcome,
             preparationConflictPaths: preparationConflictPathList,
             checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -18585,7 +19201,7 @@ var operateWorktree = async (payload, timeoutMs, signal) => {
           );
           if (preparationResults.some((item) => item.state === "ERROR")) {
             return {
-              ...successfulProcess8,
+              ...successfulProcess9,
               exitCode: 1,
               checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
               preparations: preparationResults
@@ -18617,7 +19233,7 @@ var operateWorktree = async (payload, timeoutMs, signal) => {
             state: "SUSPENDED"
           }));
           return {
-            ...successfulProcess8,
+            ...successfulProcess9,
             outcome: operationOutcome,
             preparationConflictPaths: preparationConflictPathList,
             checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -18679,7 +19295,7 @@ var operateWorktree = async (payload, timeoutMs, signal) => {
           operationOutcome = "PREPARATION_CONFLICT";
           preparationResults = await inspectPreparations();
           return {
-            ...successfulProcess8,
+            ...successfulProcess9,
             outcome: operationOutcome,
             preparationConflictPaths: preparationConflictPathList,
             checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -18696,7 +19312,7 @@ var operateWorktree = async (payload, timeoutMs, signal) => {
           );
           if (preparationResults.some((item) => item.state === "ERROR")) {
             return {
-              ...successfulProcess8,
+              ...successfulProcess9,
               exitCode: 1,
               checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
               preparations: preparationResults
@@ -18728,7 +19344,7 @@ var operateWorktree = async (payload, timeoutMs, signal) => {
             state: "SUSPENDED"
           }));
           return {
-            ...successfulProcess8,
+            ...successfulProcess9,
             outcome: operationOutcome,
             preparationConflictPaths: preparationConflictPathList,
             checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -18779,7 +19395,7 @@ var operateWorktree = async (payload, timeoutMs, signal) => {
       break;
     }
     case "CLEAR_LOCK":
-      await rm10(join14(input.gitDirectory, "index.lock"), { force: true });
+      await rm11(join15(input.gitDirectory, "index.lock"), { force: true });
       break;
     case "STASH_ALL":
       await runGit(["stash", "push", "--include-untracked"], "Stash failed");
@@ -18792,7 +19408,7 @@ var operateWorktree = async (payload, timeoutMs, signal) => {
       break;
   }
   return {
-    ...successfulProcess8,
+    ...successfulProcess9,
     outcome: operationOutcome,
     preparationConflictPaths: preparationConflictPathList,
     checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -18855,7 +19471,7 @@ var autoSyncWorktree = async (payload, timeoutMs, signal) => {
     const continuingRebase = await rebaseInProgress(folder, timeoutMs, signal);
     if (changes.hasConflicts && !continuingRebase) {
       return {
-        ...successfulProcess8,
+        ...successfulProcess9,
         outcome: "UNRESOLVED",
         checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
         preparations: suspendedPreparations(),
@@ -18885,7 +19501,7 @@ var autoSyncWorktree = async (payload, timeoutMs, signal) => {
       );
       if (continued.exitCode !== 0) {
         return {
-          ...successfulProcess8,
+          ...successfulProcess9,
           outcome: "UNRESOLVED",
           checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
           preparations: suspendedPreparations(),
@@ -18907,7 +19523,7 @@ var autoSyncWorktree = async (payload, timeoutMs, signal) => {
     }
     if (changes.hasConflicts || changes.hasStagedChanges || changes.hasUnstagedChanges || await rebaseInProgress(folder, timeoutMs, signal)) {
       return {
-        ...successfulProcess8,
+        ...successfulProcess9,
         outcome: "UNRESOLVED",
         checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
         preparations: suspendedPreparations(),
@@ -18950,7 +19566,7 @@ var autoSyncWorktree = async (payload, timeoutMs, signal) => {
     }
     const preparations = await reapplyPreparations();
     return {
-      ...successfulProcess8,
+      ...successfulProcess9,
       outcome: "SYNCED",
       checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
       preparations,
@@ -18996,7 +19612,7 @@ var autoSyncWorktree = async (payload, timeoutMs, signal) => {
     if (upstreamContainsHead.exitCode !== 0) {
       await runGit(["push", "--force-with-lease"], "Auto Sync push failed");
       return {
-        ...successfulProcess8,
+        ...successfulProcess9,
         outcome: "SYNCED",
         checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
         preparations: await inspectPreparations(),
@@ -19011,7 +19627,7 @@ var autoSyncWorktree = async (payload, timeoutMs, signal) => {
       };
     }
     return {
-      ...successfulProcess8,
+      ...successfulProcess9,
       outcome: "NO_CHANGE",
       checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
       preparations: await inspectPreparations(),
@@ -19034,7 +19650,7 @@ var autoSyncWorktree = async (payload, timeoutMs, signal) => {
   );
   if (preparationConflictPathList.length > 0 && !input.forcePreparations) {
     return {
-      ...successfulProcess8,
+      ...successfulProcess9,
       outcome: "PREPARATION_CONFLICT",
       preparationConflictPaths: preparationConflictPathList,
       checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -19059,7 +19675,7 @@ var autoSyncWorktree = async (payload, timeoutMs, signal) => {
     );
     if (preparationResults.some((item) => item.state === "ERROR")) {
       return {
-        ...successfulProcess8,
+        ...successfulProcess9,
         exitCode: 1,
         checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
         preparations: preparationResults
@@ -19077,7 +19693,7 @@ var autoSyncWorktree = async (payload, timeoutMs, signal) => {
     const conflicts = conflictStatus.exitCode === 0 && statusChangeState(conflictStatus.stdout).hasConflicts;
     if (conflicts && await rebaseInProgress(folder, timeoutMs, signal)) {
       return {
-        ...successfulProcess8,
+        ...successfulProcess9,
         outcome: "CONFLICT",
         checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
         preparations: suspendedPreparations(),
@@ -19107,7 +19723,7 @@ var autoSyncWorktree = async (payload, timeoutMs, signal) => {
   }
   preparationResults = input.forcePreparations ? await reapplyPreparations() : await inspectPreparations();
   return {
-    ...successfulProcess8,
+    ...successfulProcess9,
     outcome: "SYNCED",
     checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
     preparations: preparationResults,
@@ -19126,7 +19742,7 @@ var autoSyncWorktree = async (payload, timeoutMs, signal) => {
 import { accessSync as accessSync2, constants as constants2 } from "node:fs";
 var MAX_OUTPUT_BYTES2 = 2 * 1024 * 1024;
 var mutationQueues = /* @__PURE__ */ new Map();
-function objectValue14(value) {
+function objectValue15(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
 function resolveTailscaleExecutable(platform2 = process.platform, resolve12 = findExecutable, isExecutable2 = (path) => {
@@ -19155,7 +19771,7 @@ function resolveTailscaleExecutable(platform2 = process.platform, resolve12 = fi
 function parseTailscaleJson(value, label) {
   try {
     const parsed = JSON.parse(value);
-    const object = objectValue14(parsed);
+    const object = objectValue15(parsed);
     if (!object) throw new Error("expected an object");
     return object;
   } catch (error) {
@@ -19185,7 +19801,7 @@ async function captureTailscale(executable, args, timeoutMs, signal) {
   return result;
 }
 function backendIdentity(status2) {
-  const self2 = objectValue14(status2.Self);
+  const self2 = objectValue15(status2.Self);
   const rawAddresses = Array.isArray(self2?.TailscaleIPs) ? self2.TailscaleIPs : status2.TailscaleIPs;
   const addresses = Array.isArray(rawAddresses) ? rawAddresses.filter((value) => typeof value === "string") : [];
   const dnsName = typeof self2?.DNSName === "string" ? self2.DNSName : null;
@@ -19215,21 +19831,21 @@ function portFromListener(value) {
 }
 function normalizeTailscaleServeSnapshot(status2, serve, inspectedAt = (/* @__PURE__ */ new Date()).toISOString()) {
   const routes = [];
-  const tcp = objectValue14(serve.TCP) ?? {};
-  const web = objectValue14(serve.Web) ?? {};
-  const funnel = objectValue14(serve.AllowFunnel) ?? {};
+  const tcp = objectValue15(serve.TCP) ?? {};
+  const web = objectValue15(serve.Web) ?? {};
+  const funnel = objectValue15(serve.AllowFunnel) ?? {};
   for (const [listener, rawWeb] of Object.entries(web)) {
     const listenPort = portFromListener(listener);
-    const webConfig = objectValue14(rawWeb);
-    const handlers2 = objectValue14(webConfig?.Handlers);
+    const webConfig = objectValue15(rawWeb);
+    const handlers2 = objectValue15(webConfig?.Handlers);
     if (!listenPort || !handlers2) continue;
-    const tcpConfig = objectValue14(tcp[String(listenPort)]);
+    const tcpConfig = objectValue15(tcp[String(listenPort)]);
     const protocol = tcpConfig?.HTTPS === true ? "HTTPS" : "HTTP";
     const isFunnel = Object.entries(funnel).some(
       ([key, enabled]) => enabled === true && portFromListener(key) === listenPort
     );
     for (const [mountPath, rawHandler] of Object.entries(handlers2)) {
-      const handler = objectValue14(rawHandler);
+      const handler = objectValue15(rawHandler);
       if (!handler || typeof handler.Proxy !== "string") continue;
       const capabilities = Array.isArray(handler.AcceptAppCaps) ? handler.AcceptAppCaps.filter(
         (value) => typeof value === "string"
@@ -19252,7 +19868,7 @@ function normalizeTailscaleServeSnapshot(status2, serve, inspectedAt = (/* @__PU
   }
   for (const [listener, rawTcp] of Object.entries(tcp)) {
     const listenPort = portFromListener(listener);
-    const config = objectValue14(rawTcp);
+    const config = objectValue15(rawTcp);
     if (!listenPort || !config || typeof config.TCPForward !== "string")
       continue;
     const destination = config.TCPForward.startsWith("tcp://") ? config.TCPForward : `tcp://${config.TCPForward}`;
@@ -19446,6 +20062,7 @@ var handlers = {
   [IOS_COVERAGE_REPORT_JOB_KIND]: generateIosBuildReport,
   [IOS_SIGNING_INSPECT_JOB_KIND]: inspectIosSigning,
   [COVERAGE_IMPORT_JOB_KIND]: importCoverageReport,
+  [CRASH_SYMBOLICATE_JOB_KIND]: symbolicateCrash,
   [SIGNING_ASSETS_SCAN_JOB_KIND]: scanSigningAssets,
   [SIGNING_PROFILE_READ_JOB_KIND]: readSigningProfile,
   [SIGNING_PROFILE_INSTALL_JOB_KIND]: installSigningProfile,
@@ -19574,7 +20191,7 @@ var JobExecutor = class {
         claimed.payload,
         claimed.timeoutSeconds * 1e3,
         controller.signal,
-        (log) => this.client.appendLog(claimed.id, log).then(() => void 0),
+        (log2) => this.client.appendLog(claimed.id, log2).then(() => void 0),
         {
           agentId: claimed.agentId,
           reportWorktreeActivity: (input) => this.client.reportWorktreeActivity(input),
@@ -19589,6 +20206,7 @@ var JobExecutor = class {
           uploadBuildArtifact: (input) => this.client.uploadBuildArtifact(input),
           uploadBuildArtifactTransfer: (input) => this.client.uploadBuildArtifactTransfer(input),
           downloadBuildArtifactTransfer: (input) => this.client.downloadBuildArtifactTransfer(input),
+          downloadDsymDwarf: (input) => this.client.downloadDsymDwarf(input),
           claimSigningSecretTransfer: (transferId) => this.client.claimSigningSecretTransfer(transferId),
           claimWorkflowJobSecrets: () => this.client.claimWorkflowJobSecrets(claimed.id),
           appendCommandOutput: (attemptId, chunks) => this.client.appendCommandOutput(claimed.id, attemptId, chunks)
@@ -19755,21 +20373,21 @@ var CodebaseMonitor = class {
 
 // src/runs/run-manager.ts
 import { execFile as execFile4 } from "node:child_process";
-import { mkdir as mkdir9, rm as rm15 } from "node:fs/promises";
-import { dirname as dirname14, join as join21 } from "node:path";
+import { mkdir as mkdir10, rm as rm16 } from "node:fs/promises";
+import { dirname as dirname14, join as join22 } from "node:path";
 import { promisify as promisify4 } from "node:util";
 
 // src/runs/journal.ts
-import { randomUUID as randomUUID4 } from "node:crypto";
+import { randomUUID as randomUUID5 } from "node:crypto";
 import {
   appendFile,
-  mkdir as mkdir6,
+  mkdir as mkdir7,
   readFile as readFile10,
-  rename as rename4,
-  rm as rm11,
-  writeFile as writeFile8
+  rename as rename5,
+  rm as rm12,
+  writeFile as writeFile9
 } from "node:fs/promises";
-import { dirname as dirname9, join as join15 } from "node:path";
+import { dirname as dirname9, join as join16 } from "node:path";
 var RunJournal = class {
   constructor(runId, attemptId) {
     this.runId = runId;
@@ -19788,13 +20406,13 @@ var RunJournal = class {
     this.attemptId = attemptId;
   }
   get directory() {
-    return join15(dirname9(configPath()), "runs", this.runId);
+    return join16(dirname9(configPath()), "runs", this.runId);
   }
   get eventsPath() {
-    return join15(this.directory, "events.jsonl");
+    return join16(this.directory, "events.jsonl");
   }
   get statePath() {
-    return join15(this.directory, "state.json");
+    return join16(this.directory, "state.json");
   }
   async load() {
     if (this.loaded) return;
@@ -19806,7 +20424,7 @@ var RunJournal = class {
     await this.loading;
   }
   async loadState() {
-    await mkdir6(this.directory, { recursive: true, mode: 448 });
+    await mkdir7(this.directory, { recursive: true, mode: 448 });
     try {
       const state = JSON.parse(await readFile10(this.statePath, "utf8"));
       this.acknowledged = state.acknowledged ?? -1;
@@ -19826,7 +20444,7 @@ var RunJournal = class {
       await this.load();
       const value = {
         ...event,
-        id: randomUUID4(),
+        id: randomUUID5(),
         sequence: this.nextSequence++,
         attemptId: this.attemptId
       };
@@ -19893,12 +20511,12 @@ var RunJournal = class {
     const contents = `${JSON.stringify({ acknowledged: this.acknowledged, nextSequence: this.nextSequence })}
 `;
     const operation = this.saving.then(async () => {
-      const temporary = `${this.statePath}.${process.pid}.${randomUUID4()}.tmp`;
+      const temporary = `${this.statePath}.${process.pid}.${randomUUID5()}.tmp`;
       try {
-        await writeFile8(temporary, contents, { mode: 384 });
-        await rename4(temporary, this.statePath);
+        await writeFile9(temporary, contents, { mode: 384 });
+        await rename5(temporary, this.statePath);
       } catch (error) {
-        await rm11(temporary, { force: true }).catch(() => void 0);
+        await rm12(temporary, { force: true }).catch(() => void 0);
         throw error;
       }
     });
@@ -19908,7 +20526,7 @@ var RunJournal = class {
 };
 
 // src/runs/claude-adapter.ts
-import { randomUUID as randomUUID6 } from "node:crypto";
+import { randomUUID as randomUUID7 } from "node:crypto";
 
 // ../../node_modules/@anthropic-ai/claude-agent-sdk/sdk.mjs
 import { createRequire as ose } from "node:module";
@@ -46483,7 +47101,7 @@ var HR = class {
     this.isClosed = true, this.onclose?.();
   }
 };
-function rm13(e) {
+function rm14(e) {
   return typeof e === "number" && Number.isInteger(e) && e > 0 ? e : void 0;
 }
 var om = /* @__PURE__ */ Symbol("suppressControlResponse");
@@ -47030,7 +47648,7 @@ var sS = class _sS {
       for (let [a, c] of Object.entries(t)) {
         let l = this.sdkMcpServers.get(a);
         if (!l) this.connectSdkMcpServer(a, c);
-        else if (rm13(c.timeout) !== l.timeout) ie(`[Query.setMcpServers] MCP server '${a}' is already registered; its timeout change is ignored until the server is removed and re-added`);
+        else if (rm14(c.timeout) !== l.timeout) ie(`[Query.setMcpServers] MCP server '${a}' is already registered; its timeout change is ignored until the server is removed and re-added`);
       }
       let s = {};
       for (let a of Object.keys(t)) {
@@ -47081,7 +47699,7 @@ var sS = class _sS {
   }
   connectSdkMcpServer(e, t) {
     let n = new HR((r) => this.sendMcpServerMessageToCli(e, r));
-    this.sdkMcpServers.set(e, { transport: n, timeout: rm13(t.timeout) }), t.instance.connect(n).catch((r) => {
+    this.sdkMcpServers.set(e, { transport: n, timeout: rm14(t.timeout) }), t.instance.connect(n).catch((r) => {
       if (this.sdkMcpServers.get(e)?.transport === n) this.sdkMcpServers.delete(e);
       ie(`[Query.connectSdkMcpServer] Failed to connect MCP server '${e}': ${r}`, { level: "error" });
     });
@@ -56532,7 +57150,7 @@ var ClaudeAdapter = class {
           if (toolName !== "AskUserQuestion") {
             return { behavior: "allow", updatedInput: toolInput };
           }
-          const requestId = options.toolUseID || randomUUID6();
+          const requestId = options.toolUseID || randomUUID7();
           const questions = questionsFromInput(toolInput);
           await callbacks.onQuestion(requestId, questions);
           const answers = await new Promise((resolve12) => {
@@ -56679,9 +57297,9 @@ import {
   execFile as execFile3,
   spawn as spawn9
 } from "node:child_process";
-import { mkdtemp as mkdtemp7, rm as rm14, writeFile as writeFile9 } from "node:fs/promises";
-import { tmpdir as tmpdir7 } from "node:os";
-import { join as join20 } from "node:path";
+import { mkdtemp as mkdtemp7, rm as rm15, writeFile as writeFile10 } from "node:fs/promises";
+import { tmpdir as tmpdir8 } from "node:os";
+import { join as join21 } from "node:path";
 import { createInterface as createInterface2 } from "node:readline";
 import { promisify as promisify3 } from "node:util";
 var execFileAsync2 = promisify3(execFile3);
@@ -56814,7 +57432,7 @@ var CodexAppServer = class {
     }
   }
   async createBundledModelCatalog(executable) {
-    const directory = await mkdtemp7(join20(tmpdir7(), "aide-codex-models-"));
+    const directory = await mkdtemp7(join21(tmpdir8(), "aide-codex-models-"));
     try {
       const { stdout } = await execFileAsync2(
         executable,
@@ -56824,12 +57442,12 @@ var CodexAppServer = class {
           maxBuffer: 16 * 1024 * 1024
         }
       );
-      const catalogPath = join20(directory, "models.json");
-      await writeFile9(catalogPath, stdout, "utf8");
+      const catalogPath = join21(directory, "models.json");
+      await writeFile10(catalogPath, stdout, "utf8");
       this.modelCatalogDirectory = directory;
       return catalogPath;
     } catch (error) {
-      await rm14(directory, { recursive: true, force: true }).catch(
+      await rm15(directory, { recursive: true, force: true }).catch(
         () => void 0
       );
       throw error;
@@ -56840,7 +57458,7 @@ var CodexAppServer = class {
     if (this.modelCatalogDirectory === directory) {
       this.modelCatalogDirectory = void 0;
     }
-    await rm14(directory, { recursive: true, force: true }).catch(
+    await rm15(directory, { recursive: true, force: true }).catch(
       () => void 0
     );
   }
@@ -63709,7 +64327,7 @@ var RunManager = class {
         5
       );
       await this.completeCommand(command3.id, "SUCCEEDED");
-      await rm15(join21(dirname14(configPath()), "runs", run.id, "attachments"), {
+      await rm16(join22(dirname14(configPath()), "runs", run.id, "attachments"), {
         recursive: true,
         force: true
       }).catch(() => void 0);
@@ -63891,7 +64509,7 @@ var RunManager = class {
         this.active.delete(run.id);
       this.interruptionRequests.delete(run.id);
       this.executingCommands.delete(command3.id);
-      await rm15(join21(dirname14(configPath()), "runs", run.id, "attachments"), {
+      await rm16(join22(dirname14(configPath()), "runs", run.id, "attachments"), {
         recursive: true,
         force: true
       }).catch(() => void 0);
@@ -64119,11 +64737,11 @@ var RunManager = class {
   }
   async stageAttachments(runId, attachments) {
     if (!attachments.length) return [];
-    const directory = join21(dirname14(configPath()), "runs", runId, "attachments");
-    await mkdir9(directory, { recursive: true, mode: 448 });
+    const directory = join22(dirname14(configPath()), "runs", runId, "attachments");
+    await mkdir10(directory, { recursive: true, mode: 448 });
     return Promise.all(
       attachments.map(async (attachment) => {
-        const path = join21(
+        const path = join22(
           directory,
           `${attachment.id}-${safeFilename(attachment.filename)}`
         );
@@ -64811,7 +65429,7 @@ async function unenroll() {
     config = await loadConfig(path);
   } catch {
   }
-  await rm16(path, { force: true });
+  await rm17(path, { force: true });
   console.log(
     config ? `Removed the enrollment for ${config.name} (${config.agentId}) from ${path}` : `Removed ${path}`
   );