@ai-development-environment/control-agent 0.0.78 → 0.0.80

package/dist/control-agent.js

@@ -2276,7 +2276,7 @@ var require_websocket = __commonJS({
     var http = __require("http");
     var net = __require("net");
     var tls = __require("tls");
-    var { randomBytes, createHash: createHash6 } = __require("crypto");
+    var { randomBytes, createHash: createHash7 } = __require("crypto");
     var { Duplex, Readable: Readable2 } = __require("stream");
     var { URL: URL2 } = __require("url");
     var PerMessageDeflate2 = require_permessage_deflate();
@@ -2944,7 +2944,7 @@ var require_websocket = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest = createHash6("sha1").update(key + GUID).digest("base64");
+        const digest = createHash7("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -3313,7 +3313,7 @@ var require_websocket_server = __commonJS({
     var EventEmitter = __require("events");
     var http = __require("http");
     var { Duplex } = __require("stream");
-    var { createHash: createHash6 } = __require("crypto");
+    var { createHash: createHash7 } = __require("crypto");
     var extension2 = require_extension();
     var PerMessageDeflate2 = require_permessage_deflate();
     var subprotocol2 = require_subprotocol();
@@ -3620,7 +3620,7 @@ var require_websocket_server = __commonJS({
           );
         }
         if (this._state > RUNNING) return abortHandshake(socket, 503);
-        const digest = createHash6("sha1").update(key + GUID).digest("base64");
+        const digest = createHash7("sha1").update(key + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -6106,6 +6106,7 @@ function codebaseGitOperationPayload(value) {
 // ../agent-contract/src/worktrees.ts
 var WORKTREE_INSPECT_JOB_KIND = "worktree.inspect";
 var WORKTREE_OPERATION_JOB_KIND = "worktree.operation";
+var WORKTREE_COMMIT_JOB_KIND = "worktree.commit";
 var WORKTREE_AUTO_SYNC_JOB_KIND = "worktree.auto-sync";
 var WORKTREE_GIT_INSPECT_JOB_KIND = "worktree.git.inspect";
 var WORKTREE_GIT_OPERATION_JOB_KIND = "worktree.git.operation";
@@ -6119,6 +6120,7 @@ var WORKTREE_DIFF_ASSET_JOB_KIND = "worktree.diff.asset";
 var WORKTREE_JOB_KINDS = [
   WORKTREE_INSPECT_JOB_KIND,
   WORKTREE_OPERATION_JOB_KIND,
+  WORKTREE_COMMIT_JOB_KIND,
   WORKTREE_AUTO_SYNC_JOB_KIND,
   WORKTREE_GIT_INSPECT_JOB_KIND,
   WORKTREE_GIT_OPERATION_JOB_KIND,
@@ -6145,6 +6147,7 @@ var WORKTREE_OPERATIONS = [
   "SYNC",
   "REBASE",
   "CANCEL_REBASE",
+  "PULL",
   "PUSH",
   "RESET",
   "STASH_ALL",
@@ -6463,6 +6466,71 @@ function worktreeDeleteJobPayload(value) {
     expectedHeadSha
   };
 }
+function worktreeCommitJobPayload(value) {
+  const payload = objectValue4(value, "worktree commit payload");
+  const allowed = /* @__PURE__ */ new Set([
+    "codebaseId",
+    "folder",
+    "gitDirectory",
+    "expectedOrigin",
+    "baseBranch",
+    "message",
+    "signed",
+    "stageAll",
+    "paths"
+  ]);
+  const unexpected = Object.keys(payload).find((key) => !allowed.has(key));
+  if (unexpected) {
+    throw new Error(`Unexpected worktree commit payload field: ${unexpected}`);
+  }
+  const message = stringValue4(
+    payload.message,
+    "worktree commit payload.message"
+  );
+  if (!message.trim()) throw new Error("Commit message must not be blank");
+  if (message.length > 5e4) throw new Error("Commit message is too long");
+  if (payload.signed !== null && typeof payload.signed !== "boolean") {
+    throw new Error("worktree commit payload.signed must be a boolean or null");
+  }
+  if (typeof payload.stageAll !== "boolean") {
+    throw new Error("worktree commit payload.stageAll must be a boolean");
+  }
+  if (!Array.isArray(payload.paths) || payload.paths.length > 500) {
+    throw new Error("worktree commit payload.paths is invalid");
+  }
+  const paths = payload.paths.map(
+    (path, index) => safeRelativePath(path, `worktree commit payload.paths[${index}]`)
+  );
+  if (new Set(paths).size !== paths.length) {
+    throw new Error("worktree commit payload.paths must be unique");
+  }
+  if (!payload.stageAll && paths.length === 0) {
+    throw new Error("A partial commit requires at least one path");
+  }
+  return {
+    codebaseId: stringValue4(
+      payload.codebaseId,
+      "worktree commit payload.codebaseId"
+    ),
+    folder: stringValue4(payload.folder, "worktree commit payload.folder"),
+    gitDirectory: stringValue4(
+      payload.gitDirectory,
+      "worktree commit payload.gitDirectory"
+    ),
+    expectedOrigin: stringValue4(
+      payload.expectedOrigin,
+      "worktree commit payload.expectedOrigin"
+    ),
+    baseBranch: nullableString3(
+      payload.baseBranch,
+      "worktree commit payload.baseBranch"
+    ),
+    message,
+    signed: payload.signed,
+    stageAll: payload.stageAll,
+    paths
+  };
+}
 function worktreeJobPayload(value) {
   const payload = objectValue4(value, "worktree payload");
   const allowed = /* @__PURE__ */ new Set([
@@ -8283,10 +8351,183 @@ function collectInventory() {
 }
 
 // src/handlers/commands.ts
-import { spawn } from "node:child_process";
+import { spawn as spawn2 } from "node:child_process";
 import { chmod as chmod2, mkdtemp, realpath, rm as rm2, writeFile as writeFile2 } from "node:fs/promises";
 import { homedir as homedir2, tmpdir } from "node:os";
 import { join as join2 } from "node:path";
+
+// src/command-processes.ts
+import { createHash as createHash3 } from "node:crypto";
+
+// src/capture-command.ts
+import { spawn } from "node:child_process";
+var MAX_OUTPUT_BYTES = 2 * 1024 * 1024;
+function captureCommand(options) {
+  if (options.signal.aborted || options.timeoutMs <= 0) {
+    return Promise.resolve({
+      exitCode: null,
+      signal: null,
+      timedOut: !options.signal.aborted,
+      cancelled: options.signal.aborted,
+      stdout: "",
+      stderr: ""
+    });
+  }
+  return new Promise((resolve8, reject) => {
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+    let cancelled = false;
+    let settled = false;
+    let killTimer = null;
+    const child = spawn(options.command, options.args, {
+      shell: false,
+      stdio: [
+        "ignore",
+        options.stdoutFileDescriptor === void 0 ? "pipe" : options.stdoutFileDescriptor,
+        "pipe"
+      ],
+      env: options.env ?? process.env,
+      cwd: options.cwd
+    });
+    const append = (current, chunk) => `${current}${String(chunk)}`.slice(0, MAX_OUTPUT_BYTES);
+    child.stdout?.on("data", (chunk) => {
+      stdout = append(stdout, chunk);
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr = append(stderr, chunk);
+    });
+    const terminate = () => {
+      if (child.exitCode !== null || child.killed) return;
+      child.kill("SIGTERM");
+      killTimer = setTimeout(() => {
+        if (child.exitCode === null) child.kill("SIGKILL");
+      }, 5e3);
+      killTimer.unref();
+    };
+    const timeout = setTimeout(() => {
+      timedOut = true;
+      terminate();
+    }, options.timeoutMs);
+    timeout.unref();
+    const abort = () => {
+      cancelled = true;
+      terminate();
+    };
+    options.signal.addEventListener("abort", abort, { once: true });
+    if (options.signal.aborted) abort();
+    child.once("error", (error) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+      if (killTimer) clearTimeout(killTimer);
+      options.signal.removeEventListener("abort", abort);
+      reject(error);
+    });
+    child.once("close", (exitCode, signal) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+      if (killTimer) clearTimeout(killTimer);
+      options.signal.removeEventListener("abort", abort);
+      resolve8({
+        exitCode,
+        signal,
+        timedOut,
+        cancelled,
+        stdout,
+        stderr
+      });
+    });
+  });
+}
+
+// src/command-processes.ts
+var COMMAND_SCRIPT_PREFIX = "aide-command-";
+var TERMINATE_GRACE_MS = 5e3;
+function commandScriptPrefix(agentId) {
+  const marker = createHash3("sha256").update(agentId).digest("hex").slice(0, 16);
+  return `${COMMAND_SCRIPT_PREFIX}${marker}-`;
+}
+var scriptPattern = (agentId) => `${commandScriptPrefix(agentId)}[^/]*/command\\.sh`;
+function parseCommandProcesses(output, ownPid) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const line of output.split("\n")) {
+    const [rawPid, rawGroup] = line.trim().split(/\s+/);
+    const pid = Number(rawPid);
+    const processGroup = Number(rawGroup);
+    if (!Number.isInteger(pid) || !Number.isInteger(processGroup)) continue;
+    if (processGroup <= 1 || pid <= 1) continue;
+    if (pid === ownPid || processGroup === ownPid) continue;
+    const known = groups.get(processGroup);
+    if (!known || pid === processGroup) {
+      groups.set(processGroup, { pid, processGroup });
+    }
+  }
+  return [...groups.values()];
+}
+async function listCommandProcesses(agentId, signal) {
+  const found = await captureCommand({
+    command: "/usr/bin/pgrep",
+    args: ["-f", scriptPattern(agentId)],
+    timeoutMs: 5e3,
+    signal
+  });
+  const pids = found.stdout.split("\n").map((line) => line.trim()).filter((line) => /^\d+$/.test(line));
+  if (!pids.length) return [];
+  const described = await captureCommand({
+    command: "/bin/ps",
+    args: ["-o", "pid=,pgid=", "-p", pids.join(",")],
+    timeoutMs: 5e3,
+    signal
+  });
+  return parseCommandProcesses(described.stdout, process.pid);
+}
+function signalGroup(processGroup, name) {
+  try {
+    process.kill(-processGroup, name);
+    return true;
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ESRCH") {
+      return false;
+    }
+    console.error(
+      `Could not signal orphaned command process group ${processGroup}:`,
+      error instanceof Error ? error.message : error
+    );
+    return false;
+  }
+}
+async function reapOrphanedCommandProcesses(agentId, signal = new AbortController().signal) {
+  if (process.platform === "win32") return [];
+  let orphans;
+  try {
+    orphans = await listCommandProcesses(agentId, signal);
+  } catch (error) {
+    console.error(
+      "Could not look for orphaned command processes:",
+      error instanceof Error ? error.message : error
+    );
+    return [];
+  }
+  const signalled = orphans.filter(
+    (orphan) => signalGroup(orphan.processGroup, "SIGTERM")
+  );
+  if (!signalled.length) return [];
+  console.error(
+    `Terminating ${signalled.length} command process(es) left by a previous agent run.`
+  );
+  await new Promise((resolve8) => {
+    const timer = setTimeout(resolve8, TERMINATE_GRACE_MS);
+    timer.unref();
+    if (signal.aborted) resolve8();
+    else signal.addEventListener("abort", () => resolve8(), { once: true });
+  });
+  for (const orphan of signalled) signalGroup(orphan.processGroup, "SIGKILL");
+  return signalled;
+}
+
+// src/handlers/commands.ts
 var MAX_BATCH_BYTES = 128 * 1024;
 var FLUSH_DELAY_MS = 25;
 var MAX_UPLOAD_ATTEMPTS = 8;
@@ -8295,7 +8536,9 @@ var runCommand = async (rawPayload, _timeoutMs, signal, _onLog, context) => {
   if (!context?.appendCommandOutput) {
     throw new Error("Command output uploader is unavailable");
   }
-  const directory = await mkdtemp(join2(tmpdir(), "aide-command-"));
+  const directory = await mkdtemp(
+    join2(tmpdir(), commandScriptPrefix(context.agentId))
+  );
   const scriptPath = join2(directory, "command.sh");
   await writeFile2(scriptPath, payload.script, {
     encoding: "utf8",
@@ -8382,7 +8625,7 @@ var runCommand = async (rawPayload, _timeoutMs, signal, _onLog, context) => {
     return await new Promise((resolve8, reject) => {
       let cancelled = false;
       let settled = false;
-      const child = spawn(process.env.SHELL || "/bin/sh", ["-l", scriptPath], {
+      const child = spawn2(process.env.SHELL || "/bin/sh", ["-l", scriptPath], {
         cwd,
         detached: process.platform !== "win32",
         env: {
@@ -8466,7 +8709,7 @@ import { readFile as readFile3, realpath as realpath3, stat as stat3 } from "nod
 import { join as join4, relative as relative4, sep as sep4 } from "node:path";
 
 // src/handlers/builds.ts
-import { createHash as createHash4, randomUUID } from "node:crypto";
+import { createHash as createHash5, randomUUID } from "node:crypto";
 import {
   cp,
   mkdir as mkdir2,
@@ -8643,91 +8886,8 @@ function parsePlist(xml) {
   return parseValue(xml, from, 0)[0];
 }
 
-// src/capture-command.ts
-import { spawn as spawn2 } from "node:child_process";
-var MAX_OUTPUT_BYTES = 2 * 1024 * 1024;
-function captureCommand(options) {
-  if (options.signal.aborted || options.timeoutMs <= 0) {
-    return Promise.resolve({
-      exitCode: null,
-      signal: null,
-      timedOut: !options.signal.aborted,
-      cancelled: options.signal.aborted,
-      stdout: "",
-      stderr: ""
-    });
-  }
-  return new Promise((resolve8, reject) => {
-    let stdout = "";
-    let stderr = "";
-    let timedOut = false;
-    let cancelled = false;
-    let settled = false;
-    let killTimer = null;
-    const child = spawn2(options.command, options.args, {
-      shell: false,
-      stdio: [
-        "ignore",
-        options.stdoutFileDescriptor === void 0 ? "pipe" : options.stdoutFileDescriptor,
-        "pipe"
-      ],
-      env: options.env ?? process.env,
-      cwd: options.cwd
-    });
-    const append = (current, chunk) => `${current}${String(chunk)}`.slice(0, MAX_OUTPUT_BYTES);
-    child.stdout?.on("data", (chunk) => {
-      stdout = append(stdout, chunk);
-    });
-    child.stderr?.on("data", (chunk) => {
-      stderr = append(stderr, chunk);
-    });
-    const terminate = () => {
-      if (child.exitCode !== null || child.killed) return;
-      child.kill("SIGTERM");
-      killTimer = setTimeout(() => {
-        if (child.exitCode === null) child.kill("SIGKILL");
-      }, 5e3);
-      killTimer.unref();
-    };
-    const timeout = setTimeout(() => {
-      timedOut = true;
-      terminate();
-    }, options.timeoutMs);
-    timeout.unref();
-    const abort = () => {
-      cancelled = true;
-      terminate();
-    };
-    options.signal.addEventListener("abort", abort, { once: true });
-    if (options.signal.aborted) abort();
-    child.once("error", (error) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timeout);
-      if (killTimer) clearTimeout(killTimer);
-      options.signal.removeEventListener("abort", abort);
-      reject(error);
-    });
-    child.once("close", (exitCode, signal) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timeout);
-      if (killTimer) clearTimeout(killTimer);
-      options.signal.removeEventListener("abort", abort);
-      resolve8({
-        exitCode,
-        signal,
-        timedOut,
-        cancelled,
-        stdout,
-        stderr
-      });
-    });
-  });
-}
-
 // src/git-code-state.ts
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash4 } from "node:crypto";
 import { createReadStream as createReadStream2 } from "node:fs";
 import { lstat, readlink } from "node:fs/promises";
 import { isAbsolute as isAbsolute2, relative as relative2, resolve as resolve2, sep as sep2 } from "node:path";
@@ -8854,7 +9014,7 @@ async function worktreeCodeStateHash(folder, timeoutMs, signal) {
     if (head.exitCode !== 0 || untracked.exitCode !== 0 || submodules.exitCode !== 0 || operation.signal.aborted) {
       return null;
     }
-    const hash = createHash3("sha256");
+    const hash = createHash4("sha256");
     hash.update("head\0");
     hash.update(head.stdout.trim());
     hash.update("\0diff\0");
@@ -10209,7 +10369,7 @@ async function fileChecksum(path) {
   try {
     const information = await stat2(path);
     if (!information.isFile()) return null;
-    const hash = createHash4("sha256");
+    const hash = createHash5("sha256");
     await pipeline(createReadStream3(path), hash);
     return hash.digest("hex");
   } catch {
@@ -11563,7 +11723,7 @@ var importCoverageReport = async (payloadValue, timeoutMs, signal, onLog) => {
 };
 
 // src/handlers/signing.ts
-import { createHash as createHash5, randomUUID as randomUUID2, X509Certificate } from "node:crypto";
+import { createHash as createHash6, randomUUID as randomUUID2, X509Certificate } from "node:crypto";
 import {
   mkdir as mkdir3,
   mkdtemp as mkdtemp3,
@@ -11656,7 +11816,7 @@ function certificateFingerprints(value) {
     try {
       const der = Buffer.from(encoded.replace(/\s+/g, ""), "base64");
       if (!der.length) return [];
-      return [createHash5("sha1").update(der).digest("hex").toUpperCase()];
+      return [createHash6("sha1").update(der).digest("hex").toUpperCase()];
     } catch {
       return [];
     }
@@ -11737,7 +11897,7 @@ function profileAsset(decoded, now) {
   const createdAt = text(decoded.raw.CreationDate);
   return {
     uuid: profile.uuid,
-    contentHash: createHash5("sha256").update(decoded.content).digest("hex").toUpperCase(),
+    contentHash: createHash6("sha256").update(decoded.content).digest("hex").toUpperCase(),
     name: profile.name,
     profileType: profile.type,
     bundleId: profile.bundleId,
@@ -12031,7 +12191,7 @@ var readSigningProfile = async (payload, timeoutMs, signal) => {
     ...successfulProcess3,
     uuid,
     contentBase64: profile.content.toString("base64"),
-    sha256: createHash5("sha256").update(profile.content).digest("hex").toUpperCase()
+    sha256: createHash6("sha256").update(profile.content).digest("hex").toUpperCase()
   };
 };
 var installSigningProfile = async (payload, timeoutMs, signal) => {
@@ -12073,7 +12233,7 @@ var importSigningIdentity = async (payload, timeoutMs, signal, _onLog, context)
   }
   const secret = await context.claimSigningSecretTransfer(input.transferId);
   const p12 = Buffer.from(secret.p12Base64, "base64");
-  const hash = createHash5("sha256").update(p12).digest("hex").toUpperCase();
+  const hash = createHash6("sha256").update(p12).digest("hex").toUpperCase();
   if (hash !== input.sha256)
     throw new Error("Signing identity transfer changed");
   const temporaryRoot = await mkdtemp3(join5(tmpdir3(), "ade-identity-"));
@@ -15072,10 +15232,16 @@ async function inspectCommits(folder, baseBranch, timeoutMs, signal) {
   return { commits: commits.slice(0, 100), truncated: commits.length > 100 };
 }
 async function inspectWorktreeDetail(folder, baseBranch, timeoutMs, signal) {
-  const [commitResult, changeResult, branchResult] = await Promise.all([
+  const [commitResult, changeResult, branchResult, signingResult] = await Promise.all([
     inspectCommits(folder, baseBranch, timeoutMs, signal),
     inspectChanges(folder, timeoutMs, signal),
-    inspectBranchChanges(folder, baseBranch, timeoutMs, signal)
+    inspectBranchChanges(folder, baseBranch, timeoutMs, signal),
+    git3(
+      folder,
+      ["config", "--bool", "--get", "commit.gpgsign"],
+      timeoutMs,
+      signal
+    )
   ]);
   return {
     commits: commitResult.commits,
@@ -15083,7 +15249,8 @@ async function inspectWorktreeDetail(folder, baseBranch, timeoutMs, signal) {
     branchChanges: branchResult.changes,
     commitsTruncated: commitResult.truncated,
     changesTruncated: changeResult.truncated,
-    branchChangesTruncated: branchResult.truncated
+    branchChangesTruncated: branchResult.truncated,
+    commitSigningEnabled: signingResult.exitCode === 0 && signingResult.stdout.trim() === "true"
   };
 }
 async function baseMergeCommit(folder, baseBranch, timeoutMs, signal) {
@@ -15609,6 +15776,97 @@ var inspectWorktreeGit = async (payload, timeoutMs, signal) => {
     )
   };
 };
+var commitWorktree = async (payload, timeoutMs, signal) => {
+  const input = worktreeCommitJobPayload(payload);
+  const folder = await validateWorktree2(input, timeoutMs, signal);
+  const runGit = async (args, fallback) => requireSuccess3(await git3(folder, args, timeoutMs, signal), fallback);
+  if (input.stageAll) {
+    await runGit(["add", "--all"], "Could not stage worktree changes");
+  } else {
+    const current = await inspectChanges(folder, timeoutMs, signal);
+    const byPath = new Map(
+      current.changes.map((change) => [change.path, change])
+    );
+    const selected = input.paths.map((path) => {
+      const change = byPath.get(path);
+      if (!change) throw new Error(`Worktree change no longer exists: ${path}`);
+      return change;
+    });
+    const head = await git3(
+      folder,
+      ["rev-parse", "--verify", "HEAD"],
+      timeoutMs,
+      signal
+    );
+    if (head.exitCode === 0) {
+      await runGit(
+        ["reset", "--mixed", "HEAD", "--"],
+        "Could not reset the Git index"
+      );
+    } else {
+      await runGit(
+        ["rm", "--cached", "-r", "--ignore-unmatch", "."],
+        "Could not reset the Git index"
+      );
+    }
+    const selectedPaths = [
+      ...new Set(
+        selected.flatMap(
+          (change) => change.previousPath ? [change.previousPath, change.path] : [change.path]
+        )
+      )
+    ];
+    await runGit(
+      ["--literal-pathspecs", "add", "--all", "--", ...selectedPaths],
+      "Could not stage selected worktree changes"
+    );
+  }
+  const staged = await git3(
+    folder,
+    ["diff", "--cached", "--quiet", "--exit-code"],
+    timeoutMs,
+    signal
+  );
+  if (staged.exitCode === 0) throw new Error("No staged changes to commit");
+  if (staged.exitCode !== 1)
+    requireSuccess3(staged, "Could not inspect staged changes");
+  let signed = input.signed;
+  if (signed === null) {
+    const configured = await git3(
+      folder,
+      ["config", "--bool", "--get", "commit.gpgsign"],
+      timeoutMs,
+      signal
+    );
+    signed = configured.exitCode === 0 && configured.stdout.trim() === "true";
+  }
+  await runGit(
+    ["commit", signed ? "--gpg-sign" : "--no-gpg-sign", "-m", input.message],
+    "Commit failed"
+  );
+  const sha = runGit(["rev-parse", "HEAD"], "Could not read the new commit");
+  const subject = runGit(
+    ["log", "-1", "--format=%s"],
+    "Could not read the new commit subject"
+  );
+  const [shaResult, subjectResult] = await Promise.all([sha, subject]);
+  return {
+    ...successfulProcess8,
+    commit: {
+      sha: shaResult.stdout.trim(),
+      subject: subjectResult.stdout.trim(),
+      signed
+    },
+    worktree: await inspectWorktreeItem(
+      folder,
+      folder,
+      input.baseBranch,
+      false,
+      Math.min(timeoutMs, 3e4),
+      signal
+    )
+  };
+};
 var operateWorktreeGit = async (payload, timeoutMs, signal) => {
   const input = worktreeGitOperationPayload(payload);
   const folder = await validateWorktree2(input, timeoutMs, signal);
@@ -16364,6 +16622,14 @@ var operateWorktree = async (payload, timeoutMs, signal) => {
       await runGit(["rebase", "--abort"], "Could not cancel rebase");
       break;
     }
+    case "PULL": {
+      if (!branch || !upstream)
+        throw new Error("Pull requires a branch with an upstream");
+      const remote = upstream.split("/")[0] || "origin";
+      await runGit(["fetch", remote], `Could not fetch ${remote}`);
+      await runGit(["merge", "--ff-only", "@{upstream}"], "Pull failed");
+      break;
+    }
     case "PUSH":
       if (!branch) throw new Error("Push requires a branch");
       await runGit(
@@ -16643,6 +16909,7 @@ var handlers = {
   [WORKTREE_INSPECT_JOB_KIND]: inspectWorktree,
   [WORKTREE_AUTO_SYNC_JOB_KIND]: autoSyncWorktree,
   [WORKTREE_BRANCH_JOB_KIND]: branchWorktree,
+  [WORKTREE_COMMIT_JOB_KIND]: commitWorktree,
   [WORKTREE_MOVE_PUSH_JOB_KIND]: pushMovedWorktree,
   [WORKTREE_MOVE_CHECKOUT_JOB_KIND]: checkoutMovedWorktree,
   [WORKTREE_DELETE_JOB_KIND]: deleteWorktree,
@@ -16754,6 +17021,7 @@ var JobExecutor = class {
         controller.signal,
         (log) => this.client.appendLog(claimed.id, log).then(() => void 0),
         {
+          agentId: claimed.agentId,
           reportWorktreeActivity: (input) => this.client.reportWorktreeActivity(input),
           reportBuildProgress: (input) => this.client.reportBuildProgress(input),
           appendBuildLogChunks: (buildId, chunks) => this.client.appendBuildLogChunks(buildId, chunks),
@@ -51097,6 +51365,7 @@ async function prepareDevelopmentAgent(options, signal, dependencies = defaultDe
 }
 async function runDevelopmentAgent(options, signal) {
   const config = await prepareDevelopmentAgent(options, signal);
+  await reapOrphanedCommandProcesses(config.agentId, signal);
   await runAgent(config, signal);
 }
 
@@ -51369,7 +51638,9 @@ async function main() {
           controller.signal
         );
       }
-      return await runAgent(await loadConfig(), controller.signal);
+      const config = await loadConfig();
+      await reapOrphanedCommandProcesses(config.agentId, controller.signal);
+      return await runAgent(config, controller.signal);
     } finally {
       for (const signal of shutdownSignals) process.off(signal, stop2);
     }

package/package.json

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