@ai-development-environment/control-agent 0.0.29 → 0.0.30

package/dist/control-agent.js

@@ -1506,6 +1506,8 @@ var WORKTREE_BRANCH_JOB_KIND = "worktree.branch";
 var WORKTREE_MOVE_PUSH_JOB_KIND = "worktree.move.push";
 var WORKTREE_MOVE_CHECKOUT_JOB_KIND = "worktree.move.checkout";
 var WORKTREE_DELETE_JOB_KIND = "worktree.delete";
+var WORKTREE_DIFF_JOB_KIND = "worktree.diff.inspect";
+var WORKTREE_DIFF_ASSET_JOB_KIND = "worktree.diff.asset";
 var WORKTREE_JOB_KINDS = [
   WORKTREE_INSPECT_JOB_KIND,
   WORKTREE_OPERATION_JOB_KIND,
@@ -1513,7 +1515,9 @@ var WORKTREE_JOB_KINDS = [
   WORKTREE_BRANCH_JOB_KIND,
   WORKTREE_MOVE_PUSH_JOB_KIND,
   WORKTREE_MOVE_CHECKOUT_JOB_KIND,
-  WORKTREE_DELETE_JOB_KIND
+  WORKTREE_DELETE_JOB_KIND,
+  WORKTREE_DIFF_JOB_KIND,
+  WORKTREE_DIFF_ASSET_JOB_KIND
 ];
 var DEFAULT_JIRA_BRANCH_REGEX = String.raw`\b([A-Z][A-Z0-9_]*-\d+)\b`;
 var WORKTREE_OPERATIONS = [
@@ -1534,6 +1538,13 @@ function validGitBranchName(value) {
   }
   return value.split("/").every((part) => part && !part.startsWith(".") && !part.endsWith(".lock"));
 }
+var WORKTREE_DIFF_SCOPES = [
+  "STAGED",
+  "UNSTAGED",
+  "UNTRACKED",
+  "COMMIT",
+  "BRANCH"
+];
 function objectValue4(value, name) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     throw new Error(`${name} must be an object`);
@@ -1550,6 +1561,13 @@ function nullableString3(value, name) {
   if (value === null || value === void 0) return null;
   return stringValue4(value, name);
 }
+function safeRelativePath(value, name) {
+  const path = stringValue4(value, name).replaceAll("\\", "/");
+  if (path.startsWith("/") || /^[A-Za-z]:\//.test(path) || path.split("/").includes("..") || path.includes("\0")) {
+    throw new Error(`${name} must stay within the worktree`);
+  }
+  return path;
+}
 function worktreeBranchJobPayload(value) {
   const payload = objectValue4(value, "worktree branch payload");
   const allowed = /* @__PURE__ */ new Set([
@@ -1858,6 +1876,73 @@ function worktreeJobPayload(value) {
     ...editorVariant === void 0 ? {} : { editorVariant }
   };
 }
+function worktreeDiffPayload(value) {
+  const payload = objectValue4(value, "worktree diff payload");
+  const allowed = /* @__PURE__ */ new Set([
+    "codebaseId",
+    "folder",
+    "gitDirectory",
+    "expectedOrigin",
+    "baseBranch",
+    "scope",
+    "path",
+    "previousPath",
+    "commitSha",
+    "uploadId",
+    "side"
+  ]);
+  const unexpected = Object.keys(payload).find((key) => !allowed.has(key));
+  if (unexpected) {
+    throw new Error(`Unexpected worktree diff payload field: ${unexpected}`);
+  }
+  if (!WORKTREE_DIFF_SCOPES.includes(payload.scope)) {
+    throw new Error("worktree diff payload.scope is invalid");
+  }
+  if (payload.side !== null && payload.side !== void 0 && payload.side !== "BEFORE" && payload.side !== "AFTER") {
+    throw new Error("worktree diff payload.side is invalid");
+  }
+  const path = payload.path === null || payload.path === void 0 ? null : safeRelativePath(payload.path, "worktree diff payload.path");
+  const previousPath = payload.previousPath === null || payload.previousPath === void 0 ? null : safeRelativePath(
+    payload.previousPath,
+    "worktree diff payload.previousPath"
+  );
+  const scope = payload.scope;
+  const commitSha = nullableString3(
+    payload.commitSha,
+    "worktree diff payload.commitSha"
+  );
+  if (scope === "COMMIT" && !commitSha) {
+    throw new Error("Commit diffs require a commit SHA");
+  }
+  return {
+    codebaseId: stringValue4(
+      payload.codebaseId,
+      "worktree diff payload.codebaseId"
+    ),
+    folder: stringValue4(payload.folder, "worktree diff payload.folder"),
+    gitDirectory: stringValue4(
+      payload.gitDirectory,
+      "worktree diff payload.gitDirectory"
+    ),
+    expectedOrigin: stringValue4(
+      payload.expectedOrigin,
+      "worktree diff payload.expectedOrigin"
+    ),
+    baseBranch: stringValue4(
+      payload.baseBranch,
+      "worktree diff payload.baseBranch"
+    ),
+    scope,
+    path,
+    previousPath,
+    commitSha,
+    uploadId: nullableString3(
+      payload.uploadId,
+      "worktree diff payload.uploadId"
+    ),
+    side: payload.side ?? null
+  };
+}
 function worktreeWatchJobPayload(value) {
   const payload = objectValue4(value, "worktree watch payload");
   const allowed = /* @__PURE__ */ new Set([
@@ -2201,6 +2286,8 @@ var IOS_BUILD_DELETE_JOB_KIND = "ios.build.delete";
 var IOS_ARTIFACT_DOWNLOAD_JOB_KIND = "ios.artifact.download";
 var IOS_DEPLOY_JOB_KIND = "ios.build.deploy";
 var IOS_EXPORT_JOB_KIND = "ios.archive.export";
+var IOS_TEST_RESULTS_JOB_KIND = "ios.test-results.parse";
+var IOS_COVERAGE_REPORT_JOB_KIND = "ios.coverage.generate";
 var IOS_BUILD_JOB_KINDS = [
   IOS_SOURCE_DISCOVER_JOB_KIND,
   IOS_SOURCE_PARSE_JOB_KIND,
@@ -2210,7 +2297,9 @@ var IOS_BUILD_JOB_KINDS = [
   IOS_BUILD_DELETE_JOB_KIND,
   IOS_ARTIFACT_DOWNLOAD_JOB_KIND,
   IOS_DEPLOY_JOB_KIND,
-  IOS_EXPORT_JOB_KIND
+  IOS_EXPORT_JOB_KIND,
+  IOS_TEST_RESULTS_JOB_KIND,
+  IOS_COVERAGE_REPORT_JOB_KIND
 ];
 var BUILD_ACTIONS = [
   "BUILD",
@@ -2259,6 +2348,7 @@ var DEFAULT_BUILD_ADVANCED_SETTINGS = {
   allowProvisioningDeviceRegistration: false,
   testPlan: null,
   codeCoverage: false,
+  parseTestResults: true,
   parallelTesting: null,
   parallelTestingWorkers: null,
   onlyTesting: [],
@@ -2268,6 +2358,7 @@ var DEFAULT_BUILD_ADVANCED_SETTINGS = {
   priorTestProductsPath: null,
   priorXctestrunPath: null
 };
+var BUILD_REPORT_KINDS = ["TEST_RESULTS", "CODE_COVERAGE"];
 function objectValue6(value, name) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     throw new Error(`${name} must be an object`);
@@ -2293,7 +2384,7 @@ function enumValue3(value, values, name) {
   }
   return value;
 }
-function safeRelativePath(value, name) {
+function safeRelativePath2(value, name) {
   const path = stringValue6(value, name);
   if (path.startsWith("/") || /^[A-Za-z]:[\\/]/.test(path) || path.split(/[\\/]/).includes("..") || path.includes("\0")) {
     throw new Error(`${name} must stay within the worktree`);
@@ -2318,13 +2409,14 @@ function worktreeIdentity(value) {
       value.expectedOrigin,
       "build payload.expectedOrigin"
     ),
-    headSha: nullableString4(value.headSha, "build payload.headSha")
+    headSha: nullableString4(value.headSha, "build payload.headSha"),
+    baseBranch: nullableString4(value.baseBranch, "build payload.baseBranch")
   };
 }
 function parseBuildSource(value) {
   const source = objectValue6(value, "build source");
   const kind = enumValue3(source.kind, BUILD_SOURCE_KINDS, "build source.kind");
-  const relativePath = safeRelativePath(
+  const relativePath = safeRelativePath2(
     source.relativePath,
     "build source.relativePath"
   );
@@ -2443,6 +2535,10 @@ function parseBuildAdvancedSettings(value) {
       input.codeCoverage,
       "advanced settings.codeCoverage"
     ),
+    parseTestResults: booleanValue2(
+      input.parseTestResults,
+      "advanced settings.parseTestResults"
+    ),
     parallelTesting: parallel,
     parallelTestingWorkers: workers ?? null,
     onlyTesting: stringArray2(
@@ -2580,7 +2676,27 @@ function parseBuildJobPayload(value) {
     action,
     destination,
     advancedSettings,
-    scripts
+    scripts,
+    worktreeCoverage: input.worktreeCoverage === void 0 ? false : booleanValue2(
+      input.worktreeCoverage,
+      "build job payload.worktreeCoverage"
+    )
+  };
+}
+function parseBuildReportPayload(value) {
+  const input = objectValue6(value, "build report payload");
+  return {
+    ...parseBuildDeletePayload(input),
+    reportKind: enumValue3(
+      input.reportKind,
+      BUILD_REPORT_KINDS,
+      "build report payload.reportKind"
+    ),
+    source: enumValue3(
+      input.source,
+      ["MANUAL", "WORKTREE"],
+      "build report payload.source"
+    )
   };
 }
 function parseBuildDeletePayload(value) {
@@ -2607,7 +2723,7 @@ function parseBuildArtifactDownloadPayload(value) {
   const identity = parseBuildDeletePayload(input);
   return {
     ...identity,
-    artifactRelativePath: safeRelativePath(
+    artifactRelativePath: safeRelativePath2(
       input.artifactRelativePath,
       "build artifact download payload.artifactRelativePath"
     ),
@@ -2649,7 +2765,7 @@ function parseBuildDeploymentPayload(value) {
       input.artifactDirectory,
       "build deployment payload.artifactDirectory"
     ),
-    artifactRelativePath: safeRelativePath(
+    artifactRelativePath: safeRelativePath2(
       input.artifactRelativePath,
       "build deployment payload.artifactRelativePath"
     ),
@@ -2717,7 +2833,7 @@ function parseBuildExportPayload(value) {
       input.artifactDirectory,
       "build export payload.artifactDirectory"
     ),
-    archiveRelativePath: safeRelativePath(
+    archiveRelativePath: safeRelativePath2(
       input.archiveRelativePath,
       "build export payload.archiveRelativePath"
     ),
@@ -2925,7 +3041,7 @@ import { basename, dirname as dirname2, isAbsolute, join as join2, resolve } fro
 
 // src/capture-command.ts
 import { spawn as spawn2 } from "node:child_process";
-var MAX_OUTPUT_BYTES = 1024 * 1024;
+var MAX_OUTPUT_BYTES = 2 * 1024 * 1024;
 function captureCommand(options) {
   return new Promise((resolve6, reject) => {
     let stdout = "";
@@ -2935,15 +3051,19 @@ function captureCommand(options) {
     let settled = false;
     const child = spawn2(options.command, options.args, {
       shell: false,
-      stdio: ["ignore", "pipe", "pipe"],
+      stdio: [
+        "ignore",
+        options.stdoutFileDescriptor === void 0 ? "pipe" : options.stdoutFileDescriptor,
+        "pipe"
+      ],
       env: options.env ?? process.env,
       cwd: options.cwd
     });
     const append = (current, chunk) => `${current}${String(chunk)}`.slice(0, MAX_OUTPUT_BYTES);
-    child.stdout.on("data", (chunk) => {
+    child.stdout?.on("data", (chunk) => {
       stdout = append(stdout, chunk);
     });
-    child.stderr.on("data", (chunk) => {
+    child.stderr?.on("data", (chunk) => {
       stderr = append(stderr, chunk);
     });
     const terminate = () => {
@@ -2997,7 +3117,7 @@ var successfulProcess = {
 function errorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
-function safeRelativePath2(value) {
+function safeRelativePath3(value) {
   if (!value || value.includes("\0") || isAbsolute(value)) return false;
   const normalized = value.replaceAll("\\", "/");
   return normalized !== "." && normalized.split("/").every((part) => part && part !== ".." && part !== ".");
@@ -3012,7 +3132,7 @@ async function configuredRoots(payload) {
     }
     return [resolve(payload.path)];
   }
-  if (!payload.path || !safeRelativePath2(payload.path)) {
+  if (!payload.path || !safeRelativePath3(payload.path)) {
     throw new Error("Relative Derived Data mode requires a safe relative path");
   }
   return payload.worktrees.map(
@@ -4430,9 +4550,11 @@ var applySkills = async (payload) => {
 };
 
 // src/handlers/worktrees.ts
-import { watch } from "node:fs";
-import { readFile as readFile3, realpath as realpath4, stat as stat4 } from "node:fs/promises";
+import { createWriteStream, watch } from "node:fs";
+import { mkdtemp, open, readFile as readFile3, realpath as realpath4, rm as rm3, stat as stat4 } from "node:fs/promises";
+import { tmpdir } from "node:os";
 import { basename as basename2, dirname as dirname5, join as join5, relative as relative3 } from "node:path";
+import { spawn as spawn4 } from "node:child_process";
 
 // src/git-code-state.ts
 import { createHash as createHash2 } from "node:crypto";
@@ -4633,6 +4755,16 @@ var successfulProcess4 = {
   cancelled: false
 };
 var WATCH_DEBOUNCE_MS = 500;
+var MAX_DIFF_BYTES = 2 * 1024 * 1024;
+var IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".webp",
+  ".avif",
+  ".bmp"
+]);
 var activeWorktreeWatches = /* @__PURE__ */ new Map();
 function statusChangeState(value) {
   const entries = value.split("\0").filter(Boolean);
@@ -5088,7 +5220,8 @@ async function inspectChanges(folder, timeoutMs, signal) {
     const value = values[index];
     const code = value.slice(0, 2);
     const path = value.slice(3);
-    if ((code[0] === "R" || code[0] === "C") && values[index + 1]) index += 1;
+    const previousPath = (code[0] === "R" || code[0] === "C") && values[index + 1] ? values[index + 1] : null;
+    if (previousPath) index += 1;
     const untracked = code === "??";
     const conflicted = ["DD", "AU", "UD", "UA", "DU", "AA", "UU"].includes(
       code
@@ -5100,6 +5233,8 @@ async function inspectChanges(folder, timeoutMs, signal) {
     const untrackedCount = untracked ? await untrackedLines(folder, path) : null;
     changes.push({
       path,
+      previousPath,
+      changeType: untracked ? "ADDED" : conflicted ? "CONFLICTED" : code,
       staged,
       unstaged,
       untracked,
@@ -5112,6 +5247,65 @@ async function inspectChanges(folder, timeoutMs, signal) {
   }
   return { changes: changes.slice(0, 500), truncated: changes.length > 500 };
 }
+function imagePath(path) {
+  const extension = path.slice(path.lastIndexOf(".")).toLocaleLowerCase();
+  return IMAGE_EXTENSIONS.has(extension);
+}
+function parseNameStatus(value) {
+  const entries = value.split("\0").filter(Boolean);
+  const files = [];
+  for (let index = 0; index < entries.length; ) {
+    const status2 = entries[index++] ?? "M";
+    const renamed = status2.startsWith("R") || status2.startsWith("C");
+    const first = entries[index++] ?? "";
+    const second = renamed ? entries[index++] ?? "" : null;
+    const path = second ?? first;
+    if (!path) continue;
+    files.push({
+      path,
+      previousPath: renamed ? first : null,
+      changeType: status2[0] ?? "M"
+    });
+  }
+  return files;
+}
+async function diffFiles(folder, range, timeoutMs, signal) {
+  const [status2, counts2] = await Promise.all([
+    git2(folder, ["diff", "--name-status", "-z", range], timeoutMs, signal),
+    git2(folder, ["diff", "--numstat", "-z", range], timeoutMs, signal)
+  ]);
+  requireSuccess2(status2, "Could not inspect changed files");
+  requireSuccess2(counts2, "Could not inspect changed line counts");
+  const numstat = parseNumstat(counts2.stdout);
+  return parseNameStatus(status2.stdout).map((file) => {
+    const [additions, deletions] = numstat.get(file.path) ?? [null, null];
+    return {
+      ...file,
+      additions,
+      deletions,
+      binary: additions === null && deletions === null,
+      image: imagePath(file.path)
+    };
+  });
+}
+async function inspectBranchChanges(folder, baseBranch, timeoutMs, signal) {
+  const mergeBase = requireSuccess2(
+    await git2(
+      folder,
+      ["merge-base", `refs/remotes/origin/${baseBranch}`, "HEAD"],
+      timeoutMs,
+      signal
+    ),
+    "Could not determine the base-branch merge base"
+  ).stdout.trim();
+  const files = await diffFiles(
+    folder,
+    `${mergeBase}..HEAD`,
+    timeoutMs,
+    signal
+  );
+  return { changes: files.slice(0, 500), truncated: files.length > 500 };
+}
 async function inspectCommits(folder, baseBranch, timeoutMs, signal) {
   const result = requireSuccess2(
     await git2(
@@ -5143,17 +5337,441 @@ async function inspectCommits(folder, baseBranch, timeoutMs, signal) {
   return { commits: commits.slice(0, 100), truncated: commits.length > 100 };
 }
 async function inspectWorktreeDetail(folder, baseBranch, timeoutMs, signal) {
-  const [commitResult, changeResult] = await Promise.all([
+  const [commitResult, changeResult, branchResult] = await Promise.all([
     inspectCommits(folder, baseBranch, timeoutMs, signal),
-    inspectChanges(folder, timeoutMs, signal)
+    inspectChanges(folder, timeoutMs, signal),
+    inspectBranchChanges(folder, baseBranch, timeoutMs, signal)
   ]);
   return {
     commits: commitResult.commits,
     changes: changeResult.changes,
+    branchChanges: branchResult.changes,
     commitsTruncated: commitResult.truncated,
-    changesTruncated: changeResult.truncated
+    changesTruncated: changeResult.truncated,
+    branchChangesTruncated: branchResult.truncated
   };
 }
+async function baseMergeCommit(folder, baseBranch, timeoutMs, signal) {
+  return requireSuccess2(
+    await git2(
+      folder,
+      ["merge-base", `refs/remotes/origin/${baseBranch}`, "HEAD"],
+      timeoutMs,
+      signal
+    ),
+    "Could not determine the base-branch merge base"
+  ).stdout.trim();
+}
+async function validateDisplayedCommit(folder, baseBranch, commitSha, timeoutMs, signal) {
+  if (!/^[0-9a-f]{7,64}$/i.test(commitSha)) {
+    throw new Error("Commit SHA is invalid");
+  }
+  const base = await baseMergeCommit(folder, baseBranch, timeoutMs, signal);
+  const [afterBase, beforeHead] = await Promise.all([
+    git2(
+      folder,
+      ["merge-base", "--is-ancestor", base, commitSha],
+      timeoutMs,
+      signal
+    ),
+    git2(
+      folder,
+      ["merge-base", "--is-ancestor", commitSha, "HEAD"],
+      timeoutMs,
+      signal
+    )
+  ]);
+  if (afterBase.exitCode !== 0 || beforeHead.exitCode !== 0) {
+    throw new Error("Commit is outside the displayed branch history");
+  }
+}
+async function parentCommit(folder, commitSha, timeoutMs, signal) {
+  const result = await git2(
+    folder,
+    ["rev-parse", `${commitSha}^`],
+    timeoutMs,
+    signal
+  );
+  return result.exitCode === 0 ? result.stdout.trim() : null;
+}
+async function gitObjectExists(folder, specification, timeoutMs, signal) {
+  return (await git2(folder, ["cat-file", "-e", specification], timeoutMs, signal)).exitCode === 0;
+}
+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 = join5(folder, path);
+  if (input.scope === "UNTRACKED") {
+    return { before: null, after: { kind: "FILE", path: currentPath } };
+  }
+  if (input.scope === "STAGED") {
+    return {
+      before: { kind: "GIT", specification: `HEAD:${previousPath}` },
+      after: { kind: "GIT", specification: `:${path}` }
+    };
+  }
+  if (input.scope === "UNSTAGED") {
+    return {
+      before: { kind: "GIT", specification: `:${path}` },
+      after: { kind: "FILE", path: currentPath }
+    };
+  }
+  if (input.scope === "COMMIT") {
+    const commitSha = input.commitSha;
+    await validateDisplayedCommit(
+      folder,
+      input.baseBranch,
+      commitSha,
+      timeoutMs,
+      signal
+    );
+    const parent = await parentCommit(folder, commitSha, timeoutMs, signal);
+    return {
+      before: parent ? { kind: "GIT", specification: `${parent}:${previousPath}` } : null,
+      after: { kind: "GIT", specification: `${commitSha}:${path}` }
+    };
+  }
+  const base = await baseMergeCommit(
+    folder,
+    input.baseBranch,
+    timeoutMs,
+    signal
+  );
+  return {
+    before: { kind: "GIT", specification: `${base}:${previousPath}` },
+    after: { kind: "GIT", specification: `HEAD:${path}` }
+  };
+}
+function requestedDiffPaths(input) {
+  if (!input.path) return [];
+  if (input.previousPath && ["STAGED", "COMMIT", "BRANCH"].includes(input.scope)) {
+    return [input.previousPath, input.path];
+  }
+  return [input.path];
+}
+async function readBoundedFile(path, limit) {
+  const file = await open(path, "r");
+  try {
+    const metadata = await file.stat();
+    if (!metadata.isFile()) throw new Error("Changed path is not a file");
+    if (metadata.size > limit) {
+      return { contents: Buffer.alloc(0), oversized: true };
+    }
+    const buffer = Buffer.allocUnsafe(limit + 1);
+    let length = 0;
+    while (length < buffer.length) {
+      const { bytesRead } = await file.read(
+        buffer,
+        length,
+        buffer.length - length,
+        length
+      );
+      if (bytesRead === 0) break;
+      length += bytesRead;
+    }
+    return {
+      contents: buffer.subarray(0, Math.min(length, limit)),
+      oversized: length > limit
+    };
+  } finally {
+    await file.close();
+  }
+}
+async function availableSide(side, folder, timeoutMs, signal) {
+  if (!side) return false;
+  if (side.kind === "GIT") {
+    return gitObjectExists(folder, side.specification, timeoutMs, signal);
+  }
+  try {
+    const resolved = await realpath4(side.path);
+    const difference = relative3(folder, resolved);
+    return difference !== ".." && !difference.startsWith("../") && (await stat4(resolved)).isFile();
+  } catch {
+    return false;
+  }
+}
+async function inspectRequestedDiff(input, folder, timeoutMs, signal) {
+  if (!input.path) {
+    if (input.scope === "COMMIT") {
+      await validateDisplayedCommit(
+        folder,
+        input.baseBranch,
+        input.commitSha,
+        timeoutMs,
+        signal
+      );
+      const parent = await parentCommit(
+        folder,
+        input.commitSha,
+        timeoutMs,
+        signal
+      );
+      const files = await diffFiles(
+        folder,
+        parent ? `${parent}..${input.commitSha}` : input.commitSha,
+        timeoutMs,
+        signal
+      );
+      return { files: files.slice(0, 500), truncated: files.length > 500 };
+    }
+    if (input.scope === "BRANCH") {
+      const result = await inspectBranchChanges(
+        folder,
+        input.baseBranch,
+        timeoutMs,
+        signal
+      );
+      return { files: result.changes, truncated: result.truncated };
+    }
+    throw new Error("A file path is required for this diff scope");
+  }
+  if (input.scope === "COMMIT") {
+    await validateDisplayedCommit(
+      folder,
+      input.baseBranch,
+      input.commitSha,
+      timeoutMs,
+      signal
+    );
+  }
+  await validateChangedPath(input, folder, timeoutMs, signal);
+  const args = ["diff", "--no-color", "--no-ext-diff", "--unified=3"];
+  let oversized = false;
+  if (input.scope === "STAGED") args.push("--cached");
+  if (input.scope === "COMMIT") {
+    const parent = await parentCommit(
+      folder,
+      input.commitSha,
+      timeoutMs,
+      signal
+    );
+    args.push(parent ?? `${input.commitSha}^`, input.commitSha);
+  } else if (input.scope === "BRANCH") {
+    args.push(
+      await baseMergeCommit(folder, input.baseBranch, timeoutMs, signal),
+      "HEAD"
+    );
+  }
+  args.push("--", ...requestedDiffPaths(input));
+  let patch;
+  if (input.scope === "UNTRACKED") {
+    const bounded = await readBoundedFile(
+      join5(folder, input.path),
+      MAX_DIFF_BYTES
+    );
+    const contents = bounded.contents;
+    if (bounded.oversized || contents.includes(0)) {
+      oversized = bounded.oversized;
+      patch = "";
+    } else {
+      patch = [
+        `diff --git a/${input.path} b/${input.path}`,
+        "new file mode 100644",
+        "--- /dev/null",
+        `+++ b/${input.path}`,
+        ...contents.toString("utf8").split("\n").map((line) => `+${line}`)
+      ].join("\n");
+    }
+  } else {
+    patch = requireSuccess2(
+      await git2(folder, args, timeoutMs, signal),
+      "Could not load the file diff"
+    ).stdout;
+  }
+  const sides = await comparisonSides(input, folder, timeoutMs, signal);
+  const [beforeAvailable, afterAvailable] = await Promise.all([
+    availableSide(sides.before, folder, timeoutMs, signal),
+    availableSide(sides.after, folder, timeoutMs, signal)
+  ]);
+  return {
+    files: [],
+    patch,
+    image: imagePath(input.path),
+    binary: !patch && !imagePath(input.path) && !oversized,
+    truncated: oversized || Buffer.byteLength(patch) >= MAX_DIFF_BYTES,
+    beforeAvailable,
+    afterAvailable
+  };
+}
+async function validateChangedPath(input, folder, timeoutMs, signal) {
+  if (!input.path) throw new Error("A changed file path is required");
+  let result;
+  if (input.scope === "UNTRACKED") {
+    result = await git2(
+      folder,
+      ["ls-files", "--others", "--exclude-standard", "-z", "--", input.path],
+      timeoutMs,
+      signal
+    );
+  } else {
+    const args = ["diff", "--name-status", "-z"];
+    if (input.scope === "STAGED") args.push("--cached");
+    if (input.scope === "COMMIT") {
+      await validateDisplayedCommit(
+        folder,
+        input.baseBranch,
+        input.commitSha,
+        timeoutMs,
+        signal
+      );
+      const parent = await parentCommit(
+        folder,
+        input.commitSha,
+        timeoutMs,
+        signal
+      );
+      args.push(parent ?? `${input.commitSha}^`, input.commitSha);
+    } else if (input.scope === "BRANCH") {
+      args.push(
+        await baseMergeCommit(folder, input.baseBranch, timeoutMs, signal),
+        "HEAD"
+      );
+    }
+    args.push("--", ...requestedDiffPaths(input));
+    result = await git2(folder, args, timeoutMs, signal);
+  }
+  requireSuccess2(result, "Could not validate the changed file");
+  const requested = input.scope === "UNTRACKED" ? result.stdout.split("\0").filter(Boolean).includes(input.path) : parseNameStatus(result.stdout).some(
+    (file) => file.path === input.path && (!input.previousPath || file.previousPath === input.previousPath)
+  );
+  if (!requested) {
+    throw new Error("The requested file is outside the displayed diff");
+  }
+}
+var inspectWorktreeDiff = async (payload, timeoutMs, signal) => {
+  const input = worktreeDiffPayload(payload);
+  const folder = await validateWorktree(input, timeoutMs, signal);
+  return {
+    ...successfulProcess4,
+    diff: await inspectRequestedDiff(input, folder, timeoutMs, signal)
+  };
+};
+function imageContentType(path) {
+  const extension = path.slice(path.lastIndexOf(".")).toLocaleLowerCase();
+  return {
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+    ".avif": "image/avif",
+    ".bmp": "image/bmp"
+  }[extension] ?? "application/octet-stream";
+}
+async function writeGitObject(folder, specification, destination, timeoutMs, signal) {
+  await new Promise((resolvePromise, rejectPromise) => {
+    const child = spawn4(
+      "git",
+      ["-C", folder, "cat-file", "blob", specification],
+      { stdio: ["ignore", "pipe", "pipe"] }
+    );
+    const output = createWriteStream(destination, { mode: 384 });
+    let stderr = "";
+    let settled = false;
+    const fail = (error) => {
+      if (settled) return;
+      settled = true;
+      rejectPromise(error instanceof Error ? error : new Error(String(error)));
+    };
+    child.stderr.on("data", (chunk) => {
+      stderr = `${stderr}${String(chunk)}`.slice(0, 4e3);
+    });
+    child.stdout.pipe(output);
+    child.once("error", fail);
+    output.once("error", fail);
+    const terminate = () => child.kill("SIGTERM");
+    const timer = setTimeout(() => {
+      terminate();
+      fail(new Error("Image extraction timed out"));
+    }, timeoutMs);
+    timer.unref();
+    const abort = () => {
+      terminate();
+      fail(new Error("Image extraction was cancelled"));
+    };
+    signal.addEventListener("abort", abort, { once: true });
+    child.once("close", (code) => {
+      clearTimeout(timer);
+      signal.removeEventListener("abort", abort);
+      if (settled) return;
+      if (code !== 0) {
+        fail(new Error(cleanError2(stderr || "Could not extract image")));
+        return;
+      }
+      output.end(() => {
+        if (settled) return;
+        settled = true;
+        resolvePromise();
+      });
+    });
+  });
+}
+var downloadWorktreeDiffAsset = async (payload, timeoutMs, signal, _onLog, context) => {
+  const input = worktreeDiffPayload(payload);
+  if (!input.path || !input.uploadId || !input.side) {
+    throw new Error("Diff image path, side, and upload ID are required");
+  }
+  if (!imagePath(input.path)) throw new Error("Diff asset is not an image");
+  if (!context?.uploadBuildArtifact) {
+    throw new Error("This agent cannot upload diff images");
+  }
+  const folder = await validateWorktree(input, timeoutMs, signal);
+  await validateChangedPath(input, folder, timeoutMs, signal);
+  const sides = await comparisonSides(input, folder, timeoutMs, signal);
+  const selected = input.side === "BEFORE" ? sides.before : sides.after;
+  if (!selected || !await availableSide(selected, folder, timeoutMs, signal)) {
+    throw new Error("The requested image side is unavailable");
+  }
+  let uploadPath;
+  let temporaryDirectory = null;
+  try {
+    if (selected.kind === "FILE") {
+      uploadPath = await realpath4(selected.path);
+      const difference = relative3(folder, uploadPath);
+      if (difference === ".." || difference.startsWith("../")) {
+        throw new Error("Diff image resolves outside the worktree");
+      }
+    } else {
+      const size = requireSuccess2(
+        await git2(
+          folder,
+          ["cat-file", "-s", selected.specification],
+          timeoutMs,
+          signal
+        ),
+        "Could not inspect diff image"
+      ).stdout.trim();
+      if (!/^\d+$/.test(size) || Number(size) > 20 * 1024 * 1024) {
+        throw new Error("Diff image exceeds the 20 MiB limit");
+      }
+      temporaryDirectory = await mkdtemp(join5(tmpdir(), "ade-diff-image-"));
+      uploadPath = join5(temporaryDirectory, basename2(input.path));
+      await writeGitObject(
+        folder,
+        selected.specification,
+        uploadPath,
+        timeoutMs,
+        signal
+      );
+    }
+    const information = await stat4(uploadPath);
+    if (!information.isFile() || information.size > 20 * 1024 * 1024) {
+      throw new Error("Diff image exceeds the 20 MiB limit");
+    }
+    await context.uploadBuildArtifact({
+      uploadId: input.uploadId,
+      path: uploadPath,
+      filename: basename2(input.path),
+      contentType: imageContentType(input.path)
+    });
+    return successfulProcess4;
+  } finally {
+    if (temporaryDirectory) {
+      await rm3(temporaryDirectory, { recursive: true, force: true });
+    }
+  }
+};
 var watchWorktree = async (payload, timeoutMs, signal, _onLog, context) => {
   const input = worktreeWatchJobPayload(payload);
   const current = activeWorktreeWatches.get(input.gitDirectory);
@@ -5955,16 +6573,18 @@ import { createHash as createHash3, randomUUID as randomUUID2 } from "node:crypt
 import {
   cp,
   mkdir as mkdir3,
-  mkdtemp,
+  mkdtemp as mkdtemp2,
+  open as open2,
   readdir as readdir4,
   readFile as readFile4,
   realpath as realpath5,
-  rm as rm3,
+  rename as rename3,
+  rm as rm4,
   stat as stat5,
   writeFile as writeFile3
 } from "node:fs/promises";
-import { createWriteStream } from "node:fs";
-import { tmpdir } from "node:os";
+import { createWriteStream as createWriteStream2 } from "node:fs";
+import { tmpdir as tmpdir2 } from "node:os";
 import {
   basename as basename3,
   dirname as dirname6,
@@ -5974,7 +6594,7 @@ import {
   resolve as resolve5,
   sep as sep3
 } from "node:path";
-import { spawn as spawn4 } from "node:child_process";
+import { spawn as spawn5 } from "node:child_process";
 var successfulProcess5 = {
   exitCode: 0,
   signal: null,
@@ -6005,6 +6625,22 @@ function command2(executable, args, timeoutMs, signal, cwd, env = process.env) {
     env
   });
 }
+async function commandToFile(executable, args, timeoutMs, signal, cwd, env, destination) {
+  const output = await open2(destination, "wx", 384);
+  try {
+    return await captureCommand({
+      command: executable,
+      args,
+      timeoutMs,
+      signal,
+      cwd,
+      env,
+      stdoutFileDescriptor: output.fd
+    });
+  } finally {
+    await output.close();
+  }
+}
 function requireSuccess3(result, fallback) {
   if (result.cancelled) throw new Error("Operation was cancelled");
   if (result.timedOut) throw new Error("Operation timed out");
@@ -6393,7 +7029,7 @@ function genericBuildDestinations(action) {
   ];
 }
 async function listPhysicalDevices(timeoutMs, signal) {
-  const directory = await mkdtemp(join6(tmpdir(), "ade-devices-"));
+  const directory = await mkdtemp2(join6(tmpdir2(), "ade-devices-"));
   const output = join6(directory, "devices.json");
   try {
     const result = await command2(
@@ -6414,7 +7050,7 @@ async function listPhysicalDevices(timeoutMs, signal) {
     if (result.exitCode !== 0) return [];
     return physicalDestinations(JSON.parse(await readFile4(output, "utf8")));
   } finally {
-    await rm3(directory, { recursive: true, force: true });
+    await rm4(directory, { recursive: true, force: true });
   }
 }
 var inspectBuildDestinations = async (payload, timeoutMs, signal) => {
@@ -6505,7 +7141,7 @@ var BuildLogger = class {
   constructor(buildId, context, rawLogPath, env) {
     this.buildId = buildId;
     this.context = context;
-    this.stream = createWriteStream(rawLogPath, { flags: "a", mode: 384 });
+    this.stream = createWriteStream2(rawLogPath, { flags: "a", mode: 384 });
     this.redact = createRedactor(env);
   }
   buildId;
@@ -6595,12 +7231,12 @@ function runLoggedCommand(options) {
     let killTimer = null;
     let extraStream;
     if (options.additionalLogPath) {
-      extraStream = createWriteStream(options.additionalLogPath, {
+      extraStream = createWriteStream2(options.additionalLogPath, {
         flags: "a",
         mode: 384
       });
     }
-    const child = spawn4(options.command, options.args, {
+    const child = spawn5(options.command, options.args, {
       cwd: options.cwd,
       env: options.env,
       shell: false,
@@ -6999,6 +7635,392 @@ async function artifact(root, kind, path, metadata = {}) {
     metadata
   };
 }
+function jsonObject(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function testDetails(node) {
+  const own = typeof node.details === "string" && node.details.trim() ? [node.details.trim()] : typeof node.name === "string" && ["Failure Message", "Runtime Warning"].includes(String(node.nodeType)) ? [node.name] : [];
+  const children = Array.isArray(node.children) ? node.children : [];
+  return [
+    ...own,
+    ...children.flatMap((child) => {
+      const object = jsonObject(child);
+      return object ? testDetails(object) : [];
+    })
+  ];
+}
+function testSourceFile(node, suite) {
+  const explicit = [
+    node.filePath,
+    node.sourceFilePath,
+    node.fileName,
+    node.sourceFile
+  ].find((value) => typeof value === "string" && !!value);
+  if (explicit) {
+    return { file: basename3(explicit), filePath: explicit };
+  }
+  const identifier = typeof node.nodeIdentifier === "string" ? node.nodeIdentifier : "";
+  const identifierOwner = identifier.split("/")[0]?.trim();
+  return {
+    file: identifierOwner || suite,
+    filePath: null
+  };
+}
+function normalizeTestResults(value) {
+  const root = jsonObject(value);
+  if (!root || !Array.isArray(root.testNodes)) {
+    throw new Error("xcresulttool returned invalid test results JSON");
+  }
+  const tests = [];
+  const visit = (raw, context) => {
+    const node = jsonObject(raw);
+    if (!node) return;
+    const nodeType = typeof node.nodeType === "string" ? node.nodeType : "";
+    const name = typeof node.name === "string" ? node.name : "";
+    const next = {
+      plan: nodeType === "Test Plan" ? name : context.plan,
+      configuration: nodeType === "Test Plan Configuration" ? name : context.configuration,
+      bundle: /test bundle$/.test(nodeType) ? name : context.bundle,
+      suite: nodeType === "Test Suite" ? name : context.suite
+    };
+    if (nodeType === "Test Case") {
+      const result = typeof node.result === "string" ? node.result : "unknown";
+      const sourceFile = testSourceFile(node, next.suite);
+      tests.push({
+        identifier: typeof node.nodeIdentifier === "string" ? node.nodeIdentifier : name,
+        name,
+        ...next,
+        ...sourceFile,
+        result,
+        durationSeconds: typeof node.durationInSeconds === "number" ? node.durationInSeconds : null,
+        tags: Array.isArray(node.tags) ? node.tags.filter((tag) => typeof tag === "string") : [],
+        details: [...new Set(testDetails(node))]
+      });
+    }
+    if (Array.isArray(node.children)) {
+      for (const child of node.children) visit(child, next);
+    }
+  };
+  for (const node of root.testNodes) {
+    visit(node, {
+      plan: null,
+      configuration: null,
+      bundle: null,
+      suite: null
+    });
+  }
+  const count = (result) => tests.filter((test) => test.result === result).length;
+  return {
+    summary: {
+      total: tests.length,
+      passed: count("Passed"),
+      failed: count("Failed"),
+      skipped: count("Skipped"),
+      expectedFailures: count("Expected Failure"),
+      unknown: tests.filter(
+        (test) => !["Passed", "Failed", "Skipped", "Expected Failure"].includes(
+          String(test.result)
+        )
+      ).length,
+      durationSeconds: tests.reduce(
+        (total, test) => total + Number(test.durationSeconds ?? 0),
+        0
+      )
+    },
+    data: {
+      devices: Array.isArray(root.devices) ? root.devices : [],
+      configurations: Array.isArray(root.testPlanConfigurations) ? root.testPlanConfigurations : [],
+      tests
+    }
+  };
+}
+function normalizeCoverage(value) {
+  const root = jsonObject(value);
+  if (!root || !Array.isArray(root.targets)) {
+    throw new Error("xccov returned invalid coverage JSON");
+  }
+  const files = root.targets.flatMap((rawTarget) => {
+    const target2 = jsonObject(rawTarget);
+    if (!target2 || !Array.isArray(target2.files)) return [];
+    const targetName = typeof target2.name === "string" ? target2.name : "";
+    return target2.files.flatMap((rawFile) => {
+      const file = jsonObject(rawFile);
+      if (!file) return [];
+      return [
+        {
+          target: targetName,
+          name: typeof file.name === "string" ? file.name : "",
+          path: typeof file.path === "string" ? file.path : "",
+          coveredLines: typeof file.coveredLines === "number" ? file.coveredLines : 0,
+          executableLines: typeof file.executableLines === "number" ? file.executableLines : 0,
+          lineCoverage: typeof file.lineCoverage === "number" ? file.lineCoverage : 0
+        }
+      ];
+    });
+  });
+  return {
+    summary: {
+      coveredLines: typeof root.coveredLines === "number" ? root.coveredLines : 0,
+      executableLines: typeof root.executableLines === "number" ? root.executableLines : 0,
+      lineCoverage: typeof root.lineCoverage === "number" ? root.lineCoverage : 0,
+      targetCount: root.targets.length,
+      fileCount: files.length
+    },
+    data: { files }
+  };
+}
+async function writeJsonReport(input, kind, timeoutMs, signal) {
+  const resultBundle = join6(input.artifactDirectory, "result.xcresult");
+  const filename = kind === "TEST_RESULTS" ? "test-results.json" : "code-coverage.json";
+  const destination = join6(input.artifactDirectory, filename);
+  const temporary = `${destination}.tmp-${randomUUID2()}`;
+  try {
+    if (!await pathExists(resultBundle)) {
+      throw new Error("The build result bundle is unavailable");
+    }
+    const args = kind === "TEST_RESULTS" ? [
+      "xcresulttool",
+      "get",
+      "test-results",
+      "tests",
+      "--path",
+      "result.xcresult",
+      "--format",
+      "json"
+    ] : ["xccov", "view", "--report", "--json", "result.xcresult"];
+    requireSuccess3(
+      await commandToFile(
+        "xcrun",
+        args,
+        timeoutMs,
+        signal,
+        input.artifactDirectory,
+        xcodeEnvironment(),
+        temporary
+      ),
+      `Could not generate ${filename}`
+    );
+    const serialized = await readFile4(temporary, "utf8");
+    const parsed = JSON.parse(serialized);
+    const normalized = kind === "TEST_RESULTS" ? normalizeTestResults(parsed) : normalizeCoverage(parsed);
+    await rename3(temporary, destination);
+    return {
+      kind,
+      status: "READY",
+      artifact: await artifact(
+        input.artifactDirectory,
+        kind === "TEST_RESULTS" ? "TEST_RESULTS_JSON" : "CODE_COVERAGE_JSON",
+        destination
+      ),
+      ...normalized,
+      error: null
+    };
+  } catch (error) {
+    await rm4(temporary, { force: true });
+    return {
+      kind,
+      status: "FAILED",
+      artifact: null,
+      summary: {},
+      data: {},
+      error: cleanError3(error)
+    };
+  }
+}
+async function gitCommand(folder, args, timeoutMs, signal) {
+  return command2("git", ["-C", folder, ...args], timeoutMs, signal, void 0, {
+    ...process.env,
+    GIT_TERMINAL_PROMPT: "0",
+    GIT_OPTIONAL_LOCKS: "0"
+  });
+}
+function changedLinesFromPatch(value) {
+  const result = /* @__PURE__ */ new Map();
+  let path = null;
+  for (const line of value.split("\n")) {
+    if (line.startsWith("+++ ")) {
+      const raw = line.slice(4);
+      path = raw === "/dev/null" ? null : raw.replace(/^b\//, "");
+      if (path && !result.has(path)) result.set(path, /* @__PURE__ */ new Set());
+      continue;
+    }
+    if (!path || !line.startsWith("@@")) continue;
+    const match = /\+(\d+)(?:,(\d+))?/.exec(line);
+    if (!match) continue;
+    const start = Number(match[1]);
+    const count = match[2] === void 0 ? 1 : Number(match[2]);
+    const lines = result.get(path);
+    for (let number = start; number < start + count; number += 1) {
+      lines.add(number);
+    }
+  }
+  return result;
+}
+function changeTypesFromStatus(value) {
+  const entries = value.split("\0").filter(Boolean);
+  const result = /* @__PURE__ */ new Map();
+  for (let index = 0; index < entries.length; ) {
+    const status2 = entries[index++] ?? "M";
+    const renamed = status2.startsWith("R") || status2.startsWith("C");
+    const first = entries[index++] ?? "";
+    const second = renamed ? entries[index++] ?? "" : null;
+    const path = second ?? first;
+    if (path) result.set(path, status2[0] ?? "M");
+  }
+  return result;
+}
+async function snapshotCoverageChanges(input, folder, timeoutMs, signal) {
+  if (!input.baseBranch) throw new Error("A base branch is required");
+  const base = requireSuccess3(
+    await gitCommand(
+      folder,
+      ["merge-base", `refs/remotes/origin/${input.baseBranch}`, "HEAD"],
+      timeoutMs,
+      signal
+    ),
+    "Could not determine the coverage merge base"
+  ).stdout.trim();
+  const [patch, status2, untracked] = await Promise.all([
+    gitCommand(
+      folder,
+      ["diff", "--no-color", "--unified=0", base, "--"],
+      timeoutMs,
+      signal
+    ),
+    gitCommand(
+      folder,
+      ["diff", "--name-status", "-z", base, "--"],
+      timeoutMs,
+      signal
+    ),
+    gitCommand(
+      folder,
+      ["ls-files", "--others", "--exclude-standard", "-z"],
+      timeoutMs,
+      signal
+    )
+  ]);
+  requireSuccess3(patch, "Could not inspect changed coverage lines");
+  requireSuccess3(status2, "Could not inspect coverage change types");
+  requireSuccess3(untracked, "Could not inspect untracked coverage files");
+  const lines = changedLinesFromPatch(patch.stdout);
+  const types = changeTypesFromStatus(status2.stdout);
+  for (const path of untracked.stdout.split("\0").filter(Boolean)) {
+    try {
+      const contents = await readFile4(join6(folder, path));
+      if (contents.includes(0)) continue;
+      const lineCount = contents.length ? contents.toString("utf8").split("\n").length - (contents.toString("utf8").endsWith("\n") ? 1 : 0) : 0;
+      lines.set(
+        path,
+        new Set(Array.from({ length: lineCount }, (_, index) => index + 1))
+      );
+      types.set(path, "A");
+    } catch {
+    }
+  }
+  return [.../* @__PURE__ */ new Set([...lines.keys(), ...types.keys()])].map((path) => ({
+    path,
+    changeType: types.get(path) ?? "M",
+    lines: [...lines.get(path) ?? []].sort((a, b) => a - b)
+  }));
+}
+async function addChangedCoverage(report, changes, input, folder, timeoutMs, signal) {
+  if (report.status !== "READY") return report;
+  const rawFiles = Array.isArray(report.data.files) ? report.data.files : [];
+  const coveragePaths = rawFiles.flatMap((raw) => {
+    const file = jsonObject(raw);
+    return file && typeof file.path === "string" ? [file.path] : [];
+  });
+  const changedFiles = [];
+  let changedCoveredLines = 0;
+  let changedExecutableLines = 0;
+  for (const change of changes) {
+    const coveragePath = coveragePaths.find(
+      (candidate) => relative4(folder, candidate).split(sep3).join("/") === change.path
+    );
+    let covered = 0;
+    let executable = 0;
+    if (coveragePath && change.lines.length) {
+      const temporary2 = join6(
+        input.artifactDirectory,
+        `.changed-coverage-${randomUUID2()}.json`
+      );
+      try {
+        const result = await commandToFile(
+          "xcrun",
+          [
+            "xccov",
+            "view",
+            "--archive",
+            "--file",
+            coveragePath,
+            "--json",
+            "result.xcresult"
+          ],
+          timeoutMs,
+          signal,
+          input.artifactDirectory,
+          xcodeEnvironment(),
+          temporary2
+        );
+        if (result.exitCode === 0 && !result.cancelled && !result.timedOut) {
+          const parsed = jsonObject(
+            JSON.parse(await readFile4(temporary2, "utf8"))
+          );
+          const lineData = parsed?.[coveragePath];
+          if (Array.isArray(lineData)) {
+            const changed = new Set(change.lines);
+            for (const rawLine of lineData) {
+              const line = jsonObject(rawLine);
+              if (line?.isExecutable === true && typeof line.line === "number" && changed.has(line.line)) {
+                executable += 1;
+                if (typeof line.executionCount === "number" && line.executionCount > 0) {
+                  covered += 1;
+                }
+              }
+            }
+          }
+        }
+      } finally {
+        await rm4(temporary2, { force: true });
+      }
+    }
+    changedCoveredLines += covered;
+    changedExecutableLines += executable;
+    changedFiles.push({
+      path: change.path,
+      changeType: change.changeType,
+      changedCoveredLines: covered,
+      changedExecutableLines: executable,
+      changedLineCoverage: executable ? covered / executable : null
+    });
+  }
+  const summary = {
+    ...report.summary,
+    changedCoveredLines,
+    changedExecutableLines,
+    changedLineCoverage: changedExecutableLines ? changedCoveredLines / changedExecutableLines : null
+  };
+  const data = { ...report.data, changedFiles };
+  const destination = join6(input.artifactDirectory, "worktree-coverage.json");
+  const temporary = `${destination}.tmp-${randomUUID2()}`;
+  await writeFile3(temporary, JSON.stringify({ summary, data }, null, 2), {
+    mode: 384
+  });
+  await rename3(temporary, destination);
+  return {
+    ...report,
+    summary,
+    data,
+    additionalArtifacts: [
+      await artifact(
+        input.artifactDirectory,
+        "WORKTREE_COVERAGE_JSON",
+        destination
+      )
+    ]
+  };
+}
 function parseBuildSettings(value) {
   const parsed = JSON.parse(value);
   if (!Array.isArray(parsed)) return [];
@@ -7042,14 +8064,35 @@ async function findFiles(root, predicate, limit = 20) {
   }
   return results;
 }
-async function captureArtifacts(input, folder, signal) {
+async function captureArtifacts(input, folder, signal, includeProducts = true) {
   const artifacts = [];
   const resultBundle = join6(input.artifactDirectory, "result.xcresult");
   if (await pathExists(resultBundle)) {
+    const coverageProbe = await command2(
+      "xcrun",
+      [
+        "xccov",
+        "view",
+        "--report",
+        "--only-targets",
+        "--json",
+        "result.xcresult"
+      ],
+      3e4,
+      new AbortController().signal,
+      input.artifactDirectory,
+      xcodeEnvironment()
+    );
     artifacts.push(
-      await artifact(input.artifactDirectory, "RESULT_BUNDLE", resultBundle)
+      await artifact(input.artifactDirectory, "RESULT_BUNDLE", resultBundle, {
+        testResultsAvailable: ["TEST", "TEST_WITHOUT_BUILDING"].includes(
+          input.action
+        ),
+        coverageAvailable: coverageProbe.exitCode === 0
+      })
     );
   }
+  if (!includeProducts) return artifacts;
   const archivePath = join6(input.artifactDirectory, "archive.xcarchive");
   if (await pathExists(archivePath)) {
     artifacts.push(
@@ -7078,7 +8121,7 @@ async function captureArtifacts(input, folder, signal) {
       const productDirectory = join6(input.artifactDirectory, "products");
       const destination = join6(productDirectory, basename3(source));
       await mkdir3(productDirectory, { recursive: true, mode: 448 });
-      await rm3(destination, { recursive: true, force: true });
+      await rm4(destination, { recursive: true, force: true });
       await cp(source, destination, {
         recursive: true,
         preserveTimestamps: true
@@ -7165,6 +8208,7 @@ var runIosBuild = async (payload, timeoutMs, signal, onLog, context) => {
       configuration: input.configuration
     };
     let buildResult = null;
+    let coverageChanges = [];
     let errorCode = null;
     let error = null;
     let failBuild = false;
@@ -7222,6 +8266,18 @@ var runIosBuild = async (payload, timeoutMs, signal, onLog, context) => {
         } catch (progressError) {
           logger.emit("RUNNING", "SYSTEM", cleanError3(progressError));
         }
+        if (input.worktreeCoverage) {
+          try {
+            coverageChanges = await snapshotCoverageChanges(
+              input,
+              folder,
+              Math.min(timeoutMs, 6e4),
+              signal
+            );
+          } catch (coverageError) {
+            logger.emit("COVERAGE", "STDERR", cleanError3(coverageError));
+          }
+        }
         const args2 = xcodeBuildArguments(input);
         buildResult = await runLoggedCommand({
           command: "xcrun",
@@ -7281,12 +8337,55 @@ var runIosBuild = async (payload, timeoutMs, signal, onLog, context) => {
       }
     }
     let artifacts = [];
-    if (!failBuild && !signal.aborted && buildResult?.exitCode === 0) {
+    try {
+      artifacts = await captureArtifacts(
+        input,
+        folder,
+        new AbortController().signal,
+        !failBuild && !signal.aborted && buildResult?.exitCode === 0
+      );
+    } catch (artifactError) {
+      logger.emit("ARTIFACTS", "STDERR", cleanError3(artifactError));
+    }
+    const reports = [];
+    const testAction = ["TEST", "TEST_WITHOUT_BUILDING"].includes(input.action);
+    const canGenerateReports = () => !signal.aborted && buildResult?.cancelled !== true && buildResult?.timedOut !== true;
+    if (canGenerateReports() && testAction && input.advancedSettings.parseTestResults) {
+      const report = await writeJsonReport(
+        input,
+        "TEST_RESULTS",
+        Math.min(timeoutMs, 12e4),
+        signal
+      );
+      reports.push(report);
+      if (report.artifact) artifacts.push(report.artifact);
+      if (report.error) logger.emit("REPORTS", "STDERR", report.error);
+    }
+    if (canGenerateReports() && testAction && input.worktreeCoverage) {
+      let report = await writeJsonReport(
+        input,
+        "CODE_COVERAGE",
+        Math.min(timeoutMs, 12e4),
+        signal
+      );
       try {
-        artifacts = await captureArtifacts(input, folder, signal);
-      } catch (artifactError) {
-        logger.emit("ARTIFACTS", "STDERR", cleanError3(artifactError));
+        report = await addChangedCoverage(
+          report,
+          coverageChanges,
+          input,
+          folder,
+          Math.min(timeoutMs, 12e4),
+          signal
+        );
+      } catch (coverageError) {
+        logger.emit("COVERAGE", "STDERR", cleanError3(coverageError));
       }
+      reports.push(report);
+      if (report.artifact) artifacts.push(report.artifact);
+      if (report.additionalArtifacts) {
+        artifacts.push(...report.additionalArtifacts);
+      }
+      if (report.error) logger.emit("REPORTS", "STDERR", report.error);
     }
     await logger.close();
     if (await pathExists(rawLog)) {
@@ -7313,6 +8412,7 @@ var runIosBuild = async (payload, timeoutMs, signal, onLog, context) => {
       error,
       commandSummary: commandSummary("xcrun", args),
       artifacts,
+      reports,
       scriptExecutions,
       sourceStateHash,
       finalStateHash,
@@ -7322,10 +8422,34 @@ var runIosBuild = async (payload, timeoutMs, signal, onLog, context) => {
     await logger.close();
   }
 };
+var generateIosBuildReport = async (payload, timeoutMs, signal, onLog) => {
+  const input = parseBuildReportPayload(payload);
+  if (!isAbsolute4(input.artifactDirectory) || basename3(input.artifactDirectory) !== input.buildId) {
+    throw new Error("Build artifact directory is invalid");
+  }
+  if (signal.aborted) return { ...successfulProcess5, cancelled: true };
+  const report = await writeJsonReport(
+    input,
+    input.reportKind,
+    Math.min(timeoutMs, 18e4),
+    signal
+  );
+  await onLog({
+    sequence: 0,
+    stream: report.status === "READY" ? "SYSTEM" : "STDERR",
+    message: report.status === "READY" ? `Generated ${report.kind.toLocaleLowerCase()} report` : report.error || "Report generation failed",
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  return {
+    ...successfulProcess5,
+    report,
+    artifacts: report.artifact ? [report.artifact] : []
+  };
+};
 var deleteIosBuild = async (payload, _timeoutMs, signal, onLog) => {
   const input = parseBuildDeletePayload(payload);
   if (signal.aborted) return { ...successfulProcess5, cancelled: true };
-  await rm3(input.artifactDirectory, { recursive: true, force: true });
+  await rm4(input.artifactDirectory, { recursive: true, force: true });
   await onLog({
     sequence: 0,
     stream: "SYSTEM",
@@ -7355,7 +8479,7 @@ var downloadIosBuildArtifact = async (payload, timeoutMs, signal, onLog, context
   try {
     if (information.isDirectory()) {
       temporaryArchive = join6(
-        tmpdir(),
+        tmpdir2(),
         `ade-build-artifact-${randomUUID2()}.tar.gz`
       );
       requireSuccess3(
@@ -7388,7 +8512,7 @@ var downloadIosBuildArtifact = async (payload, timeoutMs, signal, onLog, context
     return successfulProcess5;
   } finally {
     if (temporaryArchive) {
-      await rm3(temporaryArchive, { force: true });
+      await rm4(temporaryArchive, { force: true });
     }
   }
 };
@@ -7730,6 +8854,8 @@ var handlers = {
   [WORKTREE_DELETE_JOB_KIND]: deleteWorktree,
   [WORKTREE_OPERATION_JOB_KIND]: operateWorktree,
   [WORKTREE_WATCH_JOB_KIND]: watchWorktree,
+  [WORKTREE_DIFF_JOB_KIND]: inspectWorktreeDiff,
+  [WORKTREE_DIFF_ASSET_JOB_KIND]: downloadWorktreeDiffAsset,
   [SKILL_SCAN_JOB_KIND]: scanSkills,
   [SKILL_READ_JOB_KIND]: readSkills,
   [SKILL_APPLY_JOB_KIND]: applySkills,
@@ -7741,7 +8867,9 @@ var handlers = {
   [IOS_BUILD_DELETE_JOB_KIND]: deleteIosBuild,
   [IOS_ARTIFACT_DOWNLOAD_JOB_KIND]: downloadIosBuildArtifact,
   [IOS_DEPLOY_JOB_KIND]: deployIosBuild,
-  [IOS_EXPORT_JOB_KIND]: exportIosArchive
+  [IOS_EXPORT_JOB_KIND]: exportIosArchive,
+  [IOS_TEST_RESULTS_JOB_KIND]: generateIosBuildReport,
+  [IOS_COVERAGE_REPORT_JOB_KIND]: generateIosBuildReport
 };
 
 // src/repository-coordinator.ts