@ai-development-environment/control-agent 0.0.142 → 0.0.144

package/dist/control-agent.js

@@ -7445,17 +7445,18 @@ var AgentGraphQLClient = class {
       throw new Error("Downloaded dSYM checksum did not match");
     }
   }
-  completeJob(jobId, status2, result, error, executionToken) {
+  completeJob(jobId, status2, result, error, executionToken, cleanupVerified = true) {
     return this.request(
-      `mutation CompleteJob($jobId: ID!, $status: AgentJobStatus!, $result: JSON, $error: String, $executionToken: String) {
-        completeAgentJob(jobId: $jobId, status: $status, result: $result, error: $error, executionToken: $executionToken) { id status }
+      `mutation CompleteJob($jobId: ID!, $status: AgentJobStatus!, $result: JSON, $error: String, $executionToken: String, $cleanupVerified: Boolean!) {
+        completeAgentJob(jobId: $jobId, status: $status, result: $result, error: $error, executionToken: $executionToken, cleanupVerified: $cleanupVerified) { id status }
       }`,
       {
         jobId,
         status: status2,
         result,
         error,
-        ...executionToken ? { executionToken } : {}
+        ...executionToken ? { executionToken } : {},
+        cleanupVerified
       }
     );
   }
@@ -7617,22 +7618,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 +8144,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 +8493,8 @@ function codebaseJobPayload(value) {
     "codebaseId",
     "expectedOrigin",
     "baseBranch",
-    "keepBaseBranchUpToDate"
+    "keepBaseBranchUpToDate",
+    "defaultBranchPatterns"
   ]);
   const unexpected = Object.keys(payload).find((key) => !allowed.has(key));
   if (unexpected)
@@ -8461,6 +8516,11 @@ function codebaseJobPayload(value) {
         payload.keepBaseBranchUpToDate,
         "payload.keepBaseBranchUpToDate"
       )
+    },
+    ...payload.defaultBranchPatterns === void 0 ? {} : {
+      defaultBranchPatterns: normalizeDefaultBranchPatterns(
+        payload.defaultBranchPatterns
+      )
     }
   };
 }
@@ -11683,7 +11743,7 @@ function tailscaleServeRemovePayload(value) {
 // package.json
 var package_default = {
   name: "@ai-development-environment/control-agent",
-  version: "0.0.142",
+  version: "0.0.144",
   description: "Control agent for the AI Development Environment",
   license: "MIT",
   repository: {
@@ -11753,6 +11813,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,
@@ -11840,6 +11901,12 @@ import {
   writeFileSync
 } from "node:fs";
 import { dirname as dirname2, join as join2 } from "node:path";
+var ProcessInspectionTimeoutError = class extends Error {
+  constructor() {
+    super("Process inspection timed out after 30 seconds");
+    this.name = "ProcessInspectionTimeoutError";
+  }
+};
 var executions = new AsyncLocalStorage();
 function executionEnvironment() {
   const journal = executions.getStore();
@@ -11983,11 +12050,18 @@ var spawnExecutionProcess = ((command3, args = [], options = {}) => {
 });
 function processTable(environment = false) {
   const args = environment ? ["axeww", "-o", "pid=,pgid=,stat=,command="] : ["axww", "-o", "pid=,pgid=,stat=,command="];
-  const output = execFileSync("/bin/ps", args, {
-    encoding: "utf8",
-    timeout: 5e3,
-    maxBuffer: 32 * 1024 * 1024
-  });
+  let output;
+  try {
+    output = execFileSync("/bin/ps", args, {
+      encoding: "utf8",
+      timeout: 3e4,
+      maxBuffer: 32 * 1024 * 1024
+    });
+  } catch (error) {
+    if (error.code === "ETIMEDOUT")
+      throw new ProcessInspectionTimeoutError();
+    throw error;
+  }
   return output.split("\n").flatMap((line) => {
     const match = /^\s*(\d+)\s+(\d+)\s+(\S+)\s+(.*)$/.exec(line);
     return match ? [
@@ -12026,6 +12100,7 @@ var delay = (ms, signal2) => new Promise((resolve13) => {
   if (signal2?.aborted) finish();
 });
 async function cleanupGroups(journal, signal2) {
+  if (!journal.groups.length) return;
   const groups = new Set(journal.groups);
   const ownGroup = process.platform !== "win32" ? processTable().find((entry) => entry.pid === process.pid)?.group : process.pid;
   if (process.platform !== "win32") {
@@ -12106,12 +12181,40 @@ async function withExecutionJournal(identity, task) {
   try {
     return await executions.run(
       journal,
-      () => task({ cleanupProcesses: () => cleanupGroups(journal), settle })
+      () => task({
+        cleanupProcesses: () => cleanupGroups(journal),
+        settle,
+        checkpointCompletion: (completion) => {
+          journal.completion = completion;
+          persist(journal);
+        }
+      })
     );
   } finally {
     await settle();
   }
 }
+function executionCompletion(identity) {
+  let journal;
+  try {
+    journal = JSON.parse(readFileSync(journalPath(identity), "utf8"));
+  } catch (error) {
+    if (error.code === "ENOENT") return void 0;
+    throw error;
+  }
+  if (journal.version !== 1 || journal.agentId !== identity.agentId || journal.jobId !== identity.jobId || journal.executionToken !== identity.executionToken || journal.marker !== digest(identity.executionToken) || !Array.isArray(journal.groups))
+    throw new Error(
+      "Execution journal identity is invalid; its claim remains protected"
+    );
+  const completion = journal.completion;
+  if (completion && (!["SUCCEEDED", "FAILED", "CANCELLED", "TIMED_OUT"].includes(
+    completion.status
+  ) || !completion.result || typeof completion.result !== "object" || typeof completion.result.cancelled !== "boolean" || typeof completion.result.timedOut !== "boolean" || !(completion.result.exitCode === null || Number.isInteger(completion.result.exitCode))))
+    throw new Error(
+      "Execution completion checkpoint is invalid; its claim remains protected"
+    );
+  return completion;
+}
 async function recoverExecution(identity, signal2) {
   let journal;
   try {
@@ -45725,76 +45828,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(
+    return await withRepositoryMetadata(
       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(
-      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) => {
@@ -45833,46 +46025,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(
@@ -49903,7 +50086,7 @@ var runIosBuildWithPaths = async (payload, timeoutMs, signal2, onLog, context) =
         finalSignal
       );
       const codeStateObservedAt = (/* @__PURE__ */ new Date()).toISOString();
-      return {
+      const completedResult = {
         exitCode,
         signal: buildResult?.signal ?? preflightResult?.signal ?? null,
         timedOut,
@@ -49918,6 +50101,8 @@ var runIosBuildWithPaths = async (payload, timeoutMs, signal2, onLog, context) =
         finalStateHash,
         codeStateObservedAt
       };
+      await context?.finalizeBuildResult?.(completedResult);
+      return completedResult;
     };
     let enteredProtectedBuild = false;
     try {
@@ -57035,6 +57220,16 @@ async function refreshFetchedCodebase(client, input, timeoutMs, signal2, withIns
 }
 
 // src/job-executor.ts
+var PROCESS_INSPECTION_WARNING = "Process inspection timed out after 30 seconds. The completed build result and artifacts were preserved; process cleanup will be retried.";
+var resultStatus = (result) => result.cancelled ? "CANCELLED" : result.timedOut ? "TIMED_OUT" : result.exitCode === 0 ? "SUCCEEDED" : "FAILED";
+function warnPreservedBuild(completion) {
+  completion.result.warnings = [
+    .../* @__PURE__ */ new Set([
+      ...completion.result.warnings ?? [],
+      PROCESS_INSPECTION_WARNING
+    ])
+  ];
+}
 function resourceSignature(value) {
   return JSON.stringify(
     parseOperationDescriptor(value).resources.map(
@@ -57058,18 +57253,20 @@ var JobExecutor = class {
   repositoryCoordinator;
   running = /* @__PURE__ */ new Map();
   stopping = false;
+  cleanupPending = /* @__PURE__ */ new Set();
   shutdown = new AbortController();
   execute(job) {
     if (this.stopping || this.running.has(job.id)) return;
     const controller = new AbortController();
-    const task = this.run(job, controller).finally(
-      () => this.running.delete(job.id)
-    );
+    const task = this.run(job, controller).finally(() => {
+      this.running.delete(job.id);
+      this.cleanupPending.delete(job.id);
+    });
     this.running.set(job.id, { controller, task });
   }
   cancel(jobId) {
     const running = this.running.get(jobId);
-    running?.controller.abort();
+    if (!this.cleanupPending.has(jobId)) running?.controller.abort();
     return Boolean(running);
   }
   /** Hold source resources until interrupted subprocess cleanup is verified. */
@@ -57093,19 +57290,46 @@ var JobExecutor = class {
       async () => {
         entered.resolve();
         let reported = false;
+        let completion;
+        let checkpointRead = false;
+        let completedStatus = status2;
         while (!this.shutdown.signal.aborted) {
           try {
+            if (!checkpointRead) {
+              completion = job.kind === IOS_BUILD_JOB_KIND ? executionCompletion(identity) : void 0;
+              checkpointRead = true;
+              if (completion && ["RUNNING", "CANCELLING"].includes(job.status))
+                completedStatus = completion.status;
+            }
             await recoverExecution(identity, this.shutdown.signal);
             await this.client.completeJob(
               job.id,
-              status2,
-              void 0,
-              "Agent service restarted; interrupted processes were stopped and verified",
+              completedStatus,
+              completion?.result,
+              completion?.error ?? (completion ? void 0 : "Agent service restarted; interrupted processes were stopped and verified"),
               job.executionToken
             );
             forgetExecution(identity);
             return;
           } catch (error) {
+            if (completion && error instanceof ProcessInspectionTimeoutError) {
+              warnPreservedBuild(completion);
+              try {
+                await this.client.completeJob(
+                  job.id,
+                  completedStatus,
+                  completion.result,
+                  completion.error,
+                  job.executionToken,
+                  false
+                );
+              } catch (reportError) {
+                console.error(
+                  `Could not preserve completed build ${job.id}:`,
+                  reportError
+                );
+              }
+            }
             if (!reported) {
               console.error(
                 `Cleanup verification required for job ${job.id}; execution resources remain protected:`,
@@ -57177,6 +57401,7 @@ var JobExecutor = class {
       const handler = handlers[claimed.kind];
       if (!handler)
         throw new Error(`No local handler is registered for ${claimed.kind}`);
+      let execution;
       const runHandler = () => {
         controller.signal.throwIfAborted();
         return handler(
@@ -57232,6 +57457,58 @@ var JobExecutor = class {
               )
             ),
             reportBuildProgress: (input) => this.client.reportBuildProgress(input),
+            ...resourceAware && claimed.kind === IOS_BUILD_JOB_KIND ? {
+              finalizeBuildResult: async (completedResult) => {
+                if (!execution)
+                  throw new Error("Build execution journal is unavailable");
+                result = completedResult;
+                const completion = {
+                  status: resultStatus(completedResult),
+                  result: completedResult,
+                  ...completedResult.exitCode !== 0 && !completedResult.cancelled && !completedResult.timedOut ? {
+                    error: `Process exited with code ${completedResult.exitCode}`
+                  } : {}
+                };
+                execution.checkpointCompletion(completion);
+                this.cleanupPending.add(claimed.id);
+                try {
+                  await execution.settle();
+                  return;
+                } catch (error) {
+                  if (!(error instanceof ProcessInspectionTimeoutError))
+                    throw error;
+                }
+                warnPreservedBuild(completion);
+                execution.checkpointCompletion(completion);
+                let preserved = false;
+                while (!this.shutdown.signal.aborted) {
+                  try {
+                    if (!preserved) {
+                      await this.client.completeJob(
+                        claimed.id,
+                        completion.status,
+                        completion.result,
+                        completion.error,
+                        claimed.executionToken,
+                        false
+                      );
+                      preserved = true;
+                    }
+                    await execution.settle();
+                    return;
+                  } catch (error) {
+                    console.error(
+                      `Build ${claimed.id} result is preserved; cleanup verification will retry:`,
+                      error instanceof Error ? error.message : error
+                    );
+                    await waitForAgentRetry(1e3, this.shutdown.signal);
+                  }
+                }
+                throw new Error(
+                  "Build cleanup interrupted by agent shutdown; its result remains protected"
+                );
+              }
+            } : {},
             reportBuildDeploymentLaunched: (deploymentId, launchedAt) => this.client.reportBuildDeploymentLaunched(
               claimed.id,
               deploymentId,
@@ -57256,7 +57533,10 @@ var JobExecutor = class {
             jobId: claimed.id,
             executionToken: claimed.executionToken
           },
-          runHandler
+          (journal) => {
+            execution = journal;
+            return runHandler();
+          }
         );
       else if (!codebaseId) result = await runHandler();
       else if (claimed.kind === IOS_BUILD_JOB_KIND) {
@@ -57285,6 +57565,7 @@ var JobExecutor = class {
       status2 = controller.signal.aborted ? "CANCELLED" : "FAILED";
       console.error(`Job ${claimed.id} failed:`, completionError);
     }
+    if (this.stopping && this.cleanupPending.has(claimed.id)) return;
     for (let attempt = 1; ; attempt++) {
       try {
         if (resourceAware && claimed.executionToken)
@@ -57465,22 +57746,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(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-development-environment/control-agent",
-  "version": "0.0.142",
+  "version": "0.0.144",
   "description": "Control agent for the AI Development Environment",
   "license": "MIT",
   "repository": {