cruo-agent 0.1.16 → 0.1.18

package/README.md

@@ -110,8 +110,9 @@ 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 3000 — 50 minutes; keep it under an hour, which is how long a run's board session lasts) |
+| `--harness-timeout <seconds>` | kill a run that wedges (default 3000 — 50 minutes). It used to have to stay under an hour, because that is how long a run's board session lasted; since 0.1.17 the session is renewed under a running card, so what this bounds now is spend, not credentials |
 | `--max-attempts <n>` | give up on a card after n unproductive runs (default 3) |
+| `--max-cost <dollars>` | stop spending on one card once it has cost this much, and hand it to a human with what it has. Unset by default. Read from what the harness itself reported, so it only bites where those figures exist |
 
 The full list, and what each is for: <https://cruo.space/docs#agents>
 

package/dist/VERSION

@@ -1 +1 @@
-0.1.16
+0.1.18

package/dist/cli.js

@@ -36803,6 +36803,7 @@ var init_dist6 = __esm({
 });
 
 // ../../packages/mcp-kit/dist/context.js
+import { readFileSync } from "node:fs";
 function decodeJwtExpiry(token) {
   const parts = token.split(".");
   if (parts.length !== 3)
@@ -36981,19 +36982,34 @@ function createRemoteContextResolver(options2) {
     return attempt;
   };
 }
