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

package/dist/control-agent.js

@@ -269,8 +269,8 @@ function createClient(options) {
     retryWait = async function randomisedExponentialBackoff(retries2) {
       const retryDelaySeconds = Math.pow(2, retries2);
       await new Promise(
-        (resolve5) => setTimeout(
-          resolve5,
+        (resolve6) => setTimeout(
+          resolve6,
           retryDelaySeconds * 1e3 + // add random timeout from 300ms to 3s
           Math.floor(Math.random() * (3e3 - 300) + 300)
         )
@@ -506,7 +506,7 @@ function createClient(options) {
     if (socket.readyState === WebSocketImpl.CLOSING) await throwOnClose;
     let release2 = () => {
     };
-    const released = new Promise((resolve5) => release2 = resolve5);
+    const released = new Promise((resolve6) => release2 = resolve6);
     return [
       socket,
       release2,
@@ -669,7 +669,7 @@ function createClient(options) {
       const iterator = (async function* iterator2() {
         for (; ; ) {
           if (!pending.length) {
-            await new Promise((resolve5) => deferred.resolve = resolve5);
+            await new Promise((resolve6) => deferred.resolve = resolve6);
           }
           while (pending.length) {
             yield pending.shift();
@@ -960,7 +960,7 @@ function createAgentSubscriptionClient(config) {
     shouldRetry: () => true,
     retryWait: async (retries) => {
       const delay = Math.min(3e4, 1e3 * 2 ** Math.min(retries, 5));
-      await new Promise((resolve5) => setTimeout(resolve5, delay));
+      await new Promise((resolve6) => setTimeout(resolve6, delay));
     },
     on: {
       connected: () => console.log("Connected to control-plane WebSocket"),
@@ -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"
     ),
@@ -2756,7 +2872,7 @@ function collectInventory() {
 // src/process-runner.ts
 import { spawn } from "node:child_process";
 async function runProcess(options) {
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve6, reject) => {
     let sequence = 0;
     let timedOut = false;
     let cancelled = false;
@@ -2833,7 +2949,7 @@ async function runProcess(options) {
       clearTimeout(timeout);
       options.signal.removeEventListener("abort", abort);
       void logChain.then(
-        () => resolve5({ exitCode, signal, timedOut, cancelled })
+        () => resolve6({ exitCode, signal, timedOut, cancelled })
       );
     });
   });
@@ -2925,9 +3041,9 @@ 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((resolve5, reject) => {
+  return new Promise((resolve6, reject) => {
     let stdout = "";
     let stderr = "";
     let timedOut = false;
@@ -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 = () => {
@@ -2975,7 +3095,7 @@ function captureCommand(options) {
       settled = true;
       clearTimeout(timeout);
       options.signal.removeEventListener("abort", abort);
-      resolve5({
+      resolve6({
         exitCode,
         signal,
         timedOut,
@@ -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,204 @@ 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 { basename as basename2, dirname as dirname5, join as join5, relative as relative2 } from "node:path";
+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";
+import { createReadStream as createReadStream2 } from "node:fs";
+import { lstat as lstat3, readlink } from "node:fs/promises";
+import { isAbsolute as isAbsolute3, relative as relative2, resolve as resolve4, sep as sep2 } from "node:path";
+import { spawn as spawn3 } from "node:child_process";
+function gitEnvironment() {
+  return {
+    ...process.env,
+    GIT_TERMINAL_PROMPT: "0",
+    GIT_OPTIONAL_LOCKS: "0"
+  };
+}
+function remainingTimeoutMs(deadline) {
+  return Math.max(1, deadline - Date.now());
+}
+function containedPath(folder, path) {
+  const absolutePath = resolve4(folder, path);
+  const difference = relative2(folder, absolutePath);
+  if (!difference || difference === ".." || difference.startsWith(`..${sep2}`) || isAbsolute3(difference)) {
+    return null;
+  }
+  return absolutePath;
+}
+function hashGitDiff(hash, folder, timeoutMs, signal) {
+  return new Promise((resolveResult, reject) => {
+    let settled = false;
+    let timedOut = false;
+    const child = spawn3(
+      "git",
+      [
+        "-C",
+        folder,
+        "--no-optional-locks",
+        "diff",
+        "--binary",
+        "--no-ext-diff",
+        "--no-textconv",
+        "HEAD",
+        "--"
+      ],
+      {
+        env: gitEnvironment(),
+        shell: false,
+        stdio: ["ignore", "pipe", "pipe"]
+      }
+    );
+    child.stdout.on("data", (chunk) => hash.update(chunk));
+    child.stderr.resume();
+    const terminate = () => {
+      if (child.exitCode === null && !child.killed) child.kill("SIGTERM");
+    };
+    const timeout = setTimeout(() => {
+      timedOut = true;
+      terminate();
+    }, timeoutMs);
+    timeout.unref();
+    const abort = () => terminate();
+    signal.addEventListener("abort", abort, { once: true });
+    if (signal.aborted) abort();
+    child.once("error", (error) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+      signal.removeEventListener("abort", abort);
+      reject(error);
+    });
+    child.once("close", (exitCode) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+      signal.removeEventListener("abort", abort);
+      resolveResult(!timedOut && !signal.aborted && exitCode === 0);
+    });
+  });
+}
+async function worktreeCodeStateHash(folder, timeoutMs, signal) {
+  const deadline = Date.now() + timeoutMs;
+  const operation = new AbortController();
+  const abort = () => operation.abort(signal.reason);
+  signal.addEventListener("abort", abort, { once: true });
+  if (signal.aborted) abort();
+  const timeout = setTimeout(() => operation.abort(), Math.max(0, timeoutMs));
+  timeout.unref();
+  try {
+    operation.signal.throwIfAborted();
+    const [head, untracked, submodules] = await Promise.all([
+      captureCommand({
+        command: "git",
+        args: ["-C", folder, "rev-parse", "HEAD"],
+        timeoutMs: remainingTimeoutMs(deadline),
+        signal: operation.signal,
+        env: gitEnvironment()
+      }),
+      captureCommand({
+        command: "git",
+        args: [
+          "-C",
+          folder,
+          "--no-optional-locks",
+          "ls-files",
+          "--others",
+          "--exclude-standard",
+          "-z"
+        ],
+        timeoutMs: remainingTimeoutMs(deadline),
+        signal: operation.signal,
+        env: gitEnvironment()
+      }),
+      captureCommand({
+        command: "git",
+        args: [
+          "-C",
+          folder,
+          "--no-optional-locks",
+          "submodule",
+          "foreach",
+          "--quiet",
+          'printf "%s\\0" "$sm_path"'
+        ],
+        timeoutMs: remainingTimeoutMs(deadline),
+        signal: operation.signal,
+        env: gitEnvironment()
+      })
+    ]);
+    if (head.exitCode !== 0 || untracked.exitCode !== 0 || submodules.exitCode !== 0 || operation.signal.aborted) {
+      return null;
+    }
+    const hash = createHash2("sha256");
+    hash.update("head\0");
+    hash.update(head.stdout.trim());
+    hash.update("\0diff\0");
+    if (!await hashGitDiff(
+      hash,
+      folder,
+      remainingTimeoutMs(deadline),
+      operation.signal
+    )) {
+      return null;
+    }
+    hash.update("\0untracked\0");
+    const paths = untracked.stdout.split("\0").filter(Boolean).sort();
+    for (const path of paths) {
+      operation.signal.throwIfAborted();
+      const absolutePath = containedPath(folder, path);
+      if (!absolutePath) return null;
+      hash.update(path);
+      hash.update("\0");
+      const information = await lstat3(absolutePath);
+      operation.signal.throwIfAborted();
+      if (information.isSymbolicLink()) {
+        hash.update("symlink\0");
+        hash.update(await readlink(absolutePath));
+      } else if (information.isFile()) {
+        hash.update("file\0");
+        hash.update((information.mode & 511).toString(8).padStart(3, "0"));
+        hash.update("\0");
+        for await (const chunk of createReadStream2(absolutePath, {
+          signal: operation.signal
+        })) {
+          hash.update(chunk);
+        }
+      }
+      hash.update("\0");
+    }
+    hash.update("submodules\0");
+    const submodulePaths = submodules.stdout.split("\0").filter(Boolean).sort();
+    for (const path of submodulePaths) {
+      operation.signal.throwIfAborted();
+      const absolutePath = containedPath(folder, path);
+      if (!absolutePath) return null;
+      const submoduleHash = await worktreeCodeStateHash(
+        absolutePath,
+        remainingTimeoutMs(deadline),
+        operation.signal
+      );
+      if (!submoduleHash) return null;
+      hash.update(path);
+      hash.update("\0");
+      hash.update(submoduleHash);
+      hash.update("\0");
+    }
+    return hash.digest("hex");
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timeout);
+    signal.removeEventListener("abort", abort);
+  }
+}
+
+// src/handlers/worktrees.ts
 var successfulProcess4 = {
   exitCode: 0,
   signal: null,
@@ -4440,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);
@@ -4482,27 +4807,30 @@ async function flushWorktreeActivity(entry) {
   entry.pending = false;
   try {
     const signal = new AbortController().signal;
-    const [status2, branchResult, headResult] = await Promise.all([
-      git2(
-        entry.folder,
-        [
-          "--no-optional-locks",
-          "status",
-          "--porcelain=v1",
-          "-z",
-          "--untracked-files=all"
-        ],
-        entry.timeoutMs,
-        signal
-      ),
-      git2(
-        entry.folder,
-        ["symbolic-ref", "--short", "-q", "HEAD"],
-        entry.timeoutMs,
-        signal
-      ),
-      git2(entry.folder, ["rev-parse", "HEAD"], entry.timeoutMs, signal)
-    ]);
+    const [status2, branchResult, headResult, codeStateHash] = await Promise.all(
+      [
+        git2(
+          entry.folder,
+          [
+            "--no-optional-locks",
+            "status",
+            "--porcelain=v1",
+            "-z",
+            "--untracked-files=all"
+          ],
+          entry.timeoutMs,
+          signal
+        ),
+        git2(
+          entry.folder,
+          ["symbolic-ref", "--short", "-q", "HEAD"],
+          entry.timeoutMs,
+          signal
+        ),
+        git2(entry.folder, ["rev-parse", "HEAD"], entry.timeoutMs, signal),
+        worktreeCodeStateHash(entry.folder, entry.timeoutMs, signal)
+      ]
+    );
     const branch = branchResult.exitCode === 0 ? branchResult.stdout.trim() : null;
     const headSha = headResult.exitCode === 0 ? headResult.stdout.trim() : null;
     const headIdentity = headSha ? `${branch ?? ""}\0${headSha}` : null;
@@ -4510,6 +4838,7 @@ async function flushWorktreeActivity(entry) {
     const report = {
       codebaseId: entry.codebaseId,
       gitDirectory: entry.gitDirectory,
+      codeStateHash,
       ...changes,
       pushStatus: await worktreePushStatus(
         entry.folder,
@@ -4718,10 +5047,11 @@ async function inspectWorktreeItem(folderValue2, rootFolder, baseBranch, primary
     return {
       gitDirectory: gitDir,
       folder,
-      relativePath: relative2(rootFolder, folder) || ".",
+      relativePath: relative3(rootFolder, folder) || ".",
       primary,
       branch,
       headSha: headResult.exitCode === 0 ? headResult.stdout.trim() : null,
+      codeStateHash: await worktreeCodeStateHash(folder, timeoutMs, signal),
       upstream,
       ahead: upstreamCounts.ahead,
       behind: upstreamCounts.behind,
@@ -4744,10 +5074,11 @@ async function inspectWorktreeItem(folderValue2, rootFolder, baseBranch, primary
     return {
       gitDirectory: folderValue2,
       folder: folderValue2,
-      relativePath: relative2(rootFolder, folderValue2) || ".",
+      relativePath: relative3(rootFolder, folderValue2) || ".",
       primary,
       branch: null,
       headSha: null,
+      codeStateHash: null,
       upstream: null,
       ahead: null,
       behind: null,
@@ -4889,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
@@ -4901,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,
@@ -4913,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(
@@ -4944,89 +5337,513 @@ 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
   };
 }
-var watchWorktree = async (payload, timeoutMs, signal, _onLog, context) => {
-  const input = worktreeWatchJobPayload(payload);
-  const current = activeWorktreeWatches.get(input.gitDirectory);
-  if (input.action === "STOP") {
-    if (current?.watchId === input.watchId) {
-      closeWorktreeWatch(current);
-      activeWorktreeWatches.delete(input.gitDirectory);
-    }
-    return successfulProcess4;
-  }
-  if (!context) throw new Error("Worktree activity reporting is unavailable");
-  const folder = await validateWorktree(input, timeoutMs, signal);
-  if (current?.watchId === input.watchId) return successfulProcess4;
-  if (current) {
-    closeWorktreeWatch(current);
-    activeWorktreeWatches.delete(input.gitDirectory);
-  }
-  const entry = {
-    watchId: input.watchId,
-    codebaseId: input.codebaseId,
-    gitDirectory: input.gitDirectory,
-    folder,
-    baseBranch: input.baseBranch,
-    timeoutMs: Math.min(timeoutMs, 3e4),
-    watchers: [],
-    reporter: context.reportWorktreeActivity,
-    timer: null,
-    reporting: false,
-    pending: false,
-    headIdentity: null
-  };
-  activeWorktreeWatches.set(input.gitDirectory, entry);
-  try {
-    for (const target2 of /* @__PURE__ */ new Set([folder, input.gitDirectory])) {
-      const watcher = watch(
-        target2,
-        { recursive: true },
-        () => scheduleWorktreeActivity(entry)
-      );
-      watcher.on("error", (error) => {
-        console.error(
-          `Worktree watcher failed for ${target2}:`,
-          error instanceof Error ? error.message : error
-        );
-      });
-      watcher.unref();
-      entry.watchers.push(watcher);
-    }
-    scheduleWorktreeActivity(entry);
-  } catch (error) {
-    closeWorktreeWatch(entry);
-    activeWorktreeWatches.delete(input.gitDirectory);
-    throw error;
+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");
   }
-  return successfulProcess4;
-};
-var inspectWorktree = async (payload, timeoutMs, signal) => {
-  const input = worktreeJobPayload(payload);
-  const folder = await validateWorktree(input, timeoutMs, signal);
-  if (!input.baseBranch) throw new Error("A base branch is required");
-  return {
-    ...successfulProcess4,
-    detail: await inspectWorktreeDetail(
+  const base = await baseMergeCommit(folder, baseBranch, timeoutMs, signal);
+  const [afterBase, beforeHead] = await Promise.all([
+    git2(
       folder,
-      input.baseBranch,
+      ["merge-base", "--is-ancestor", base, commitSha],
+      timeoutMs,
+      signal
+    ),
+    git2(
+      folder,
+      ["merge-base", "--is-ancestor", commitSha, "HEAD"],
       timeoutMs,
       signal
     )
-  };
-};
-async function refExists(folder, ref, timeoutMs, signal) {
-  const result = await git2(
+  ]);
+  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);
+  if (input.action === "STOP") {
+    if (current?.watchId === input.watchId) {
+      closeWorktreeWatch(current);
+      activeWorktreeWatches.delete(input.gitDirectory);
+    }
+    return successfulProcess4;
+  }
+  if (!context) throw new Error("Worktree activity reporting is unavailable");
+  const folder = await validateWorktree(input, timeoutMs, signal);
+  if (current?.watchId === input.watchId) return successfulProcess4;
+  if (current) {
+    closeWorktreeWatch(current);
+    activeWorktreeWatches.delete(input.gitDirectory);
+  }
+  const entry = {
+    watchId: input.watchId,
+    codebaseId: input.codebaseId,
+    gitDirectory: input.gitDirectory,
+    folder,
+    baseBranch: input.baseBranch,
+    timeoutMs: Math.min(timeoutMs, 3e4),
+    watchers: [],
+    reporter: context.reportWorktreeActivity,
+    timer: null,
+    reporting: false,
+    pending: false,
+    headIdentity: null
+  };
+  activeWorktreeWatches.set(input.gitDirectory, entry);
+  try {
+    for (const target2 of /* @__PURE__ */ new Set([folder, input.gitDirectory])) {
+      const watcher = watch(
+        target2,
+        { recursive: true },
+        () => scheduleWorktreeActivity(entry)
+      );
+      watcher.on("error", (error) => {
+        console.error(
+          `Worktree watcher failed for ${target2}:`,
+          error instanceof Error ? error.message : error
+        );
+      });
+      watcher.unref();
+      entry.watchers.push(watcher);
+    }
+    scheduleWorktreeActivity(entry);
+  } catch (error) {
+    closeWorktreeWatch(entry);
+    activeWorktreeWatches.delete(input.gitDirectory);
+    throw error;
+  }
+  return successfulProcess4;
+};
+var inspectWorktree = async (payload, timeoutMs, signal) => {
+  const input = worktreeJobPayload(payload);
+  const folder = await validateWorktree(input, timeoutMs, signal);
+  if (!input.baseBranch) throw new Error("A base branch is required");
+  return {
+    ...successfulProcess4,
+    detail: await inspectWorktreeDetail(
+      folder,
+      input.baseBranch,
+      timeoutMs,
+      signal
+    )
+  };
+};
+async function refExists(folder, ref, timeoutMs, signal) {
+  const result = await git2(
     folder,
     ["show-ref", "--verify", "--quiet", ref],
     timeoutMs,
@@ -5752,30 +6569,32 @@ var operateWorktree = async (payload, timeoutMs, signal) => {
 };
 
 // src/handlers/builds.ts
-import { createHash as createHash2, randomUUID as randomUUID2 } from "node:crypto";
+import { createHash as createHash3, randomUUID as randomUUID2 } from "node:crypto";
 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,
-  isAbsolute as isAbsolute3,
+  isAbsolute as isAbsolute4,
   join as join6,
-  relative as relative3,
-  resolve as resolve4,
-  sep as sep2
+  relative as relative4,
+  resolve as resolve5,
+  sep as sep3
 } from "node:path";
-import { spawn as spawn3 } from "node:child_process";
+import { spawn as spawn5 } from "node:child_process";
 var successfulProcess5 = {
   exitCode: 0,
   signal: null,
@@ -5806,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");
@@ -5848,19 +6683,19 @@ async function validateWorktree2(input, timeoutMs, signal) {
   }
   return folder;
 }
-function containedPath(root, relativePath) {
-  const target2 = resolve4(root, relativePath);
-  const difference = relative3(root, target2);
-  if (difference === ".." || difference.startsWith(`..${sep2}`) || isAbsolute3(difference)) {
+function containedPath2(root, relativePath) {
+  const target2 = resolve5(root, relativePath);
+  const difference = relative4(root, target2);
+  if (difference === ".." || difference.startsWith(`..${sep3}`) || isAbsolute4(difference)) {
     throw new Error("Path must stay within the worktree");
   }
   return target2;
 }
 async function validateSource(root, source) {
-  const target2 = containedPath(root, source.relativePath);
+  const target2 = containedPath2(root, source.relativePath);
   const resolved = await realpath5(target2);
-  const difference = relative3(root, resolved);
-  if (difference === ".." || difference.startsWith(`..${sep2}`) || isAbsolute3(difference)) {
+  const difference = relative4(root, resolved);
+  if (difference === ".." || difference.startsWith(`..${sep3}`) || isAbsolute4(difference)) {
     throw new Error("Build source resolves outside the worktree");
   }
   const information = await stat5(resolved);
@@ -5880,7 +6715,7 @@ async function discoverSourcesInFolder(folder) {
     for (const entry of await readdir4(current, { withFileTypes: true })) {
       if (entry.isSymbolicLink()) continue;
       const absolute = join6(current, entry.name);
-      const path = relative3(folder, absolute).split(sep2).join("/");
+      const path = relative4(folder, absolute).split(sep3).join("/");
       if (entry.isDirectory()) {
         if (entry.name.endsWith(".xcodeproj")) {
           sources.push({ kind: "PROJECT", relativePath: path });
@@ -5971,15 +6806,15 @@ async function workspaceProjectPaths(workspacePath2, folder) {
   }).filter((path) => path.endsWith(".xcodeproj"));
   const projects = [];
   for (const location of locations) {
-    const candidate = resolve4(dirname6(workspacePath2), location);
-    const difference = relative3(folder, candidate);
-    if (difference === ".." || difference.startsWith(`..${sep2}`) || isAbsolute3(difference)) {
+    const candidate = resolve5(dirname6(workspacePath2), location);
+    const difference = relative4(folder, candidate);
+    if (difference === ".." || difference.startsWith(`..${sep3}`) || isAbsolute4(difference)) {
       continue;
     }
     try {
       const resolved = await realpath5(candidate);
-      const resolvedDifference = relative3(folder, resolved);
-      if (resolvedDifference === ".." || resolvedDifference.startsWith(`..${sep2}`) || isAbsolute3(resolvedDifference) || !(await stat5(resolved)).isDirectory()) {
+      const resolvedDifference = relative4(folder, resolved);
+      if (resolvedDifference === ".." || resolvedDifference.startsWith(`..${sep3}`) || isAbsolute4(resolvedDifference) || !(await stat5(resolved)).isDirectory()) {
         continue;
       }
       projects.push(resolved);
@@ -6194,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(
@@ -6215,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) => {
@@ -6239,12 +7074,6 @@ var inspectBuildDestinations = async (payload, timeoutMs, signal) => {
     folder
   );
   requireSuccess3(preflight, "The saved scheme or configuration is unavailable");
-  if (GENERIC_BUILD_DESTINATION_ACTIONS.includes(input.action)) {
-    return {
-      ...successfulProcess5,
-      destinations: genericBuildDestinations(input.action)
-    };
-  }
   const [simulators, physical] = await Promise.all([
     command2(
       "xcrun",
@@ -6258,6 +7087,7 @@ var inspectBuildDestinations = async (payload, timeoutMs, signal) => {
   return {
     ...successfulProcess5,
     destinations: [
+      ...genericBuildDestinations(input.action),
       ...simulators.exitCode === 0 ? simulatorDestinations(JSON.parse(simulators.stdout)) : [],
       ...physical
     ]
@@ -6311,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;
@@ -6401,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 = spawn3(options.command, options.args, {
+    const child = spawn5(options.command, options.args, {
       cwd: options.cwd,
       env: options.env,
       shell: false,
@@ -6599,7 +7429,7 @@ function actionArgument(action) {
 }
 function xcodeBuildArguments(input) {
   const resultBundle = join6(input.artifactDirectory, "result.xcresult");
-  const sourcePath = containedPath(input.folder, input.source.relativePath);
+  const sourcePath = containedPath2(input.folder, input.source.relativePath);
   const usesCapturedTestProducts = input.action === "TEST_WITHOUT_BUILDING";
   const args = [
     "xcodebuild",
@@ -6646,7 +7476,7 @@ function xcodeBuildSettingsArguments(input, folder = input.folder) {
     "xcodebuild",
     ...sourceArguments(
       input.source,
-      containedPath(folder, input.source.relativePath)
+      containedPath2(folder, input.source.relativePath)
     ),
     "-scheme",
     input.scheme,
@@ -6749,7 +7579,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: relative4(options.input.artifactDirectory, log),
       error: failed ? cleanError3(result.output || "Build hook failed") : null
     };
   } catch (hookError) {
@@ -6762,7 +7592,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: relative4(options.input.artifactDirectory, log),
       error
     };
   }
@@ -6791,7 +7621,7 @@ async function fileChecksum(path) {
     const information = await stat5(path);
     if (!information.isFile() || information.size > 256 * 1024 * 1024)
       return null;
-    return createHash2("sha256").update(await readFile4(path)).digest("hex");
+    return createHash3("sha256").update(await readFile4(path)).digest("hex");
   } catch {
     return null;
   }
@@ -6799,12 +7629,398 @@ async function fileChecksum(path) {
 async function artifact(root, kind, path, metadata = {}) {
   return {
     kind,
-    relativePath: relative3(root, path).split(sep2).join("/"),
+    relativePath: relative4(root, path).split(sep3).join("/"),
     sizeBytes: await pathSize(path),
     checksum: await fileChecksum(path),
     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 [];
@@ -6848,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(
@@ -6884,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
@@ -6941,9 +8178,14 @@ var runIosBuild = async (payload, timeoutMs, signal, onLog, context) => {
       throw new Error("The captured .xctestrun artifact is unavailable");
     }
   }
-  if (!isAbsolute3(input.artifactDirectory) || basename3(input.artifactDirectory) !== input.buildId) {
+  if (!isAbsolute4(input.artifactDirectory) || basename3(input.artifactDirectory) !== input.buildId) {
     throw new Error("Build artifact directory is invalid");
   }
+  const sourceStateHash = await worktreeCodeStateHash(
+    folder,
+    Math.min(timeoutMs, 6e4),
+    signal
+  );
   await mkdir3(input.artifactDirectory, { recursive: true, mode: 448 });
   const rawLog = join6(input.artifactDirectory, "build.log");
   const logger = new BuildLogger(input.buildId, context, rawLog, process.env);
@@ -6966,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;
@@ -7023,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",
@@ -7082,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)) {
@@ -7099,6 +8397,12 @@ var runIosBuild = async (payload, timeoutMs, signal, onLog, context) => {
     const timedOut = buildResult?.timedOut === true;
     const exitCode = cancelled ? null : failBuild || !buildResult ? 1 : buildResult.exitCode;
     const args = xcodeBuildArguments(input);
+    const finalStateHash = await worktreeCodeStateHash(
+      folder,
+      Math.min(timeoutMs, 6e4),
+      new AbortController().signal
+    );
+    const codeStateObservedAt = (/* @__PURE__ */ new Date()).toISOString();
     return {
       exitCode,
       signal: buildResult?.signal ?? null,
@@ -7108,16 +8412,44 @@ var runIosBuild = async (payload, timeoutMs, signal, onLog, context) => {
       error,
       commandSummary: commandSummary("xcrun", args),
       artifacts,
-      scriptExecutions
+      reports,
+      scriptExecutions,
+      sourceStateHash,
+      finalStateHash,
+      codeStateObservedAt
     };
   } finally {
     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",
@@ -7133,10 +8465,10 @@ var downloadIosBuildArtifact = async (payload, timeoutMs, signal, onLog, context
   }
   const root = await realpath5(input.artifactDirectory);
   const target2 = await realpath5(
-    containedPath(root, input.artifactRelativePath)
+    containedPath2(root, input.artifactRelativePath)
   );
-  const difference = relative3(root, target2);
-  if (!difference || difference === ".." || difference.startsWith(`..${sep2}`) || isAbsolute3(difference)) {
+  const difference = relative4(root, target2);
+  if (!difference || difference === ".." || difference.startsWith(`..${sep3}`) || isAbsolute4(difference)) {
     throw new Error("Build artifact resolves outside the build folder");
   }
   const information = await stat5(target2);
@@ -7147,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(
@@ -7180,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 });
     }
   }
 };
@@ -7209,7 +8541,7 @@ var deployIosBuild = async (payload, timeoutMs, signal, _onLog, context) => {
     Math.min(timeoutMs, 6e4),
     signal
   );
-  const appPath = containedPath(
+  const appPath = containedPath2(
     input.artifactDirectory,
     input.artifactRelativePath
   );
@@ -7387,7 +8719,7 @@ var deployIosBuild = async (payload, timeoutMs, signal, _onLog, context) => {
         status: signal.aborted ? "CANCELLED" : failure ? "FAILED" : "SUCCEEDED",
         error: failure,
         durationMs: Date.now() - started,
-        outputRelativePath: relative3(input.artifactDirectory, logPath)
+        outputRelativePath: relative4(input.artifactDirectory, logPath)
       });
       if (signal.aborted) break;
     }
@@ -7447,7 +8779,7 @@ var exportIosArchive = async (payload, timeoutMs, signal, _onLog, context) => {
     Math.min(timeoutMs, 6e4),
     signal
   );
-  const archivePath = containedPath(
+  const archivePath = containedPath2(
     input.artifactDirectory,
     input.archiveRelativePath
   );
@@ -7493,7 +8825,7 @@ var exportIosArchive = async (payload, timeoutMs, signal, _onLog, context) => {
       signal: result.signal,
       timedOut: result.timedOut,
       cancelled: result.cancelled,
-      outputRelativePath: relative3(input.artifactDirectory, exportDirectory),
+      outputRelativePath: relative4(input.artifactDirectory, exportDirectory),
       sizeBytes: result.exitCode === 0 ? await pathSize(exportDirectory) : null,
       error: result.exitCode === 0 ? null : cleanError3(result.output)
     };
@@ -7522,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,
@@ -7533,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
@@ -7542,8 +8878,8 @@ var RepositoryCoordinator = class {
   async run(key, task) {
     const previous = this.tails.get(key) ?? Promise.resolve();
     let release2;
-    const current = new Promise((resolve5) => {
-      release2 = resolve5;
+    const current = new Promise((resolve6) => {
+      release2 = resolve6;
     });
     const tail = previous.then(() => current);
     this.tails.set(key, tail);
@@ -7641,7 +8977,7 @@ var JobExecutor = class {
         );
         if (this.stopping) return;
         const delay = Math.min(3e4, 1e3 * 2 ** Math.min(retry++, 5));
-        await new Promise((resolve5) => setTimeout(resolve5, delay));
+        await new Promise((resolve6) => setTimeout(resolve6, delay));
       }
     }
   }
@@ -7912,9 +9248,9 @@ async function runAgent(config, signal) {
     () => void heartbeat(),
     HEARTBEAT_INTERVAL_MS
   );
-  await new Promise((resolve5) => {
-    if (signal.aborted) resolve5();
-    else signal.addEventListener("abort", () => resolve5(), { once: true });
+  await new Promise((resolve6) => {
+    if (signal.aborted) resolve6();
+    else signal.addEventListener("abort", () => resolve6(), { once: true });
   });
   clearInterval(heartbeatTimer);
   if (codebaseTimer) clearTimeout(codebaseTimer);
@@ -7931,7 +9267,7 @@ var defaultDependencies = {
   inventory: collectInventory,
   load: loadConfig,
   save: saveConfig,
-  wait: (milliseconds, signal) => new Promise((resolve5, reject) => {
+  wait: (milliseconds, signal) => new Promise((resolve6, reject) => {
     if (signal.aborted) {
       reject(new Error("Development agent startup was cancelled"));
       return;
@@ -7942,7 +9278,7 @@ var defaultDependencies = {
     };
     const timer = setTimeout(() => {
       signal.removeEventListener("abort", onAbort);
-      resolve5();
+      resolve6();
     }, milliseconds);
     signal.addEventListener("abort", onAbort, { once: true });
   })