automata-cli 0.1.0-feature-030-do-work.190 → 0.1.0-feature-030-do-work.194

package/README.md

@@ -129,14 +129,7 @@ See [docs/execute-prompt.md](docs/execute-prompt.md) for full details.
 
 ## `automata do-work`
 
-Run one tick of the autonomous loop: find the open issues whose newest message from an authorized account the agent has not answered — on the issue or on its pull request — and answer them. Designed to run from cron in a disposable VM or container.
-
-```bash
-automata do-work              # one tick
-automata do-work --dry-run    # show the work plan, change nothing
-```
-
-See [docs/do-work.md](docs/do-work.md) for the command reference, and the [wiki](docs/wiki/Home.md) for the process: the trust model, the issue lifecycle, setup and operation.
+One tick of the autonomous loop: answer the open issues whose newest message from an authorized account the agent has not answered. Reference: [docs/do-work.md](docs/do-work.md). Process, trust model and setup: [the wiki](docs/wiki/Home.md).
 
 ---
 

package/dist/{ConfigWizard-SS7OOS5T.js → ConfigWizard-GN5JC4XP.js}

@@ -164,7 +164,7 @@ function ConfigWizard() {
       } else if (key.backspace || key.delete) {
         setDoWorkMaxRuns((v) => v.slice(0, -1));
       } else if (key.escape) {
-        setScreen("do-work-executor");
+        setScreen("do-work-codex-model");
       } else if (key.ctrl && input === "c") {
         exit();
       } else if (input && !key.ctrl && !key.meta) {

package/dist/index.js

@@ -183,7 +183,7 @@ var configCommand = new Command("config").description("Configure automata settin
   const [{ render }, React, { ConfigWizard }] = await Promise.all([
     import("ink"),
     import("react"),
-    import("./ConfigWizard-SS7OOS5T.js")
+    import("./ConfigWizard-GN5JC4XP.js")
   ]);
   const { waitUntilExit } = render(React.createElement(ConfigWizard));
   await waitUntilExit();
@@ -1483,6 +1483,10 @@ import { existsSync } from "fs";
 import { delimiter, join } from "path";
 
 // src/cli/spawnUtils.ts
+function shellQuote(arg) {
+  if (/^[A-Za-z0-9_@%+=:,./-]+$/.test(arg)) return arg;
+  return `'${arg.replaceAll("'", `'\\''`)}'`;
+}
 function truncate(str, max) {
   return str.length > max ? str.slice(0, max) + "..." : str;
 }
@@ -1520,6 +1524,39 @@ function resolveCommand(name) {
   }
   return name;
 }
+function buildClaudeArgs(prompt, options = {}) {
+  const args = [];
+  if (options.yolo) args.push("--dangerously-skip-permissions");
+  if (options.model) args.push("--model", options.model);
+  if (options.verbose) args.push("--verbose", "--output-format", "stream-json");
+  args.push("-p", prompt);
+  return args;
+}
+var activeChildren = /* @__PURE__ */ new Set();
+function terminateActiveClaudeProcesses(timeoutMs = 1e4) {
+  const children = [...activeChildren];
+  if (children.length === 0) return Promise.resolve();
+  const exits = children.map(
+    (child) => new Promise((resolve2) => {
+      if (child.exitCode !== null || child.signalCode !== null) {
+        resolve2();
+        return;
+      }
+      child.once("exit", () => resolve2());
+      child.kill("SIGTERM");
+    })
+  );
+  return Promise.race([
+    Promise.all(exits).then(() => void 0),
+    new Promise((resolve2) => {
+      const timer = setTimeout(() => {
+        for (const child of children) child.kill("SIGKILL");
+        resolve2();
+      }, timeoutMs);
+      timer.unref();
+    })
+  ]);
+}
 function invokeClaudeCode(prompt, options = {}) {
   if (options.verbose) {
     return invokeClaudeCodeVerbose(prompt, options.yolo ?? false, options.model);
@@ -1528,10 +1565,7 @@ function invokeClaudeCode(prompt, options = {}) {
 }
 function invokeClaudeCodeSync(prompt, yolo, model) {
   const claudeBin = resolveCommand("claude");
-  const args = [];
-  if (yolo) args.push("--dangerously-skip-permissions");
-  if (model) args.push("--model", model);
-  args.push("-p", prompt);
+  const args = buildClaudeArgs(prompt, { yolo, model, verbose: false });
   const result = spawnSync4(claudeBin, args, { encoding: "utf8", stdio: "inherit" });
   handleSpawnError(result.error, "claude");
   handleExitCode(result.status, "Claude Code");
@@ -1539,11 +1573,9 @@ function invokeClaudeCodeSync(prompt, yolo, model) {
 function invokeClaudeCodeVerbose(prompt, yolo, model) {
   return new Promise((resolve2) => {
     const claudeBin = resolveCommand("claude");
-    const args = [];
-    if (yolo) args.push("--dangerously-skip-permissions");
-    if (model) args.push("--model", model);
-    args.push("--verbose", "--output-format", "stream-json", "-p", prompt);
+    const args = buildClaudeArgs(prompt, { yolo, model, verbose: true });
     const child = spawn(claudeBin, args, { stdio: ["inherit", "pipe", "inherit"] });
+    activeChildren.add(child);
     const rl = createInterface({ input: child.stdout });
     let turnCount = 0;
     child.on("error", (err) => {
@@ -1558,6 +1590,7 @@ function invokeClaudeCodeVerbose(prompt, yolo, model) {
       }
     });
     child.on("close", (code) => {
+      activeChildren.delete(child);
       handleExitCode(code, "Claude Code");
       resolve2();
     });
@@ -1629,6 +1662,13 @@ function summarizeTool(name, input) {
 
 // src/codex/codexService.ts
 import { spawnSync as spawnSync5 } from "child_process";
+function buildCodexArgs(prompt, options = {}) {
+  const args = ["exec"];
+  if (options.yolo) args.push("--dangerously-bypass-approvals-and-sandbox");
+  if (options.model) args.push("--model", options.model);
+  args.push(prompt);
+  return args;
+}
 function invokeCodexCode(prompt, options = {}) {
   if (options.verbose) {
     process.stderr.write("Warning: --verbose is not supported for Codex and will be ignored.\n");
@@ -1637,10 +1677,7 @@ function invokeCodexCode(prompt, options = {}) {
 }
 function invokeCodexCodeSync(prompt, yolo, model) {
   const codexBin = resolveCommand("codex");
-  const args = ["exec"];
-  if (yolo) args.push("--dangerously-bypass-approvals-and-sandbox");
-  if (model) args.push("--model", model);
-  args.push(prompt);
+  const args = buildCodexArgs(prompt, { yolo, model });
   const result = spawnSync5(codexBin, args, { encoding: "utf8", stdio: "inherit" });
   handleSpawnError(result.error, "codex");
   handleExitCode(result.status, "Codex");
@@ -2301,42 +2338,64 @@ function getIssueSurface(issueNumber) {
   };
 }
 var LINK_MAP_QUERY = `
-query($owner:String!,$repo:String!){
+query($owner:String!,$repo:String!,$cursor:String){
   repository(owner:$owner,name:$repo){
-    pullRequests(states:OPEN, first:100, orderBy:{field:UPDATED_AT, direction:DESC}){
+    pullRequests(states:OPEN, first:100, after:$cursor, orderBy:{field:UPDATED_AT, direction:DESC}){
+      pageInfo{ hasNextPage endCursor }
       nodes{
         number url title headRefName isDraft updatedAt
-        closingIssuesReferences(first:10){ nodes{ number } }
+        closingIssuesReferences(first:50){
+          pageInfo{ hasNextPage }
+          nodes{ number }
+        }
       }
     }
   }
 }`.trim();
+var MAX_LINK_MAP_PAGES = 50;
 function getOpenPrLinkMap() {
   const { owner, repo } = getRepoSlug();
-  const response = ghJson(
-    ["api", "graphql", "-f", `query=${LINK_MAP_QUERY}`, "-f", `owner=${owner}`, "-f", `repo=${repo}`],
-    "query open pull requests"
-  );
   const map = /* @__PURE__ */ new Map();
-  for (const node of response.data.repository.pullRequests.nodes) {
-    const ref = {
-      number: node.number,
-      url: node.url,
-      title: node.title,
-      headRefName: node.headRefName,
-      state: "OPEN",
-      isDraft: node.isDraft,
-      updatedAt: node.updatedAt
-    };
-    for (const issue of node.closingIssuesReferences.nodes) {
-      const existing = map.get(issue.number);
-      if (existing) {
-        existing.push(ref);
-      } else {
-        map.set(issue.number, [ref]);
+  let cursor = null;
+  for (let page = 0; page < MAX_LINK_MAP_PAGES; page++) {
+    const args = ["api", "graphql", "-f", `query=${LINK_MAP_QUERY}`, "-f", `owner=${owner}`, "-f", `repo=${repo}`];
+    if (cursor !== null) args.push("-f", `cursor=${cursor}`);
+    const response = ghJson(args, "query open pull requests");
+    const connection = response.data.repository.pullRequests;
+    for (const node of connection.nodes) {
+      const ref = {
+        number: node.number,
+        url: node.url,
+        title: node.title,
+        headRefName: node.headRefName,
+        state: "OPEN",
+        isDraft: node.isDraft,
+        updatedAt: node.updatedAt
+      };
+      if (node.closingIssuesReferences.pageInfo?.hasNextPage) {
+        process.stderr.write(
+          `Warning: pull request #${String(node.number)} closes more than 50 issues; some links were not read.
+`
+        );
       }
+      for (const issue of node.closingIssuesReferences.nodes) {
+        const existing = map.get(issue.number);
+        if (existing) {
+          existing.push(ref);
+        } else {
+          map.set(issue.number, [ref]);
+        }
+      }
+    }
+    if (!connection.pageInfo?.hasNextPage || connection.pageInfo.endCursor === null) {
+      return map;
     }
+    cursor = connection.pageInfo.endCursor;
   }
+  process.stderr.write(
+    `Warning: stopped paginating open pull requests after ${String(MAX_LINK_MAP_PAGES)} pages; the issue-to-pull-request map may be incomplete.
+`
+  );
   return map;
 }
 var REVIEW_THREADS_QUERY2 = `
@@ -2491,9 +2550,19 @@ function isAssignedToAgent(assignees, agentUser) {
   return assignees.some((name) => name.toLowerCase() === agent);
 }
 function findActionableThreads(threads, p) {
-  return threads.filter(
-    (thread) => !thread.isResolved && lastAuthorClass(thread.comments, p) === "authorized"
-  );
+  const actionable = [];
+  for (const thread of threads) {
+    if (thread.isResolved) continue;
+    const comments = thread.comments.filter((comment) => classifyForThread(comment.author, p) !== "other");
+    if (lastAuthorClass(comments, p) !== "authorized") continue;
+    actionable.push({ ...thread, comments });
+  }
+  return actionable;
+}
+function classifyForThread(author, p) {
+  const login2 = author.toLowerCase();
+  if (login2 === p.agentUser.toLowerCase()) return "agent";
+  return p.allowedUsers.some((user) => user.toLowerCase() === login2) ? "authorized" : "other";
 }
 function newestPr(prs) {
   return [...prs].sort((a, b) => b.updatedAt.localeCompare(a.updatedAt))[0];
@@ -2700,6 +2769,7 @@ function preparePrBranch(headRefName) {
 
 // src/run/runLock.ts
 import { writeFileSync, readFileSync as readFileSync3, unlinkSync, mkdirSync } from "fs";
+import { randomUUID } from "crypto";
 import { hostname } from "os";
 import { join as join2 } from "path";
 var LOCK_DIR = ".automata";
@@ -2723,7 +2793,8 @@ function readOwner(path) {
       pid: parsed.pid,
       startedAt: parsed.startedAt,
       host: parsed.host ?? "unknown",
-      command: parsed.command ?? "unknown"
+      command: parsed.command ?? "unknown",
+      token: parsed.token ?? ""
     };
   } catch {
     return null;
@@ -2731,17 +2802,23 @@ function readOwner(path) {
 }
 function isStale(owner, staleMinutes) {
   if (owner === null) return true;
-  if (owner.host === hostname() && !isAlive(owner.pid)) return true;
+  if (owner.host === hostname()) {
+    return !isAlive(owner.pid);
+  }
   const startedAt = Date.parse(owner.startedAt);
   if (Number.isNaN(startedAt)) return true;
   return Date.now() - startedAt > staleMinutes * 60 * 1e3;
 }
-function makeHandle(path) {
+function makeHandle(path, token) {
   let released = false;
   return {
     release() {
       if (released) return;
       released = true;
+      const current = readOwner(path);
+      if (current !== null && current.token !== token) {
+        return;
+      }
       try {
         unlinkSync(path);
       } catch {
@@ -2749,21 +2826,23 @@ function makeHandle(path) {
     }
   };
 }
-function write(path, command) {
+function write(path, command, token) {
   const owner = {
     pid: process.pid,
     startedAt: (/* @__PURE__ */ new Date()).toISOString(),
     host: hostname(),
-    command
+    command,
+    token
   };
   writeFileSync(path, JSON.stringify(owner, null, 2) + "\n", { encoding: "utf8", flag: "wx" });
 }
 function acquireRunLock(command, staleMinutes) {
   const path = lockPath();
+  const token = randomUUID();
   mkdirSync(join2(process.cwd(), LOCK_DIR), { recursive: true });
   try {
-    write(path, command);
-    return { ok: true, handle: makeHandle(path) };
+    write(path, command, token);
+    return { ok: true, handle: makeHandle(path, token) };
   } catch (err) {
     if (err.code !== "EEXIST") throw err;
   }
@@ -2776,14 +2855,20 @@ function acquireRunLock(command, staleMinutes) {
   } catch {
   }
   try {
-    write(path, command);
-    return { ok: true, handle: makeHandle(path) };
+    write(path, command, token);
+    return { ok: true, handle: makeHandle(path, token) };
   } catch (err) {
     if (err.code !== "EEXIST") throw err;
     const winner = readOwner(path);
     return {
       ok: false,
-      heldBy: winner ?? { pid: 0, startedAt: (/* @__PURE__ */ new Date()).toISOString(), host: "unknown", command: "unknown" }
+      heldBy: winner ?? {
+        pid: 0,
+        startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        host: "unknown",
+        command: "unknown",
+        token: ""
+      }
     };
   }
 }
@@ -2876,11 +2961,49 @@ function checkAuthenticatedIdentity(agentUser, allowedUsers) {
       `\`gh\` is authenticated as "${login2}", which is listed in allowedUsers. Everything do-work posts would be attributed to an account that is allowed to instruct the agent, so its own marker comment would look like a new instruction and each tick would answer the previous tick forever. Authenticate \`gh\` as the agent account (${agentUser}) in this environment, or correct \`agentUser\`.`
     );
   }
-  progress(
-    `Warning: \`gh\` is authenticated as "${login2}" but agentUser is "${agentUser}". The agent will not recognise its own messages and may repeat itself. Authenticate as the agent account, or correct \`agentUser\`.
-`
+  fail(
+    `\`gh\` is authenticated as "${login2}" but agentUser is "${agentUser}". Comments posted under that identity are neither the agent's nor an authorized user's, so they are filtered out of the conversation: the answer boundary would never advance and the same message would start a run on every tick. Authenticate \`gh\` as the agent account (${agentUser}) in this environment, or correct \`agentUser\`.`
   );
 }
+function planRun(item, settings, silent) {
+  const prompt = composePrompt({
+    item,
+    repo: getRepoSlug(),
+    agentUser: settings.participants.agentUser,
+    baseBranch: settings.baseBranch,
+    frame: settings.prompts[item.turn]
+  });
+  const bin = resolveCommand(settings.executor === "codex" ? "codex" : "claude");
+  const args = settings.executor === "codex" ? buildCodexArgs(prompt, { yolo: true, model: settings.model }) : buildClaudeArgs(prompt, { yolo: true, verbose: !silent, model: settings.model });
+  return { prompt, bin, args, command: [bin, ...args].map(shellQuote).join(" ") };
+}
+function describePlannedRun(item, settings, run5) {
+  const rule = "\u2500".repeat(72);
+  const lines = [
+    rule,
+    `Issue #${String(item.issue.number)} \u2014 ${item.issue.title}`,
+    rule,
+    `  Turn         ${item.turn}`,
+    `  Why          ${item.reason}`,
+    `  Branch       ${item.branch} (would check out${item.turn === "pr-work" ? " and fast-forward" : " and pull"})`,
+    `  Assign       ${item.needsAssignment ? `would assign to ${settings.participants.agentUser}` : "already assigned"}`,
+    `  Marker       would post on ${item.turn === "pr-work" && item.pr ? `pull request #${String(item.pr.number)}` : `issue #${String(item.issue.number)}`}`,
+    `  Executor     ${settings.executor}${settings.model === void 0 ? " (no model override)" : ` \xB7 model ${settings.model}`}`,
+    `  Permissions  bypassed (do-work always runs unattended)`,
+    `  Prompt       ${String(run5.prompt.length)} chars \u2014 frame + assembled context`,
+    "",
+    "  Command that would be launched:",
+    // Printed flush-left and unindented on purpose: the prompt is a multi-line
+    // quoted argument, so indenting the continuation lines would inject leading
+    // whitespace into the prompt itself and the command would no longer be the
+    // one that runs.
+    rule,
+    run5.command,
+    rule,
+    ""
+  ];
+  return lines.join("\n") + "\n";
+}
 function discoverIssues(settings) {
   const candidates = listCandidateIssues(settings.technique, settings.discoveryValue, settings.limit);
   if (settings.onlyIssue === void 0) {
@@ -2967,8 +3090,14 @@ async function invokeExecutor(prompt, settings, silent) {
   }
   await invokeClaudeCode(prompt, { yolo: true, verbose: !silent, model: settings.model });
 }
-function repairIssueLink(item) {
+function repairIssueLink(item, baseBranch) {
   try {
+    const branch = getCurrentBranch();
+    if (branch === baseBranch) {
+      progress(`  issue #${String(item.issue.number)} is still in discussion (no branch was created).
+`);
+      return;
+    }
     const pr = getCurrentBranchPr();
     if (!pr) {
       progress(`  issue #${String(item.issue.number)} is still in discussion (no pull request).
@@ -3039,7 +3168,7 @@ async function processItem(item, settings, silent) {
   progress(`  ${reconciled.detail}
 `);
   if (item.turn === "issue-discuss") {
-    repairIssueLink(item);
+    repairIssueLink(item, settings.baseBranch);
   }
   return { ...base, outcome: reconciled.outcome, detail: reconciled.detail };
 }
@@ -3056,7 +3185,10 @@ function summarize(reports) {
 }
 var doWorkCommand = new Command6("do-work").description(
   "Run one tick of the autonomous loop: find the issues whose newest authorized message the agent has not answered, and answer them"
-).option("--with <executor>", "Executor to use: claude or codex (default: from config, else claude)").option("--model <string>", "Model identifier to pass to the executor, overriding the configured default for it").option("--issue <number>", "Restrict the tick to a single issue").option("--limit <n>", "Maximum number of issues to fetch", "10").option("--max-runs <n>", "Maximum number of model runs this tick").option("--dry-run", "Print the work plan and exit without changing anything").option("--json", "Emit the work plan and outcomes as JSON on stdout").option("--silent", "Suppress step-by-step Claude output; show only the final summary").action(async (options) => {
+).option("--with <executor>", "Executor to use: claude or codex (default: from config, else claude)").option("--model <string>", "Model identifier to pass to the executor, overriding the configured default for it").option("--issue <number>", "Restrict the tick to a single issue").option("--limit <n>", "Maximum number of issues to fetch", "10").option("--max-runs <n>", "Maximum number of model runs this tick").option(
+  "--dry-run",
+  "Print the work plan, plus a summary and the exact command that would be launched for each item, and exit without changing anything"
+).option("--json", "Emit the work plan and outcomes as JSON on stdout").option("--silent", "Suppress step-by-step Claude output; show only the final summary").action(async (options) => {
   const settings = resolveSettings(options);
   const lock = acquireRunLock("do-work", settings.lockStaleMinutes);
   if (!lock.ok) {
@@ -3067,9 +3199,15 @@ var doWorkCommand = new Command6("do-work").description(
     return;
   }
   const handle = lock.handle;
+  let shuttingDown = false;
   const onSignal = () => {
-    handle.release();
-    process.exit(130);
+    if (shuttingDown) return;
+    shuttingDown = true;
+    progress("\nInterrupted: stopping the executor before releasing the run lock\u2026\n");
+    void terminateActiveClaudeProcesses().then(() => {
+      handle.release();
+      process.exit(130);
+    });
   };
   process.once("SIGINT", onSignal);
   process.once("SIGTERM", onSignal);
@@ -3100,9 +3238,40 @@ ${describePlan(decisions)}`;
     out(planText);
   }
   if (options.dryRun) {
+    const runnableInPlan = settings.maxRuns > 0 ? items.slice(0, settings.maxRuns) : items;
+    const planned = runnableInPlan.map((item) => planRun(item, settings, options.silent === true));
     if (options.json) {
-      out(JSON.stringify({ dryRun: true, plan: decisions.map(toPlanJson) }, null, 2) + "\n");
+      out(
+        JSON.stringify(
+          {
+            dryRun: true,
+            plan: decisions.map(toPlanJson),
+            runs: planned.map((run5, index) => ({
+              issue: runnableInPlan[index].issue.number,
+              turn: runnableInPlan[index].turn,
+              executor: settings.executor,
+              model: settings.model ?? null,
+              bin: run5.bin,
+              args: run5.args,
+              command: run5.command,
+              prompt: run5.prompt
+            }))
+          },
+          null,
+          2
+        ) + "\n"
+      );
+      return 0;
+    }
+    for (const [index, run5] of planned.entries()) {
+      out("\n" + describePlannedRun(runnableInPlan[index], settings, run5));
+    }
+    if (items.length > runnableInPlan.length) {
+      out(`
+(${String(items.length - runnableInPlan.length)} further item(s) deferred by the run cap.)
+`);
     }
+    out("\nDry run: nothing was assigned, posted, checked out or executed.\n");
     return 0;
   }
   const runnable = settings.maxRuns > 0 ? items.slice(0, settings.maxRuns) : items;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "automata-cli",
-  "version": "0.1.0-feature-030-do-work.190",
+  "version": "0.1.0-feature-030-do-work.194",
   "description": "Automata CLI tool",
   "type": "module",
   "bin": {