-function readDelegatedSession() {
-  const raw = process.env[DELEGATED_SESSION_ENV];
-  if (!raw || !raw.trim())
+function readSessionFile() {
+  const path = process.env[DELEGATED_SESSION_FILE_ENV];
+  if (!path || !path.trim())
+    return null;
+  let raw;
+  try {
+    raw = readFileSync(path.trim(), "utf8");
+  } catch {
+    return null;
+  }
+  return parseSession(raw, DELEGATED_SESSION_FILE_ENV, "lenient");
+}
+function parseSession(raw, source, mode) {
+  if (!raw.trim())
     return null;
   let parsed;
   try {
     parsed = JSON.parse(raw);
   } catch {
-    throw new TokenRefused(`${DELEGATED_SESSION_ENV} is not valid JSON.`);
+    if (mode === "strict")
+      throw new TokenRefused(`${source} is not valid JSON.`);
+    return null;
   }
   const s = parsed;
   if (!s.accessToken || !s.userId || !s.email || !s.workspaceId) {
-    throw new TokenRefused(`${DELEGATED_SESSION_ENV} is missing fields.`);
+    if (mode === "strict")
+      throw new TokenRefused(`${source} is missing fields.`);
+    return null;
   }
   return {
     accessToken: s.accessToken,
@@ -37003,6 +37019,15 @@ function readDelegatedSession() {
     workspaceName: s.workspaceName ?? "workspace"
   };
 }
+function readDelegatedSession() {
+  const fromFile = readSessionFile();
+  if (fromFile)
+    return fromFile;
+  const raw = process.env[DELEGATED_SESSION_ENV];
+  if (!raw)
+    return null;
+  return parseSession(raw, DELEGATED_SESSION_ENV, "strict");
+}
 function contextFromSession(schema, session) {
   return {
     client: createUserClientFor(session.accessToken, schema),
@@ -37030,7 +37055,7 @@ async function resolve(options2) {
   const principal = await authenticate({ config: config3, token, product, mintedAt });
   return mintContext({ config: config3, principal, schema });
 }
-var TokenRefused, ASSUMED_SESSION_LIFETIME_MS, sessionInFlight, MINT_ATTEMPTS, DELEGATED_SESSION_ENV;
+var TokenRefused, ASSUMED_SESSION_LIFETIME_MS, sessionInFlight, MINT_ATTEMPTS, DELEGATED_SESSION_ENV, DELEGATED_SESSION_FILE_ENV;
 var init_context = __esm({
   "../../packages/mcp-kit/dist/context.js"() {
     "use strict";
@@ -37046,6 +37071,7 @@ var init_context = __esm({
     sessionInFlight = /* @__PURE__ */ new Map();
     MINT_ATTEMPTS = 3;
     DELEGATED_SESSION_ENV = "CRUO_SESSION";
+    DELEGATED_SESSION_FILE_ENV = "CRUO_SESSION_FILE";
   }
 });
 
@@ -46048,6 +46074,7 @@ var init_options = __esm({
       "interval",
       "limit",
       "max-attempts",
+      "max-cost",
       "max-interval",
       "model",
       "prepare",
@@ -46082,14 +46109,24 @@ function safeName(agent) {
   const cleaned = agent.toLowerCase().replace(/[^a-z0-9._-]/g, "").replace(/^\.+/, "");
   return cleaned === "" ? "default" : cleaned;
 }
+function isCanonicalProcStart(value) {
+  return /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/.test(value);
+}
 async function processStartedAt(pid) {
+  let raw;
   try {
-    const { stdout } = await exec("ps", ["-p", String(pid), "-o", "lstart="]);
-    const value = stdout.trim();
-    return value === "" ? null : value;
+    const { stdout } = await exec("ps", ["-p", String(pid), "-o", "lstart="], { env: PS_ENV });
+    raw = stdout.trim();
   } catch {
     return null;
   }
+  if (raw === "") return null;
+  const m = LSTART_PATTERN.exec(raw);
+  if (!m) return null;
+  const [, mon, day, hour, min, sec, year] = m;
+  return new Date(
+    Date.UTC(Number(year), LSTART_MONTHS.indexOf(mon), Number(day), Number(hour), Number(min), Number(sec))
+  ).toISOString();
 }
 function isAlive(pid) {
   try {
@@ -46116,6 +46153,12 @@ async function readRecord(agent) {
     return null;
   }
 }
+async function looksLikeThisAgent(pid, agent) {
+  const argv2 = await processArgv(pid);
+  if (!argv2 || !entryPosition(argv2)) return false;
+  const asName = asNameFrom(argv2);
+  return asName === null || asName === agent;
+}
 async function liveness(agent, tidy = false) {
   const record2 = await readRecord(agent);
   if (!record2) return { state: "absent" };
@@ -46124,8 +46167,15 @@ async function liveness(agent, tidy = false) {
     return { state: "gone", record: record2 };
   }
   const now = await processStartedAt(record2.pid);
+  if (record2.procStartedAt !== null && !isCanonicalProcStart(record2.procStartedAt)) {
+    if (!await looksLikeThisAgent(record2.pid, record2.agent)) {
+      return { state: "recycled", record: record2 };
+    }
+    const migrated = tidy && now !== null ? { ...record2, procStartedAt: now } : record2;
+    if (migrated !== record2) await writeRecord(migrated);
+    return { state: "running", record: migrated };
+  }
   if (record2.procStartedAt !== null && now !== null && now !== record2.procStartedAt) {
-    if (tidy) await removeRecord(agent);
     return { state: "recycled", record: record2 };
   }
   return { state: "running", record: record2 };
@@ -46246,7 +46296,7 @@ function since(iso) {
   if (ms2 < 864e5) return `${Math.round(ms2 / 36e5)}h`;
   return `${Math.round(ms2 / 864e5)}d`;
 }
-var exec, runDir, logDir, recordPath, CLI_BIN_NAMES, SUPERVISOR_BIN_NAMES, OWN_PACKAGE_MARKERS, NON_LOOPING_CLI_COMMANDS, NODE_FLAGS_WITH_VALUE, SIGNALS;
+var exec, runDir, logDir, recordPath, PS_ENV, LSTART_PATTERN, LSTART_MONTHS, CLI_BIN_NAMES, SUPERVISOR_BIN_NAMES, OWN_PACKAGE_MARKERS, NON_LOOPING_CLI_COMMANDS, NODE_FLAGS_WITH_VALUE, SIGNALS;
 var init_process = __esm({
   "src/process.ts"() {
     "use strict";
@@ -46255,6 +46305,9 @@ var init_process = __esm({
     runDir = () => join(homedir(), ".cruo", "run");
     logDir = () => join(homedir(), ".cruo", "logs");
     recordPath = (agent) => join(runDir(), `${safeName(agent)}.json`);
+    PS_ENV = { ...process.env, LC_ALL: "C", LANG: "C", TZ: "UTC" };
+    LSTART_PATTERN = /^\w{3}\s+(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s+(\d{1,2})\s+(\d{2}):(\d{2}):(\d{2})\s+(\d{4})$/;
+    LSTART_MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
     CLI_BIN_NAMES = /* @__PURE__ */ new Set(["cruo", "cruo-agent"]);
     SUPERVISOR_BIN_NAMES = /* @__PURE__ */ new Set(["cruo-supervisor"]);
     OWN_PACKAGE_MARKERS = ["@cruo/mcp", "cruo-agent", "apps/mcp", "packages/cli"];
@@ -46466,6 +46519,11 @@ predate cost recording (\`CRA-89\`, 2026-08-29).
       ` ${pad(nameOf(id), w)} ${rpad(String(a.runs), 5)} ${rpad(String(a.productive), 7)} ${rpad(String(a.neverRan), 5)} ${rpad(duration3(a.ms), 7)} ${rpad(compact(a.input + a.cacheRead), 8)} ${rpad(compact(a.output), 8)} ${rpad(openingAvg, 8)} ${rpad(a.cost > 0 ? `$${a.cost.toFixed(2)}` : "\u2014", 9)}`
     );
   }
+  if (byAgent.size > 1) {
+    console.log(
+      ` ${pad("\u2014 total \u2014", w)} ${rpad(String(total.runs), 5)} ${rpad(String(total.productive), 7)} ${rpad(String(total.neverRan), 5)} ${rpad(duration3(total.ms), 7)} ${rpad(compact(total.input + total.cacheRead), 8)} ${rpad(compact(total.output), 8)} ${rpad("\u2014", 8)} ${rpad(total.cost > 0 ? `$${total.cost.toFixed(2)}` : "\u2014", 9)}`
+    );
+  }
   if (!opts.issue) {
     const byIssue = /* @__PURE__ */ new Map();
     for (const r of rows) {
@@ -46510,6 +46568,11 @@ predate cost recording (\`CRA-89\`, 2026-08-29).
  ${total.runs} run(s), ${total.productive} productive, ${total.neverRan} never reached a model.
  ${duration3(total.ms)} of wall clock, ${compact(total.bytes)} bytes of output.`
   );
+  if (total.cacheRead > 0 || total.input > 0) {
+    console.log(
+      ` ${compact(total.cacheRead)} tokens read from cache, ${compact(total.input)} fresh input, ${compact(total.output)} written \u2014 the read figure is what the bill tracks.`
+    );
+  }
   if (total.measured === 0) {
     console.log(
       `
@@ -46571,6 +46634,7 @@ var init_usage = __esm({
 });
 
 // src/session-renewal.ts
+import { rename, writeFile as writeFile2 } from "node:fs/promises";
 async function withFreshSession(ctx, attempt, renewal) {
   const first = await attempt();
   if (!first.error || !isExpiredSessionError(first.error)) {
@@ -46600,12 +46664,23 @@ async function withFreshSession(ctx, attempt, renewal) {
     return first;
   }
 }
-var warnedThisOutage;
+function sessionRefreshDue(expiresAtMs, nowMs, marginMs = SESSION_REFRESH_MARGIN_MS) {
+  if (expiresAtMs === null) return true;
+  return expiresAtMs - nowMs <= marginMs;
+}
+async function writeSessionFile(path, session) {
+  const tmp = `${path}.${process.pid}.tmp`;
+  await writeFile2(tmp, JSON.stringify(session), { mode: 384 });
+  await rename(tmp, path);
+}
+var warnedThisOutage, SESSION_REFRESH_MARGIN_MS, SESSION_REFRESH_CHECK_MS;
 var init_session_renewal = __esm({
   "src/session-renewal.ts"() {
     "use strict";
     init_dist7();
     warnedThisOutage = false;
+    SESSION_REFRESH_MARGIN_MS = 10 * 6e4;
+    SESSION_REFRESH_CHECK_MS = 6e4;
   }
 });
 
@@ -46864,14 +46939,50 @@ var init_wake_clock = __esm({
 function blocksAgentPickup(state) {
   return state.requires_human === true;
 }
+function stillEligible(subject) {
+  const { issue: issue2, state, project } = subject;
+  if (!issue2) return quiet("no longer exists");
+  if (!state || !project) return quiet("can no longer be read (state or project missing)");
+  if (subject.onlyProject && project.key !== subject.onlyProject) {
+    return quiet(`is not in --project ${subject.onlyProject}`);
+  }
+  if (blocksAgentPickup(state)) {
+    return gate(`is in ${state.name}, which requires a human`);
+  }
+  if (subject.reason === "assigned") {
+    if (issue2.assignee_id !== subject.agentId) {
+      return quiet("is no longer assigned to this agent");
+    }
+    if (state.category === "completed" || state.category === "canceled") {
+      return quiet(`is in ${state.name}, which is ${state.category}`);
+    }
+    const said = subject.lastSaidAt;
+    if (said && issue2.updated_at && said > issue2.updated_at) {
+      return quiet("has not changed since this agent last commented");
+    }
+    return { ok: true };
+  }
+  if (subject.reason === "state") {
+    if (state.owner_function !== subject.jobFunction) {
+      return quiet(`is in ${state.name}, which "${subject.jobFunction}" does not own`);
+    }
+    if (issue2.assignee_id !== null && issue2.assignee_id !== subject.agentId) {
+      return quiet("is now assigned to someone else");
+    }
+    return { ok: true };
+  }
+  return { ok: true };
+}
 function byPriority(a, b) {
   return (PRIORITY_RANK[a.issue.priority] ?? 9) - (PRIORITY_RANK[b.issue.priority] ?? 9);
 }
-var PRIORITY_RANK;
+var gate, quiet, PRIORITY_RANK;
 var init_queries = __esm({
   "src/queries.ts"() {
     "use strict";
     init_dist();
+    gate = (why) => ({ ok: false, why, announce: true });
+    quiet = (why) => ({ ok: false, why, announce: false });
     PRIORITY_RANK = {
       urgent: 0,
       high: 1,
@@ -46960,7 +47071,7 @@ async function createWorktree(ref, config3) {
       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
+The run ended \u2014 ${reason} \u2014 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.
 
@@ -47024,7 +47135,7 @@ var init_worktree = __esm({
 var supervisor_exports = {};
 import { spawn } from "node:child_process";
 import { createRequire } from "node:module";
-import { mkdtemp, readdir as readdir3, readFile as readFile2, rm as rm3, stat as stat2, writeFile as writeFile2 } from "node:fs/promises";
+import { mkdtemp, readdir as readdir3, readFile as readFile2, rm as rm3, stat as stat2, writeFile as writeFile3 } from "node:fs/promises";
 import { homedir as homedir2, tmpdir } from "node:os";
 import { join as join3 } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -47053,7 +47164,7 @@ function resolveWorktreeRoot(identity) {
   const name = slug(identity.name) || slug(identity.email.split("@")[0] ?? "") || "agent";
   return join3(homedir2(), ".cruo-work", name);
 }
-async function pollAssigned(ctx) {
+async function pollAssigned(ctx, identity) {
   const { data: issues, error: error51 } = await ctx.client.from("issues").select("*").eq("assignee_id", ctx.userId).order("created_at", { ascending: true });
   if (error51) throw new Error(`Assignment poll failed: ${error51.message}`);
   if (!issues || issues.length === 0) return [];
@@ -47072,17 +47183,23 @@ async function pollAssigned(ctx) {
   return issues.flatMap((issue2) => {
     const state = byState.get(issue2.status_id);
     const project = byProject.get(issue2.project_id);
-    if (!state || !project) return [];
-    if (options.project && project.key !== options.project) return [];
-    if (blocksAgentPickup(state)) {
-      log(
-        `  ${project.key}-${issue2.number} is in ${state.name}, which requires a human \u2014 not starting`
-      );
+    const eligible = stillEligible({
+      reason: "assigned",
+      issue: issue2,
+      state: state ?? null,
+      project: project ?? null,
+      agentId: ctx.userId,
+      jobFunction: identity.jobFunction,
+      onlyProject: options.project ?? null,
+      lastSaidAt: lastSaid.get(issue2.id) ?? null
+    });
+    if (!eligible.ok) {
+      if (eligible.announce && project) {
+        log(`  ${project.key}-${issue2.number} ${eligible.why} \u2014 not starting`);
+      }
       return [];
     }
-    if (state.category === "completed" || state.category === "canceled") return [];
-    const said = lastSaid.get(issue2.id);
-    if (said && issue2.updated_at && said > issue2.updated_at) return [];
+    if (!project || !state) return [];
     return [
       {
         ref: `${project.key}-${issue2.number}`,
@@ -47112,14 +47229,22 @@ async function poll(ctx, identity) {
   return issues.flatMap((issue2) => {
     const project = byProject.get(issue2.project_id);
     const state = byState.get(issue2.status_id);
-    if (!project || !state) return [];
-    if (options.project && project.key !== options.project) return [];
-    if (blocksAgentPickup(state)) {
-      log(
-        `  ${project.key}-${issue2.number} is in ${state.name}, which requires a human \u2014 not starting`
-      );
+    const eligible = stillEligible({
+      reason: "state",
+      issue: issue2,
+      state: state ?? null,
+      project: project ?? null,
+      agentId: ctx.userId,
+      jobFunction: identity.jobFunction,
+      onlyProject: options.project ?? null
+    });
+    if (!eligible.ok) {
+      if (eligible.announce && project) {
+        log(`  ${project.key}-${issue2.number} ${eligible.why} \u2014 not starting`);
+      }
       return [];
     }
+    if (!project || !state) return [];
     return [
       {
         ref: `${project.key}-${issue2.number}`,
@@ -47161,8 +47286,22 @@ async function pollMentions(ctx, identity) {
   return issues.flatMap((issue2) => {
     const project = byProject.get(issue2.project_id);
     const state = byState.get(issue2.status_id);
+    const eligible = stillEligible({
+      reason: "mention",
+      issue: issue2,
+      state: state ?? null,
+      project: project ?? null,
+      agentId: ctx.userId,
+      jobFunction: identity.jobFunction,
+      onlyProject: options.project ?? null
+    });
+    if (!eligible.ok) {
+      if (eligible.announce && project) {
+        log(`  ${project.key}-${issue2.number} ${eligible.why} \u2014 not starting`);
+      }
+      return [];
+    }
     if (!project || !state) return [];
-    if (options.project && project.key !== options.project) return [];
     return [
       {
         ref: `${project.key}-${issue2.number}`,
@@ -47175,6 +47314,34 @@ async function pollMentions(ctx, identity) {
     ];
   }).sort(byPriority);
 }
+async function recheckEligibility(ctx, hit, identity) {
+  const { data: issue2, error: error51 } = await ctx.client.from("issues").select("*").eq("id", hit.issue.id).maybeSingle();
+  if (error51) {
+    log(`  ${hit.ref} could not be re-read (${error51.message}) \u2014 going on what the poll saw`);
+    return { ok: true, hit };
+  }
+  if (!issue2) return { ok: false, why: "no longer exists" };
+  const [{ data: state }, { data: said }] = await Promise.all([
+    ctx.client.from("workflow_states").select("*").eq("id", issue2.status_id).maybeSingle(),
+    // Only the `assigned` route reads this, and only to apply CRA-96's
+    // already-answered rule; one query rather than a branch, because the cost
+    // is a single indexed read next to a harness invocation.
+    ctx.client.from("comments").select("created_at").eq("issue_id", issue2.id).eq("author_id", ctx.userId).order("created_at", { ascending: false }).limit(1).maybeSingle()
+  ]);
+  const eligible = stillEligible({
+    reason: hit.reason,
+    issue: issue2,
+    state: state ?? null,
+    project: hit.project,
+    agentId: ctx.userId,
+    jobFunction: identity.jobFunction,
+    onlyProject: options.project ?? null,
+    lastSaidAt: said?.created_at ?? null
+  });
+  if (!eligible.ok) return { ok: false, why: eligible.why };
+  if (!state) return { ok: false, why: "can no longer be read (state missing)" };
+  return { ok: true, hit: { ...hit, issue: issue2, state } };
+}
 async function claim(ctx, hit) {
   const ttlMs = options.harnessTimeoutMs + 3e4;
   const { data, error: error51 } = await withFreshSession(
@@ -47221,11 +47388,14 @@ async function writeMcpConfig() {
   const session = await childSession();
   const dir = await mkdtemp(join3(tmpdir(), CONFIG_DIR_PREFIX));
   const path = join3(dir, "mcp.json");
+  const sessionPath = join3(dir, "session.json");
+  const writeSession = (s) => writeSessionFile(sessionPath, s);
+  await writeSession(session);
   const here = fileURLToPath(new URL(".", import.meta.url));
   const bundled = /[/\\]dist[/\\]?$/.test(here);
   const server = join3(here, bundled ? "index.js" : "index.ts");
   const loader = bundled ? null : createRequire(import.meta.url).resolve("tsx");
-  await writeFile2(
+  await writeFile3(
     path,
     JSON.stringify(
       {
@@ -47239,7 +47409,12 @@ async function writeMcpConfig() {
               // Neither the service-role key nor the PAT. The child gets a
               // session already minted from that PAT, by this process, which
               // is the one entitled to hold the key that mints one.
-              [DELEGATED_SESSION_ENV]: JSON.stringify(session)
+              // Both, deliberately (CRA-128). The file is what a renewal can
+              // replace; the env var is the floor, so a child whose file is
+              // unreadable for any reason behaves exactly as it did before
+              // this existed rather than losing the board outright.
+              [DELEGATED_SESSION_ENV]: JSON.stringify(session),
+              [DELEGATED_SESSION_FILE_ENV]: sessionPath
             }
           }
         }
@@ -47249,7 +47424,42 @@ async function writeMcpConfig() {
     ),
     { mode: 384 }
   );
-  return { path, cleanup: () => rm3(dir, { recursive: true, force: true }) };
+  const keepSessionFresh = () => {
+    let current = session;
+    let stopped = false;
+    let timer = null;
+    const tick2 = async () => {
+      if (stopped) return;
+      if (sessionRefreshDue(decodeJwtExpiry(current.accessToken), Date.now())) {
+        try {
+          const fresh = await childSession();
+          if (stopped) return;
+          await writeSession(fresh);
+          current = fresh;
+          log(`  session for this run renewed before expiry`);
+        } catch (error51) {
+          log(
+            `  could not renew this run's session (${error51 instanceof Error ? error51.message.split("\n")[0] : String(error51)}) \u2014 the harness keeps the one it has and this is retried`
+          );
+        }
+      }
+      if (!stopped) schedule();
+    };
+    const schedule = () => {
+      timer = setTimeout(() => void tick2(), SESSION_REFRESH_CHECK_MS);
+      timer.unref?.();
+    };
+    schedule();
+    return () => {
+      stopped = true;
+      if (timer) clearTimeout(timer);
+    };
+  };
+  return {
+    path,
+    keepSessionFresh,
+    cleanup: () => rm3(dir, { recursive: true, force: true })
+  };
 }
 async function sweepStaleConfigs() {
   const dir = tmpdir();
@@ -47422,7 +47632,8 @@ function headFor(head2) {
 }
 async function invokeHarness(ctx, identity, hit, worktree) {
   const cwd = worktree?.path ?? options.cwd;
-  const { path: mcpConfig, cleanup } = await writeMcpConfig();
+  const { path: mcpConfig, cleanup, keepSessionFresh } = await writeMcpConfig();
+  const stopSessionRefresh = keepSessionFresh();
   const streaming = options.usage === true;
   const builtinTools = [
     ...new Set(
@@ -47562,6 +47773,7 @@ async function invokeHarness(ctx, identity, hit, worktree) {
       });
     });
   } finally {
+    stopSessionRefresh();
     await cleanup();
   }
 }
@@ -47576,6 +47788,19 @@ async function loadAttempts(ctx, hits) {
   for (const row of data ?? []) out.set(`${row.reason}:${row.issue_id}`, row.attempts);
   return out;
 }
+async function loadOutcomes(ctx, hits) {
+  const out = /* @__PURE__ */ new Map();
+  if (hits.length === 0) return out;
+  const { data, error: error51 } = await ctx.client.from("issue_attempts").select("issue_id, reason, last_outcome").eq("agent_id", ctx.userId).in("issue_id", [...new Set(hits.map((h) => h.issue.id))]);
+  if (error51) {
+    log(`  could not read why (${error51.message}) \u2014 logging without a reason`);
+    return out;
+  }
+  for (const row of data ?? []) {
+    if (row.last_outcome) out.set(`${row.reason}:${row.issue_id}`, row.last_outcome);
+  }
+  return out;
+}
 async function recordAttempt(ctx, hit, outcome, previous) {
   const attempts = previous + 1;
   const { error: error51 } = await withFreshSession(
@@ -47599,6 +47824,47 @@ async function recordAttempt(ctx, hit, outcome, previous) {
   if (error51) log(`  could not record the attempt on ${hit.ref}: ${error51.message}`);
   return attempts;
 }
+async function loadSpend(ctx, hits) {
+  const out = /* @__PURE__ */ new Map();
+  if (hits.length === 0 || options.maxCostUsd === void 0) return out;
+  const { data, error: error51 } = await ctx.client.from("harness_runs").select("issue_id, cost_usd").eq("agent_id", ctx.userId).in("issue_id", [...new Set(hits.map((h) => h.issue.id))]);
+  if (error51) {
+    log(`  could not read spend so far (${error51.message}) \u2014 treating as $0`);
+    return out;
+  }
+  for (const row of data ?? []) {
+    if (row.cost_usd === null || row.issue_id === null) continue;
+    out.set(row.issue_id, (out.get(row.issue_id) ?? 0) + Number(row.cost_usd));
+  }
+  return out;
+}
+async function handOffForCost(ctx, hit, spent) {
+  const cap = options.maxCostUsd;
+  const { error: commentError } = await ctx.client.from("comments").insert({
+    issue_id: hit.issue.id,
+    author_id: ctx.userId,
+    body: `Spend ceiling reached: this card has cost **$${spent.toFixed(2)}**, at or over its \`--max-cost $${cap.toFixed(2)}\` limit, and is not finished. Stopping here rather than spending more on another run \u2014 a human should pick it up from whatever the runs so far left on it (state, comments, and any branch named on the card).`
+  });
+  if (commentError) {
+    log(`  ${hit.ref} could not post the spend-ceiling comment: ${commentError.message}`);
+  }
+  const { error: error51 } = await ctx.client.from("issue_attempts").upsert(
+    {
+      issue_id: hit.issue.id,
+      agent_id: ctx.userId,
+      reason: hit.reason,
+      attempts: options.maxAttempts,
+      last_tried_at: (/* @__PURE__ */ new Date()).toISOString(),
+      last_outcome: `spend ceiling reached ($${spent.toFixed(2)} \u2265 $${cap.toFixed(2)})`,
+      set_aside_at: (/* @__PURE__ */ new Date()).toISOString()
+    },
+    { onConflict: "issue_id,agent_id,reason" }
+  );
+  if (error51) log(`  could not set aside ${hit.ref} for spend: ${error51.message}`);
+  log(
+    `  ${hit.ref} hit its $${cap.toFixed(2)} spend ceiling ($${spent.toFixed(2)} spent) \u2014 commented and handed to a human, not invoking again`
+  );
+}
 async function clearAttempts(ctx, hit) {
   const { error: error51 } = await withFreshSession(
     ctx,
@@ -47714,25 +47980,49 @@ async function recordRun(ctx, hit, run, outcome) {
   }
 }
 async function tick(ctx, identity, deadTicks, allowance) {
-  const mentions = await pollMentions(ctx, identity);
-  const [assigned, stateWork] = await Promise.all([pollAssigned(ctx), poll(ctx, identity)]);
-  const seen = /* @__PURE__ */ new Set();
-  const hits = [...mentions, ...assigned, ...stateWork].filter((h) => {
-    if (seen.has(h.ref)) return false;
-    seen.add(h.ref);
-    return true;
-  });
-  const heldByOthers = await claimedElsewhere(ctx, hits);
-  const free = hits.filter((h) => !heldByOthers.has(h.issue.id));
-  if (heldByOthers.size > 0) {
-    log(`${heldByOthers.size} issue(s) already being worked by someone else`);
-  }
-  const attemptsByHit = await loadAttempts(ctx, free);
-  const attemptsFor = (h) => attemptsByHit.get(`${h.reason}:${h.issue.id}`) ?? 0;
-  const actionable = free.filter((h) => attemptsFor(h) < options.maxAttempts);
+  const readQueue = async (exclude, quiet2) => {
+    const mentions = await pollMentions(ctx, identity);
+    const [assigned, stateWork] = await Promise.all([pollAssigned(ctx, identity), poll(ctx, identity)]);
+    const seen = /* @__PURE__ */ new Set();
+    const hits = [...mentions, ...assigned, ...stateWork].filter((h) => {
+      if (seen.has(h.ref)) return false;
+      seen.add(h.ref);
+      return true;
+    });
+    const heldByOthers2 = await claimedElsewhere(ctx, hits);
+    const free2 = hits.filter((h) => !heldByOthers2.has(h.issue.id));
+    if (heldByOthers2.size > 0 && !quiet2) {
+      log(`${heldByOthers2.size} issue(s) already being worked by someone else`);
+    }
+    const attemptsByHit = await loadAttempts(ctx, free2);
+    const attemptsFor2 = (h) => attemptsByHit.get(`${h.reason}:${h.issue.id}`) ?? 0;
+    const spendByHit = await loadSpend(ctx, free2);
+    const spendFor = (h) => spendByHit.get(h.issue.id) ?? 0;
+    const overBudget = options.maxCostUsd !== void 0 ? free2.filter(
+      (h) => !exclude.has(h.issue.id) && attemptsFor2(h) < options.maxAttempts && spendFor(h) >= options.maxCostUsd
+    ) : [];
+    for (const hit of overBudget) {
+      exclude.add(hit.issue.id);
+      await handOffForCost(ctx, hit, spendFor(hit));
+    }
+    const actionable2 = free2.filter(
+      (h) => !exclude.has(h.issue.id) && attemptsFor2(h) < options.maxAttempts && (options.maxCostUsd === void 0 || spendFor(h) < options.maxCostUsd)
+    );
+    return { free: free2, heldByOthers: heldByOthers2, actionable: actionable2, attemptsFor: attemptsFor2 };
+  };
+  const tried = /* @__PURE__ */ new Set();
+  const queue = await readQueue(tried, false);
+  const { free, heldByOthers } = queue;
+  let { actionable, attemptsFor } = queue;
   if (actionable.length === 0) {
-    if (free.length > 0) log(`${free.length} issue(s) waiting, all set aside`);
-    else if (heldByOthers.size > 0) log(`nothing free \u2014 everything waiting is claimed`);
+    if (free.length > 0) {
+      log(`${free.length} issue(s) waiting, all set aside`);
+      const outcomes = await loadOutcomes(ctx, free);
+      for (const h of free) {
+        const why = outcomes.get(`${h.reason}:${h.issue.id}`);
+        log(`  ${h.ref}: ${why ?? "attempts exhausted, no reason recorded"}`);
+      }
+    } else if (heldByOthers.size > 0) log(`nothing free \u2014 everything waiting is claimed`);
     await beat(ctx, { holding: 0, deadTicks, intervalMs: options.intervalMs });
     return { invoked: 0, failedToRun: 0, suppressed: false, waiting: 0 };
   }
@@ -47761,15 +48051,34 @@ async function tick(ctx, identity, deadTicks, allowance) {
     `${actionable.length} issue(s) for "${identity.jobFunction}"` + (mentionCount > 0 ? ` \u2014 ${mentionCount} from unread mentions` : "")
   );
   const cap = allowance === "probe" ? 1 : options.limit;
-  const taking = cap ? actionable.slice(0, cap) : actionable;
-  if (taking.length < actionable.length) {
+  if (cap && cap < actionable.length) {
     log(
-      allowance === "probe" ? `  probing with ${taking.length} of ${actionable.length} \u2014 one card is enough to learn whether the harness works again` : `  taking ${taking.length} this tick (--limit ${options.limit})`
+      allowance === "probe" ? `  probing with ${cap} of ${actionable.length} \u2014 one card is enough to learn whether the harness works again` : `  taking ${cap} this tick (--limit ${options.limit})`
     );
   }
-  for (const hit of taking) {
+  const firstRead = new Set(actionable.map((h) => h.issue.id));
+  let worked = 0;
+  for (let first = true; ; first = false) {
+    if (cap && worked >= cap) break;
+    if (!first) {
+      if (stopping || paused) break;
+      ({ actionable, attemptsFor } = await readQueue(tried, true));
+    }
+    const queued = actionable.find((h) => !tried.has(h.issue.id));
+    if (!queued) break;
+    tried.add(queued.issue.id);
+    if (!firstRead.has(queued.issue.id)) {
+      log(`  ${queued.ref} arrived since this pass began \u2014 taking it next`);
+    }
+    const rechecked = await recheckEligibility(ctx, queued, identity);
+    if (!rechecked.ok) {
+      log(`  ${queued.ref} ${rechecked.why} \u2014 skipping`);
+      continue;
+    }
+    const hit = rechecked.hit;
     const why = hit.reason === "mention" ? "mentioned" : hit.reason === "assigned" ? `assigned \xB7 ${hit.state.name}` : hit.state.name;
     log(`\u2192 ${hit.ref} "${hit.issue.title}" (${why})`);
+    worked += 1;
     if (options.dryRun) {
       log(`  dry run \u2014 would invoke: ${options.harness} -p \u2026  --allowedTools ${options.allow}`);
       continue;
@@ -47803,23 +48112,20 @@ async function tick(ctx, identity, deadTicks, allowance) {
     try {
       run = await invokeHarness(ctx, identity, hit, worktree);
       if (worktree) committed = await worktree.commits();
-      if (worktree && run.killed) {
+      if (worktree) {
+        const endedBecause = run.killed ? "killed at the harness timeout" : run.refusal ? `stopped by a harness refusal (${run.refusal})` : run.code === 0 ? "exited 0 without committing this" : `cut short by exit ${run.code}`;
         try {
-          salvaged = await worktree.saveWip("killed at the harness timeout");
+          salvaged = await worktree.saveWip(endedBecause);
           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`
+              `  ${hit.ref} ${run.killed ? "killed" : `exited ${run.code}`} 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)}`
+            `  ${hit.ref} could not save the run's tree, and it goes with the worktree: ${error51 instanceof Error ? error51.message.split("\n")[0] : String(error51)}${options.keepFailed ? " (kept: --keep-failed)" : ""}`
           );
         }
-      } 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 {
       stopBusyBeat();
@@ -48099,6 +48405,7 @@ var init_supervisor = __esm({
   "src/supervisor.ts"() {
     "use strict";
     init_dist();
+    init_session_renewal();
     init_dist7();
     init_env2();
     init_auth();
@@ -48164,10 +48471,30 @@ var init_supervisor = __esm({
        * 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.
        */
-      // 50 minutes since CRA-122: roughly double the longest real run (26.3 min),
-      // and deliberately short of an hour — the run's own board session lasts
-      // exactly 60 minutes (see `writeMcpConfig`), so a longer limit lets a run
-      // lose the board in the minutes it hands the card on.
+      // 50 minutes since CRA-122: roughly double the longest real run (26.3 min).
+      //
+      // WHAT THE CEILING IS, AND WHY — read this before raising it (CRA-128 AC4).
+      //
+      // It used to be an hour, hard: the run's own board session lasted exactly 60
+      // minutes and was captured by the harness at start-up, so a longer limit let
+      // a run lose the board in the minutes it comments and hands the card on —
+      // the one part of a run nobody else can reconstruct. **That is fixed.**
+      // `writeMcpConfig` now writes the session to a file the child re-reads on
+      // every tool call and rewrites it ten minutes ahead of expiry, so a run can
+      // outlast its session.
+      //
+      // What still argues against a very long ceiling is money, not credentials.
+      // `CRA-127` measured it: cost tracks cached tokens READ, almost linearly, and
+      // a long run re-reads its own accumulating context on every turn — $8.04 for
+      // 22 minutes at the top of the range. So `--harness-timeout` is also a spend
+      // ceiling, and `--max-cost` is the one that says so out loud.
+      //
+      // One mechanical limit remains: `sweepStaleConfigs` removes a temp config
+      // older than `max(--harness-timeout + --prepare-timeout + 5min, 1h)`, read
+      // from the options of whichever supervisor is STARTING. Two supervisors with
+      // very different timeouts, and the short one can in principle sweep the long
+      // one's config mid-run. Nothing has hit this; raising the ceiling far past an
+      // hour is what would make it reachable.
       harnessTimeoutMs: ms("harness-timeout", 3e3),
       /**
        * Give up on an issue after this many unproductive runs. Persisted in
@@ -48175,6 +48502,24 @@ var init_supervisor = __esm({
        * forgot every set-aside and nothing outside the process could see one.
        */
       maxAttempts: num2("max-attempts", { fallback: 3, integer: true }),
+      /**
+       * Stop spending on ONE CARD once it has cost this many dollars, and hand it
+       * to a human instead of trying again — `CRA-127`. Unset means no ceiling,
+       * which is today's behaviour exactly: nothing stops a card costing $20.
+       *
+       * Read back from `harness_runs.cost_usd` — the same figure `cruo usage`
+       * shows — rather than a separate counter, so the two can never disagree
+       * about what a card has spent. That also means it only bites when the
+       * harness is reporting cost at all (`--usage`, for Claude Code): a harness
+       * that volunteers nothing is read as $0 spent, honestly, not metered
+       * against a figure it never produced.
+       *
+       * Checked BEFORE a harness is spawned, not after — the whole finding on
+       * this card is that a run's cost is paid turn by turn as it re-reads its
+       * own context, so the only ceiling worth having is one that stops the next
+       * invocation rather than one that bills it and complains afterwards.
+       */
+      maxCostUsd: num2("max-cost"),
       /**
        * Ask the harness to report what each run spent — `CRA-89`.
        *
@@ -48320,7 +48665,7 @@ init_dist();
 init_dist7();
 init_options();
 init_process();
-import { chmod, mkdir as mkdir3, readFile as readFile3, rm as rm4, writeFile as writeFile3 } from "node:fs/promises";
+import { chmod, mkdir as mkdir3, readFile as readFile3, rm as rm4, writeFile as writeFile4 } from "node:fs/promises";
 import { homedir as homedir3 } from "node:os";
 import { join as join4 } from "node:path";
 var CONFIG_DIR = join4(homedir3(), ".cruo");
@@ -48398,7 +48743,7 @@ async function readConfig2() {
 }
 async function writeConfig(config3) {
   await mkdir3(CONFIG_DIR, { recursive: true, mode: 448 });
-  await writeFile3(CONFIG_PATH, JSON.stringify(config3, null, 2) + "\n", { mode: 384 });
+  await writeFile4(CONFIG_PATH, JSON.stringify(config3, null, 2) + "\n", { mode: 384 });
   await chmod(CONFIG_PATH, 384);
 }
 async function lookup(token, timeoutMs = 5e3) {
@@ -48614,9 +48959,14 @@ Not signalled. Look at it yourself, then act if you are sure:
 ${name} is not running (it left a record behind; cleared).
 `);
     } else if (live.state === "recycled") {
-      console.error(`
-${name} is not running \u2014 its pid now belongs to something else. Cleared.
-`);
+      console.error(
+        `
+${name}'s record names pid ${live.record.pid}, which is alive but does not look like the same process anymore \u2014 cannot confirm it is still ${name}. Not touched: nothing here deletes the record of a pid that is alive. Look at it yourself, then act if you are sure:
+
+  ps -p ${live.record.pid} -o pid,lstart,command
+  rm ~/.cruo/run/${safeName(name)}.json   # only once you are sure it is not ${name}
+`
+      );
     } else {
       console.error(`
 ${name} is not running. Start it with \`cruo start --as ${name}\`.
@@ -48736,8 +49086,9 @@ Nothing running. Start one with \`cruo start\`.
       console.log(`  ${agent.padEnd(14)} \u2014        \u2014        died or was killed (record cleared)`);
       await removeRecord(agent);
     } else if (live.state === "recycled") {
-      console.log(`  ${agent.padEnd(14)} \u2014        \u2014        gone; its pid is now someone else's (cleared)`);
-      await removeRecord(agent);
+      console.log(
+        `  ${agent.padEnd(14)} ${String(live.record.pid).padEnd(8)} \u2014        cannot confirm this is still the same process \u2014 left for you to check`
+      );
     }
   }
   for (const proc of untracked) {

package/dist/index.js

@@ -45048,7 +45048,7 @@ var require_dist_cjs13 = __commonJS({
   "../../node_modules/.pnpm/@aws-sdk+credential-provider-web-identity@3.972.71/node_modules/@aws-sdk/credential-provider-web-identity/dist-cjs/index.js"(exports) {
     var { setCredentialFeature: setCredentialFeature2 } = (init_client3(), __toCommonJS(client_exports2));
     var { CredentialsProviderError: CredentialsProviderError2, externalDataInterceptor: externalDataInterceptor2 } = (init_config2(), __toCommonJS(config_exports));
-    var { readFileSync } = __require("node:fs");
+    var { readFileSync: readFileSync2 } = __require("node:fs");
     var fromWebToken = (init) => async (awsIdentityProperties) => {
       init.logger?.debug("@aws-sdk/credential-provider-web-identity - fromWebToken");
       const { roleArn, roleSessionName, webIdentityToken, providerId, policyArns, policy, durationSeconds } = init;
@@ -45089,7 +45089,7 @@ var require_dist_cjs13 = __commonJS({
       }
       const credentials = await fromWebToken({
         ...init,
-        webIdentityToken: externalDataInterceptor2?.getTokenRecord?.()[webIdentityTokenFile] ?? readFileSync(webIdentityTokenFile, { encoding: "ascii" }),
+        webIdentityToken: externalDataInterceptor2?.getTokenRecord?.()[webIdentityTokenFile] ?? readFileSync2(webIdentityTokenFile, { encoding: "ascii" }),
         roleArn,
         roleSessionName
       })(awsIdentityProperties);
@@ -78141,6 +78141,7 @@ async function touchAccessToken(admin, tokenId) {
 }
 
 // ../../packages/mcp-kit/dist/context.js
+import { readFileSync } from "node:fs";
 function decodeJwtExpiry(token) {
   const parts = token.split(".");
   if (parts.length !== 3)
@@ -78255,6 +78256,7 @@ async function sessionFor(config3, principal) {
   return attempt;
 }
 var DELEGATED_SESSION_ENV = "CRUO_SESSION";
+var DELEGATED_SESSION_FILE_ENV = "CRUO_SESSION_FILE";
 async function fetchDelegatedSession(endpoint, token, options = {}) {
   let response;
   try {
@@ -78306,19 +78308,34 @@ function createRemoteContextResolver(options) {
     return attempt;
   };
 }
-function readDelegatedSession() {
-  const raw = process.env[DELEGATED_SESSION_ENV];
-  if (!raw || !raw.trim())
+function readSessionFile() {
+  const path = process.env[DELEGATED_SESSION_FILE_ENV];
+  if (!path || !path.trim())
+    return null;
+  let raw;
+  try {
+    raw = readFileSync(path.trim(), "utf8");
+  } catch {
+    return null;
+  }
+  return parseSession(raw, DELEGATED_SESSION_FILE_ENV, "lenient");
+}
+function parseSession(raw, source, mode) {
+  if (!raw.trim())
     return null;
   let parsed;
   try {
     parsed = JSON.parse(raw);
   } catch {
-    throw new TokenRefused(`${DELEGATED_SESSION_ENV} is not valid JSON.`);
+    if (mode === "strict")
+      throw new TokenRefused(`${source} is not valid JSON.`);
+    return null;
   }
   const s2 = parsed;
   if (!s2.accessToken || !s2.userId || !s2.email || !s2.workspaceId) {
-    throw new TokenRefused(`${DELEGATED_SESSION_ENV} is missing fields.`);
+    if (mode === "strict")
+      throw new TokenRefused(`${source} is missing fields.`);
+    return null;
   }
   return {
     accessToken: s2.accessToken,
@@ -78328,6 +78345,15 @@ function readDelegatedSession() {
     workspaceName: s2.workspaceName ?? "workspace"
   };
 }
+function readDelegatedSession() {
+  const fromFile = readSessionFile();
+  if (fromFile)
+    return fromFile;
+  const raw = process.env[DELEGATED_SESSION_ENV];
+  if (!raw)
+    return null;
+  return parseSession(raw, DELEGATED_SESSION_ENV, "strict");
+}
 function contextFromSession(schema, session) {
   return {
     client: createUserClientFor(session.accessToken, schema),
@@ -89327,7 +89353,7 @@ function registerTools(server, getContext2, options = {}) {
     "delete_issue",
     {
       title: "Delete issue",
-      description: "Delete an issue (its comments, labels and activity cascade).",
+      description: "Move an issue to the trash. It disappears from the board and every tool, with its comments, labels and activity; a person can restore it from Trash in the app for 30 days, after which it is deleted for good.",
       inputSchema: { issue: external_exports.string().describe("Issue reference, e.g. CRU-14") }
     },
     async (args, ctx) => {
@@ -89335,7 +89361,7 @@ function registerTools(server, getContext2, options = {}) {
       const ref = issueRef(project, issue2);
       const { error: error52 } = await ctx.client.from("issues").delete().eq("id", issue2.id);
       if (error52) throw new ToolError(error52.message);
-      return `Deleted ${ref}.`;
+      return `Moved ${ref} to the trash. It can be restored from Trash in the app for 30 days.`;
     }
   );
   register(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cruo-agent",
-  "version": "0.1.16",
+  "version": "0.1.18",
   "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",