@ai-development-environment/control-agent 0.0.137 → 0.0.139

package/dist/control-agent.js

@@ -7130,25 +7130,38 @@ var AgentGraphQLClient = class {
     );
   }
   async uploadBuildArtifact(input) {
+    const timeoutMs = input.timeoutMs ?? this.requestTimeoutMs;
+    if (timeoutMs <= 0)
+      throw new DOMException("Artifact upload timed out", "TimeoutError");
+    const timeout = AbortSignal.timeout(timeoutMs);
+    const signal2 = input.signal ? AbortSignal.any([input.signal, timeout]) : timeout;
+    signal2.throwIfAborted();
     const information = await stat(input.path);
-    const response = await fetch(
-      `${this.server}/api/build-artifact-uploads/${encodeURIComponent(input.uploadId)}`,
-      {
-        method: "POST",
-        headers: mergeHeaders(this.headers, {
-          ...this.credential ? { authorization: `Bearer ${this.credential}` } : {},
-          "content-length": String(information.size),
-          "content-type": input.contentType,
-          "x-artifact-filename": encodeURIComponent(input.filename)
-        }),
-        body: Readable.toWeb(createReadStream(input.path)),
-        duplex: "half"
-      }
-    );
-    if (!response.ok) {
-      throw new Error(
-        `Artifact upload failed: HTTP ${response.status} ${await response.text()}`
+    signal2.throwIfAborted();
+    const source = createReadStream(input.path);
+    try {
+      const response = await fetch(
+        `${this.server}/api/build-artifact-uploads/${encodeURIComponent(input.uploadId)}`,
+        {
+          method: "POST",
+          headers: mergeHeaders(this.headers, {
+            ...this.credential ? { authorization: `Bearer ${this.credential}` } : {},
+            "content-length": String(information.size),
+            "content-type": input.contentType,
+            "x-artifact-filename": encodeURIComponent(input.filename)
+          }),
+          body: Readable.toWeb(source),
+          duplex: "half",
+          signal: signal2
+        }
       );
+      if (!response.ok) {
+        throw new Error(
+          `Artifact upload failed: HTTP ${response.status} ${await response.text()}`
+        );
+      }
+    } finally {
+      source.destroy();
     }
   }
   artifactTransferHeaders(values = {}) {
@@ -7471,12 +7484,12 @@ var AgentGraphQLClient = class {
     );
     return data.beginRunAttempt;
   }
-  updateRunAttemptNativeId(attemptId, nativeId, providerVersion) {
+  updateRunAttemptNativeId(attemptId, nativeId, providerVersion, sessionInfo) {
     return this.request(
-      `mutation UpdateRunAttemptNativeId($attemptId: ID!, $nativeId: String!, $providerVersion: String) {
-        updateRunAttemptNativeId(attemptId: $attemptId, nativeId: $nativeId, providerVersion: $providerVersion) { id nativeId }
+      `mutation UpdateRunAttemptNativeId($attemptId: ID!, $nativeId: String!, $providerVersion: String, $sessionInfo: RunSessionInfoInput) {
+        updateRunAttemptNativeId(attemptId: $attemptId, nativeId: $nativeId, providerVersion: $providerVersion, sessionInfo: $sessionInfo) { id nativeId }
       }`,
-      { attemptId, nativeId, providerVersion }
+      { attemptId, nativeId, providerVersion, sessionInfo }
     );
   }
   appendRunEvents(runId, attemptId, events) {
@@ -9301,7 +9314,7 @@ function worktreeGitInspectPayload(value) {
       `Unexpected worktree Git inspect payload field: ${unexpected}`
     );
   }
-  if (payload.action !== "STATE" && payload.action !== "STASH_DIFF") {
+  if (payload.action !== "STATE" && payload.action !== "REFRESH" && payload.action !== "STASH_DIFF") {
     throw new Error("worktree Git inspect payload.action is invalid");
   }
   const common = {
@@ -9319,9 +9332,9 @@ function worktreeGitInspectPayload(value) {
       "worktree Git inspect payload.expectedOrigin"
     )
   };
-  if (payload.action === "STATE") {
+  if (payload.action === "STATE" || payload.action === "REFRESH") {
     if (payload.stashOid !== void 0) {
-      throw new Error("STATE inspection cannot include stashOid");
+      throw new Error(`${payload.action} inspection cannot include stashOid`);
     }
     return { action: payload.action, ...common };
   }
@@ -11552,7 +11565,7 @@ function tailscaleServeRemovePayload(value) {
 // package.json
 var package_default = {
   name: "@ai-development-environment/control-agent",
-  version: "0.0.137",
+  version: "0.0.139",
   description: "Control agent for the AI Development Environment",
   license: "MIT",
   repository: {
@@ -12060,6 +12073,17 @@ function repairToolPath(options = {}) {
 
 // src/runs/codex-adapter.ts
 var execFileAsync = promisify(execFile);
+async function codexSessionInfo(thread, cwd) {
+  const path = typeof thread.path === "string" && thread.path ? thread.path : await findCodexSessionFile(
+    String(thread.id),
+    homedir4(),
+    process.env.CODEX_HOME
+  ).catch(() => null);
+  return {
+    workingDirectory: typeof thread.cwd === "string" && thread.cwd ? thread.cwd : cwd,
+    ...path ? { nativeTranscriptPath: path } : {}
+  };
+}
 function codexAppServerArgs(modelCatalogPath) {
   return [
     "app-server",
@@ -12453,7 +12477,8 @@ var CodexAdapter = class {
       throw new Error("Codex did not return a thread ID");
     await callbacks.onNativeId(
       nativeId,
-      typeof thread.cliVersion === "string" ? thread.cliVersion : void 0
+      typeof thread.cliVersion === "string" ? thread.cliVersion : void 0,
+      await codexSessionInfo(thread, cwd)
     );
     let turnId = "";
     let stopReason = null;
@@ -12618,6 +12643,7 @@ var CodexAdapter = class {
             const thread = asRecord(value);
             const updatedAtKey = String(thread.updatedAt ?? "");
             const cached = this.hydrationCache.get(String(thread.id));
+            const sessionInfo = await codexSessionInfo(thread, worktree.folder);
             let history = {};
             const active = asRecord(thread.status).type === "active";
             if (active) this.hydrationCache.delete(String(thread.id));
@@ -12640,11 +12666,7 @@ var CodexAdapter = class {
               } catch {
               }
               try {
-                const path = typeof thread.path === "string" ? thread.path : await findCodexSessionFile(
-                  String(thread.id),
-                  homedir4(),
-                  process.env.CODEX_HOME
-                );
+                const path = sessionInfo.nativeTranscriptPath;
                 if (path)
                   Object.assign(
                     history,
@@ -12671,7 +12693,8 @@ var CodexAdapter = class {
               branch: firstString(asRecord(thread.gitInfo).branch) || worktree.branch || void 0,
               createdAt: thread.createdAt ? new Date(Number(thread.createdAt) * 1e3).toISOString() : void 0,
               updatedAt: thread.updatedAt ? new Date(Number(thread.updatedAt) * 1e3).toISOString() : void 0,
-              rawMetadata: thread
+              rawMetadata: thread,
+              sessionInfo
             });
           }
           cursor = typeof page.nextCursor === "string" ? page.nextCursor : null;
@@ -42895,7 +42918,15 @@ var ClaudeAdapter = class {
           if (sessionId && sessionId !== nativeId) {
             nativeId = sessionId;
             const version = record.subtype === "init" && typeof record.claude_code_version === "string" ? record.claude_code_version : void 0;
-            await callbacks.onNativeId(sessionId, version);
+            const path = await findClaudeSessionFile(
+              sessionId,
+              homedir5(),
+              process.env.CLAUDE_CONFIG_DIR
+            ).catch(() => null);
+            await callbacks.onNativeId(sessionId, version, {
+              workingDirectory: typeof record.cwd === "string" && record.cwd ? record.cwd : input.run.worktree.folder,
+              ...path ? { nativeTranscriptPath: path } : {}
+            });
           }
           const messageText = firstString(
             record.message ?? record.result ?? record.summary
@@ -42976,16 +43007,20 @@ var ClaudeAdapter = class {
         const lastModifiedKey = `${session.lastModified ?? ""}:${session.fileSize ?? ""}`;
         const cached = this.hydrationCache.get(session.sessionId);
         let history = {};
+        const path = await findClaudeSessionFile(
+          session.sessionId,
+          homedir5(),
+          process.env.CLAUDE_CONFIG_DIR
+        ).catch(() => null);
+        const sessionInfo = {
+          workingDirectory: session.cwd || worktree.folder,
+          ...path ? { nativeTranscriptPath: path } : {}
+        };
         if (cached && cached.lastModified === lastModifiedKey) {
           history = cached.history;
         } else {
           let transcript = [];
           try {
-            const path = await findClaudeSessionFile(
-              session.sessionId,
-              homedir5(),
-              process.env.CLAUDE_CONFIG_DIR
-            );
             if (path) transcript = await readClaudeTranscript(path);
             history = claudeTranscriptMetadata(transcript);
           } catch {
@@ -43016,7 +43051,8 @@ var ClaudeAdapter = class {
           branch: session.gitBranch || worktree.branch || void 0,
           createdAt: session.createdAt ? new Date(session.createdAt).toISOString() : void 0,
           updatedAt: new Date(session.lastModified).toISOString(),
-          rawMetadata: session
+          rawMetadata: session,
+          sessionInfo
         });
       }
     }
@@ -43788,6 +43824,7 @@ function captureCommand(options) {
     let timedOut = false;
     let cancelled = false;
     let settled = false;
+    let terminating = false;
     let killTimer = null;
     const detached = process.platform !== "win32";
     const child = spawn3(options.command, options.args, {
@@ -43842,10 +43879,11 @@ function captureCommand(options) {
       }
     };
     const terminate2 = () => {
-      if (child.exitCode !== null || child.killed) return;
+      if (settled || terminating) return;
+      terminating = true;
       sendSignal("SIGTERM");
       killTimer = setTimeout(() => {
-        if (child.exitCode === null) sendSignal("SIGKILL");
+        if (!settled) sendSignal("SIGKILL");
       }, 5e3);
       killTimer.unref();
     };
@@ -45298,21 +45336,148 @@ import {
 
 // src/repository-coordinator.ts
 var RepositoryCoordinator = class {
-  tails = /* @__PURE__ */ new Map();
-  async run(key, task) {
-    const previous = this.tails.get(key) ?? Promise.resolve();
-    let release2;
-    const current = new Promise((resolve11) => {
-      release2 = resolve11;
+  queues = /* @__PURE__ */ new Map();
+  run(key, task, signal2) {
+    return this.enqueue(key, "exclusive", () => task(), signal2);
+  }
+  /** Keep source files stable during builds while allowing live inspections. */
+  runBuild(key, task, signal2) {
+    return this.enqueue(key, "build", () => task(), signal2);
+  }
+  /** Read-only worktree inspections may overlap builds and reconciliation. */
+  runInspection(key, task, signal2) {
+    return this.enqueue(key, "inspection", () => task(), signal2);
+  }
+  /** Keep reconciliation and its reports ordered with all user mutations. */
+  runReconciliation(key, task, signal2) {
+    return this.enqueue(
+      key,
+      "reconciliation",
+      (queue) => task({
+        runExclusive: (exclusiveTask) => this.runReconciliationExclusive(key, queue, exclusiveTask)
+      }),
+      signal2
+    );
+  }
+  runReconciliationExclusive(key, queue, task) {
+    if (!queue.reconciliation || queue.exclusiveReconciliationPhase) {
+      return Promise.reject(new Error("Invalid reconciliation phase"));
+    }
+    return new Promise((resolve11, reject) => {
+      const complete = () => {
+        queue.exclusiveReconciliationPhase = null;
+        queue.exclusive = false;
+        this.drain(key, queue);
+      };
+      queue.exclusiveReconciliationPhase = () => {
+        void Promise.resolve().then(task).then(
+          (result) => {
+            complete();
+            resolve11(result);
+          },
+          (error) => {
+            complete();
+            reject(error);
+          }
+        );
+      };
+      this.drain(key, queue);
     });
-    const tail = previous.then(() => current);
-    this.tails.set(key, tail);
-    await previous;
-    try {
-      return await task();
-    } finally {
-      release2();
-      if (this.tails.get(key) === tail) this.tails.delete(key);
+  }
+  enqueue(key, kind, task, signal2) {
+    if (signal2?.aborted) return Promise.reject(signal2.reason);
+    let queue = this.queues.get(key);
+    if (!queue) {
+      queue = {
+        inspections: 0,
+        reconciliation: false,
+        exclusive: false,
+        build: false,
+        exclusiveReconciliationPhase: null,
+        pending: []
+      };
+      this.queues.set(key, queue);
+    }
+    const repositoryQueue = queue;
+    return new Promise((resolve11, reject) => {
+      let pending = true;
+      const complete = () => {
+        if (kind === "inspection") repositoryQueue.inspections -= 1;
+        else if (kind === "reconciliation")
+          repositoryQueue.reconciliation = false;
+        else if (kind === "build") repositoryQueue.build = false;
+        else repositoryQueue.exclusive = false;
+        this.drain(key, repositoryQueue);
+      };
+      const abort = () => {
+        if (!pending) return;
+        pending = false;
+        const index = repositoryQueue.pending.indexOf(operation);
+        if (index !== -1) repositoryQueue.pending.splice(index, 1);
+        signal2?.removeEventListener("abort", abort);
+        reject(signal2?.reason);
+        this.drain(key, repositoryQueue);
+      };
+      const operation = {
+        kind,
+        start: () => {
+          pending = false;
+          signal2?.removeEventListener("abort", abort);
+          void Promise.resolve().then(() => {
+            signal2?.throwIfAborted();
+            return task(repositoryQueue);
+          }).then(
+            (result) => {
+              complete();
+              resolve11(result);
+            },
+            (error) => {
+              complete();
+              reject(error);
+            }
+          );
+        }
+      };
+      repositoryQueue.pending.push(operation);
+      signal2?.addEventListener("abort", abort, { once: true });
+      if (signal2?.aborted) abort();
+      else this.drain(key, repositoryQueue);
+    });
+  }
+  drain(key, queue) {
+    if (queue.exclusiveReconciliationPhase) {
+      if (!queue.exclusive && queue.inspections === 0) {
+        queue.exclusive = true;
+        queue.exclusiveReconciliationPhase();
+      }
+      return;
+    }
+    while (!queue.exclusive && !queue.build && queue.pending.length) {
+      const next = queue.pending[0];
+      if (next.kind === "exclusive" && (queue.inspections > 0 || queue.reconciliation) || next.kind === "build" && queue.reconciliation || next.kind === "reconciliation" && queue.reconciliation) {
+        return;
+      }
+      queue.pending.shift();
+      if (next.kind === "inspection") queue.inspections += 1;
+      else if (next.kind === "reconciliation") queue.reconciliation = true;
+      else if (next.kind === "build") queue.build = true;
+      else queue.exclusive = true;
+      next.start();
+    }
+    if (queue.build) {
+      const inspections = queue.pending.filter(
+        (operation) => operation.kind === "inspection"
+      );
+      queue.pending = queue.pending.filter(
+        (operation) => operation.kind !== "inspection"
+      );
+      for (const inspection of inspections) {
+        queue.inspections += 1;
+        inspection.start();
+      }
+    }
+    if (!queue.exclusive && !queue.build && !queue.reconciliation && queue.inspections === 0 && queue.pending.length === 0) {
+      this.queues.delete(key);
     }
   }
 };
@@ -48322,7 +48487,9 @@ var downloadIosBuildArtifact = async (payload, timeoutMs, signal2, onLog, contex
       uploadId: input.uploadId,
       path: uploadPath,
       filename,
-      contentType
+      contentType,
+      signal: signal2,
+      timeoutMs
     });
     return successfulProcess3;
   } finally {
@@ -51028,6 +51195,17 @@ async function compareGitCheckpoint(cwd, target2, current) {
     ],
     PATCH_LIMIT
   );
+  const worktreeSummary = await cappedGit(
+    cwd,
+    [
+      "diff",
+      "--stat",
+      "--find-renames",
+      target2.worktreeTree,
+      current.worktreeTree
+    ],
+    SUMMARY_LIMIT
+  );
   const indexPatch = target2.indexTree && current.indexTree ? await cappedGit(
     cwd,
     [
@@ -51048,6 +51226,8 @@ async function compareGitCheckpoint(cwd, target2, current) {
     ])
   ) : 0;
   return {
+    worktreePatch,
+    worktreeSummary,
     rollbackPatch: [
       worktreePatch && `Worktree changes that will be undone:
 
@@ -51844,6 +52024,62 @@ async function rebaseInProgress(folder, timeoutMs, signal2) {
   }
   return false;
 }
+async function gitStatePathExists(folder, name, timeoutMs, signal2) {
+  const result = requireSuccess4(
+    await git4(
+      folder,
+      ["rev-parse", "--path-format=absolute", "--git-path", name],
+      timeoutMs,
+      signal2
+    ),
+    `Could not resolve Git state path ${name}`
+  );
+  const candidate = result.stdout.trim();
+  if (!candidate || result.outputTruncated) {
+    throw new Error(`Could not resolve Git state path ${name}`);
+  }
+  try {
+    await stat11(candidate);
+    return true;
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+}
+async function inspectWorktreeRefreshState(folder, timeoutMs, signal2) {
+  const [status2, rebaseMerge, rebaseApply, mergeInProgress] = await Promise.all(
+    [
+      git4(
+        folder,
+        [
+          "--no-optional-locks",
+          "status",
+          "--porcelain=v1",
+          "-z",
+          "--untracked-files=all",
+          "--ignore-submodules=none"
+        ],
+        timeoutMs,
+        signal2
+      ),
+      gitStatePathExists(folder, "rebase-merge", timeoutMs, signal2),
+      gitStatePathExists(folder, "rebase-apply", timeoutMs, signal2),
+      gitStatePathExists(folder, "MERGE_HEAD", timeoutMs, signal2)
+    ]
+  );
+  requireSuccess4(status2, "Could not refresh worktree Git status");
+  if (status2.outputTruncated) {
+    throw new Error("Worktree Git status exceeded the output limit");
+  }
+  return {
+    dirty: Boolean(status2.stdout),
+    hasConflicts: statusChangeState(status2.stdout).hasConflicts,
+    rebaseInProgress: rebaseMerge || rebaseApply,
+    mergeInProgress
+  };
+}
 async function rebaseBranch(folder, timeoutMs, signal2) {
   for (const name of ["rebase-merge/head-name", "rebase-apply/head-name"]) {
     const pathResult = await git4(
@@ -52900,7 +53136,9 @@ var downloadWorktreeDiffAsset = async (payload, timeoutMs, signal2, _onLog, cont
       uploadId: input.uploadId,
       path: uploadPath,
       filename: basename5(input.path),
-      contentType: imageContentType(input.path)
+      contentType: imageContentType(input.path),
+      signal: signal2,
+      timeoutMs
     });
     return successfulProcess9;
   } finally {
@@ -52982,10 +53220,10 @@ var inspectWorktree = async (payload, timeoutMs, signal2) => {
 var inspectWorktreeGit = async (payload, timeoutMs, signal2) => {
   const input = worktreeGitInspectPayload(payload);
   const folder = await validateWorktree2(input, timeoutMs, signal2);
-  if (input.action === "STATE") {
+  if (input.action !== "STASH_DIFF") {
     return {
       ...successfulProcess9,
-      state: await inspectCodebaseGitState(folder, timeoutMs, signal2)
+      state: input.action === "REFRESH" ? await inspectWorktreeRefreshState(folder, timeoutMs, signal2) : await inspectCodebaseGitState(folder, timeoutMs, signal2)
     };
   }
   return {
@@ -55146,39 +55384,61 @@ var JobExecutor = class {
       const handler = handlers[claimed.kind];
       if (!handler)
         throw new Error(`No local handler is registered for ${claimed.kind}`);
-      const runHandler = () => handler(
-        claimed.payload,
-        claimed.timeoutSeconds * 1e3,
-        controller.signal,
-        (log2) => this.client.appendLog(claimed.id, log2).then(() => void 0),
-        {
-          agentId: claimed.agentId,
-          reportBranchDeletionResult: (result2) => this.client.reportBranchDeletionResult(claimed.id, result2),
-          reportWorktreeActivity: (input) => this.client.reportWorktreeActivity(input),
-          refreshFetchedCodebase: (input) => refreshFetchedCodebase(
-            this.client,
-            input,
-            claimed.timeoutSeconds * 1e3,
-            controller.signal
-          ),
-          reportBuildProgress: (input) => this.client.reportBuildProgress(input),
-          reportBuildDeploymentLaunched: (deploymentId, launchedAt) => this.client.reportBuildDeploymentLaunched(
-            claimed.id,
-            deploymentId,
-            launchedAt
-          ),
-          appendBuildLogChunks: (buildId, chunks) => this.client.appendBuildLogChunks(buildId, chunks),
-          uploadBuildArtifact: (input) => this.client.uploadBuildArtifact(input),
-          uploadBuildArtifactTransfer: (input) => this.client.uploadBuildArtifactTransfer(input),
-          downloadBuildArtifactTransfer: (input) => this.client.downloadBuildArtifactTransfer(input),
-          downloadDsymDwarf: (input) => this.client.downloadDsymDwarf(input),
-          claimSigningSecretTransfer: (transferId) => this.client.claimSigningSecretTransfer(transferId),
-          claimWorkflowJobSecrets: () => this.client.claimWorkflowJobSecrets(claimed.id),
-          appendCommandOutput: (attemptId, chunks) => this.client.appendCommandOutput(claimed.id, attemptId, chunks)
-        }
-      );
+      const runHandler = () => {
+        controller.signal.throwIfAborted();
+        return handler(
+          claimed.payload,
+          claimed.timeoutSeconds * 1e3,
+          controller.signal,
+          (log2) => this.client.appendLog(claimed.id, log2).then(() => void 0),
+          {
+            agentId: claimed.agentId,
+            reportBranchDeletionResult: (result2) => this.client.reportBranchDeletionResult(claimed.id, result2),
+            reportWorktreeActivity: (input) => this.client.reportWorktreeActivity(input),
+            refreshFetchedCodebase: (input) => refreshFetchedCodebase(
+              this.client,
+              input,
+              claimed.timeoutSeconds * 1e3,
+              controller.signal
+            ),
+            reportBuildProgress: (input) => this.client.reportBuildProgress(input),
+            reportBuildDeploymentLaunched: (deploymentId, launchedAt) => this.client.reportBuildDeploymentLaunched(
+              claimed.id,
+              deploymentId,
+              launchedAt
+            ),
+            appendBuildLogChunks: (buildId, chunks) => this.client.appendBuildLogChunks(buildId, chunks),
+            uploadBuildArtifact: (input) => this.client.uploadBuildArtifact(input),
+            uploadBuildArtifactTransfer: (input) => this.client.uploadBuildArtifactTransfer(input),
+            downloadBuildArtifactTransfer: (input) => this.client.downloadBuildArtifactTransfer(input),
+            downloadDsymDwarf: (input) => this.client.downloadDsymDwarf(input),
+            claimSigningSecretTransfer: (transferId) => this.client.claimSigningSecretTransfer(transferId),
+            claimWorkflowJobSecrets: () => this.client.claimWorkflowJobSecrets(claimed.id),
+            appendCommandOutput: (attemptId, chunks) => this.client.appendCommandOutput(claimed.id, attemptId, chunks)
+          }
+        );
+      };
       const codebaseId = claimed.payload && typeof claimed.payload === "object" && !Array.isArray(claimed.payload) && typeof claimed.payload.codebaseId === "string" ? String(claimed.payload.codebaseId) : null;
-      result = codebaseId ? await this.repositoryCoordinator.run(codebaseId, runHandler) : await runHandler();
+      if (!codebaseId) result = await runHandler();
+      else if (claimed.kind === IOS_BUILD_JOB_KIND) {
+        result = await this.repositoryCoordinator.runBuild(
+          codebaseId,
+          runHandler,
+          controller.signal
+        );
+      } else if (claimed.kind === WORKTREE_INSPECT_JOB_KIND || claimed.kind === WORKTREE_DIFF_JOB_KIND || claimed.kind === WORKTREE_DIFF_ASSET_JOB_KIND || claimed.kind === WORKTREE_GIT_INSPECT_JOB_KIND || claimed.kind === CODEBASE_GIT_INSPECT_JOB_KIND) {
+        result = await this.repositoryCoordinator.runInspection(
+          codebaseId,
+          runHandler,
+          controller.signal
+        );
+      } else {
+        result = await this.repositoryCoordinator.run(
+          codebaseId,
+          runHandler,
+          controller.signal
+        );
+      }
       status2 = result.cancelled ? "CANCELLED" : result.timedOut ? "TIMED_OUT" : result.exitCode === 0 ? "SUCCEEDED" : "FAILED";
       completionError = status2 === "FAILED" ? `Process exited with code ${result.exitCode}` : void 0;
     } catch (error) {
@@ -55244,110 +55504,118 @@ var CodebaseMonitor = class {
         const batch = codebases.slice(index, index + CONCURRENCY2);
         await Promise.all(
           batch.map(
-            (codebase) => this.repositoryCoordinator.run(codebase.id, async () => {
-              let snapshot = await inspectCodebase(
-                codebase.folder,
-                INSPECTION_TIMEOUT_MS,
-                signal2,
-                codebase.canonicalOrigin
-              );
-              let fetchAttemptedAt = null;
-              let fetchError = null;
-              const fetchedAt2 = Math.max(
-                snapshot.fetchedAt ? new Date(snapshot.fetchedAt).getTime() : 0,
-                codebase.lastFetchAttemptAt ? new Date(codebase.lastFetchAttemptAt).getTime() : 0
-              );
-              const fetchDue = snapshot.availability === "AVAILABLE" && Date.now() - fetchedAt2 >= configuration.fetchIntervalSeconds * 1e3;
-              if (fetchDue && !signal2.aborted) {
-                fetchAttemptedAt = (/* @__PURE__ */ new Date()).toISOString();
-                const fetchResult = await captureCommand({
-                  command: "git",
-                  args: ["-C", codebase.folder, "fetch", "origin"],
-                  timeoutMs: 3e5,
-                  signal: signal2,
-                  env: {
-                    ...process.env,
-                    GIT_TERMINAL_PROMPT: "0",
-                    GIT_OPTIONAL_LOCKS: "0"
-                  }
-                });
-                if (fetchResult.exitCode === 0) {
-                  if (codebase.keepBaseBranchUpToDate && codebase.defaultBranch) {
-                    await updateBaseBranchAfterFetch(
+            (codebase) => this.repositoryCoordinator.runReconciliation(
+              codebase.id,
+              async ({ runExclusive }) => {
+                let snapshot = await inspectCodebase(
+                  codebase.folder,
+                  INSPECTION_TIMEOUT_MS,
+                  signal2,
+                  codebase.canonicalOrigin
+                );
+                let fetchAttemptedAt = null;
+                let fetchError = null;
+                const fetchedAt2 = Math.max(
+                  snapshot.fetchedAt ? new Date(snapshot.fetchedAt).getTime() : 0,
+                  codebase.lastFetchAttemptAt ? new Date(codebase.lastFetchAttemptAt).getTime() : 0
+                );
+                const fetchDue = snapshot.availability === "AVAILABLE" && Date.now() - fetchedAt2 >= configuration.fetchIntervalSeconds * 1e3;
+                if (fetchDue && !signal2.aborted) {
+                  fetchAttemptedAt = (/* @__PURE__ */ new Date()).toISOString();
+                  const fetchResult = await captureCommand({
+                    command: "git",
+                    args: ["-C", codebase.folder, "fetch", "origin"],
+                    timeoutMs: 3e5,
+                    signal: signal2,
+                    env: {
+                      ...process.env,
+                      GIT_TERMINAL_PROMPT: "0",
+                      GIT_OPTIONAL_LOCKS: "0"
+                    }
+                  });
+                  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 inspectCodebase(
                       codebase.folder,
-                      codebase.defaultBranch,
                       INSPECTION_TIMEOUT_MS,
-                      signal2
+                      signal2,
+                      codebase.canonicalOrigin
                     );
+                  } else {
+                    fetchError = (fetchResult.stderr || "Git fetch failed").replace(/([a-z][a-z0-9+.-]*:\/\/)[^\s/@]+@/gi, "$1").slice(0, 2e3);
                   }
-                  snapshot = await inspectCodebase(
+                }
+                let inventory;
+                try {
+                  inventory = await discoverWorktrees(
                     codebase.folder,
+                    new Map(
+                      codebase.worktrees.map((worktree) => [
+                        worktree.gitDirectory,
+                        worktree.baseBranchOverride
+                      ])
+                    ),
+                    codebase.defaultBranch,
                     INSPECTION_TIMEOUT_MS,
-                    signal2,
-                    codebase.canonicalOrigin
+                    signal2
                   );
-                } else {
-                  fetchError = (fetchResult.stderr || "Git fetch failed").replace(/([a-z][a-z0-9+.-]*:\/\/)[^\s/@]+@/gi, "$1").slice(0, 2e3);
+                } catch (error) {
+                  inventory = {
+                    complete: false,
+                    defaultBranch: null,
+                    localBranches: [],
+                    remoteBranches: [],
+                    worktrees: []
+                  };
+                  fetchError ??= error instanceof Error ? error.message.slice(0, 2e3) : String(error);
                 }
-              }
-              let inventory;
-              try {
-                inventory = await discoverWorktrees(
-                  codebase.folder,
-                  new Map(
-                    codebase.worktrees.map((worktree) => [
-                      worktree.gitDirectory,
-                      worktree.baseBranchOverride
-                    ])
-                  ),
-                  codebase.defaultBranch,
-                  INSPECTION_TIMEOUT_MS,
-                  signal2
-                );
-              } catch (error) {
-                inventory = {
-                  complete: false,
-                  defaultBranch: null,
-                  localBranches: [],
-                  remoteBranches: [],
-                  worktrees: []
-                };
-                fetchError ??= error instanceof Error ? error.message.slice(0, 2e3) : String(error);
-              }
-              const localBranchInventoryAttemptedAt = (/* @__PURE__ */ new Date()).toISOString();
-              let localBranchInventory = null;
-              let localBranchInventoryError = null;
-              try {
-                if (snapshot.availability !== "AVAILABLE")
-                  throw new Error(snapshot.error || "Codebase is unavailable");
-                localBranchInventory = await scanLocalBranches(
-                  codebase.folder,
-                  INSPECTION_TIMEOUT_MS,
-                  signal2
-                );
-              } catch (error) {
-                localBranchInventoryError = error instanceof Error ? error.message.slice(0, 2e3) : String(error).slice(0, 2e3);
-              }
-              if (signal2.aborted) return;
-              await this.client.reportCodebaseStatuses([
-                {
-                  codebaseId: codebase.id,
-                  snapshot,
-                  localBranchInventory,
-                  localBranchInventoryError,
-                  localBranchInventoryAttemptedAt
-                }
-              ]);
-              await this.client.reportWorktrees([
-                {
-                  codebaseId: codebase.id,
-                  ...inventory,
-                  fetchedAt: snapshot.fetchedAt,
-                  fetchAttemptedAt,
-                  fetchError
+                const localBranchInventoryAttemptedAt = (/* @__PURE__ */ new Date()).toISOString();
+                let localBranchInventory = null;
+                let localBranchInventoryError = null;
+                try {
+                  if (snapshot.availability !== "AVAILABLE")
+                    throw new Error(
+                      snapshot.error || "Codebase is unavailable"
+                    );
+                  localBranchInventory = await scanLocalBranches(
+                    codebase.folder,
+                    INSPECTION_TIMEOUT_MS,
+                    signal2
+                  );
+                } catch (error) {
+                  localBranchInventoryError = error instanceof Error ? error.message.slice(0, 2e3) : String(error).slice(0, 2e3);
                 }
-              ]);
-            })
+                if (signal2.aborted) return;
+                await this.client.reportCodebaseStatuses([
+                  {
+                    codebaseId: codebase.id,
+                    snapshot,
+                    localBranchInventory,
+                    localBranchInventoryError,
+                    localBranchInventoryAttemptedAt
+                  }
+                ]);
+                await this.client.reportWorktrees([
+                  {
+                    codebaseId: codebase.id,
+                    ...inventory,
+                    fetchedAt: snapshot.fetchedAt,
+                    fetchAttemptedAt,
+                    fetchError
+                  }
+                ]);
+              }
+            )
           )
         );
       }
@@ -56200,7 +56468,9 @@ var OpenCodeAdapter = class {
       initial = new Set(
         (await openCodeMessages(client, nativeId)).map((entry) => entry.id)
       );
-      await callbacks.onNativeId(nativeId, runtime.version);
+      await callbacks.onNativeId(nativeId, runtime.version, {
+        workingDirectory: cwd
+      });
     } catch (error) {
       await cleanup();
       throw error;
@@ -56645,7 +56915,8 @@ var OpenCodeAdapter = class {
           pricingSource: "opencode-history",
           createdAt: opencodeTimestamp(session.time.created),
           updatedAt: opencodeTimestamp(session.time.updated),
-          rawMetadata: session
+          rawMetadata: session,
+          sessionInfo: { workingDirectory: session.location.directory }
         });
       }
     }
@@ -56945,12 +57216,17 @@ var RunManager = class {
       return;
     }
     const callbacks = {
-      onNativeId: async (nativeId, providerVersion) => {
+      onNativeId: async (nativeId, providerVersion, sessionInfo) => {
         await this.retry(
           () => this.client.updateRunAttemptNativeId(
             attempt.id,
             nativeId,
-            providerVersion
+            providerVersion,
+            {
+              workingDirectory: run.worktree.folder,
+              ...sessionInfo,
+              activityLogPath: journal.eventsPath
+            }
           )
         );
       },
@@ -57091,7 +57367,8 @@ var RunManager = class {
         await this.retryFinalization(
           () => this.client.reportRunCheckpoint(run.id, attemptId, {
             ...finalCheckpoint,
-            diffPatch: comparison.rollbackPatch
+            diffPatch: comparison.worktreePatch || null,
+            diffSummary: comparison.worktreeSummary || null
           })
         );
       }

package/package.json

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