@ai-development-environment/control-agent 0.0.141 → 0.0.143

package/dist/control-agent.js

@@ -7617,22 +7617,31 @@ var AgentGraphQLClient = class {
   health() {
     return this.request(`query Health { health }`);
   }
+  async requestDefaultBranchConfiguration(query) {
+    try {
+      return await this.request(query);
+    } catch (error) {
+      if (!(error instanceof Error) || !/Cannot query field "defaultBranchPatterns"/.test(error.message))
+        throw error;
+      return this.request(query.replace(/\sdefaultBranchPatterns\b/g, ""));
+    }
+  }
   async agentCodebases() {
-    const data = await this.request(`query AgentCodebases {
+    const data = await this.requestDefaultBranchConfiguration(`query AgentCodebases {
       agentCodebases {
-        id folder canonicalOrigin defaultBranch keepBaseBranchUpToDate lastFetchedAt lastFetchAttemptAt
+        id folder canonicalOrigin defaultBranch keepBaseBranchUpToDate defaultBranchPatterns lastFetchedAt lastFetchAttemptAt
         worktrees { id folder branch gitDirectory baseBranchOverride }
       }
     }`);
     return data.agentCodebases;
   }
   async agentCodebaseConfiguration() {
-    const data = await this.request(`query AgentCodebaseConfiguration {
+    const data = await this.requestDefaultBranchConfiguration(`query AgentCodebaseConfiguration {
       agentCodebaseConfiguration {
         refreshIntervalSeconds
         fetchIntervalSeconds
         codebases {
-          id folder canonicalOrigin defaultBranch keepBaseBranchUpToDate lastFetchedAt lastFetchAttemptAt
+          id folder canonicalOrigin defaultBranch keepBaseBranchUpToDate defaultBranchPatterns lastFetchedAt lastFetchAttemptAt
           worktrees { id folder branch gitDirectory baseBranchOverride }
         }
       }
@@ -8134,6 +8143,50 @@ var CODEBASE_GIT_INSPECT_JOB_KIND = "codebase.git.inspect";
 var CODEBASE_GIT_OPERATION_JOB_KIND = "codebase.git.operation";
 var CODEBASE_BRANCHES_DELETE_JOB_KIND = "codebase.branches.delete";
 var CODEBASE_RECONCILE_EVENT_CAPABILITY = "codebase.reconcile.requested";
+var CODEBASE_DEFAULT_BRANCHES_CAPABILITY = "codebase.default-branches.v1";
+function normalizeDefaultBranchPatterns(value) {
+  if (!Array.isArray(value) || value.length > 100)
+    throw new Error(
+      "Default branch patterns must be a list of at most 100 entries"
+    );
+  const patterns = value.map((entry) => {
+    if (typeof entry !== "string" || entry.trim().length > 255)
+      throw new Error(
+        "Default branch patterns must be strings of at most 255 characters"
+      );
+    const pattern = entry.trim();
+    if (pattern && /[\s\x00-\x1f\x7f]/.test(pattern))
+      throw new Error(
+        "Default branch patterns cannot contain whitespace or control characters"
+      );
+    return pattern;
+  });
+  return [...new Set(patterns.filter(Boolean))];
+}
+function isDefaultBranch(branch, remoteDefaultBranch, patterns = []) {
+  if (!branch) return false;
+  if (branch === remoteDefaultBranch) return true;
+  return patterns.some((pattern) => {
+    let position = 0;
+    let patternPosition = 0;
+    let star = -1;
+    let resume = 0;
+    while (position < branch.length) {
+      if (pattern[patternPosition] === "*") {
+        star = patternPosition++;
+        resume = position;
+      } else if (pattern[patternPosition] === branch[position]) {
+        patternPosition++;
+        position++;
+      } else if (star >= 0) {
+        patternPosition = star + 1;
+        position = ++resume;
+      } else return false;
+    }
+    while (pattern[patternPosition] === "*") patternPosition++;
+    return patternPosition === pattern.length;
+  });
+}
 var MAX_CODEBASE_GIT_BRANCHES = 1e3;
 var MAX_CODEBASE_STASHES = 200;
 var MAX_CODEBASE_STASH_PATCH_BYTES = 256 * 1024;
@@ -8439,7 +8492,8 @@ function codebaseJobPayload(value) {
     "codebaseId",
     "expectedOrigin",
     "baseBranch",
-    "keepBaseBranchUpToDate"
+    "keepBaseBranchUpToDate",
+    "defaultBranchPatterns"
   ]);
   const unexpected = Object.keys(payload).find((key) => !allowed.has(key));
   if (unexpected)
@@ -8461,6 +8515,11 @@ function codebaseJobPayload(value) {
         payload.keepBaseBranchUpToDate,
         "payload.keepBaseBranchUpToDate"
       )
+    },
+    ...payload.defaultBranchPatterns === void 0 ? {} : {
+      defaultBranchPatterns: normalizeDefaultBranchPatterns(
+        payload.defaultBranchPatterns
+      )
     }
   };
 }
@@ -11683,7 +11742,7 @@ function tailscaleServeRemovePayload(value) {
 // package.json
 var package_default = {
   name: "@ai-development-environment/control-agent",
-  version: "0.0.141",
+  version: "0.0.143",
   description: "Control agent for the AI Development Environment",
   license: "MIT",
   repository: {
@@ -11753,6 +11812,7 @@ var PORTABLE_AGENT_CAPABILITIES = [
   CCUSAGE_REPORT_JOB_KIND,
   ...CODEBASE_JOB_KINDS,
   CODEBASE_RECONCILE_EVENT_CAPABILITY,
+  CODEBASE_DEFAULT_BRANCHES_CAPABILITY,
   ...WORKTREE_JOB_KINDS,
   WORKTREE_REVIEWED_SYNC_CAPABILITY,
   ...SKILL_JOB_KINDS,
@@ -11810,7 +11870,7 @@ import { randomUUID as randomUUID10 } from "node:crypto";
 // src/runs/branch-naming.ts
 import { mkdtemp as mkdtemp2, rm as rm7 } from "node:fs/promises";
 import { tmpdir as tmpdir2 } from "node:os";
-import { join as join9 } from "node:path";
+import { join as join10 } from "node:path";
 
 // src/runs/codex-adapter.ts
 import {
@@ -13166,7 +13226,9 @@ var CodexAdapter = class {
 
 // src/runs/claude-adapter.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
+import { stat as stat3 } from "node:fs/promises";
 import { homedir as homedir5 } from "node:os";
+import { dirname as dirname5, join as join7 } from "node:path";
 
 // src/runs/claude-import.ts
 import { createReadStream as createReadStream3 } from "node:fs";
@@ -13194,6 +13256,83 @@ function timestamp2(value) {
   const date = typeof value === "string" || typeof value === "number" ? new Date(value) : void 0;
   return date && Number.isFinite(date.getTime()) ? date.toISOString() : void 0;
 }
+function claudeSubagentSnapshot(nativeId, values, metadataValues = [], options = { transcriptStatus: "AVAILABLE" }) {
+  const messages = /* @__PURE__ */ new Map();
+  for (const value of values) {
+    const record = asRecord(value);
+    if ((record.type === "user" || record.type === "assistant") && typeof record.uuid === "string")
+      messages.set(record.uuid, { ...record, agent_id: nativeId });
+  }
+  const records = [...messages.values()];
+  const toolUseId = records.map((record) => record.parent_tool_use_id).find((value) => typeof value === "string" && !!value);
+  const parentNativeId = records.map((record) => record.parent_agent_id).find((value) => typeof value === "string" && !!value);
+  let label;
+  let agentType;
+  let status2;
+  let nativeRunId;
+  for (const value of metadataValues) {
+    const envelope = asRecord(value);
+    const record = envelope.raw ? asRecord(envelope.raw) : envelope;
+    const content = asRecord(record.message).content;
+    for (const candidate of Array.isArray(content) ? content : []) {
+      const block = asRecord(candidate);
+      if (block.type === "tool_use" && block.id === toolUseId && (block.name === "Agent" || block.name === "Task")) {
+        const input = asRecord(block.input);
+        if (typeof input.description === "string") label = input.description;
+        if (typeof input.subagent_type === "string")
+          agentType = input.subagent_type;
+      }
+    }
+    if (record.task_id !== nativeId) continue;
+    if (typeof record.description === "string") label ??= record.description;
+    if (typeof record.subagent_type === "string")
+      agentType = record.subagent_type;
+    const runId = typeof record.run_id === "string" ? record.run_id : void 0;
+    if (nativeRunId && (!runId || runId < nativeRunId)) continue;
+    if (runId && runId !== nativeRunId) {
+      nativeRunId = runId;
+      status2 = void 0;
+    }
+    const state = record.status ?? asRecord(record.patch).status ?? (record.subtype === "task_started" || record.subtype === "task_progress" ? "RUNNING" : void 0);
+    if (typeof state === "string") status2 = state.toUpperCase();
+  }
+  const prompt = records.filter((record) => record.type === "user").map((record) => textBlocks(asRecord(record.message).content)).find(Boolean);
+  const replies = /* @__PURE__ */ new Map();
+  let finalReplyId;
+  for (const record of records) {
+    if (record.type !== "assistant") continue;
+    const message2 = asRecord(record.message);
+    const reply = textBlocks(message2.content);
+    if (reply) {
+      const replyId = String(message2.id ?? record.uuid);
+      const parts = replies.get(replyId) ?? /* @__PURE__ */ new Map();
+      parts.set(String(record.uuid), reply);
+      replies.set(replyId, parts);
+      finalReplyId = replyId;
+    }
+  }
+  const last = records.at(-1);
+  const finished = options.transcriptStatus === "AVAILABLE" && status2 !== "RUNNING" && status2 !== "PAUSED" && last?.type === "assistant" && asRecord(last.message).stop_reason === "end_turn";
+  return {
+    nativeId,
+    ...nativeRunId ? { nativeRunId } : {},
+    ...parentNativeId ? { parentNativeId } : {},
+    ...toolUseId ? { toolUseId } : {},
+    ...label ? { label } : {},
+    ...agentType ? { agentType } : {},
+    ...status2 || finished ? { status: status2 ?? "COMPLETED" } : {},
+    ...prompt ? { prompt } : {},
+    ...finalReplyId && status2 !== "RUNNING" && status2 !== "PAUSED" ? { finalOutput: [...replies.get(finalReplyId).values()].join("\n\n") } : {},
+    startedAt: timestamp2(records[0]?.timestamp),
+    ...finished ? { finishedAt: timestamp2(last?.timestamp) } : {},
+    ...options,
+    messages: records.map((record) => ({
+      nativeId: String(record.uuid),
+      raw: record,
+      createdAt: timestamp2(record.timestamp)
+    }))
+  };
+}
 function claudeTranscriptMetadata(values) {
   const records = values.map(asRecord);
   const requests = /* @__PURE__ */ new Map();
@@ -13422,6 +13561,8 @@ import { randomBytes as Wwe } from "crypto";
 import { closeSync as nct, constants as Gt, fchmodSync as rct, fstatSync as oct, ftruncateSync as sct, lstatSync as ict, openSync as act, readFileSync as lct, renameSync as cct, unlinkSync as uct, writeFileSync as dct } from "fs";
 import { lstat as cg, open as Rd, rename as rF, stat as Vwe, unlink as Ad, writeFile as qwe } from "fs/promises";
 import { basename as Ywe, join as Zwe } from "path";
+import { readdir as zxe, readFile as EF } from "fs/promises";
+import { isAbsolute as bF, join as ug, relative as CF, sep as dg } from "path";
 import { randomUUID as A$e } from "crypto";
 import { join as j1 } from "path";
 import { lstat as s6e } from "fs/promises";
@@ -17312,6 +17453,10 @@ function Ef(e10) {
 }
 var ak = "[\\w-]{1,63}";
 var AJ = new RegExp(`^${ak}$`);
+var RJ = /^[\w-]{1,128}$/;
+function eS(e10) {
+  return RJ.test(e10);
+}
 var DJe = new RegExp(`^a(?:${ak}-)?[0-9a-f]{16}$`);
 function tS(e10, t) {
   let n = Buffer.from(t.replace(/-/g, ""), "hex"), r = ik("sha1").update(n).update(Buffer.from(e10, "utf8")).digest();
@@ -30304,6 +30449,12 @@ function R0(e10, t) {
 function DR(e10, t) {
   return typeof t === "string" && e10.test(t);
 }
+function VTe(e10) {
+  if (e10.year !== void 0 && e10.projectKey === void 0) return Y("scope.projectKey", "required when year is given");
+  if (e10.month !== void 0 && e10.year === void 0) return Y("scope.year", "required when month is given");
+  if (e10.day !== void 0 && e10.month === void 0) return Y("scope.month", "required when day is given");
+  return R0("scope", e10);
+}
 var qTe = /^[0-9a-f]{8}$/;
 function YTe(e10) {
   switch (e10.namespace) {
@@ -30376,6 +30527,97 @@ function YTe(e10) {
   }
   return;
 }
+function LR(e10) {
+  if (typeof e10 !== "object" || e10 === null) return Y("scope", "expected a scope object");
+  let t = QTe(e10);
+  if (t === void 0) return Y("scope", `${String(e10.namespace)} is not a listable namespace`);
+  return JTe(e10) ?? n0("scope", t);
+}
+var ZTe = { transcript: [["agentId", "names one agent transcript, a stream key, not a scope: narrow a scope with agentRelPath"], ["journal", "names a run journal, a stream key, not a scope: narrow a scope with agentRelPath"], ["sessionJournal", "names a session's own journal, a stream key, not a scope: the session scope lists it"]], log: [["agentId", "names one log stream, a stream key, not a scope"], ["runId", "names one log stream, a stream key, not a scope"]], sessionLog: [["logName", "names one session's log, a stream key, not a scope: a day scope lists its logs"]], task: [["taskId", "names one task value, a key, not a scope: a list scope narrows with listId only"], ["meta", "names one task value, a key, not a scope: a list scope narrows with listId only"], ["highWaterMark", "names one task value, a key, not a scope: a list scope narrows with listId only"]], mailbox: [["teammate", "names one inbox, a key, not a scope"]], cache: [["id", "names one cached value, a key, not a scope: a cache scope narrows with store only"]], pluginAssetCache: [["digest", "names one cached asset, a key, not a scope"]], fileHistory: [["backupFileName", "names one backup, a key, not a scope: a file-history scope narrows with sessionId only"]], state: [["id", "names one value, a key, not a scope"]], feedbackDraft: [["draftId", "names one draft, a key, not a scope"]], jobsRoot: [["file", "names one value, a key, not a scope"], ["draftKey", "names one value, a key, not a scope"]], plan: [["name", "names one plan, a key, not a scope"]], paste: [["id", "names one paste, a key, not a scope"]], session: [["file", "names one value, a key, not a scope"]], globalConfig: [["stamp", "names one recovery copy, a key, not a scope: the scope narrows with kind only"]], marketplaceCache: [["form", "names one of the marketplace's two engine-written files, a key, not a scope: the tree narrows with relPath only"]], memory: [], pluginCache: [], daemon: [], sidecar: [], agentMemory: [], scratch: [], userConfigDir: [], job: [], bridgeSpawn: [] };
+function JTe(e10) {
+  let t = e10.namespace === "agentMemory" ? XTe(e10) : void 0;
+  if (t !== void 0) return t;
+  if (e10.namespace === "transcript" || e10.namespace === "sidecar") {
+    let r = ng("scope.sessionId", e10.sessionId);
+    if (r !== void 0) return r;
+  }
+  for (let [r, o] of ZTe[e10.namespace]) if (r in e10 && e10[r] !== void 0) return Y(`scope.${r}`, o);
+  if (e10.namespace === "sidecar" && rg(e10.relPath)) return Y("scope.relPath", _d);
+  if (e10.namespace === "sidecar" && h0(e10.relPath)) return Y("scope.relPath", m0);
+  if (e10.namespace === "log" && e10.channel !== void 0 && !E0(e10.channel)) return Y("scope.channel", S0);
+  if (e10.namespace === "job" && A0(e10.relPath)) return Y("scope.relPath", C0);
+  let n = e10.namespace === "sessionLog" ? VTe(e10) : void 0;
+  if (n !== void 0) return n;
+  if (e10.namespace === "scratch" && e10.sessionId === void 0 && e10.relPath !== void 0) return Y("scope.relPath", "requires scope.sessionId: a scratch relPath narrows one session directory, and no cross-session prefix filter exists");
+  if (e10.namespace === "userConfigDir" && !o0.has(e10.dir)) return Y("scope.dir", s0);
+  if (e10.namespace === "transcript" && e10.agentRelPath !== void 0 && (e10.projectKey === void 0 || e10.sessionId === void 0)) return Y("scope.agentRelPath", "requires scope.projectKey and scope.sessionId: an agentRelPath narrows the subagents/ tree of one session directory");
+  if (e10.namespace === "transcript" && rg(e10.agentRelPath)) return Y("scope.agentRelPath", _d);
+  if (e10.namespace === "pluginCache") {
+    if (e10.marketplace === void 0 && e10.plugin !== void 0) return Y("scope.plugin", "requires scope.marketplace: a plugin narrows one marketplace folder");
+    if (e10.plugin === void 0 && e10.version !== void 0) return Y("scope.version", "requires scope.plugin: a version narrows one plugin folder");
+    if (e10.version === void 0 && e10.relPath !== void 0) return Y("scope.relPath", "requires scope.version: a relPath narrows one version folder");
+  }
+  if (e10.namespace === "job" && e10.jobId === void 0 && e10.relPath !== void 0) return Y("scope.relPath", "requires scope.jobId: a job relPath narrows one job directory, and no cross-job prefix filter exists");
+  if (e10.namespace === "transcript" && e10.projectKey === void 0 && e10.sessionId !== void 0) return Y("scope.sessionId", "requires scope.projectKey: a session narrows one project folder, and no cross-project session filter exists");
+  if (e10.namespace === "globalConfig" && e10.kind !== void 0 && !p0(e10.kind)) return Y("scope.kind", d0);
+  return;
+}
+function XTe(e10) {
+  if (!c0(e10.layer)) return Y("scope.layer", "must be user, project or local");
+  if (e10.layer === "user" && "projectKey" in e10) return Y("scope.projectKey", "the user layer is not keyed by project");
+  if (e10.layer !== "user" && typeof e10.projectKey !== "string") return Y("scope.projectKey", "required for the project and local layers");
+  return e10.agentType === void 0 && e10.relPath !== void 0 ? Y("scope.relPath", "requires scope.agentType: an agent-memory relPath narrows one agent directory") : void 0;
+}
+function QTe(e10) {
+  switch (e10.namespace) {
+    case "transcript":
+      return [["projectKey", e10.projectKey, "optional"], ["sessionId", e10.sessionId, "optional"], ["agentRelPath", e10.agentRelPath, "optional"]];
+    case "task":
+      return [["listId", e10.listId, "optional"]];
+    case "mailbox":
+      return [["team", e10.team, "optional"]];
+    case "memory":
+      return [["projectKey", e10.projectKey], ["relPath", e10.relPath, "optional"]];
+    case "pluginCache":
+      return [["marketplace", e10.marketplace, "optional"], ["plugin", e10.plugin, "optional"], ["version", e10.version, "optional"], ["relPath", e10.relPath, "optional"]];
+    case "marketplaceCache":
+      return [["marketplace", e10.marketplace], ["relPath", e10.relPath, "optional"]];
+    case "cache":
+      return [["store", e10.store]];
+    case "state":
+    case "plan":
+    case "paste":
+    case "pluginAssetCache":
+    case "feedbackDraft":
+      return [];
+    case "sidecar":
+      return [["projectKey", e10.projectKey], ["sessionId", e10.sessionId], ["relPath", e10.relPath, "optional"]];
+    case "agentMemory":
+      return [["projectKey", e10.layer === "user" ? void 0 : e10.projectKey, "optional"], ["agentType", e10.agentType, "optional"], ["relPath", e10.relPath, "optional"]];
+    case "scratch":
+      return [["sessionId", e10.sessionId, "optional"], ["relPath", e10.relPath, "optional"]];
+    case "userConfigDir":
+      return [["relPath", e10.relPath, "optional"]];
+    case "fileHistory":
+      return [["sessionId", e10.sessionId, "optional"]];
+    case "job":
+      return [["jobId", e10.jobId, "optional"], ["relPath", e10.relPath, "optional"]];
+    case "daemon":
+      return [["relPath", e10.relPath, "optional"]];
+    case "jobsRoot":
+    case "session":
+      return [];
+    case "bridgeSpawn":
+      return [["dir", e10.dir, "optional"]];
+    case "globalConfig":
+      return [["kind", e10.kind, "optional"]];
+    case "log":
+      return [["sessionId", e10.sessionId, "optional"]];
+    case "sessionLog":
+      return [["projectKey", e10.projectKey, "optional"], ["year", e10.year, "optional"], ["month", e10.month, "optional"], ["day", e10.day, "optional"]];
+  }
+  return;
+}
 function twe(e10) {
   let t = process.cwd();
   return t.endsWith(O0) ? t + e10 : t + O0 + e10;
@@ -31553,6 +31795,158 @@ var xxe = new Exe();
 function gl() {
   return xxe.getStore() ?? new fF();
 }
+async function AF(e10, t, n, r, o) {
+  let s = await ws(e10, t, Hn(n), r, o);
+  if (!s) return null;
+  let i = s.filePath.replace(/\.jsonl$/, "");
+  return ug(i, "subagents");
+}
+function RF(e10) {
+  let t = CF(Et(), e10);
+  if (t === "" || t.startsWith(`..${dg}`) || t === ".." || bF(t)) return null;
+  let n = t.split(dg);
+  return n.length < 4 || n[2] !== "subagents" ? null : n;
+}
+function jxe(e10) {
+  let t = RF(e10), n = t?.at(-1);
+  if (!t || !n?.startsWith("agent-") || !n.endsWith(".jsonl")) return null;
+  let r = n.slice(6, -6), o = t.slice(3, -1);
+  if (!$n([t[0], t[1], r]) || o.length > 0 && !$n(o)) return null;
+  let s = Ut.transcript(t[0], t[1], r, o.length > 0 ? o : void 0);
+  return zo(s) === void 0 ? s : null;
+}
+function Bxe(e10) {
+  let t = RF(e10);
+  if (!t) return null;
+  let n = t.slice(2);
+  if (!$n([t[0], t[1]]) || !$n(n)) return null;
+  let r = Ut.sidecar(t[0], t[1], n);
+  return zo(r) === void 0 ? r : null;
+}
+async function OF(e10, t, { rejectUnlistable: n = false } = {}) {
+  let r = be() && t !== void 0 ? Kxe(e10) : null;
+  if (t !== void 0 && r !== null) return Wxe(t, r, e10, Gxe, n);
+  let o = [];
+  async function s(i) {
+    let a;
+    try {
+      a = await zxe(i, { withFileTypes: true });
+    } catch (l) {
+      if (n && !at(l)) throw l;
+      return;
+    }
+    for (let l of a) if (l.isFile() && l.name.startsWith("agent-") && l.name.endsWith(".jsonl")) {
+      let c = l.name.slice(6, -6);
+      o.push({ agentId: c, filePath: ug(i, l.name) });
+    } else if (l.isDirectory()) await s(ug(i, l.name));
+  }
+  return await s(e10), o;
+}
+function Kxe(e10) {
+  let t = CF(Et(), e10);
+  if (t === "" || t.startsWith(`..${dg}`) || bF(t)) return null;
+  let n = t.split(dg);
+  if (n.length !== 3 || n[2] !== "subagents" || !$n([n[0], n[1]])) return null;
+  let r = { namespace: "transcript", projectKey: n[0], sessionId: n[1] };
+  return LR(r) === void 0 ? r : null;
+}
+var Gxe = 1e4;
+async function Wxe(e10, t, n, r, o) {
+  let s = [], i = [t], a = /* @__PURE__ */ new Set([""]), l = 0;
+  try {
+    while (i.length > 0) {
+      if (++l > r) throw Error("sub-agent listing incomplete");
+      let c = i.shift(), d = [];
+      if ((await kr((f) => e10.listEntries(c, { skipKeyStats: true, skipScopeStats: true, ...f !== void 0 && { cursor: f } }), (f) => {
+        for (let m of f) if (m.kind === "key" && m.key.namespace === "transcript" && m.key.agentId !== void 0 && en(m.key.agentId) && (m.key.agentRelPath === void 0 || $n(m.key.agentRelPath))) s.push({ agentId: m.key.agentId, filePath: ug(n, ...m.key.agentRelPath ?? [], `agent-${m.key.agentId}.jsonl`) });
+        else if (m.kind === "scope" && m.scope.namespace === "transcript" && m.scope.agentRelPath !== void 0 && $n(m.scope.agentRelPath) && !a.has(m.scope.agentRelPath.join("/"))) {
+          let g = { ...t, agentRelPath: m.scope.agentRelPath };
+          if (LR(g) === void 0) a.add(m.scope.agentRelPath.join("/")), d.push(g);
+        }
+      })).status !== "done") throw Error("sub-agent listing incomplete");
+      i.unshift(...d);
+    }
+  } catch (c) {
+    if (o) throw c;
+    return [];
+  }
+  return s;
+}
+function Vxe(e10) {
+  let t = [], n = 10, r = e10.length, o = 0;
+  while (o < r) {
+    let s = e10.indexOf(10, o);
+    if (s === -1) s = r;
+    let i = o;
+    while (i < s && e10[i] <= 32) i++;
+    if (o = s + 1, i >= s) continue;
+    let a = e10.toString("utf-8", i, s);
+    try {
+      let l = je(a), c = l.type;
+      if ((c === "user" || c === "assistant" || c === "attachment") && typeof l.uuid === "string") t.push(l);
+    } catch {
+    }
+  }
+  return t;
+}
+function qxe(e10) {
+  if (e10.length === 0) return [];
+  let t = /* @__PURE__ */ new Map();
+  for (let i of e10) t.set(i.uuid, i);
+  let n = e10.findLast((i) => i.type === "user" || i.type === "assistant");
+  if (!n) return [];
+  let r = [], o = /* @__PURE__ */ new Set(), s = n;
+  while (s) {
+    if (o.has(s.uuid)) break;
+    o.add(s.uuid), r.push(s), s = s.parentUuid ? t.get(s.parentUuid) : void 0;
+  }
+  return r.reverse(), r;
+}
+async function TF(e10, t, n, r) {
+  if (!Ve(e10)) return [];
+  let o = be(), s = o ? n : void 0, i = await AF(e10, t?.dir, s, o, r);
+  if (!i) return [];
+  return (await OF(i, s)).map((l) => l.agentId);
+}
+async function wF(e10, t, n, r, o) {
+  if (!Ve(e10)) return [];
+  if (!t) return [];
+  let s = be(), i = s ? r : void 0, a = await AF(e10, n?.dir, i, s, o);
+  if (!a) return [];
+  let c = (await OF(a, i)).find((g) => g.agentId === t);
+  if (!c) return [];
+  let d, p = i !== void 0 ? jxe(c.filePath) : null;
+  if (i !== void 0 && p !== null) try {
+    let g = await i.read([p]), _ = g.ok ? g.value.items[0] : void 0;
+    if (!_?.found) return [];
+    d = Buffer.from(_.value);
+  } catch {
+    return [];
+  }
+  else try {
+    d = await EF(c.filePath);
+  } catch {
+    return [];
+  }
+  let f, m;
+  try {
+    let g = c.filePath.replace(/\.jsonl$/, ".meta.json"), _ = i !== void 0 ? Bxe(g) : null, y;
+    if (i !== void 0 && _ !== null) {
+      let E = await i.read([_]);
+      if (!E.ok || !E.value.items[0]?.found) throw Error("sidecar absent");
+      y = Buffer.from(E.value.items[0].value).toString("utf-8");
+    } else y = await EF(g, "utf-8");
+    let S = je(y);
+    f = S.toolUseId, m = S.parentAgentId;
+  } catch {
+  }
+  return YR(d, n, f, m);
+}
+function YR(e10, t, n, r) {
+  if (e10.length === 0) return [];
+  let o = Vxe(e10), s = qxe(o), i = Du(n), a = typeof r === "string" && eS(r) ? r : void 0, l = FR(s, { keepMeta: true }).filter((c) => c.type === "user" || c.type === "assistant").map((c) => $R(c, i, a));
+  return HR(l, t);
+}
 function IF(e10, t) {
   let n = e10.data;
   if (n.isSidechain === true) return null;
@@ -43065,6 +43459,14 @@ async function jWt(e10) {
   if (e10?.sessionStore) return bJe(e10.sessionStore, e10);
   return X0(e10);
 }
+async function WWt(e10, t) {
+  if (t?.sessionStore) return wJe(t.sessionStore, e10, t.dir);
+  return TF(e10, t);
+}
+async function VWt(e10, t, n) {
+  if (n?.sessionStore) return xJe(n.sessionStore, e10, t, n);
+  return wF(e10, t, n);
+}
 function tJ(e10) {
   return e10.map((t) => ae(t)).join(`
 `) + `
@@ -43129,8 +43531,46 @@ async function RJe(e10, t, n) {
   if (!o || o.length === 0) return [];
   return M0(o, { limit: n.limit, offset: n.offset, includeSystemMessages: n.includeSystemMessages });
 }
+async function wJe(e10, t, n) {
+  if (!Ve(t)) return [];
+  if (!e10.listSubkeys) throw Error("sessionStore.listSubkeys is not implemented -- cannot list subagents. Provide a store with a listSubkeys() method.");
+  let r = Pn(n), o = await e10.listSubkeys({ projectKey: r, sessionId: t }), s = /* @__PURE__ */ new Set();
+  for (let i of o) {
+    if (!i.startsWith("subagents/")) continue;
+    let a = i.split("/").at(-1);
+    if (a.startsWith("agent-")) s.add(a.slice(6));
+  }
+  return [...s];
+}
+async function xJe(e10, t, n, r) {
+  if (!Ve(t)) return [];
+  if (!n) return [];
+  let o = Pn(r.dir), s = `subagents/agent-${n}`;
+  if (e10.listSubkeys) {
+    let p = await e10.listSubkeys({ projectKey: o, sessionId: t }), f = `agent-${n}`, m = p.find((g) => g.startsWith("subagents/") && g.split("/").at(-1) === f);
+    if (!m) return [];
+    s = m;
+  }
+  let i = await e10.load({ projectKey: o, sessionId: t, subpath: s });
+  if (!i || i.length === 0) return [];
+  let a = i.findLast(df), l = typeof a?.toolUseId === "string" ? a.toolUseId : void 0, c = typeof a?.parentAgentId === "string" ? a.parentAgentId : void 0, d = i.filter((p) => !df(p));
+  if (d.length === 0) return [];
+  return YR(Buffer.from(tJ(d)), { limit: r.limit, offset: r.offset }, l, c);
+}
 
 // src/runs/claude-adapter.ts
+var SUBAGENT_PAGE_SIZE = 500;
+var MAX_SUBAGENT_MESSAGES = 1e4;
+var MAX_SUBAGENT_BYTES = 8 * 1024 * 1024;
+var MAX_SESSION_SUBAGENT_BYTES = 32 * 1024 * 1024;
+var MAX_SUBAGENT_CACHE_BYTES = 64 * 1024 * 1024;
+function claudeMessageSummary(record) {
+  const message2 = asRecord(record.message);
+  const content = Array.isArray(message2.content) ? message2.content : [];
+  return content.map(asRecord).map(
+    (block) => block.type === "tool_use" ? String(block.name ?? "Tool call") : block.type === "tool_result" ? "Tool result" : block.type === "thinking" || block.type === "redacted_thinking" ? "Thinking" : String(block.type ?? "Claude message")
+  ).join(", ") || `Claude ${String(record.type)}`;
+}
 function findClaudeCodeExecutable(options = {}) {
   return findExecutable("claude", {
     ...options,
@@ -43276,6 +43716,23 @@ var ClaudeAdapter = class {
   };
   catalogPromise;
   hydrationCache = /* @__PURE__ */ new Map();
+  subagentHistoryCache = /* @__PURE__ */ new Map();
+  subagentHistoryCacheBytes = 0;
+  cacheSubagentHistory(key, entry) {
+    const previous = this.subagentHistoryCache.get(key);
+    if (previous) this.subagentHistoryCacheBytes -= previous.bytes;
+    this.subagentHistoryCache.delete(key);
+    if (entry) {
+      this.subagentHistoryCache.set(key, entry);
+      this.subagentHistoryCacheBytes += entry.bytes;
+    }
+    while (this.subagentHistoryCacheBytes > MAX_SUBAGENT_CACHE_BYTES) {
+      const oldest = this.subagentHistoryCache.keys().next().value;
+      if (oldest === void 0) break;
+      this.subagentHistoryCacheBytes -= this.subagentHistoryCache.get(oldest).bytes;
+      this.subagentHistoryCache.delete(oldest);
+    }
+  }
   catalog() {
     this.catalogPromise ??= (async () => {
       const messages = new MessageQueue();
@@ -43337,6 +43794,7 @@ var ClaudeAdapter = class {
         permissionMode: input.run.kind === "PLAN" ? "plan" : "bypassPermissions",
         allowDangerouslySkipPermissions: input.run.kind === "SESSION",
         includePartialMessages: true,
+        forwardSubagentText: true,
         env: { ...claudeEnvironment(), ...executionEnvironment() },
         spawnClaudeCodeProcess: ({ command: command3, args, cwd, env, signal: signal2 }) => spawnExecutionProcess(command3, args, {
           cwd,
@@ -43376,8 +43834,9 @@ var ClaudeAdapter = class {
       try {
         for await (const message2 of activeQuery) {
           const record = asRecord(message2);
+          const childMessage = typeof record.agent_id === "string" || typeof record.parent_tool_use_id === "string";
           const sessionId = typeof record.session_id === "string" ? record.session_id : void 0;
-          if (sessionId && sessionId !== nativeId) {
+          if (sessionId && sessionId !== nativeId && !childMessage) {
             nativeId = sessionId;
             const version = record.subtype === "init" && typeof record.claude_code_version === "string" ? record.claude_code_version : void 0;
             const path = await findClaudeSessionFile(
@@ -43394,11 +43853,14 @@ var ClaudeAdapter = class {
             record.message ?? record.result ?? record.summary
           );
           const type = String(record.type ?? "message").toUpperCase();
-          if (messageText) {
+          if (messageText || record.type === "assistant" || record.type === "user") {
             await callbacks.onEvent({
               type: type === "ASSISTANT" ? "ASSISTANT" : type,
-              summary: messageText.slice(0, 2e3),
-              detailMarkdown: messageText,
+              summary: (messageText || claudeMessageSummary(record)).slice(
+                0,
+                2e3
+              ),
+              detailMarkdown: messageText || void 0,
               raw: message2
             });
           } else if (record.type === "system" && record.subtype) {
@@ -43408,7 +43870,7 @@ var ClaudeAdapter = class {
               raw: message2
             });
           }
-          if (record.type === "result") {
+          if (record.type === "result" && !childMessage) {
             finalOutput = typeof record.result === "string" ? record.result : finalOutput;
             for (const usage2 of claudeModelUsages(record, input.run.model)) {
               await callbacks.onUsage(usage2);
@@ -43459,6 +43921,118 @@ var ClaudeAdapter = class {
   delete(nativeId, cwd) {
     return dJe(nativeId, { dir: cwd });
   }
+  async discoverSubagents(sessionId, folder, history, transcriptPath) {
+    let ids;
+    try {
+      ids = await WWt(sessionId, { dir: folder });
+    } catch {
+      return void 0;
+    }
+    const children = [];
+    let sessionBytes = 0;
+    for (const nativeId of [...new Set(ids)]) {
+      const cacheKey = JSON.stringify([sessionId, folder, nativeId]);
+      let fingerprint;
+      if (transcriptPath && !/[/\\]/.test(nativeId)) {
+        try {
+          const childPath = join7(
+            dirname5(transcriptPath),
+            sessionId,
+            "subagents",
+            `agent-${nativeId}`
+          );
+          const file = await stat3(`${childPath}.jsonl`);
+          const metadata2 = await stat3(`${childPath}.meta.json`).catch(
+            (error) => {
+              if (error.code === "ENOENT")
+                return null;
+              throw error;
+            }
+          );
+          if (file.isFile())
+            fingerprint = `${file.size}:${file.mtimeMs}:${metadata2?.size ?? "missing"}:${metadata2?.mtimeMs ?? "missing"}`;
+        } catch {
+        }
+      }
+      const cached = this.subagentHistoryCache.get(cacheKey);
+      if (cached && cached.fingerprint === fingerprint && sessionBytes + cached.bytes <= MAX_SESSION_SUBAGENT_BYTES) {
+        this.cacheSubagentHistory(cacheKey, cached);
+        children.push({
+          nativeId,
+          messages: cached.messages,
+          transcriptStatus: "AVAILABLE"
+        });
+        sessionBytes += cached.bytes;
+        continue;
+      }
+      this.cacheSubagentHistory(cacheKey);
+      const messages = [];
+      let transcriptStatus = "AVAILABLE";
+      let transcriptError;
+      let offset = 0;
+      let childBytes = 0;
+      try {
+        while (offset < MAX_SUBAGENT_MESSAGES) {
+          if (sessionBytes >= MAX_SESSION_SUBAGENT_BYTES) {
+            transcriptStatus = messages.length ? "PARTIAL" : "UNAVAILABLE";
+            transcriptError = "Session subagent transcript size limit reached.";
+            break;
+          }
+          const limit = Math.min(
+            SUBAGENT_PAGE_SIZE,
+            MAX_SUBAGENT_MESSAGES - offset
+          );
+          const page = await VWt(sessionId, nativeId, {
+            dir: folder,
+            limit,
+            offset
+          });
+          for (const message2 of page) {
+            const bytes = Buffer.byteLength(JSON.stringify(message2));
+            if (childBytes + bytes > MAX_SUBAGENT_BYTES || sessionBytes + bytes > MAX_SESSION_SUBAGENT_BYTES) {
+              transcriptStatus = messages.length ? "PARTIAL" : "UNAVAILABLE";
+              transcriptError = "Subagent transcript size limit reached.";
+              break;
+            }
+            messages.push(message2);
+            childBytes += bytes;
+            sessionBytes += bytes;
+          }
+          if (transcriptError || page.length < limit) break;
+          offset += page.length;
+          if (offset >= MAX_SUBAGENT_MESSAGES) {
+            transcriptStatus = "PARTIAL";
+            transcriptError = "Subagent transcript message limit reached.";
+          }
+        }
+        if (!messages.length && !transcriptError) {
+          transcriptStatus = "UNAVAILABLE";
+          transcriptError = "Subagent transcript was not found.";
+        }
+      } catch (error) {
+        transcriptStatus = messages.length ? "PARTIAL" : "UNAVAILABLE";
+        transcriptError = error instanceof Error ? error.message : "Subagent transcript failed.";
+      }
+      children.push({ nativeId, messages, transcriptStatus, transcriptError });
+      if (transcriptStatus === "AVAILABLE" && fingerprint) {
+        this.cacheSubagentHistory(cacheKey, {
+          fingerprint,
+          messages,
+          bytes: childBytes
+        });
+      }
+    }
+    const metadata = [
+      ...history.events ?? [],
+      ...children.flatMap((child) => child.messages)
+    ];
+    return children.map(
+      (child) => claudeSubagentSnapshot(child.nativeId, child.messages, metadata, {
+        transcriptStatus: child.transcriptStatus,
+        transcriptError: child.transcriptError
+      })
+    );
+  }
   async discover(worktrees) {
     const results = [];
     for (const worktree of worktrees) {
@@ -43505,6 +44079,12 @@ var ClaudeAdapter = class {
           } catch {
           }
         }
+        const subagents = await this.discoverSubagents(
+          session.sessionId,
+          worktree.folder,
+          history,
+          sessionInfo.nativeTranscriptPath
+        );
         results.push({
           nativeId: session.sessionId,
           worktreeId: worktree.id,
@@ -43515,7 +44095,8 @@ var ClaudeAdapter = class {
           createdAt: session.createdAt ? new Date(session.createdAt).toISOString() : void 0,
           updatedAt: new Date(session.lastModified).toISOString(),
           rawMetadata: session,
-          sessionInfo
+          sessionInfo,
+          ...subagents === void 0 ? {} : { subagents }
         });
       }
     }
@@ -43528,7 +44109,7 @@ init_promise();
 import { execFile as execFile2 } from "node:child_process";
 import { randomUUID as randomUUID3 } from "node:crypto";
 import { mkdir as mkdir2, rm as rm6 } from "node:fs/promises";
-import { dirname as dirname5, join as join8 } from "node:path";
+import { dirname as dirname6, join as join9 } from "node:path";
 import { promisify as promisify2 } from "node:util";
 
 // ../../node_modules/@opencode/client/dist/chunks/rpc-runtime-ve4aws36.js
@@ -43661,7 +44242,7 @@ function matchesVersion2(version, options) {
 
 // ../../node_modules/@opencode/client/dist/chunks/rpc-runtime-8ye1ye6f.js
 import { homedir as homedir6 } from "node:os";
-import { join as join7 } from "node:path";
+import { join as join8 } from "node:path";
 function decide2(service, options) {
   if (!matchesVersion2(service.version, options))
     return { _tag: "replace", pty: service.state === "ready" ? "handoff" : "clear" };
@@ -43677,7 +44258,7 @@ function fail(message2) {
   return { _tag: "fail", error: new Error(message2) };
 }
 function fallback2() {
-  return join7(process.env["XDG_STATE_HOME"] ?? join7(homedir6(), ".local", "state"), "opencode", "service.json");
+  return join8(process.env["XDG_STATE_HOME"] ?? join8(homedir6(), ".local", "state"), "opencode", "service.json");
 }
 function same2(left, right) {
   return left.id === right.id && left.version === right.version && left.url === right.url && left.pid === right.pid;
@@ -44013,12 +44594,12 @@ var supportedOpenCodeVersion = (version) => {
 var OpenCodeRuntime = class {
   constructor(isolated = false) {
     this.isolated = isolated;
-    this.stateDirectory = join8(
-      dirname5(configPath()),
+    this.stateDirectory = join9(
+      dirname6(configPath()),
       "opencode",
       isolated ? `run-${randomUUID3()}` : "agent"
     );
-    this.file = join8(this.stateDirectory, "opencode", "service.json");
+    this.file = join9(this.stateDirectory, "opencode", "service.json");
   }
   isolated;
   starting;
@@ -44064,7 +44645,7 @@ var OpenCodeRuntime = class {
         `OpenCode >=2.1.1 <3 is required; found ${stdout.trim()}`
       );
     const version = stdout.trim().replace(/^(?:opencode\s+)?v?/, "");
-    await mkdir2(dirname5(this.file), { recursive: true, mode: 448 });
+    await mkdir2(dirname6(this.file), { recursive: true, mode: 448 });
     try {
       const endpoint = await Service.ensure({
         file: this.file,
@@ -44135,7 +44716,7 @@ async function generateBranchName(naming, parentSignal) {
     ),
     12e4
   );
-  const directory = await mkdtemp2(join9(tmpdir2(), "aide-branch-"));
+  const directory = await mkdtemp2(join10(tmpdir2(), "aide-branch-"));
   const signal2 = controller.signal;
   const adapter = naming.provider === "CODEX" ? new CodexAdapter() : naming.provider === "CLAUDE" ? new ClaudeAdapter() : null;
   const runtime = naming.provider === "OPENCODE" ? new OpenCodeRuntime(true) : null;
@@ -44256,7 +44837,7 @@ var generateTicketBranch = async (payload, _timeout, signal2) => {
 // src/handlers/commands.ts
 import { chmod as chmod2, mkdtemp as mkdtemp3, realpath, rm as rm8, writeFile as writeFile4 } from "node:fs/promises";
 import { homedir as homedir7, tmpdir as tmpdir3 } from "node:os";
-import { join as join10 } from "node:path";
+import { join as join11 } from "node:path";
 
 // src/command-processes.ts
 import { createHash as createHash4 } from "node:crypto";
@@ -44403,9 +44984,9 @@ var runCommand = async (rawPayload, _timeoutMs, signal2, _onLog, context) => {
     throw new Error("Command output uploader is unavailable");
   }
   const directory = await mkdtemp3(
-    join10(tmpdir3(), commandScriptPrefix(context.agentId))
+    join11(tmpdir3(), commandScriptPrefix(context.agentId))
   );
-  const scriptPath = join10(directory, "command.sh");
+  const scriptPath = join11(directory, "command.sh");
   await writeFile4(scriptPath, payload.script, {
     encoding: "utf8",
     mode: 384
@@ -44649,9 +45230,9 @@ async function localBranchReport(folder, timeoutMs, signal2, unavailable) {
 }
 
 // src/handlers/codebases.ts
-import { readdir as readdir2, realpath as realpath3, stat as stat3 } from "node:fs/promises";
+import { readdir as readdir2, realpath as realpath3, stat as stat4 } from "node:fs/promises";
 import { homedir as homedir8 } from "node:os";
-import { dirname as dirname6, join as join12, resolve as resolve4 } from "node:path";
+import { dirname as dirname7, join as join13, resolve as resolve4 } from "node:path";
 
 // src/repository-metadata.ts
 import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
@@ -44721,7 +45302,7 @@ async function withMetadataKey(key, task, signal2) {
 // src/git-sync-snapshot.ts
 import { readFile as readFile5, rename as rename3, rm as rm9, writeFile as writeFile5 } from "node:fs/promises";
 import { randomUUID as randomUUID4 } from "node:crypto";
-import { join as join11 } from "node:path";
+import { join as join12 } from "node:path";
 async function git(folder, args, timeoutMs, signal2, allowMissing = false) {
   const result = await captureCommand({
     command: "git",
@@ -44851,7 +45432,7 @@ async function fetchPinnedRef(folder, remote, ref, timeoutMs, signal2) {
     signal2
   );
 }
-var leaseFile = (gitDirectory2) => join11(gitDirectory2, "aide-sync-push-lease.json");
+var leaseFile = (gitDirectory2) => join12(gitDirectory2, "aide-sync-push-lease.json");
 async function saveSyncPushLease(gitDirectory2, lease) {
   const destination = leaseFile(gitDirectory2);
   const temporary = `${destination}.${randomUUID4()}.tmp`;
@@ -44964,7 +45545,7 @@ function baseSnapshot(folder) {
 }
 async function fetchedAt(commonDirectory) {
   try {
-    return (await stat3(join12(commonDirectory, "FETCH_HEAD"))).mtime.toISOString();
+    return (await stat4(join13(commonDirectory, "FETCH_HEAD"))).mtime.toISOString();
   } catch {
     return null;
   }
@@ -44975,7 +45556,7 @@ async function inspectCodebaseProcess(selectedFolder, timeoutMs, signal2, expect
   let selected;
   try {
     selected = await realpath3(fallbackFolder);
-    if (!(await stat3(selected)).isDirectory())
+    if (!(await stat4(selected)).isDirectory())
       throw new Error("Folder is not a directory");
   } catch (error) {
     return {
@@ -45145,7 +45726,7 @@ var browseCodebaseDirectories = async (payload) => {
   const input = codebaseBrowsePayload(payload);
   const homePath = await realpath3(homedir8());
   const path = await realpath3(input.path ? resolve4(input.path) : homePath);
-  if (!(await stat3(path)).isDirectory())
+  if (!(await stat4(path)).isDirectory())
     throw new Error("Path is not a directory");
   const candidates = await readdir2(path, { withFileTypes: true });
   const entries = [];
@@ -45153,13 +45734,13 @@ var browseCodebaseDirectories = async (payload) => {
     if (candidate.isDirectory()) {
       entries.push({
         name: candidate.name,
-        path: join12(path, candidate.name),
+        path: join13(path, candidate.name),
         hidden: candidate.name.startsWith(".")
       });
     } else if (candidate.isSymbolicLink()) {
       try {
-        const target2 = join12(path, candidate.name);
-        if ((await stat3(target2)).isDirectory()) {
+        const target2 = join13(path, candidate.name);
+        if ((await stat4(target2)).isDirectory()) {
           entries.push({
             name: candidate.name,
             path: target2,
@@ -45173,7 +45754,7 @@ var browseCodebaseDirectories = async (payload) => {
   entries.sort((first, second) => first.name.localeCompare(second.name));
   const listing = {
     path,
-    parentPath: dirname6(path) === path ? null : dirname6(path),
+    parentPath: dirname7(path) === path ? null : dirname7(path),
     homePath,
     entries: entries.slice(0, 1e3),
     truncated: entries.length > 1e3
@@ -45204,76 +45785,165 @@ var refreshCodebase = async (payload, timeoutMs, signal2) => {
     )
   };
 };
-async function updateBaseBranchAfterFetch(folder, baseBranch, timeoutMs, signal2) {
-  const localRef = `refs/heads/${baseBranch}`;
-  const remoteRef = `refs/remotes/origin/${baseBranch}`;
+async function updateBaseBranchAfterFetch(folder, baseBranch, timeoutMs, signal2, expectedOrigin, expectedGitDirectory) {
   try {
-    const validRef = await git2(
-      folder,
-      ["check-ref-format", localRef],
-      timeoutMs,
-      signal2
-    );
-    if (validRef.exitCode !== 0) return false;
-    const staged = await git2(
-      folder,
-      ["diff", "--cached", "--quiet"],
-      timeoutMs,
-      signal2
-    );
-    if (staged.exitCode !== 0) return false;
-    const remoteExists = await git2(
-      folder,
-      ["show-ref", "--verify", "--quiet", remoteRef],
-      timeoutMs,
-      signal2
-    );
-    if (remoteExists.exitCode !== 0) return false;
-    const remoteTip = requireSuccess(
-      await git2(folder, ["rev-parse", remoteRef], timeoutMs, signal2),
-      "Could not pin the fetched base branch"
-    ).stdout.trim();
-    const currentBranch2 = await git2(
+    return await withRepositoryMetadata(
       folder,
-      ["symbolic-ref", "--short", "-q", "HEAD"],
-      timeoutMs,
+      async () => {
+        if (expectedGitDirectory) {
+          const directory = await git2(
+            folder,
+            ["rev-parse", "--path-format=absolute", "--git-dir"],
+            timeoutMs,
+            signal2
+          );
+          if (directory.exitCode !== 0 || await realpath3(directory.stdout.trim()) !== expectedGitDirectory)
+            return false;
+        }
+        const current = await git2(
+          folder,
+          ["symbolic-ref", "--short", "-q", "HEAD"],
+          timeoutMs,
+          signal2
+        );
+        if (current.exitCode !== 0 || current.stdout.trim() !== baseBranch)
+          return false;
+        if (expectedOrigin) {
+          const remote = await git2(
+            folder,
+            ["remote", "get-url", "origin"],
+            timeoutMs,
+            signal2
+          );
+          if (remote.exitCode !== 0 || normalizeGitOrigin(remote.stdout.trim()).canonicalOrigin !== expectedOrigin)
+            return false;
+        }
+        const status2 = await git2(
+          folder,
+          [
+            "status",
+            "--porcelain=v1",
+            "-z",
+            "--untracked-files=all",
+            "--ignore-submodules=none"
+          ],
+          timeoutMs,
+          signal2
+        );
+        if (status2.exitCode !== 0 || status2.outputTruncated || status2.stdout)
+          return false;
+        for (const name of [
+          "MERGE_HEAD",
+          "rebase-merge",
+          "rebase-apply",
+          "CHERRY_PICK_HEAD",
+          "REVERT_HEAD"
+        ]) {
+          const path = await git2(
+            folder,
+            ["rev-parse", "--path-format=absolute", "--git-path", name],
+            timeoutMs,
+            signal2
+          );
+          if (path.exitCode !== 0) return false;
+          try {
+            await stat4(path.stdout.trim());
+            return false;
+          } catch (error) {
+            if (error.code !== "ENOENT") throw error;
+          }
+        }
+        const remoteRef = `refs/remotes/origin/${baseBranch}`;
+        const valid = await git2(
+          folder,
+          ["check-ref-format", remoteRef],
+          timeoutMs,
+          signal2
+        );
+        if (valid.exitCode !== 0) return false;
+        const tip = await git2(
+          folder,
+          ["rev-parse", "--verify", remoteRef],
+          timeoutMs,
+          signal2
+        );
+        if (tip.exitCode !== 0) return false;
+        const ancestor = await git2(
+          folder,
+          ["merge-base", "--is-ancestor", "HEAD", tip.stdout.trim()],
+          timeoutMs,
+          signal2
+        );
+        if (ancestor.exitCode !== 0) return false;
+        const branch = await git2(
+          folder,
+          ["symbolic-ref", "--short", "-q", "HEAD"],
+          timeoutMs,
+          signal2
+        );
+        if (branch.exitCode !== 0 || branch.stdout.trim() !== baseBranch)
+          return false;
+        return (await git2(
+          folder,
+          ["merge", "--ff-only", tip.stdout.trim()],
+          timeoutMs,
+          signal2
+        )).exitCode === 0;
+      },
       signal2
     );
-    if (currentBranch2.exitCode === 0 && currentBranch2.stdout.trim() === baseBranch) {
-      const merged = await git2(
-        folder,
-        ["merge", "--ff-only", remoteTip],
-        timeoutMs,
-        signal2
-      );
-      return merged.exitCode === 0;
-    }
-    const localExists = await git2(
+  } catch (error) {
+    if (signal2.aborted) throw error;
+    return false;
+  }
+}
+async function updateDefaultBranchesAfterFetch(folder, defaultBranch, patterns, timeoutMs, signal2, withCheckout, expectedOrigin) {
+  const listed = requireSuccess(
+    await git2(
       folder,
-      ["show-ref", "--verify", "--quiet", localRef],
+      ["worktree", "list", "--porcelain", "-z"],
       timeoutMs,
       signal2
-    );
-    if (localExists.exitCode === 0) {
-      const fastForward = await git2(
-        folder,
-        ["merge-base", "--is-ancestor", localRef, remoteTip],
-        timeoutMs,
-        signal2
+    ),
+    "Could not list worktrees"
+  );
+  if (listed.outputTruncated) return;
+  for (const block of listed.stdout.split("\0\0")) {
+    signal2.throwIfAborted();
+    const fields = block.split("\0");
+    if (fields.some((field) => field.startsWith("prunable")) || fields.includes("bare"))
+      continue;
+    const checkout = fields.find((field) => field.startsWith("worktree "))?.slice(9);
+    const branch = fields.find((field) => field.startsWith("branch refs/heads/"))?.slice(18);
+    if (!checkout || !isDefaultBranch(branch, defaultBranch, patterns))
+      continue;
+    try {
+      const path = await realpath3(checkout);
+      const directory = requireSuccess(
+        await git2(
+          path,
+          ["rev-parse", "--path-format=absolute", "--git-dir"],
+          timeoutMs,
+          signal2
+        ),
+        "Could not resolve worktree"
+      ).stdout.trim();
+      const expectedGitDirectory = await realpath3(directory);
+      await withCheckout(
+        path,
+        expectedGitDirectory,
+        () => updateBaseBranchAfterFetch(
+          path,
+          branch,
+          timeoutMs,
+          signal2,
+          expectedOrigin,
+          expectedGitDirectory
+        )
       );
-      if (fastForward.exitCode !== 0) return false;
-    } else if (localExists.exitCode !== 1) {
-      return false;
+    } catch (error) {
+      if (signal2.aborted) throw error;
     }
-    const updated = await git2(
-      folder,
-      ["branch", "--force", baseBranch, remoteTip],
-      timeoutMs,
-      signal2
-    );
-    return updated.exitCode === 0;
-  } catch {
-    return false;
   }
 }
 var fetchCodebase = async (payload, timeoutMs, signal2, onLog, context) => {
@@ -45312,46 +45982,37 @@ var fetchCodebase = async (payload, timeoutMs, signal2, onLog, context) => {
     if (error instanceof InterruptedGitInspection) return error.result;
     throw error;
   }
-  if (result.exitCode === 0 && input.keepBaseBranchUpToDate && input.baseBranch) {
-    await log2("Updating the base branch where it can be fast-forwarded");
-    const update = () => updateBaseBranchAfterFetch(
+  if (result.exitCode === 0 && input.keepBaseBranchUpToDate) {
+    await log2(
+      "Updating clean default branch worktrees from their matching origin branches"
+    );
+    await updateDefaultBranchesAfterFetch(
       input.folder,
-      input.baseBranch,
+      input.baseBranch ?? null,
+      input.defaultBranchPatterns ?? [],
       timeoutMs,
-      signal2
-    );
-    const gitDirectory2 = requireSuccess(
-      await git2(
-        input.folder,
-        ["rev-parse", "--path-format=absolute", "--git-dir"],
-        timeoutMs,
-        signal2
-      ),
-      "Could not resolve base worktree"
-    ).stdout.trim();
-    const grant = context?.tryWithOperationResources ? await context.tryWithOperationResources(
-      [
-        {
-          kind: "WORKTREE",
-          key: `${context.agentId}:worktree:${await realpath3(gitDirectory2)}`,
-          agentId: context.agentId,
-          codebaseId: input.codebaseId,
-          mode: "WRITE"
-        },
-        {
-          kind: "PATH",
-          key: input.folder,
-          path: input.folder,
-          agentId: context.agentId,
-          codebaseId: input.codebaseId,
-          mode: "WRITE"
-        }
-      ],
-      update
-    ) : { ran: true, result: await update() };
-    const updated = grant.ran && grant.result;
-    await log2(
-      updated ? "Base branch updated" : "Base branch left unchanged because it could not be safely fast-forwarded"
+      signal2,
+      (folder, gitDirectory2, update) => context?.tryWithOperationResources ? context.tryWithOperationResources(
+        [
+          {
+            kind: "WORKTREE",
+            key: `${context.agentId}:worktree:${gitDirectory2}`,
+            agentId: context.agentId,
+            codebaseId: input.codebaseId,
+            mode: "WRITE"
+          },
+          {
+            kind: "PATH",
+            key: folder,
+            path: folder,
+            agentId: context.agentId,
+            codebaseId: input.codebaseId,
+            mode: "WRITE"
+          }
+        ],
+        update
+      ) : update(),
+      input.expectedOrigin
     );
   }
   const afterResult = await inspectCodebaseProcess(
@@ -45986,9 +46647,9 @@ import {
   rmdir
 } from "node:fs/promises";
 import {
-  dirname as dirname8,
+  dirname as dirname9,
   isAbsolute as isAbsolute4,
-  join as join14,
+  join as join15,
   parse as parse3,
   relative as relative2,
   resolve as resolve6,
@@ -45998,7 +46659,7 @@ import {
 // src/repository-coordinator.ts
 import { AsyncLocalStorage as AsyncLocalStorage3 } from "node:async_hooks";
 import { lstat, readlink, realpath as realpath4 } from "node:fs/promises";
-import { basename as basename2, dirname as dirname7, join as join13, resolve as resolve5 } from "node:path";
+import { basename as basename2, dirname as dirname8, join as join14, resolve as resolve5 } from "node:path";
 async function canonicalResourcePath(path) {
   const absolute = resolve5(path);
   try {
@@ -46008,15 +46669,15 @@ async function canonicalResourcePath(path) {
     try {
       if ((await lstat(absolute)).isSymbolicLink())
         return canonicalResourcePath(
-          resolve5(dirname7(absolute), await readlink(absolute))
+          resolve5(dirname8(absolute), await readlink(absolute))
         );
     } catch (linkError) {
       if (linkError.code !== "ENOENT")
         throw linkError;
     }
-    const parent = dirname7(absolute);
+    const parent = dirname8(absolute);
     if (parent === absolute) throw error;
-    return join13(await canonicalResourcePath(parent), basename2(absolute));
+    return join14(await canonicalResourcePath(parent), basename2(absolute));
   }
 }
 var RepositoryCoordinator = class {
@@ -46342,7 +47003,7 @@ async function safeDirectory(path, create) {
   const absolute = resolve6(path);
   let current = parse3(absolute).root;
   for (const component of absolute.slice(current.length).split(sep3).filter(Boolean)) {
-    current = join14(current, component);
+    current = join15(current, component);
     let info;
     try {
       info = await lstat2(current);
@@ -46377,7 +47038,7 @@ var inspectCloneDestination = async (value, timeoutMs, signal2) => {
     throw new Error("Clone base directory must be absolute on this agent");
   const destination = resolve6(payload.baseDirectory, payload.relativePath);
   try {
-    await safeDirectory(dirname8(destination), false);
+    await safeDirectory(dirname9(destination), false);
     const info = await lstat2(destination);
     if (info.isSymbolicLink() || !info.isDirectory())
       throw new Error(
@@ -46431,7 +47092,7 @@ var cloneCodebase = async (value, timeoutMs, signal2) => {
     const deadline = Date.now() + timeoutMs;
     const remaining = () => Math.max(0, deadline - Date.now());
     await safeDirectory(payload.baseDirectory, true);
-    const parent = await safeDirectory(dirname8(destination), true);
+    const parent = await safeDirectory(dirname9(destination), true);
     const parentIdentity = await lstat2(parent);
     const existing = await lstat2(destination).catch((error) => {
       if (missing(error)) return null;
@@ -46456,9 +47117,9 @@ var cloneCodebase = async (value, timeoutMs, signal2) => {
       }
       return { ...success, snapshot, reused: true };
     }
-    const staging = await mkdtemp4(join14(parent, ".aide-clone-"));
+    const staging = await mkdtemp4(join15(parent, ".aide-clone-"));
     const stagingIdentity = await lstat2(staging);
-    const checkout = join14(staging, "checkout");
+    const checkout = join15(staging, "checkout");
     const verifyStaging = async () => {
       if (!await ownsDirectory(parent, parentIdentity, staging, stagingIdentity)) {
         throw new Error(
@@ -46538,8 +47199,8 @@ var cloneCodebase = async (value, timeoutMs, signal2) => {
 };
 
 // src/handlers/coverage.ts
-import { readFile as readFile7, realpath as realpath7, stat as stat5 } from "node:fs/promises";
-import { join as join16, relative as relative5, sep as sep6 } from "node:path";
+import { readFile as readFile7, realpath as realpath7, stat as stat6 } from "node:fs/promises";
+import { join as join17, relative as relative5, sep as sep6 } from "node:path";
 
 // src/handlers/builds.ts
 import { createHash as createHash6, randomUUID as randomUUID5 } from "node:crypto";
@@ -46553,7 +47214,7 @@ import {
   realpath as realpath6,
   rename as rename5,
   rm as rm11,
-  stat as stat4,
+  stat as stat5,
   writeFile as writeFile6
 } from "node:fs/promises";
 import { createReadStream as createReadStream5, createWriteStream as createWriteStream2 } from "node:fs";
@@ -46562,9 +47223,9 @@ import { pipeline } from "node:stream/promises";
 import { StringDecoder } from "node:string_decoder";
 import {
   basename as basename3,
-  dirname as dirname9,
+  dirname as dirname10,
   isAbsolute as isAbsolute6,
-  join as join15,
+  join as join16,
   relative as relative4,
   resolve as resolve8,
   sep as sep5
@@ -46965,7 +47626,7 @@ function requireSuccess2(result, fallback) {
 }
 async function validateWorktree(input, timeoutMs, signal2) {
   const folder = await realpath6(input.folder);
-  if (!(await stat4(folder)).isDirectory())
+  if (!(await stat5(folder)).isDirectory())
     throw new Error("Worktree is missing");
   const gitDirectory2 = requireSuccess2(
     await command(
@@ -47012,7 +47673,7 @@ async function validateSource(root, source) {
   if (difference === ".." || difference.startsWith(`..${sep5}`) || isAbsolute6(difference)) {
     throw new Error("Build source resolves outside the worktree");
   }
-  const information = await stat4(resolved);
+  const information = await stat5(resolved);
   if (source.kind === "PACKAGE" && !information.isFile()) {
     throw new Error("Package.swift is missing");
   }
@@ -47028,7 +47689,7 @@ async function discoverSourcesInFolder(folder) {
     const current = queue.shift();
     for (const entry of await readdir3(current, { withFileTypes: true })) {
       if (entry.isSymbolicLink()) continue;
-      const absolute = join15(current, entry.name);
+      const absolute = join16(current, entry.name);
       const path = relative4(folder, absolute).split(sep5).join("/");
       if (entry.isDirectory()) {
         if (entry.name.endsWith(".xcodeproj")) {
@@ -47099,7 +47760,7 @@ function metadataFromList(value) {
   };
 }
 async function workspaceProjectPaths(workspacePath2, folder) {
-  const contentsPath = join15(workspacePath2, "contents.xcworkspacedata");
+  const contentsPath = join16(workspacePath2, "contents.xcworkspacedata");
   let contents;
   try {
     contents = await readFile6(contentsPath, "utf8");
@@ -47120,7 +47781,7 @@ async function workspaceProjectPaths(workspacePath2, folder) {
   }).filter((path) => path.endsWith(".xcodeproj"));
   const projects = [];
   for (const location of locations) {
-    const candidate = resolve8(dirname9(workspacePath2), location);
+    const candidate = resolve8(dirname10(workspacePath2), location);
     const difference = relative4(folder, candidate);
     if (difference === ".." || difference.startsWith(`..${sep5}`) || isAbsolute6(difference)) {
       continue;
@@ -47128,7 +47789,7 @@ async function workspaceProjectPaths(workspacePath2, folder) {
     try {
       const resolved = await realpath6(candidate);
       const resolvedDifference = relative4(folder, resolved);
-      if (resolvedDifference === ".." || resolvedDifference.startsWith(`..${sep5}`) || isAbsolute6(resolvedDifference) || !(await stat4(resolved)).isDirectory()) {
+      if (resolvedDifference === ".." || resolvedDifference.startsWith(`..${sep5}`) || isAbsolute6(resolvedDifference) || !(await stat5(resolved)).isDirectory()) {
         continue;
       }
       projects.push(resolved);
@@ -47319,7 +47980,7 @@ async function dependentSigningRequirements(source, absolutePath, folder, rootTa
   for (const project of projects.slice(0, 50)) {
     const converted = await command(
       "plutil",
-      ["-convert", "json", "-o", "-", join15(project, "project.pbxproj")],
+      ["-convert", "json", "-o", "-", join16(project, "project.pbxproj")],
       Math.min(timeoutMs, 15e3),
       signal2,
       folder
@@ -47580,8 +48241,8 @@ function physicalDestinations(value, includeUnavailable = false) {
   });
 }
 async function listPhysicalDevices(timeoutMs, signal2, includeUnavailable = false) {
-  const directory = await mkdtemp5(join15(tmpdir4(), "ade-devices-"));
-  const output = join15(directory, "devices.json");
+  const directory = await mkdtemp5(join16(tmpdir4(), "ade-devices-"));
+  const output = join16(directory, "devices.json");
   try {
     const result = await command(
       "xcrun",
@@ -48033,7 +48694,7 @@ function actionArgument(action) {
   }[action];
 }
 function xcodeBuildArguments(input) {
-  const resultBundle = join15(input.artifactDirectory, "result.xcresult");
+  const resultBundle = join16(input.artifactDirectory, "result.xcresult");
   const sourcePath = containedPath2(input.folder, input.source.relativePath);
   const usesCapturedTestProducts = input.action === "TEST_WITHOUT_BUILDING";
   const args = [
@@ -48056,13 +48717,13 @@ function xcodeBuildArguments(input) {
   if (input.action === "ARCHIVE") {
     args.push(
       "-archivePath",
-      join15(input.artifactDirectory, "archive.xcarchive")
+      join16(input.artifactDirectory, "archive.xcarchive")
     );
   }
   if (input.action === "BUILD_FOR_TESTING") {
     args.push(
       "-testProductsPath",
-      join15(input.artifactDirectory, "test-products.xctestproducts")
+      join16(input.artifactDirectory, "test-products.xctestproducts")
     );
   }
   if (input.action === "TEST_WITHOUT_BUILDING" && input.advancedSettings.priorTestProductsPath) {
@@ -48126,15 +48787,15 @@ function classifyFailure(output) {
 }
 async function runHook(options) {
   const phaseDirectory = options.phase === "PRE_BUILD" ? "pre" : "post";
-  const directory = join15(
+  const directory = join16(
     options.input.artifactDirectory,
     "hooks",
     phaseDirectory
   );
   const prefix = `${String(options.script.position).padStart(3, "0")}-${options.script.id}`;
-  const file = join15(directory, `${prefix}.mjs`);
-  const runner = join15(directory, `${prefix}.runner.mjs`);
-  const log2 = join15(directory, `${prefix}.log`);
+  const file = join16(directory, `${prefix}.mjs`);
+  const runner = join16(directory, `${prefix}.runner.mjs`);
+  const log2 = join16(directory, `${prefix}.log`);
   const started = Date.now();
   try {
     await mkdir4(directory, { recursive: true, mode: 448 });
@@ -48229,26 +48890,26 @@ if (typeof hookModule.default === "function") {
 }
 async function pathExists(path) {
   try {
-    await stat4(path);
+    await stat5(path);
     return true;
   } catch {
     return false;
   }
 }
 async function pathSize(path) {
-  const information = await stat4(path);
+  const information = await stat5(path);
   if (information.isFile()) return information.size;
   if (!information.isDirectory()) return 0;
   let size = 0;
   for (const entry of await readdir3(path, { withFileTypes: true })) {
     if (entry.isSymbolicLink()) continue;
-    size += await pathSize(join15(path, entry.name));
+    size += await pathSize(join16(path, entry.name));
   }
   return size;
 }
 async function fileChecksum(path) {
   try {
-    const information = await stat4(path);
+    const information = await stat5(path);
     if (!information.isFile()) return null;
     const hash = createHash6("sha256");
     await pipeline(createReadStream5(path), hash);
@@ -48272,7 +48933,7 @@ async function plistString(plistPath, keyPath, timeoutMs, signal2) {
   }
 }
 async function archiveApplicationProperties(archivePath, timeoutMs, signal2) {
-  const plistPath = join15(archivePath, "Info.plist");
+  const plistPath = join16(archivePath, "Info.plist");
   const read3 = (key) => plistString(plistPath, `ApplicationProperties.${key}`, timeoutMs, signal2);
   const [bundleIdentifier2, bundleShortVersion, bundleVersion, applicationPath] = await Promise.all([
     read3("CFBundleIdentifier"),
@@ -48431,9 +49092,9 @@ function normalizeCoverage(value) {
   };
 }
 async function writeJsonReport(input, kind, timeoutMs, signal2) {
-  const resultBundle = join15(input.artifactDirectory, "result.xcresult");
+  const resultBundle = join16(input.artifactDirectory, "result.xcresult");
   const filename = kind === "TEST_RESULTS" ? "test-results.json" : "code-coverage.json";
-  const destination = join15(input.artifactDirectory, filename);
+  const destination = join16(input.artifactDirectory, filename);
   const temporary = `${destination}.tmp-${randomUUID5()}`;
   try {
     if (!await pathExists(resultBundle)) {
@@ -48575,7 +49236,7 @@ async function snapshotCoverageChangesLocked(baseBranch, folder, timeoutMs, sign
   const types = changeTypesFromStatus(status2.stdout);
   for (const path of untracked.stdout.split("\0").filter(Boolean)) {
     try {
-      const contents = await readFile6(join15(folder, path));
+      const contents = await readFile6(join16(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(
@@ -48638,7 +49299,7 @@ async function addChangedCoverage(report, changes, input, folder, timeoutMs, sig
     );
     let lines = EMPTY_COVERAGE_LINES;
     if (coveragePath && change.lines.length) {
-      const temporary2 = join15(
+      const temporary2 = join16(
         input.artifactDirectory,
         `.changed-coverage-${randomUUID5()}.json`
       );
@@ -48689,7 +49350,7 @@ async function addChangedCoverage(report, changes, input, folder, timeoutMs, sig
     changedLineCoverage: changedExecutableLines ? changedCoveredLines / changedExecutableLines : null
   };
   const data = { ...report.data, changedFiles };
-  const destination = join15(input.artifactDirectory, "worktree-coverage.json");
+  const destination = join16(input.artifactDirectory, "worktree-coverage.json");
   const temporary = `${destination}.tmp-${randomUUID5()}`;
   await writeFile6(temporary, JSON.stringify({ summary, data }, null, 2), {
     mode: 384
@@ -48743,7 +49404,7 @@ async function findFiles(root, predicate, limit = 20) {
     }
     for (const entry of entries) {
       if (entry.isSymbolicLink()) continue;
-      const path = join15(current, entry.name);
+      const path = join16(current, entry.name);
       if (entry.isDirectory()) queue.push(path);
       else if (entry.isFile() && predicate(entry.name)) results.push(path);
       if (results.length >= limit) break;
@@ -48781,18 +49442,18 @@ async function dwarfdumpUuids(paths, signal2) {
 }
 async function captureDsyms(input, entries, signal2) {
   const sources = [];
-  const archiveDsyms = join15(
+  const archiveDsyms = join16(
     input.artifactDirectory,
     "archive.xcarchive",
     "dSYMs"
   );
   if (input.action === "ARCHIVE" && await pathExists(archiveDsyms)) {
     for (const name of await readdir3(archiveDsyms)) {
-      if (name.endsWith(".dSYM")) sources.push(join15(archiveDsyms, name));
+      if (name.endsWith(".dSYM")) sources.push(join16(archiveDsyms, name));
     }
   } else {
     const binaries = entries.map(
-      ({ buildSettings: settings }) => settings.TARGET_BUILD_DIR && settings.EXECUTABLE_PATH ? join15(settings.TARGET_BUILD_DIR, settings.EXECUTABLE_PATH) : null
+      ({ buildSettings: settings }) => settings.TARGET_BUILD_DIR && settings.EXECUTABLE_PATH ? join16(settings.TARGET_BUILD_DIR, settings.EXECUTABLE_PATH) : null
     ).filter((path) => Boolean(path));
     const existing = [];
     for (const binary of new Set(binaries)) {
@@ -48808,21 +49469,21 @@ async function captureDsyms(input, entries, signal2) {
       if (!await pathExists(folder)) continue;
       for (const name of await readdir3(folder)) {
         if (!name.endsWith(".dSYM")) continue;
-        const bundle = join15(folder, name);
+        const bundle = join16(folder, name);
         const uuids = await dwarfdumpUuids([bundle], signal2);
         if (uuids.some((entry) => built.has(entry.uuid))) sources.push(bundle);
       }
     }
   }
   if (!sources.length) return null;
-  const staging = join15(input.artifactDirectory, "dSYMs");
-  const zipPath = join15(input.artifactDirectory, DSYMS_ARTIFACT_FILENAME);
+  const staging = join16(input.artifactDirectory, "dSYMs");
+  const zipPath = join16(input.artifactDirectory, DSYMS_ARTIFACT_FILENAME);
   await rm11(staging, { recursive: true, force: true });
   await rm11(zipPath, { force: true });
   await mkdir4(staging, { recursive: true, mode: 448 });
   try {
     for (const source of sources) {
-      await cp(source, join15(staging, basename3(source)), {
+      await cp(source, join16(staging, basename3(source)), {
         recursive: true,
         preserveTimestamps: true
       });
@@ -48839,7 +49500,7 @@ async function captureDsyms(input, entries, signal2) {
       );
     }
     const uuids = await dwarfdumpUuids(
-      sources.map((source) => join15(staging, basename3(source))),
+      sources.map((source) => join16(staging, basename3(source))),
       signal2
     );
     return await artifact(
@@ -48857,7 +49518,7 @@ async function captureDsyms(input, entries, signal2) {
 }
 async function captureArtifacts(input, folder, signal2, includeProducts = true) {
   const artifacts = [];
-  const resultBundle = join15(input.artifactDirectory, "result.xcresult");
+  const resultBundle = join16(input.artifactDirectory, "result.xcresult");
   if (await pathExists(resultBundle)) {
     const coverageProbe = await command(
       "xcrun",
@@ -48884,7 +49545,7 @@ async function captureArtifacts(input, folder, signal2, includeProducts = true)
     );
   }
   if (!includeProducts) return artifacts;
-  const archivePath = join15(input.artifactDirectory, "archive.xcarchive");
+  const archivePath = join16(input.artifactDirectory, "archive.xcarchive");
   if (await pathExists(archivePath)) {
     artifacts.push(
       await artifact(input.artifactDirectory, "ARCHIVE", archivePath)
@@ -48921,10 +49582,10 @@ async function captureArtifacts(input, folder, signal2, includeProducts = true)
   if (apps.length === 1) {
     const settings = apps[0].buildSettings;
     const productName = settings.FULL_PRODUCT_NAME ?? settings.WRAPPER_NAME;
-    const source = settings.TARGET_BUILD_DIR && productName ? join15(settings.TARGET_BUILD_DIR, productName) : null;
+    const source = settings.TARGET_BUILD_DIR && productName ? join16(settings.TARGET_BUILD_DIR, productName) : null;
     if (source && await pathExists(source)) {
-      const productDirectory = join15(input.artifactDirectory, "products");
-      const destination = join15(productDirectory, basename3(source));
+      const productDirectory = join16(input.artifactDirectory, "products");
+      const destination = join16(productDirectory, basename3(source));
       await mkdir4(productDirectory, { recursive: true, mode: 448 });
       await rm11(destination, { recursive: true, force: true });
       await cp(source, destination, {
@@ -48944,7 +49605,7 @@ async function captureArtifacts(input, folder, signal2, includeProducts = true)
     }
   }
   if (input.action === "BUILD_FOR_TESTING") {
-    const testDirectory = join15(
+    const testDirectory = join16(
       input.artifactDirectory,
       "test-products.xctestproducts"
     );
@@ -48971,8 +49632,8 @@ var runIosBuild = async (payload, timeoutMs, signal2, onLog, context) => {
   const input = parseBuildJobPayload(payload);
   if (!input.worktreeId || /[\\/\0]/.test(input.worktreeId) || input.worktreeId === "." || input.worktreeId === "..")
     throw new Error("Invalid build worktree identifier");
-  const derivedDataPath = input.derivedDataPath ?? join15(
-    dirname9(input.artifactDirectory),
+  const derivedDataPath = input.derivedDataPath ?? join16(
+    dirname10(input.artifactDirectory),
     ".worktree-derived-data",
     input.worktreeId
   );
@@ -49068,7 +49729,7 @@ var runIosBuildWithPaths = async (payload, timeoutMs, signal2, onLog, context) =
   if (input.derivedDataPath) {
     await mkdir4(input.derivedDataPath, { recursive: true, mode: 448 });
     await writeFile6(
-      join15(input.derivedDataPath, ".aide-worktree.json"),
+      join16(input.derivedDataPath, ".aide-worktree.json"),
       `${JSON.stringify({ version: 1, worktreeId: input.worktreeId, folder })}
 `,
       { mode: 384 }
@@ -49078,10 +49739,10 @@ var runIosBuildWithPaths = async (payload, timeoutMs, signal2, onLog, context) =
     const testProductsPath = input.advancedSettings.priorTestProductsPath;
     const xctestrunPath = input.advancedSettings.priorXctestrunPath;
     if (testProductsPath) {
-      if (!testProductsPath.endsWith(".xctestproducts") || !await pathExists(testProductsPath) || !(await stat4(testProductsPath)).isDirectory()) {
+      if (!testProductsPath.endsWith(".xctestproducts") || !await pathExists(testProductsPath) || !(await stat5(testProductsPath)).isDirectory()) {
         throw new Error("The captured test-products artifact is unavailable");
       }
-    } else if (!xctestrunPath?.endsWith(".xctestrun") || !await pathExists(xctestrunPath) || !(await stat4(xctestrunPath)).isFile()) {
+    } else if (!xctestrunPath?.endsWith(".xctestrun") || !await pathExists(xctestrunPath) || !(await stat5(xctestrunPath)).isFile()) {
       throw new Error("The captured .xctestrun artifact is unavailable");
     }
   }
@@ -49094,11 +49755,11 @@ var runIosBuildWithPaths = async (payload, timeoutMs, signal2, onLog, context) =
     signal2
   );
   await mkdir4(input.artifactDirectory, { recursive: true, mode: 448 });
-  const rawLog = join15(input.artifactDirectory, "build.log");
+  const rawLog = join16(input.artifactDirectory, "build.log");
   const logger = new BuildLogger(input.buildId, context, rawLog, process.env);
   try {
     const scriptExecutions = [];
-    const contextPath = join15(input.artifactDirectory, "context.json");
+    const contextPath = join16(input.artifactDirectory, "context.json");
     const baseHookContext = {
       buildId: input.buildId,
       branch: input.branch ?? null,
@@ -49123,15 +49784,40 @@ var runIosBuildWithPaths = async (payload, timeoutMs, signal2, onLog, context) =
     let errorCode = null;
     let error = null;
     let failBuild = false;
-    try {
-      await context?.reportBuildProgress?.({
-        buildId: input.buildId,
-        status: "PREPARING",
-        startedAt: (/* @__PURE__ */ new Date()).toISOString()
+    let progressStatus = "PREPARING";
+    const reportProgress = async (progress) => {
+      try {
+        await context?.reportBuildProgress?.({
+          ...progress,
+          buildId: input.buildId
+        });
+      } catch (progressError) {
+        logger.emit(progress.status, "SYSTEM", cleanError2(progressError));
+      }
+    };
+    const runReportedHook = async (options) => {
+      await reportProgress({
+        status: progressStatus,
+        scriptExecutions: [
+          {
+            phase: options.phase,
+            position: options.script.position,
+            status: "RUNNING"
+          }
+        ]
       });
-    } catch (progressError) {
-      logger.emit("PREPARING", "SYSTEM", cleanError2(progressError));
-    }
+      const execution = await runHook(options);
+      scriptExecutions.push(execution);
+      await reportProgress({
+        status: progressStatus,
+        scriptExecutions: [execution]
+      });
+      return execution;
+    };
+    await reportProgress({
+      status: "PREPARING",
+      startedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
     logger.emit("PREPARING", "SYSTEM", `Preparing build in ${folder}`);
     try {
       await onLog({
@@ -49167,7 +49853,7 @@ var runIosBuildWithPaths = async (payload, timeoutMs, signal2, onLog, context) =
         (a, b) => a.position - b.position
       )) {
         if (!script.preBuildScript) continue;
-        const execution = await runHook({
+        const execution = await runReportedHook({
           input,
           folder,
           script,
@@ -49178,7 +49864,6 @@ var runIosBuildWithPaths = async (payload, timeoutMs, signal2, onLog, context) =
           logger,
           signal: signal2
         });
-        scriptExecutions.push(execution);
         if (execution.causedBuildFailure) {
           failBuild = true;
           errorCode = "SCRIPT_FAILED";
@@ -49210,14 +49895,11 @@ var runIosBuildWithPaths = async (payload, timeoutMs, signal2, onLog, context) =
     const finishBuild = async () => {
       try {
         if (!failBuild && !signal2.aborted) {
-          try {
-            await context?.reportBuildProgress?.({
-              buildId: input.buildId,
-              status: "RUNNING"
-            });
-          } catch (progressError) {
-            logger.emit("RUNNING", "SYSTEM", cleanError2(progressError));
-          }
+          progressStatus = "RUNNING";
+          await reportProgress({
+            status: progressStatus,
+            scriptExecutions: [...scriptExecutions]
+          });
           if (input.worktreeCoverage) {
             try {
               coverageChanges = await snapshotCoverageChanges(
@@ -49254,7 +49936,7 @@ var runIosBuildWithPaths = async (payload, timeoutMs, signal2, onLog, context) =
         )) {
           if (!script.postBuildScript) continue;
           try {
-            const execution = await runHook({
+            const execution = await runReportedHook({
               input,
               folder,
               script,
@@ -49272,7 +49954,6 @@ var runIosBuildWithPaths = async (payload, timeoutMs, signal2, onLog, context) =
               logger,
               signal: postSignal
             });
-            scriptExecutions.push(execution);
             if (execution.causedBuildFailure && !signal2.aborted) {
               failBuild = true;
               errorCode ??= "SCRIPT_FAILED";
@@ -49461,21 +50142,21 @@ var downloadIosBuildArtifact = async (payload, timeoutMs, signal2, onLog, contex
   if (!difference || difference === ".." || difference.startsWith(`..${sep5}`) || isAbsolute6(difference)) {
     throw new Error("Build artifact resolves outside the build folder");
   }
-  const information = await stat4(target2);
+  const information = await stat5(target2);
   let uploadPath = target2;
   let filename = basename3(target2);
   let contentType = "application/octet-stream";
   let temporaryArchive = null;
   try {
     if (information.isDirectory()) {
-      temporaryArchive = join15(
+      temporaryArchive = join16(
         tmpdir4(),
         `ade-build-artifact-${randomUUID5()}.tar.gz`
       );
       requireSuccess2(
         await command(
           "tar",
-          ["-czf", temporaryArchive, "-C", dirname9(target2), basename3(target2)],
+          ["-czf", temporaryArchive, "-C", dirname10(target2), basename3(target2)],
           timeoutMs,
           signal2
         ),
@@ -49521,21 +50202,21 @@ var uploadTransferredIosBuildArtifact = async (payload, timeoutMs, signal2, onLo
   if (!difference || difference === ".." || difference.startsWith(`..${sep5}`) || isAbsolute6(difference)) {
     throw new Error("Build artifact resolves outside the build folder");
   }
-  const information = await stat4(target2);
+  const information = await stat5(target2);
   let uploadPath = target2;
   let filename = basename3(target2);
   let contentType = "application/octet-stream";
   let temporaryArchive = null;
   try {
     if (information.isDirectory()) {
-      temporaryArchive = join15(
+      temporaryArchive = join16(
         tmpdir4(),
         `ade-build-transfer-${input.transferId}-${randomUUID5()}.tar.gz`
       );
       requireSuccess2(
         await command(
           "tar",
-          ["-czf", temporaryArchive, "-C", dirname9(target2), basename3(target2)],
+          ["-czf", temporaryArchive, "-C", dirname10(target2), basename3(target2)],
           timeoutMs,
           signal2
         ),
@@ -49591,24 +50272,24 @@ async function deployPreparedIosBuild(input, folder, appPath, timeoutMs, signal2
   if (!await pathExists(appPath) || !appPath.endsWith(".app")) {
     throw new Error("Runnable app artifact is missing");
   }
-  const deploymentsDirectory = join15(input.artifactDirectory, "deployments");
+  const deploymentsDirectory = join16(input.artifactDirectory, "deployments");
   await mkdir4(deploymentsDirectory, { recursive: true, mode: 448 });
   const logger = new BuildLogger(
     input.buildId,
     context,
-    join15(deploymentsDirectory, "deployments.log"),
+    join16(deploymentsDirectory, "deployments.log"),
     process.env
   );
   try {
     const outcomes = [];
     for (const deployment of input.deployments) {
-      const directory = join15(
+      const directory = join16(
         input.artifactDirectory,
         "deployments",
         deployment.id
       );
       await mkdir4(directory, { recursive: true, mode: 448 });
-      const logPath = join15(directory, "deployment.log");
+      const logPath = join16(directory, "deployment.log");
       const started = Date.now();
       let failure = null;
       let launchedAt = null;
@@ -49830,7 +50511,7 @@ var deployIosBuild = async (payload, timeoutMs, signal2, _onLog, context) => {
 };
 async function createRemoteBuildStagingDirectory(buildId) {
   return realpath6(
-    await mkdtemp5(join15(tmpdir4(), `ade-remote-build-${buildId}-`))
+    await mkdtemp5(join16(tmpdir4(), `ade-remote-build-${buildId}-`))
   );
 }
 var deployTransferredIosBuild = async (payload, timeoutMs, signal2, onLog, context) => {
@@ -49839,7 +50520,7 @@ var deployTransferredIosBuild = async (payload, timeoutMs, signal2, onLog, conte
     throw new Error("This agent cannot download transferred build artifacts");
   }
   const staging = await createRemoteBuildStagingDirectory(input.buildId);
-  const archive = join15(staging, "artifact.tar.gz");
+  const archive = join16(staging, "artifact.tar.gz");
   try {
     await onLog({
       sequence: 0,
@@ -49881,7 +50562,7 @@ var deployTransferredIosBuild = async (payload, timeoutMs, signal2, onLog, conte
       ),
       "Could not extract the transferred app"
     );
-    const appPath = await realpath6(join15(staging, root));
+    const appPath = await realpath6(join16(staging, root));
     const pathDifference = relative4(staging, appPath);
     if (pathDifference === ".." || pathDifference.startsWith(`..${sep5}`) || isAbsolute6(pathDifference)) {
       throw new Error("Transferred app resolves outside its staging directory");
@@ -49946,14 +50627,14 @@ var exportIosArchive = async (payload, timeoutMs, signal2, _onLog, context) => {
   if (!await pathExists(archivePath) || !archivePath.endsWith(".xcarchive")) {
     throw new Error("Archive artifact is missing");
   }
-  const exportDirectory = join15(
+  const exportDirectory = join16(
     input.artifactDirectory,
     "exports",
     input.exportId
   );
   await mkdir4(exportDirectory, { recursive: true, mode: 448 });
-  const plistPath = join15(exportDirectory, "ExportOptions.plist");
-  const logPath = join15(exportDirectory, "export.log");
+  const plistPath = join16(exportDirectory, "ExportOptions.plist");
+  const logPath = join16(exportDirectory, "export.log");
   await writeFile6(plistPath, exportPlist(input.settings), { mode: 384 });
   const logger = new BuildLogger(input.buildId, context, logPath, process.env);
   try {
@@ -50022,7 +50703,7 @@ var importCoverageReport = async (payloadValue, timeoutMs, signal2, onLog) => {
   const payload = parseCoverageImportPayload(payloadValue);
   if (signal2.aborted) return { ...successfulProcess4, cancelled: true };
   const folder = await realpath7(payload.folder);
-  const reportPath = await realpath7(join16(folder, payload.reportPath)).catch(
+  const reportPath = await realpath7(join17(folder, payload.reportPath)).catch(
     () => {
       throw new Error(`Coverage file ${payload.reportPath} does not exist`);
     }
@@ -50031,7 +50712,7 @@ var importCoverageReport = async (payloadValue, timeoutMs, signal2, onLog) => {
   if (!difference || difference === ".." || difference.startsWith("../")) {
     throw new Error("Coverage file resolves outside the worktree");
   }
-  const information = await stat5(reportPath);
+  const information = await stat6(reportPath);
   if (!information.isFile()) throw new Error("Coverage file is not a file");
   if (information.size > MAX_REPORT_BYTES) {
     throw new Error("Coverage file exceeds the 64 MiB limit");
@@ -50095,12 +50776,12 @@ import {
   readdir as readdir4,
   rename as rename6,
   rm as rm12,
-  stat as stat6,
+  stat as stat7,
   utimes,
   writeFile as writeFile7
 } from "node:fs/promises";
 import { homedir as homedir9, tmpdir as tmpdir5 } from "node:os";
-import { join as join17 } from "node:path";
+import { join as join18 } from "node:path";
 var CACHE_LIMIT_BYTES = 10 * 1024 ** 3;
 var ATOS_OUTPUT_LIMIT_BYTES = 16 * 1024 * 1024;
 var successfulProcess5 = {
@@ -50113,7 +50794,7 @@ function dsymCacheDirectory() {
   if (process.env.CONTROL_AGENT_DSYM_CACHE) {
     return process.env.CONTROL_AGENT_DSYM_CACHE;
   }
-  return process.platform === "darwin" ? join17(homedir9(), "Library", "Caches", "control-agent", "dsym-cache") : join17(homedir9(), ".cache", "control-agent", "dsym-cache");
+  return process.platform === "darwin" ? join18(homedir9(), "Library", "Caches", "control-agent", "dsym-cache") : join18(homedir9(), ".cache", "control-agent", "dsym-cache");
 }
 async function log(onLog, sequence, message2, stream = "SYSTEM") {
   await onLog({
@@ -50124,10 +50805,10 @@ async function log(onLog, sequence, message2, stream = "SYSTEM") {
   });
 }
 async function cachedDwarf(dsym, cache, download, signal2) {
-  const folder = join17(cache, dsym.sha256);
-  const path = join17(folder, dsym.binaryName);
+  const folder = join18(cache, dsym.sha256);
+  const path = join18(folder, dsym.binaryName);
   try {
-    const existing = await stat6(path);
+    const existing = await stat7(path);
     if (existing.size === dsym.sizeBytes) {
       const now = /* @__PURE__ */ new Date();
       await utimes(folder, now, now).catch(() => void 0);
@@ -50136,7 +50817,7 @@ async function cachedDwarf(dsym, cache, download, signal2) {
   } catch {
   }
   await mkdir5(folder, { recursive: true, mode: 448 });
-  const partial = join17(folder, `.${dsym.binaryName}.${randomUUID6()}.partial`);
+  const partial = join18(folder, `.${dsym.binaryName}.${randomUUID6()}.partial`);
   try {
     await download({
       downloadPath: dsym.downloadPath,
@@ -50160,13 +50841,13 @@ async function trimDsymCache(cache, keep, limit = CACHE_LIMIT_BYTES) {
   }
   const folders = [];
   for (const name of entries) {
-    const folder = join17(cache, name);
+    const folder = join18(cache, name);
     try {
-      const information = await stat6(folder);
+      const information = await stat7(folder);
       if (!information.isDirectory()) continue;
       let size = 0;
       for (const file of await readdir4(folder)) {
-        size += (await stat6(join17(folder, file))).size;
+        size += (await stat7(join18(folder, file))).size;
       }
       folders.push({ name, size, used: information.mtimeMs });
     } catch {
@@ -50176,7 +50857,7 @@ async function trimDsymCache(cache, keep, limit = CACHE_LIMIT_BYTES) {
   for (const folder of folders.sort((left, right) => left.used - right.used)) {
     if (total <= limit) break;
     if (keep.has(folder.name)) continue;
-    await rm12(join17(cache, folder.name), { recursive: true, force: true });
+    await rm12(join18(cache, folder.name), { recursive: true, force: true });
     total -= folder.size;
   }
 }
@@ -50228,7 +50909,7 @@ var symbolicateCrash = async (payloadValue, timeoutMs, signal2, onLog, context)
       );
     }
   }
-  const workFolder = join17(tmpdir5(), `control-agent-atos-${randomUUID6()}`);
+  const workFolder = join18(tmpdir5(), `control-agent-atos-${randomUUID6()}`);
   await mkdir5(workFolder, { recursive: true, mode: 448 });
   const lookups = [];
   try {
@@ -50244,7 +50925,7 @@ var symbolicateCrash = async (payloadValue, timeoutMs, signal2, onLog, context)
       if (!dwarfPath) continue;
       for (let start = 0; start < lookup.offsets.length; start += ATOS_BATCH_SIZE) {
         const batch = lookup.offsets.slice(start, start + ATOS_BATCH_SIZE);
-        const offsetsFile = join17(workFolder, `${lookup.uuid}-${start}.txt`);
+        const offsetsFile = join18(workFolder, `${lookup.uuid}-${start}.txt`);
         await writeFile7(offsetsFile, `${batch.join("\n")}
 `, { mode: 384 });
         const run = await captureCommand({
@@ -50465,13 +51146,13 @@ import {
   readFile as readFile8,
   readdir as readdir5,
   rm as rm13,
-  stat as stat7,
+  stat as stat8,
   writeFile as writeFile8
 } from "node:fs/promises";
 import { homedir as homedir11, tmpdir as tmpdir6 } from "node:os";
-import { basename as basename4, join as join18, relative as relative6, sep as sep7 } from "node:path";
+import { basename as basename4, join as join19, relative as relative6, sep as sep7 } from "node:path";
 var PROFILE_DIRECTORIES = [
-  join18(
+  join19(
     homedir11(),
     "Library",
     "Developer",
@@ -50479,7 +51160,7 @@ var PROFILE_DIRECTORIES = [
     "UserData",
     "Provisioning Profiles"
   ),
-  join18(homedir11(), "Library", "MobileDevice", "Provisioning Profiles")
+  join19(homedir11(), "Library", "MobileDevice", "Provisioning Profiles")
 ];
 var PROFILE_EXTENSIONS = [".mobileprovision", ".provisionprofile"];
 function text(value) {
@@ -50572,7 +51253,7 @@ async function readProfiles(timeoutMs, signal2) {
         continue;
       signal2.throwIfAborted();
       const raw = await decodeProfile(
-        join18(directory, entry),
+        join19(directory, entry),
         timeoutMs,
         signal2
       );
@@ -50606,7 +51287,7 @@ async function decodedProfiles(timeoutMs, signal2, strict = false) {
         continue;
       }
       signal2.throwIfAborted();
-      const path = join18(directory, entry);
+      const path = join19(directory, entry);
       const raw = await decodeProfile(path, timeoutMs, signal2, strict);
       if (!raw) continue;
       let content;
@@ -50762,7 +51443,7 @@ async function readCertificates(timeoutMs, signal2, strict = false) {
   );
 }
 async function readArchiveBundles(archivePath, timeoutMs, signal2) {
-  const products = join18(archivePath, "Products");
+  const products = join19(archivePath, "Products");
   const bundles = [];
   const queue = [products];
   while (queue.length) {
@@ -50776,7 +51457,7 @@ async function readArchiveBundles(archivePath, timeoutMs, signal2) {
     }
     for (const entry of entries) {
       if (entry.isSymbolicLink() || !entry.isDirectory()) continue;
-      const path = join18(current, entry.name);
+      const path = join19(current, entry.name);
       const signable = /\.(app|appex)$/.test(entry.name);
       if (!signable) {
         if (!/\.[A-Za-z0-9]+$/.test(entry.name)) queue.push(path);
@@ -50808,7 +51489,7 @@ async function bundleIdentifier(bundlePath, timeoutMs, signal2) {
         "raw",
         "-o",
         "-",
-        join18(bundlePath, "Info.plist")
+        join19(bundlePath, "Info.plist")
       ],
       timeoutMs: Math.min(timeoutMs, 5e3),
       signal: signal2
@@ -50824,9 +51505,9 @@ async function embeddedProfile(bundlePath, timeoutMs, signal2) {
     "embedded.mobileprovision",
     "embedded.provisionprofile"
   ]) {
-    const path = join18(bundlePath, name);
+    const path = join19(bundlePath, name);
     try {
-      await stat7(path);
+      await stat8(path);
     } catch {
       continue;
     }
@@ -50871,7 +51552,7 @@ async function inspectSigningAssets(archivePath, timeoutMs, signal2) {
 }
 var inspectIosSigning = async (payload, timeoutMs, signal2) => {
   const input = parseBuildSigningInspectPayload(payload);
-  const archivePath = join18(input.artifactDirectory, input.archiveRelativePath);
+  const archivePath = join19(input.artifactDirectory, input.archiveRelativePath);
   const inspection = await inspectSigningAssets(archivePath, timeoutMs, signal2);
   return {
     exitCode: 0,
@@ -50933,8 +51614,8 @@ var installSigningProfile = async (payload, timeoutMs, signal2) => {
   const { contentBase64 } = signingProfileInstallPayload(payload);
   const content = Buffer.from(contentBase64, "base64");
   if (!content.length) throw new Error("Provisioning profile is empty");
-  const temporaryRoot = await mkdtemp6(join18(tmpdir6(), "ade-profile-"));
-  const temporaryPath = join18(temporaryRoot, `${randomUUID7()}.mobileprovision`);
+  const temporaryRoot = await mkdtemp6(join19(tmpdir6(), "ade-profile-"));
+  const temporaryPath = join19(temporaryRoot, `${randomUUID7()}.mobileprovision`);
   try {
     await writeFile8(temporaryPath, content, { mode: 384 });
     const raw = await decodeProfile(temporaryPath, timeoutMs, signal2);
@@ -50943,7 +51624,7 @@ var installSigningProfile = async (payload, timeoutMs, signal2) => {
     if (!uuid) throw new Error("Provisioning profile UUID is missing");
     const directory = PROFILE_DIRECTORIES[0];
     await mkdir6(directory, { recursive: true, mode: 448 });
-    const destination = join18(directory, `${uuid}.mobileprovision`);
+    const destination = join19(directory, `${uuid}.mobileprovision`);
     await writeFile8(destination, content, { mode: 384 });
     return { ...successfulProcess6, uuid };
   } finally {
@@ -50971,8 +51652,8 @@ var importSigningIdentity = async (payload, timeoutMs, signal2, _onLog, context)
   const hash = createHash7("sha256").update(p12).digest("hex").toUpperCase();
   if (hash !== input.sha256)
     throw new Error("Signing identity transfer changed");
-  const temporaryRoot = await mkdtemp6(join18(tmpdir6(), "ade-identity-"));
-  const path = join18(temporaryRoot, "identity.p12");
+  const temporaryRoot = await mkdtemp6(join19(tmpdir6(), "ade-identity-"));
+  const path = join19(temporaryRoot, "identity.p12");
   try {
     await writeFile8(path, p12, { mode: 384 });
     const result = await captureCommand({
@@ -51191,15 +51872,15 @@ import {
   realpath as realpath8,
   readFile as readFile9,
   rm as rm14,
-  stat as stat8,
+  stat as stat9,
   statfs
 } from "node:fs/promises";
 import { homedir as homedir12 } from "node:os";
 import {
   basename as basename5,
-  dirname as dirname10,
+  dirname as dirname11,
   isAbsolute as isAbsolute7,
-  join as join19,
+  join as join20,
   relative as relative7,
   resolve as resolve9
 } from "node:path";
@@ -51228,7 +51909,7 @@ async function configuredRoots(payload) {
 }
 async function legacyConfiguredRoots(payload) {
   if (payload.mode === "DEFAULT") {
-    return [join19(homedir12(), "Library", "Developer", "Xcode", "DerivedData")];
+    return [join20(homedir12(), "Library", "Developer", "Xcode", "DerivedData")];
   }
   if (payload.mode === "ABSOLUTE") {
     if (!payload.path || !isAbsolute7(payload.path)) {
@@ -51285,21 +51966,21 @@ async function scanRoot(configuredRoot, timeoutMs, signal2) {
     };
   }
   const entries = [];
-  const rootStats = await stat8(rootPath2);
+  const rootStats = await stat9(rootPath2);
   const volumeId = String(rootStats.dev);
   for (const child of children) {
     signal2.throwIfAborted();
     if (!child.isDirectory()) continue;
-    const path = join19(rootPath2, child.name);
+    const path = join20(rootPath2, child.name);
     const information = await lstat4(path);
     let projectPath = await workspacePath(
-      join19(path, "info.plist"),
+      join20(path, "info.plist"),
       timeoutMs,
       signal2
     );
     try {
       const ownership = JSON.parse(
-        await readFile9(join19(path, ".aide-worktree.json"), "utf8")
+        await readFile9(join20(path, ".aide-worktree.json"), "utf8")
       );
       if (ownership.version === 1 && ownership.worktreeId === child.name && typeof ownership.folder === "string" && isAbsolute7(ownership.folder))
         projectPath = ownership.folder;
@@ -51319,7 +52000,7 @@ async function scanRoot(configuredRoot, timeoutMs, signal2) {
   return { entries, warning: null };
 }
 async function scanDeviceSupport(signal2) {
-  const configuredRoot = join19(
+  const configuredRoot = join20(
     process.env.ADE_IOS_DEVICE_SUPPORT_DIRECTORY ?? homedir12(),
     ...process.env.ADE_IOS_DEVICE_SUPPORT_DIRECTORY ? [] : ["Library", "Developer", "Xcode", "iOS DeviceSupport"]
   );
@@ -51340,7 +52021,7 @@ async function scanDeviceSupport(signal2) {
     const children = await readdir6(rootPath2, { withFileTypes: true });
     return {
       entries: children.filter((child) => child.isDirectory() && !child.isSymbolicLink()).map((child) => ({
-        path: join19(rootPath2, child.name),
+        path: join20(rootPath2, child.name),
         rootPath: rootPath2,
         name: child.name,
         kind: "DEVICE_SUPPORT",
@@ -51408,7 +52089,7 @@ async function ownedWorktreeBuildData(folder, configuration, timeoutMs, signal2)
           warnings.push(`${entry.path}: ${errorMessage(error)}`);
           continue;
         }
-        let ancestor = dirname10(entry.workspacePath);
+        let ancestor = dirname11(entry.workspacePath);
         while (within(folder, ancestor) && ancestor !== folder) {
           try {
             if (!within(folder, await realpath8(ancestor))) ancestor = "";
@@ -51418,7 +52099,7 @@ async function ownedWorktreeBuildData(folder, configuration, timeoutMs, signal2)
               ancestor = "";
               break;
             }
-            ancestor = dirname10(ancestor);
+            ancestor = dirname11(ancestor);
           }
         }
         if (!ancestor) continue;
@@ -51434,7 +52115,7 @@ function assertDirectChild(rootPath2, path) {
   }
   const root = resolve9(rootPath2);
   const target2 = resolve9(path);
-  if (target2 === root || dirname10(target2) !== root || basename5(target2) !== basename5(path)) {
+  if (target2 === root || dirname11(target2) !== root || basename5(target2) !== basename5(path)) {
     throw new Error("Build Data target must be a direct child of its root");
   }
 }
@@ -51448,7 +52129,7 @@ async function allocatedBytes(path, signal2) {
   try {
     for await (const entry of directory) {
       signal2.throwIfAborted();
-      total += await allocatedBytes(join19(path, entry.name), signal2);
+      total += await allocatedBytes(join20(path, entry.name), signal2);
     }
   } finally {
     await directory.close().catch(() => void 0);
@@ -51463,7 +52144,7 @@ var sizeBuildData = async (rawPayload, _timeoutMs, signal2) => {
     try {
       assertDirectChild(target2.rootPath, target2.path);
       const rootPath2 = await realpath8(target2.rootPath);
-      if (rootPath2 !== resolve9(target2.rootPath) || dirname10(resolve9(target2.path)) !== rootPath2) {
+      if (rootPath2 !== resolve9(target2.rootPath) || dirname11(resolve9(target2.path)) !== rootPath2) {
         throw new Error("Build Data root changed since the scan");
       }
       const stats = await lstat4(target2.path);
@@ -51495,7 +52176,7 @@ var deleteBuildData = async (rawPayload, _timeoutMs, signal2, _onLog, context) =
       const removeTarget2 = async () => {
         assertDirectChild(target2.rootPath, target2.path);
         const rootPath2 = await realpath8(target2.rootPath);
-        if (rootPath2 !== resolve9(target2.rootPath) || dirname10(resolve9(target2.path)) !== rootPath2) {
+        if (rootPath2 !== resolve9(target2.rootPath) || dirname11(resolve9(target2.path)) !== rootPath2) {
           throw new Error("Build Data root changed since the scan");
         }
         const stats = await lstat4(target2.path);
@@ -51564,13 +52245,13 @@ async function inspectVolume(configuredPath, role, signal2, allowMissing) {
     let candidate = resolve9(configuredPath);
     for (; ; ) {
       signal2.throwIfAborted();
-      const parent = dirname10(candidate);
+      const parent = dirname11(candidate);
       if (parent === candidate) throw error;
       missingSegments.unshift(basename5(candidate));
       candidate = parent;
       try {
         inspectionPath = await realpath8(candidate);
-        canonicalPath = join19(inspectionPath, ...missingSegments);
+        canonicalPath = join20(inspectionPath, ...missingSegments);
         break;
       } catch (parentError) {
         if (parentError.code !== "ENOENT") {
@@ -51580,7 +52261,7 @@ async function inspectVolume(configuredPath, role, signal2, allowMissing) {
     }
   }
   const [information, filesystem] = await Promise.all([
-    stat8(inspectionPath),
+    stat9(inspectionPath),
     statfs(inspectionPath, { bigint: true })
   ]);
   const id2 = String(information.dev);
@@ -51689,11 +52370,11 @@ import {
   readdir as readdir7,
   rename as rename7,
   rm as rm15,
-  stat as stat9,
+  stat as stat10,
   writeFile as writeFile9
 } from "node:fs/promises";
 import { homedir as homedir13 } from "node:os";
-import { dirname as dirname11, isAbsolute as isAbsolute8, join as join20, relative as relative8, resolve as resolve10, sep as sep8 } from "node:path";
+import { dirname as dirname12, isAbsolute as isAbsolute8, join as join21, relative as relative8, resolve as resolve10, sep as sep8 } from "node:path";
 import { promisify as promisify3 } from "node:util";
 var executeFile = promisify3(execFile3);
 var successfulProcess8 = {
@@ -51748,7 +52429,7 @@ var PROJECT_ROOTS = {
 };
 async function directoryExists(path) {
   try {
-    return (await stat9(path)).isDirectory();
+    return (await stat10(path)).isDirectory();
   } catch {
     return false;
   }
@@ -51758,7 +52439,7 @@ async function configuredTools(tools) {
   return Promise.all(
     AI_TOOLS.filter((tool) => tools.includes(tool)).map(async (tool) => ({
       tool,
-      configured: await directoryExists(join20(homePath, ...CONFIG_PATHS[tool])),
+      configured: await directoryExists(join21(homePath, ...CONFIG_PATHS[tool])),
       homePath
     }))
   );
@@ -51795,7 +52476,7 @@ async function listPackageFiles(skillDirectory) {
   let totalBytes = 0;
   const visit = async (directory) => {
     for (const entry of await readdir7(directory, { withFileTypes: true })) {
-      const path = join20(directory, entry.name);
+      const path = join21(directory, entry.name);
       const metadata = await lstat5(path);
       if (metadata.isSymbolicLink()) {
         throw new Error(
@@ -51894,7 +52575,7 @@ async function scanRoot2(location, configured, targets, warnings) {
   const installations = [];
   for (const entry of await readdir7(root, { withFileTypes: true })) {
     if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
-    const directory = join20(root, entry.name);
+    const directory = join21(root, entry.name);
     try {
       const skillPackage = await readPackage(directory, resolvedRoot);
       const relativeDirectory = location.folder ? relative8(location.folder, directory).split(sep8).join("/") : "";
@@ -51974,7 +52655,7 @@ var readSkills = async (payload) => {
     const { resolvedRoot } = await resolvedSkillRoot(request);
     packages.push({
       ...request,
-      package: await readPackage(join20(root, request.skillName), resolvedRoot)
+      package: await readPackage(join21(root, request.skillName), resolvedRoot)
     });
   }
   return { ...successfulProcess8, packages };
@@ -51992,7 +52673,7 @@ async function gitExcludePath(folder) {
 }
 async function updateManagedExclude(folder, relativeSkillPath, present) {
   const excludePath = await gitExcludePath(folder);
-  await mkdir7(dirname11(excludePath), { recursive: true });
+  await mkdir7(dirname12(excludePath), { recursive: true });
   let existing = "";
   try {
     existing = await readFile10(excludePath, "utf8");
@@ -52036,18 +52717,18 @@ async function writePackage(location, skillPackage) {
     throw new Error("New skill copies may only be written to shared roots");
   }
   const root = rootPath(location);
-  const destination = join20(root, skillPackage.name);
+  const destination = join21(root, skillPackage.name);
   await assertUntracked(location, destination);
   await mkdir7(root, { recursive: true });
-  const temporary = join20(root, `.${skillPackage.name}.${randomUUID8()}.tmp`);
-  const backup = join20(root, `.${skillPackage.name}.${randomUUID8()}.bak`);
+  const temporary = join21(root, `.${skillPackage.name}.${randomUUID8()}.tmp`);
+  const backup = join21(root, `.${skillPackage.name}.${randomUUID8()}.bak`);
   await mkdir7(temporary, { recursive: true });
   try {
     for (const file of skillPackage.files) {
       const path = resolve10(temporary, ...file.path.split("/"));
       if (!path.startsWith(`${temporary}${sep8}`))
         throw new Error("Skill file escaped temporary directory");
-      await mkdir7(dirname11(path), { recursive: true });
+      await mkdir7(dirname12(path), { recursive: true });
       await writeFile9(path, Buffer.from(file.contentsBase64, "base64"));
       await chmod3(path, file.executable ? 493 : 420);
     }
@@ -52078,7 +52759,7 @@ var applySkills = async (payload) => {
   for (const operation of operations) {
     const root = rootPath(operation);
     const skillName = operation.kind === "WRITE" ? operation.package.name : operation.skillName;
-    const destination = join20(root, skillName);
+    const destination = join21(root, skillName);
     await assertUntracked(operation, destination);
     if (operation.kind === "WRITE") {
       await writePackage(operation, operation.package);
@@ -52112,16 +52793,16 @@ import {
   readFile as readFile11,
   realpath as realpath10,
   rm as rm17,
-  stat as stat10,
+  stat as stat11,
   writeFile as writeFile10
 } from "node:fs/promises";
 import { tmpdir as tmpdir8 } from "node:os";
-import { join as join22 } from "node:path";
+import { join as join23 } from "node:path";
 
 // src/runs/git-checkpoint.ts
 import { copyFile, mkdtemp as mkdtemp7, rm as rm16 } from "node:fs/promises";
 import { tmpdir as tmpdir7 } from "node:os";
-import { join as join21 } from "node:path";
+import { join as join22 } from "node:path";
 var PATCH_LIMIT = 2e6;
 var SUMMARY_LIMIT = 24e4;
 var MANIFEST_LIMIT = 2e6;
@@ -52355,12 +53036,12 @@ async function captureGitCheckpoint(cwd, runId, kind) {
     ["diff", "--stat", "HEAD"],
     SUMMARY_LIMIT
   );
-  const directory = await mkdtemp7(join21(tmpdir7(), "aide-run-index-"));
+  const directory = await mkdtemp7(join22(tmpdir7(), "aide-run-index-"));
   let worktreeTree = null;
   let refName = null;
   try {
     const actualIndex = await git3(cwd, ["rev-parse", "--git-path", "index"]);
-    const temporaryIndex = join21(directory, "index");
+    const temporaryIndex = join22(directory, "index");
     try {
       await copyFile(actualIndex, temporaryIndex);
     } catch {
@@ -52425,13 +53106,13 @@ var success2 = {
 var runWorkflowTerminal = async (payloadValue, timeoutMs, signal2, onLog, context) => {
   const payload = parseWorkflowTerminalPayload(payloadValue);
   const cwd = await realpath10(payload.cwd);
-  const information = await stat10(cwd);
+  const information = await stat11(cwd);
   if (!information.isDirectory())
     throw new Error("Workflow working directory is not a directory");
-  const directory = await mkdtemp8(join22(tmpdir8(), "aide-workflow-"));
+  const directory = await mkdtemp8(join23(tmpdir8(), "aide-workflow-"));
   const extension2 = payload.interpreter === "NODE" ? "mjs" : "sh";
-  const scriptPath = join22(directory, `step.${extension2}`);
-  const sessionPath = join22(directory, "session.json");
+  const scriptPath = join23(directory, `step.${extension2}`);
+  const sessionPath = join23(directory, "session.json");
   try {
     await writeFile10(scriptPath, `${payload.script}
 `, { mode: 384 });
@@ -52522,9 +53203,9 @@ var runWorkflowGitCheckpoint = async (payloadValue, _timeoutMs, signal2) => {
 
 // src/handlers/worktrees.ts
 import { createWriteStream as createWriteStream3, watch } from "node:fs";
-import { mkdtemp as mkdtemp9, open as open3, readFile as readFile13, realpath as realpath12, rm as rm19, stat as stat11 } from "node:fs/promises";
+import { mkdtemp as mkdtemp9, open as open3, readFile as readFile13, realpath as realpath12, rm as rm19, stat as stat12 } from "node:fs/promises";
 import { tmpdir as tmpdir9 } from "node:os";
-import { basename as basename6, dirname as dirname13, isAbsolute as isAbsolute10, join as join24, relative as relative10 } from "node:path";
+import { basename as basename6, dirname as dirname14, isAbsolute as isAbsolute10, join as join25, relative as relative10 } from "node:path";
 
 // src/handlers/worktree-preparations.ts
 import { createHash as createHash8 } from "node:crypto";
@@ -52538,7 +53219,7 @@ import {
   rm as rm18,
   writeFile as writeFile11
 } from "node:fs/promises";
-import { dirname as dirname12, isAbsolute as isAbsolute9, join as join23, relative as relative9, resolve as resolve11 } from "node:path";
+import { dirname as dirname13, isAbsolute as isAbsolute9, join as join24, relative as relative9, resolve as resolve11 } from "node:path";
 import { randomUUID as randomUUID9 } from "node:crypto";
 var EXCLUDE_BEGIN = "# BEGIN AIDE PREPARATIONS";
 var EXCLUDE_END = "# END AIDE PREPARATIONS";
@@ -52590,7 +53271,7 @@ async function safeTarget(folder, path) {
   let current = root;
   const segments = fromRoot.split(/[\\/]/);
   for (const segment of segments.slice(0, -1)) {
-    current = join23(current, segment);
+    current = join24(current, segment);
     try {
       const info = await lstat6(current);
       if (info.isSymbolicLink()) {
@@ -52713,7 +53394,7 @@ async function writeExcludeFile(folder, definitions, timeoutMs, signal2) {
   const entries = definitions.filter((definition) => definition.kind === "WRITE").map((definition) => excludeEntry(definition.path)).sort((left, right) => left.localeCompare(right));
   const block = entries.length ? [EXCLUDE_BEGIN, ...entries, EXCLUDE_END].join("\n") : "";
   const next = [base, block].filter(Boolean).join("\n\n");
-  await mkdir8(dirname12(path), { recursive: true });
+  await mkdir8(dirname13(path), { recursive: true });
   const temporary = `${path}.${randomUUID9()}.tmp`;
   try {
     await writeFile11(temporary, next ? `${next}
@@ -52803,7 +53484,7 @@ async function applyOne(folder, definition, timeoutMs, signal2) {
         throw error;
       }
     }
-    await mkdir8(dirname12(target2), { recursive: true, mode: 493 });
+    await mkdir8(dirname13(target2), { recursive: true, mode: 493 });
     await safeTarget(folder, definition.path);
     await writeFile11(target2, contents, { mode: executable ? 493 : 420 });
     if (executable) await chmod4(target2, 493);
@@ -53077,7 +53758,7 @@ async function rebaseInProgress(folder, timeoutMs, signal2) {
     const candidate = pathResult.stdout.trim();
     if (!candidate) continue;
     try {
-      await stat11(isAbsolute10(candidate) ? candidate : join24(folder, candidate));
+      await stat12(isAbsolute10(candidate) ? candidate : join25(folder, candidate));
       return true;
     } catch {
     }
@@ -53099,7 +53780,7 @@ async function gitStatePathExists(folder, name, timeoutMs, signal2) {
     throw new Error(`Could not resolve Git state path ${name}`);
   }
   try {
-    await stat11(candidate);
+    await stat12(candidate);
     return true;
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT") {
@@ -53153,7 +53834,7 @@ async function rebaseBranch(folder, timeoutMs, signal2) {
     if (!candidate) continue;
     try {
       const headName = (await readFile13(
-        isAbsolute10(candidate) ? candidate : join24(folder, candidate),
+        isAbsolute10(candidate) ? candidate : join25(folder, candidate),
         "utf8"
       )).trim();
       if (headName.startsWith("refs/heads/")) {
@@ -53348,7 +54029,7 @@ async function origin(folder, timeoutMs, signal2) {
 }
 async function validateWorktree2(input, timeoutMs, signal2) {
   const folder = await realpath12(input.folder);
-  if (!(await stat11(folder)).isDirectory())
+  if (!(await stat12(folder)).isDirectory())
     throw new Error("Worktree is missing");
   const observedGitDirectory = await gitDirectory(folder, timeoutMs, signal2);
   if (observedGitDirectory !== input.gitDirectory) {
@@ -53590,7 +54271,7 @@ function parseNumstat(value) {
 }
 async function untrackedLines(folder, path) {
   try {
-    const file = await stat11(`${folder}/${path}`);
+    const file = await stat12(`${folder}/${path}`);
     if (!file.isFile() || file.size > 1024 * 1024) return null;
     const contents = await readFile13(`${folder}/${path}`);
     if (contents.includes(0)) return null;
@@ -53823,7 +54504,7 @@ async function comparisonSides(input, folder, timeoutMs, signal2) {
   if (!input.path) return { before: null, after: null };
   const path = input.path;
   const previousPath = input.previousPath ?? path;
-  const currentPath = join24(folder, path);
+  const currentPath = join25(folder, path);
   if (input.scope === "UNTRACKED") {
     return { before: null, after: { kind: "FILE", path: currentPath } };
   }
@@ -53927,7 +54608,7 @@ async function availableSide(side, folder, timeoutMs, signal2) {
   try {
     const resolved = await realpath12(side.path);
     const difference = relative10(folder, resolved);
-    return difference !== ".." && !difference.startsWith("../") && (await stat11(resolved)).isFile();
+    return difference !== ".." && !difference.startsWith("../") && (await stat12(resolved)).isFile();
   } catch {
     return false;
   }
@@ -53998,7 +54679,7 @@ async function inspectRequestedDiff(input, folder, timeoutMs, signal2) {
   let patch;
   if (input.scope === "UNTRACKED") {
     const bounded = await readBoundedFile(
-      join24(folder, input.path),
+      join25(folder, input.path),
       MAX_DIFF_BYTES
     );
     const contents = bounded.contents;
@@ -54180,8 +54861,8 @@ var downloadWorktreeDiffAsset = async (payload, timeoutMs, signal2, _onLog, cont
       if (!/^\d+$/.test(size) || Number(size) > 20 * 1024 * 1024) {
         throw new Error("Diff image exceeds the 20 MiB limit");
       }
-      temporaryDirectory = await mkdtemp9(join24(tmpdir9(), "ade-diff-image-"));
-      uploadPath = join24(temporaryDirectory, basename6(input.path));
+      temporaryDirectory = await mkdtemp9(join25(tmpdir9(), "ade-diff-image-"));
+      uploadPath = join25(temporaryDirectory, basename6(input.path));
       await writeGitObject(
         folder,
         selected.specification,
@@ -54190,7 +54871,7 @@ var downloadWorktreeDiffAsset = async (payload, timeoutMs, signal2, _onLog, cont
         signal2
       );
     }
-    const information = await stat11(uploadPath);
+    const information = await stat12(uploadPath);
     if (!information.isFile() || information.size > 20 * 1024 * 1024) {
       throw new Error("Diff image exceeds the 20 MiB limit");
     }
@@ -54474,7 +55155,7 @@ async function chooseNewBranch(folder, candidates, allowedCurrentBranch, timeout
 }
 async function validateBranchRoot(input, timeoutMs, signal2) {
   const rootFolder = await realpath12(input.rootFolder);
-  if (!(await stat11(rootFolder)).isDirectory()) {
+  if (!(await stat12(rootFolder)).isDirectory()) {
     throw new Error("Base repository is missing");
   }
   if (await origin(rootFolder, timeoutMs, signal2) !== input.expectedOrigin) {
@@ -54545,8 +55226,8 @@ var branchWorktree = async (payload, timeoutMs, signal2, _onLog, context) => {
     timeoutMs,
     signal2
   ) : input.candidates[0];
-  const targetFolder = input.action === "CREATE" ? join24(
-    dirname13(rootFolder),
+  const targetFolder = input.action === "CREATE" ? join25(
+    dirname14(rootFolder),
     `${basename6(rootFolder)}-${branch.replaceAll("/", "-")}`
   ) : changeFolder;
   const execute2 = () => finishBranchWorktree(
@@ -54575,7 +55256,7 @@ var branchWorktree = async (payload, timeoutMs, signal2, _onLog, context) => {
 async function finishBranchWorktree(input, rootFolder, targetFolder, branch, beforeBranch, timeoutMs, signal2) {
   if (input.action === "CREATE") {
     try {
-      await stat11(targetFolder);
+      await stat12(targetFolder);
       throw new Error(`Worktree folder already exists: ${targetFolder}`);
     } catch (error) {
       if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT") {
@@ -54820,8 +55501,8 @@ async function checkedOutBranchFolder(rootFolder, branch, timeoutMs, signal2) {
 var checkoutMovedWorktree = async (payload, timeoutMs, signal2, _onLog, context) => {
   const input = worktreeMoveCheckoutJobPayload(payload);
   const rootFolder = await validateBranchRoot(input, timeoutMs, signal2);
-  const targetFolder = input.mode === "NEW" ? join24(
-    dirname13(rootFolder),
+  const targetFolder = input.mode === "NEW" ? join25(
+    dirname14(rootFolder),
     `${basename6(rootFolder)}-${input.branch.replaceAll("/", "-")}`
   ) : input.folder;
   const execute2 = () => finishMovedWorktree(input, rootFolder, timeoutMs, signal2);
@@ -54881,12 +55562,12 @@ async function finishMovedWorktree(input, rootFolder, timeoutMs, signal2) {
         `Branch ${input.branch} is already checked out in ${occupiedFolder}`
       );
     }
-    targetFolder = join24(
-      dirname13(rootFolder),
+    targetFolder = join25(
+      dirname14(rootFolder),
       `${basename6(rootFolder)}-${input.branch.replaceAll("/", "-")}`
     );
     try {
-      await stat11(targetFolder);
+      await stat12(targetFolder);
       throw new Error(`Worktree folder already exists: ${targetFolder}`);
     } catch (error) {
       if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT") {
@@ -55132,7 +55813,7 @@ var prepareWorktree = async (payload, timeoutMs, signal2) => {
 var deleteWorktree = async (payload, timeoutMs, signal2, _onLog, context) => {
   const input = worktreeDeleteJobPayload(payload);
   const rootFolder = await realpath12(input.rootFolder);
-  if (!(await stat11(rootFolder)).isDirectory()) {
+  if (!(await stat12(rootFolder)).isDirectory()) {
     throw new Error("Base repository is missing");
   }
   if (await origin(rootFolder, timeoutMs, signal2) !== input.expectedOrigin) {
@@ -55605,7 +56286,7 @@ var operateWorktree = async (payload, timeoutMs, signal2) => {
       break;
     }
     case "CLEAR_LOCK":
-      await rm19(join24(input.gitDirectory, "index.lock"), { force: true });
+      await rm19(join25(input.gitDirectory, "index.lock"), { force: true });
       break;
     case "STASH_ALL":
       await runGit(["stash", "push", "--include-untracked"], "Stash failed");
@@ -56924,22 +57605,43 @@ var CodebaseMonitor = class {
                   signal2
                 );
                 if (fetchResult.exitCode === 0) {
-                  if (codebase.keepBaseBranchUpToDate && codebase.defaultBranch) {
-                    const baseBranch = codebase.defaultBranch;
-                    await runExclusive(
-                      () => updateBaseBranchAfterFetch(
-                        codebase.folder,
-                        baseBranch,
-                        INSPECTION_TIMEOUT_MS,
-                        signal2
-                      )
-                    );
-                  }
                   snapshot = await this.inspectRoot(codebase, signal2);
                 } else {
                   fetchError = (fetchResult.stderr || "Git fetch failed").replace(/([a-z][a-z0-9+.-]*:\/\/)[^\s/@]+@/gi, "$1").slice(0, 2e3);
                 }
               }
+              if (snapshot.availability === "AVAILABLE" && codebase.keepBaseBranchUpToDate && !signal2.aborted) {
+                await updateDefaultBranchesAfterFetch(
+                  codebase.folder,
+                  codebase.defaultBranch,
+                  codebase.defaultBranchPatterns ?? [],
+                  INSPECTION_TIMEOUT_MS,
+                  signal2,
+                  (folder, gitDirectory2, update) => this.agentId ? this.repositoryCoordinator.tryWithResources(
+                    [
+                      {
+                        kind: "WORKTREE",
+                        key: `${this.agentId}:worktree:${gitDirectory2}`,
+                        agentId: this.agentId,
+                        codebaseId: codebase.id,
+                        mode: "WRITE"
+                      },
+                      {
+                        kind: "PATH",
+                        key: folder,
+                        path: folder,
+                        agentId: this.agentId,
+                        codebaseId: codebase.id,
+                        mode: "WRITE"
+                      }
+                    ],
+                    update,
+                    signal2
+                  ) : runExclusive(update),
+                  codebase.canonicalOrigin
+                );
+                snapshot = await this.inspectRoot(codebase, signal2);
+              }
               let inventory;
               try {
                 inventory = await discoverWorktrees(
@@ -57042,7 +57744,7 @@ var CodebaseMonitor = class {
 import { execFile as execFile4 } from "node:child_process";
 import { createHash as createHash9, randomUUID as randomUUID12 } from "node:crypto";
 import { mkdir as mkdir10, rm as rm21, realpath as realpath13 } from "node:fs/promises";
-import { dirname as dirname15, join as join26 } from "node:path";
+import { dirname as dirname16, join as join27 } from "node:path";
 import { promisify as promisify4 } from "node:util";
 
 // src/runs/journal.ts
@@ -57054,11 +57756,11 @@ import {
   readFile as readFile14,
   rename as rename9,
   rm as rm20,
-  stat as stat12,
+  stat as stat13,
   truncate,
   writeFile as writeFile12
 } from "node:fs/promises";
-import { dirname as dirname14, join as join25 } from "node:path";
+import { dirname as dirname15, join as join26 } from "node:path";
 var RunJournal = class {
   constructor(runId, attemptId) {
     this.runId = runId;
@@ -57078,13 +57780,13 @@ var RunJournal = class {
     this.attemptId = attemptId;
   }
   get directory() {
-    return join25(dirname14(configPath()), "runs", this.runId);
+    return join26(dirname15(configPath()), "runs", this.runId);
   }
   get eventsPath() {
-    return join25(this.directory, "events.jsonl");
+    return join26(this.directory, "events.jsonl");
   }
   get statePath() {
-    return join25(this.directory, "state.json");
+    return join26(this.directory, "state.json");
   }
   async load() {
     if (this.loaded) return;
@@ -57106,7 +57808,7 @@ var RunJournal = class {
       if (!(error instanceof SyntaxError) && error.code !== "ENOENT")
         throw error;
     }
-    const size = await stat12(this.eventsPath).then(
+    const size = await stat13(this.eventsPath).then(
       ({ size: size2 }) => size2,
       (error) => {
         if (error.code === "ENOENT") return 0;
@@ -58781,7 +59483,7 @@ var RunManager = class {
         5
       );
       await this.completeCommand(command3.id, "SUCCEEDED");
-      await rm21(join26(dirname15(configPath()), "runs", run.id, "attachments"), {
+      await rm21(join27(dirname16(configPath()), "runs", run.id, "attachments"), {
         recursive: true,
         force: true
       }).catch(() => void 0);
@@ -58994,7 +59696,7 @@ var RunManager = class {
         this.active.delete(run.id);
       this.interruptionRequests.delete(run.id);
       this.executingCommands.delete(command3.id);
-      await rm21(join26(dirname15(configPath()), "runs", run.id, "attachments"), {
+      await rm21(join27(dirname16(configPath()), "runs", run.id, "attachments"), {
         recursive: true,
         force: true
       }).catch(() => void 0);
@@ -59232,11 +59934,11 @@ var RunManager = class {
   }
   async stageAttachments(runId, attachments) {
     if (!attachments.length) return [];
-    const directory = join26(dirname15(configPath()), "runs", runId, "attachments");
+    const directory = join27(dirname16(configPath()), "runs", runId, "attachments");
     await mkdir10(directory, { recursive: true, mode: 448 });
     return Promise.all(
       attachments.map(async (attachment) => {
-        const path = join26(
+        const path = join27(
           directory,
           `${attachment.id}-${safeFilename(attachment.filename)}`
         );