cruo-agent 0.1.4 → 0.1.5

package/README.md

@@ -93,7 +93,7 @@ given up on work nobody abandoned.
 | `--worktree` | a checkout per card |
 | `--allow <tools>` | what the harness may use |
 | `--push` | publish the branch after a run that commits |
-| `--harness-timeout <seconds>` | kill a run that wedges (default 600) |
+| `--harness-timeout <seconds>` | kill a run that wedges (default 1800) |
 | `--max-attempts <n>` | give up on a card after n unproductive runs (default 3) |
 
 The full list, and what each is for: <https://cruo.space/docs#agents>

package/dist/VERSION

@@ -1 +1 @@
-0.1.4
+0.1.5

package/dist/cli.js

@@ -15247,6 +15247,13 @@ var init_plans = __esm({
   }
 });
 
+// ../../packages/core/dist/reports.js
+var init_reports = __esm({
+  "../../packages/core/dist/reports.js"() {
+    "use strict";
+  }
+});
+
 // ../../packages/core/dist/mcp-connect.js
 var DOCS_URL, AGENT_DOCS_URL, MCP_DOCS_URL, CRUO_CLOUD;
 var init_mcp_connect = __esm({
@@ -15293,6 +15300,7 @@ var init_dist = __esm({
     init_identity();
     init_effort();
     init_plans();
+    init_reports();
     init_mcp_connect();
     init_tree();
     init_place();
@@ -46237,15 +46245,77 @@ function usageIn(text) {
   const measured = Object.values(out).some((v) => v !== void 0);
   return measured ? out : null;
 }
+function renderEvent(line) {
+  let event;
+  try {
+    event = JSON.parse(line);
+  } catch {
+    return { text: line, show: line };
+  }
+  if (typeof event !== "object" || event === null) return { text: line, show: line };
+  const e = event;
+  if (e.type === "assistant" || e.type === "user") {
+    const message = e.message;
+    const content = Array.isArray(message?.content) ? message.content : [];
+    const said = [];
+    const shown = [];
+    for (const part of content) {
+      if (typeof part !== "object" || part === null) continue;
+      const p = part;
+      if (p.type === "text" && typeof p.text === "string") {
+        said.push(p.text);
+        shown.push(p.text);
+      } else if (p.type === "tool_use" && typeof p.name === "string") {
+        shown.push(`  \xB7 ${p.name}`);
+      } else if (p.type === "tool_result") {
+        const failed = p.is_error === true;
+        if (failed) shown.push("  \xB7 tool error");
+      }
+    }
+    return {
+      text: said.length > 0 ? said.join("\n") : null,
+      show: shown.length > 0 ? shown.join("\n") : null
+    };
+  }
+  if (e.type === "result") {
+    const summary = typeof e.result === "string" ? e.result : null;
+    const usage = usageIn(line);
+    const spend = usage ? ` \u2014 ${usage.inputTokens ?? "?"} in / ${usage.outputTokens ?? "?"} out` + (usage.costUsd !== void 0 ? `, $${usage.costUsd.toFixed(4)}` : "") : "";
+    return { text: summary, show: `  [${String(e.subtype ?? "result")}${spend}]` };
+  }
+  if (e.type === "system") return { text: null, show: null };
+  return { text: null, show: null };
+}
 var REFUSALS, num;
 var init_harness_signal = __esm({
   "src/harness-signal.ts"() {
     "use strict";
     REFUSALS = [
-      [/hit your (monthly |weekly |daily )?(spend|usage) limit/i, "the account's spend limit is reached"],
-      [/insufficient credit|out of credit|credit balance is too low/i, "the account is out of credit"],
+      // "hit your" AND "reached your". The original had only the first, and the
+      // harness ships the second — `you have reached your weekly usage limit` is a
+      // literal string in the 2.x binary. That one word cost 8,239 runs (CRA-89):
+      // the refusal went unrecognised, so `neverRan` was false, so the backoff
+      // never engaged and every card was charged for an outage.
+      [
+        /(hit|reached) your (monthly |weekly |daily )?(spend|usage) limit/i,
+        "the account's usage limit is reached"
+      ],
+      // The passive voice of the same thing, which is what the harness prints when
+      // it is reporting rather than addressing you.
+      [/(usage|spend|usage credit) limit reached/i, "the account's usage limit is reached"],
+      // `is` optional: the binary carries BOTH "credit balance is too low" and
+      // "credit balance too low", and the pattern only knew the longer one.
+      [
+        /insufficient credit|out of credit|credit balance (is )?too low/i,
+        "the account is out of credit"
+      ],
       [/upgrade to (a paid plan|claude pro)/i, "the plan does not cover this"],
       [/invalid api key|authentication[_ ]error|please run \/login/i, "the harness is not signed in"],
+      // Still requires the follow-up clause. A bare "rate limited" is left
+      // UNMATCHED on purpose — it is a phrase a model writes about a codebase
+      // ("the endpoint is rate limited"), and the note above is explicit that a
+      // false positive is the worse error: it credits an issue an attempt it
+      // should have been charged.
       [/rate limit(ed| exceeded|s? reached)\b.*\btry again/i, "the account is rate limited"]
     ];
     num = (v) => typeof v === "number" && Number.isFinite(v) ? v : void 0;
@@ -46357,10 +46427,28 @@ async function createWorktree(ref, config3) {
     const out = await git(config3.repo, ["rev-list", "--count", `${startCommit}..${branch}`]);
     return Number(out) || 0;
   };
+  const isDirty = async () => (await git(path, ["status", "--porcelain"])).length > 0;
   return {
     path,
     branch,
     commits: countCommits,
+    dirty: isDirty,
+    async saveWip(reason) {
+      if (!await isDirty()) return null;
+      await git(path, ["add", "-A"]);
+      const staged = await git(path, ["diff", "--cached", "--name-only"]);
+      if (staged.length === 0) return null;
+      const message = `wip(${ref}): saved by the supervisor when the run was cut short
+
+The harness was ${reason} with this in the tree. NOT a handoff: the
+agent did not choose to commit it and nothing here has been reviewed.
+The next attempt on this card starts from here rather than from scratch.
+
+Cruo-Wip: ${reason}
+`;
+      await git(path, ["commit", "--no-verify", "-m", message]);
+      return await git(path, ["rev-parse", "HEAD"]);
+    },
     async push(remote) {
       assertPublishable(branch);
       if (await countCommits() === 0 && !await hasRef(config3.repo, `${remote}/${branch}`)) {
@@ -46778,9 +46866,14 @@ function userPrompt(hit) {
     `which your function owns. Pick it up and do your part.`
   ].join(" ");
 }
+function headFor(head2) {
+  const flat = head2.replace(/\s+/g, " ").trim();
+  return flat === "" ? null : flat.slice(0, HEAD_STORED);
+}
 async function invokeHarness(ctx, identity, hit, worktree) {
   const cwd = worktree?.path ?? options.cwd;
   const { path: mcpConfig, cleanup } = await writeMcpConfig();
+  const streaming = options.usage === true;
   const args = [
     "-p",
     userPrompt(hit),
@@ -46794,7 +46887,11 @@ async function invokeHarness(ctx, identity, hit, worktree) {
     options.allow,
     "--system-prompt",
     systemPrompt(ctx, identity, worktree),
-    ...options.model ? ["--model", options.model] : []
+    ...options.model ? ["--model", options.model] : [],
+    // `--verbose` is not optional alongside stream-json: without it the harness
+    // emits only the final result and the live view is a blank terminal for the
+    // length of the run.
+    ...streaming ? ["--output-format", "stream-json", "--verbose"] : []
   ];
   try {
     return await new Promise((resolve2) => {
@@ -46810,14 +46907,34 @@ async function invokeHarness(ctx, identity, hit, worktree) {
       let stdoutBytes = 0;
       let tail = "";
       let head2 = "";
+      let pending = "";
+      const addHead = (text) => {
+        if (head2.length < 2048) head2 += text.slice(0, 2048 - head2.length);
+      };
       child.stdout?.on("data", (c) => {
         stdoutBytes += c.length;
-        if (head2.length < 2048) head2 += c.toString("utf8").slice(0, 2048 - head2.length);
-        tail = (tail + c.toString("utf8")).slice(-4096);
-        process.stdout.write(c);
+        const chunk = c.toString("utf8");
+        if (!streaming) {
+          addHead(chunk);
+          tail = (tail + chunk).slice(-4096);
+          process.stdout.write(c);
+          return;
+        }
+        pending += chunk;
+        const lines = pending.split("\n");
+        pending = lines.pop() ?? "";
+        for (const line of lines) {
+          if (line.trim() === "") continue;
+          tail = line;
+          const rendered = renderEvent(line);
+          if (rendered.text) addHead(rendered.text + "\n");
+          if (rendered.show) process.stdout.write(rendered.show + "\n");
+        }
       });
       child.stderr?.on("data", (c) => process.stderr.write(c));
+      let killed = false;
       const timer = setTimeout(() => {
+        killed = true;
         log(`  harness exceeded ${options.harnessTimeoutMs / 1e3}s \u2014 killing it`);
         child.kill("SIGTERM");
         setTimeout(() => child.kill("SIGKILL"), 1e4).unref();
@@ -46830,17 +46947,28 @@ async function invokeHarness(ctx, identity, hit, worktree) {
           stdoutBytes,
           refusal: refusalIn(head2),
           durationMs: Date.now() - startedAtMs,
-          usage: null
+          usage: null,
+          killed,
+          stdoutHead: headFor(head2)
         });
       });
       child.on("close", (code) => {
         clearTimeout(timer);
+        if (streaming && pending.trim() !== "") {
+          tail = pending;
+          const rendered = renderEvent(pending);
+          if (rendered.text) addHead(rendered.text + "\n");
+          if (rendered.show) process.stdout.write(rendered.show + "\n");
+          pending = "";
+        }
         resolve2({
           code: code ?? 1,
           stdoutBytes,
           refusal: refusalIn(head2),
           durationMs: Date.now() - startedAtMs,
-          usage: usageIn(tail)
+          usage: usageIn(tail),
+          killed,
+          stdoutHead: headFor(head2)
         });
       });
     });
@@ -46933,6 +47061,7 @@ async function recordRun(ctx, hit, run, outcome) {
     duration_ms: run.durationMs,
     exit_code: run.code,
     stdout_bytes: run.stdoutBytes,
+    stdout_head: run.stdoutHead,
     outcome,
     model: run.usage?.model ?? null,
     input_tokens: run.usage?.inputTokens ?? null,
@@ -47029,9 +47158,28 @@ async function tick(ctx, identity, deadTicks, allowance) {
     }
     let run;
     let committed = 0;
+    let salvaged = null;
     try {
       run = await invokeHarness(ctx, identity, hit, worktree);
       if (worktree) committed = await worktree.commits();
+      if (worktree && run.killed) {
+        try {
+          salvaged = await worktree.saveWip("killed at the harness timeout");
+          if (salvaged) {
+            log(
+              `  ${hit.ref} killed with an uncommitted tree \u2014 saved as ${salvaged.slice(0, 8)} on ${worktree.branch}; the next attempt resumes from it`
+            );
+          }
+        } catch (error51) {
+          log(
+            `  ${hit.ref} could not save the killed run's tree: ${error51 instanceof Error ? error51.message.split("\n")[0] : String(error51)}`
+          );
+        }
+      } else if (worktree && committed === 0 && await worktree.dirty()) {
+        log(
+          `  ${hit.ref} exited ${run.code} leaving uncommitted changes \u2014 they go with the worktree${options.keepFailed ? " (kept: --keep-failed)" : "; use --keep-failed to inspect them"}`
+        );
+      }
     } finally {
       await release(ctx, hit);
     }
@@ -47071,7 +47219,8 @@ async function tick(ctx, identity, deadTicks, allowance) {
       }
     } else {
       const what = hit.reason === "mention" ? "no reply written" : "unchanged";
-      const n2 = await recordAttempt(ctx, hit, `${what} (exit ${code})`, attemptsFor(hit));
+      const note = salvaged ? `${what} (exit ${code}); cut short, work saved as ${salvaged.slice(0, 8)}` : `${what} (exit ${code})`;
+      const n2 = await recordAttempt(ctx, hit, note, attemptsFor(hit));
       log(
         `  ${hit.ref} ${what} after the run (exit ${code}) \u2014 attempt ${n2}/${options.maxAttempts}` + (n2 >= options.maxAttempts ? "; setting it aside, a human should look" : "")
       );
@@ -47196,7 +47345,7 @@ async function main() {
     await new Promise((r) => setTimeout(r, options.intervalMs));
   }
 }
-var argv, flag, opt, num2, ms, readOptions, options, log, worktreeConfig, lastRefusal, PRIORITY_RANK, CONFIG_DIR_PREFIX, CRUO_OWNED_ENV, warnedAboutSpendTable;
+var argv, flag, opt, num2, ms, readOptions, options, log, worktreeConfig, lastRefusal, PRIORITY_RANK, CONFIG_DIR_PREFIX, CRUO_OWNED_ENV, HEAD_STORED, warnedAboutSpendTable;
 var init_supervisor = __esm({
   "src/supervisor.ts"() {
     "use strict";
@@ -47250,14 +47399,40 @@ var init_supervisor = __esm({
        * supervisor down with it. Observed in the first live run: a harness that
        * produced no output and no writes for ten minutes. A killed run counts as
        * unproductive like any other, so the retry/set-aside path handles it.
+       *
+       * THIRTY MINUTES, and the number is a decision rather than a guess — the two
+       * mistakes this sits between are nowhere near the same size (`CRA-105`).
+       * Killing a wedged run late costs wall clock the supervisor was not using
+       * anyway. Killing a WORKING run early costs everything it did: the checkout
+       * is recreated from scratch on the next attempt, so an uncommitted tree is
+       * discarded rather than resumed (`CRA-104`). Ten minutes was tuned on the
+       * cards the loop was first exercised on, and `CRA-83` — four packages and a
+       * test file — was killed at it twice, having written real work both times
+       * and committed neither. Err long: the cheap failure is the slow one.
        */
-      harnessTimeoutMs: ms("harness-timeout", 600),
+      harnessTimeoutMs: ms("harness-timeout", 1800),
       /**
        * Give up on an issue after this many unproductive runs. Persisted in
        * `pm.issue_attempts` since CRA-7 — it was in-memory, which meant a restart
        * forgot every set-aside and nothing outside the process could see one.
        */
       maxAttempts: num2("max-attempts", { fallback: 3, integer: true }),
+      /**
+       * Ask the harness to report what each run spent — `CRA-89`.
+       *
+       * Off by default and that is a real choice, not caution. It appends
+       * `--output-format stream-json --verbose`, which are Claude Code's flags, and
+       * the supervisor's whole design is that `--harness` takes any command that
+       * accepts a prompt and exits. Turning this on says "my harness is Claude Code
+       * shaped"; leaving it off keeps the promise.
+       *
+       * What it costs: the harness's stdout stops being prose and becomes NDJSON,
+       * so the live view is reconstructed by `renderEvent` rather than passed
+       * through. What it buys is the only numbers there are — without it every
+       * token column in `pm.harness_runs` is null, which is what 8,335 rows of it
+       * were.
+       */
+      usage: flag("usage"),
       /**
        * Ceiling on how long invocation is held back after a run of dead ticks.
        * Ten minutes: long enough that a broken harness stops being spawned over and
@@ -47350,6 +47525,7 @@ cruo-supervisor: ${error51.message}
       // stands in for. Cheap to list, and wrong to discover the hard way.
       "CRUO_SESSION"
     ];
+    HEAD_STORED = 200;
     warnedAboutSpendTable = false;
     main().catch((e) => {
       console.error(e instanceof Error ? e.message : e);
@@ -47391,6 +47567,7 @@ Common options
   --allow <tools>        what the harness may use; default is the board only
   --push                 publish the branch after a run that commits
   --interval <seconds>   how often to poll (default 20)
+  --usage                record what each run costs (needs a Claude Code harness)
 
   Full list and what each one is for: https://cruo.space/docs#agents
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cruo-agent",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "Run a Cruo agent: it watches your board, picks up the cards you assign it, and works them.",
   "license": "MIT",
   "homepage": "https://cruo.space/docs#agents",