@garuda-agent/garuda 0.16.1 → 0.17.0

package/dist/{chunk-YQTGMCU6.js → chunk-3MRQJKUO.js}

@@ -2,7 +2,7 @@
 import {
   passed,
   testSummary
-} from "./chunk-OUCV3FCT.js";
+} from "./chunk-AOGFYUKG.js";
 
 // src/jobs/text.ts
 function jobPrompt(request, plan) {
@@ -22,7 +22,28 @@ function jobPrompt(request, plan) {
     "</plan>"
   ].join("\n");
 }
-var cost = (usd) => usd === void 0 ? "unknown" : `$${usd.toFixed(4)}`;
+var cost = (usd, incomplete = false) => formatCost({ usd, incomplete });
+function formatCost(c) {
+  if (c.usd === void 0) return "unknown";
+  return c.incomplete ? `\u2265 $${c.usd.toFixed(4)} (incomplete)` : `$${c.usd.toFixed(4)}`;
+}
+function sumCosts(costs) {
+  let usd = 0;
+  let incomplete = false;
+  for (const c of costs) {
+    usd = usd === void 0 || c.usd === void 0 ? void 0 : usd + c.usd;
+    incomplete ||= c.incomplete;
+  }
+  return { usd, incomplete };
+}
+function jobCost(r) {
+  const run = { usd: r.costUsd, incomplete: r.costIncomplete === true };
+  const proof = r.proof;
+  const review = proof?.review;
+  const reviewIncomplete = proof?.reviewCostIncomplete === true;
+  if (review === void 0) return sumCosts([run, { usd: 0, incomplete: reviewIncomplete }]);
+  return sumCosts([run, { usd: review.costUsd, incomplete: reviewIncomplete }]);
+}
 function jobReport(job) {
   const r = job.result;
   const lines = [`# Garuda job ${job.id}: ${job.title}`, ""];
@@ -40,7 +61,7 @@ function jobReport(job) {
   if (job.startedAt !== void 0) lines.push(`- Started: ${job.startedAt}`);
   if (r === void 0) return lines.join("\n");
   lines.push(
-    `- Steps: ${r.steps} \xB7 tokens: ${Math.round(r.tokens / 100) / 10}k \xB7 cost: ${cost(r.costUsd)} \xB7 time: ${Math.round(r.durationMs / 1e3)} s`
+    `- Steps: ${r.steps} \xB7 tokens: ${Math.round(r.tokens / 100) / 10}k \xB7 cost: ${cost(r.costUsd, r.costIncomplete === true)} \xB7 time: ${Math.round(r.durationMs / 1e3)} s`
   );
   if (r.sessionId !== void 0) lines.push(`- Session: ${r.sessionId}`);
   if (r.modelCalls !== void 0) {
@@ -96,7 +117,7 @@ function proofLines(job, proof) {
   if (proof.flags.length === 0) out.push("None.");
   for (const f of proof.flags) out.push(`- ${f.level === "stop" ? "STOP" : "look"}: ${f.text}`);
   if (proof.review !== void 0) {
-    const cost2 = proof.review.costUsd === void 0 ? "" : ` (${`$${proof.review.costUsd.toFixed(4)}`})`;
+    const cost2 = proof.review.costUsd === void 0 ? "" : ` (${formatCost({ usd: proof.review.costUsd, incomplete: proof.reviewCostIncomplete === true })})`;
     out.push("", `## Review by a principal engineer${cost2}`, "", proof.review.text);
   } else if (proof.reviewError !== void 0) {
     out.push("", "## Review", "", `The review failed: ${proof.reviewError}`);
@@ -106,6 +127,9 @@ function proofLines(job, proof) {
 
 export {
   jobPrompt,
+  formatCost,
+  sumCosts,
+  jobCost,
   jobReport
 };
-//# sourceMappingURL=chunk-YQTGMCU6.js.map
+//# sourceMappingURL=chunk-3MRQJKUO.js.map

package/dist/{chunk-WMOLXTBU.js → chunk-4LFJFDCF.js}

@@ -56,6 +56,7 @@ export {
   isInside,
   resolveInRoot,
   realRelative,
+  realpathOfNearestExisting,
   displayPath
 };
-//# sourceMappingURL=chunk-WMOLXTBU.js.map
+//# sourceMappingURL=chunk-4LFJFDCF.js.map

package/dist/{chunk-44QN5SWZ.js → chunk-55CFEEIN.js}

@@ -2,7 +2,10 @@
 import {
   JobGitError,
   git
-} from "./chunk-TUUEBHG2.js";
+} from "./chunk-6XHON3Q6.js";
+import {
+  inWriteScope
+} from "./chunk-UIRJOQQS.js";
 
 // src/jobs/worktree.ts
 import { createHash } from "crypto";
@@ -86,6 +89,22 @@ async function commitJob(executor, job, message) {
   await git(executor, job.worktree, ["commit", "--no-verify", "-q", "-m", message]);
   return (await git(executor, job.worktree, ["rev-parse", "HEAD"])).stdout.trim();
 }
+async function outsideScope(executor, job) {
+  if (job.writeScope === void 0) return [];
+  const exclude = [...NEVER_COMMIT, ...job.links].map((p) => `:(exclude)${p}`);
+  const status = await git(executor, job.worktree, [
+    "status",
+    "--porcelain=v1",
+    "-z",
+    "--untracked-files=all",
+    "--no-renames",
+    "--",
+    ".",
+    ...exclude
+  ]);
+  const scope = job.writeScope;
+  return status.stdout.split("\0").filter((entry) => entry.length > 3).map((entry) => entry.slice(3)).filter((path) => !inWriteScope(path, scope));
+}
 async function jobChanges(executor, job) {
   const range = [job.base, job.branch];
   const names = await git(executor, job.root, [
@@ -133,6 +152,7 @@ export {
   linkCandidates,
   prepareWorktree,
   commitJob,
+  outsideScope,
   jobChanges
 };
-//# sourceMappingURL=chunk-44QN5SWZ.js.map
+//# sourceMappingURL=chunk-55CFEEIN.js.map

package/dist/{chunk-USCUXCAU.js → chunk-5B5HDTUR.js}

@@ -2,10 +2,10 @@
 import {
   hostCommand,
   shellWord
-} from "./chunk-TUUEBHG2.js";
+} from "./chunk-6XHON3Q6.js";
 import {
   JOBS_DIR
-} from "./chunk-KKB5W47S.js";
+} from "./chunk-VTMD5IHD.js";
 
 // src/jobs/launchd.ts
 import { createHash } from "crypto";
@@ -154,4 +154,4 @@ export {
   nightAgentTime,
   removeAgent
 };
-//# sourceMappingURL=chunk-USCUXCAU.js.map
+//# sourceMappingURL=chunk-5B5HDTUR.js.map

package/dist/{chunk-TUUEBHG2.js → chunk-6XHON3Q6.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   DEFAULT_ENV_ALLOWLIST
-} from "./chunk-GXZACJUI.js";
+} from "./chunk-B4SJY7KT.js";
 
 // src/jobs/git.ts
 var GIT_TIMEOUT_MS = 12e4;
@@ -46,4 +46,4 @@ export {
   git,
   hostCommand
 };
-//# sourceMappingURL=chunk-TUUEBHG2.js.map
+//# sourceMappingURL=chunk-6XHON3Q6.js.map

package/dist/chunk-735BKABA.js

@@ -0,0 +1,472 @@
+#!/usr/bin/env node
+import {
+  Redactor,
+  contextSize,
+  totalTokens
+} from "./chunk-J4346IDH.js";
+import {
+  cleanLine
+} from "./chunk-PZS3V6P3.js";
+import {
+  ZERO_USAGE,
+  addUsage,
+  reportedUsage
+} from "./chunk-BHZ6G65V.js";
+import {
+  formatRule
+} from "./chunk-3NJNVZTK.js";
+
+// src/session/store.ts
+import { randomBytes } from "crypto";
+import { appendFileSync, mkdirSync } from "fs";
+import { readdir, readFile, rm, stat, utimes } from "fs/promises";
+import { basename, join } from "path";
+var SESSIONS_DIR = join(".garuda", "sessions");
+var FileSessionStore = class {
+  dir;
+  redactor;
+  constructor(root, redactor = new Redactor()) {
+    this.dir = join(root, SESSIONS_DIR);
+    this.redactor = redactor;
+  }
+  path(sessionId) {
+    if (!SESSION_ID.test(sessionId)) throw new Error(`"${sessionId}" is not a session id.`);
+    return join(this.dir, `${sessionId}.jsonl`);
+  }
+  open(sessionId) {
+    return this.journal(this.dir, this.path(sessionId));
+  }
+  /** `.garuda/sessions/<session id>/<child id>.jsonl`. */
+  childPath(sessionId, childId) {
+    return join(this.dir, safeId(sessionId), `${safeId(childId)}.jsonl`);
+  }
+  openChild(sessionId, childId) {
+    return this.journal(join(this.dir, safeId(sessionId)), this.childPath(sessionId, childId));
+  }
+  journal(dir, file) {
+    mkdirSync(dir, { recursive: true, mode: 448 });
+    return {
+      write: (record) => {
+        const line = { t: (/* @__PURE__ */ new Date()).toISOString(), ...record };
+        appendFileSync(file, `${JSON.stringify(this.redactor.value(line))}
+`, { mode: 384 });
+      }
+    };
+  }
+  async read(sessionId) {
+    return parseRecords(await readFile(this.path(sessionId), "utf8"));
+  }
+  async setTitle(sessionId, title) {
+    const file = this.path(sessionId);
+    const before = await stat(file);
+    this.open(sessionId).write({ type: "title", title });
+    await utimes(file, before.atime, before.mtime);
+  }
+  async remove(sessionId) {
+    await rm(this.path(sessionId));
+    await rm(join(this.dir, safeId(sessionId)), { recursive: true, force: true });
+  }
+  async latest() {
+    return (await this.list())[0]?.id;
+  }
+  async list() {
+    let names;
+    try {
+      names = (await readdir(this.dir)).filter((name) => name.endsWith(".jsonl"));
+    } catch {
+      return [];
+    }
+    const out = [];
+    for (const name of names) {
+      const info = await stat(join(this.dir, name)).catch(() => void 0);
+      if (info?.isFile()) out.push({ id: basename(name, ".jsonl"), updated: info.mtime });
+    }
+    return out.sort((a, b) => b.updated.getTime() - a.updated.getTime());
+  }
+};
+var SESSION_ID = /^[A-Za-z0-9_-]{1,80}$/;
+function safeId(id) {
+  return id.replace(/[^A-Za-z0-9_-]/g, "_").slice(0, 80) || "_";
+}
+function parseRecords(text) {
+  const lines = text.split("\n").filter((line) => line.trim() !== "");
+  const records = [];
+  lines.forEach((line, i) => {
+    try {
+      records.push(JSON.parse(line));
+    } catch (error) {
+      if (i < lines.length - 1) throw new Error(`Session file line ${i + 1} is not valid JSON.`);
+      void error;
+    }
+  });
+  return records;
+}
+function newSessionId(now = /* @__PURE__ */ new Date()) {
+  const pad = (n) => String(n).padStart(2, "0");
+  const date = `${now.getFullYear()}${pad(now.getMonth() + 1)}${pad(now.getDate())}`;
+  const time = `${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`;
+  return `${date}-${time}-${randomBytes(2).toString("hex")}`;
+}
+
+// src/session/fileTracker.ts
+import { createHash } from "crypto";
+var FileTracker = class {
+  seen = /* @__PURE__ */ new Map();
+  /** "path|offset|limit" → hash of the whole file at that read. */
+  reads = /* @__PURE__ */ new Map();
+  /** Record the content the agent now knows for `path` (absolute). */
+  record(path, content) {
+    this.seen.set(path, hash(content));
+  }
+  /** "unread", "changed" or "current". */
+  status(path, content) {
+    const known = this.seen.get(path);
+    if (known === void 0) return "unread";
+    return known === hash(content) ? "current" : "changed";
+  }
+  /**
+   * Record a read of some lines. Returns true when the agent already read the same lines
+   * of the same content, so the output is still in its context.
+   */
+  noteRead(path, content, offset, limit) {
+    const key = `${path}|${offset}|${limit}`;
+    const digest = hash(content);
+    const repeat = this.reads.get(key) === digest;
+    this.reads.set(key, digest);
+    return repeat;
+  }
+  /**
+   * Compaction cuts or summarises old tool outputs, so earlier reads may no longer be in the context.
+   * The edit freshness records stay: they are about the file, not the context.
+   */
+  forgetReads() {
+    this.reads.clear();
+  }
+};
+function hash(content) {
+  return createHash("sha256").update(content).digest("hex");
+}
+
+// src/session/undo.ts
+var MAX_UNDO_POINTS = 50;
+var PROMPT_CHARS = 80;
+function emptyUndoState() {
+  return { points: [], redo: [] };
+}
+function pushPoint(state, tree, messages, prompt) {
+  const line = prompt.replace(/\s+/g, " ").trim();
+  state.points.push({
+    tree,
+    messages,
+    conversation: true,
+    prompt: line.length > PROMPT_CHARS ? `${line.slice(0, PROMPT_CHARS)}\u2026` : line
+  });
+  if (state.points.length > MAX_UNDO_POINTS) state.points.shift();
+  state.redo = [];
+}
+function popPoint(state, messages, after) {
+  const point = state.points.pop();
+  if (point === void 0) return void 0;
+  const removed = point.conversation ? messages.splice(point.messages) : [];
+  state.redo.push({ point, after, removed });
+  return point;
+}
+function redoPoint(state, messages) {
+  const entry = state.redo.pop();
+  if (entry === void 0) return void 0;
+  messages.push(...entry.removed);
+  state.points.push(entry.point);
+  return entry;
+}
+function compacted(state) {
+  for (const point of state.points) point.conversation = false;
+  for (const entry of state.redo) {
+    entry.point.conversation = false;
+    entry.removed = [];
+  }
+}
+function newUserMessage(state) {
+  state.redo = [];
+}
+
+// src/session/session.ts
+function createSession(root, id = newSessionId(), journal) {
+  const session = {
+    id,
+    root,
+    messages: [],
+    usage: { ...ZERO_USAGE },
+    costUsd: 0,
+    costIncomplete: false,
+    contextTokens: 0,
+    unreportedTokens: 0,
+    childDebits: /* @__PURE__ */ new Map(),
+    files: new FileTracker(),
+    undo: emptyUndoState()
+  };
+  if (journal !== void 0) session.journal = journal;
+  return session;
+}
+function addUserMessage(session, text, notes = [], attachments = []) {
+  const message = {
+    role: "user",
+    content: [
+      { type: "text", text },
+      ...attachments.map((a) => ({ type: "text", text: a })),
+      ...notes.map((note) => ({
+        type: "text",
+        text: `<garuda_note>${note}</garuda_note>`
+      }))
+    ]
+  };
+  session.messages.push(message);
+  newUserMessage(session.undo);
+  session.journal?.write({ type: "user", message });
+}
+function addSnapshot(session, tree, prompt, durationMs) {
+  const messages = session.messages.length;
+  pushPoint(session.undo, tree, messages, prompt);
+  const point = session.undo.points.at(-1);
+  session.journal?.write({ type: "snapshot", tree, messages, prompt: point.prompt, durationMs });
+}
+function undoTurn(session, after) {
+  const point = popPoint(session.undo, session.messages, after);
+  if (point !== void 0) {
+    session.journal?.write({ type: "undo", after });
+    session.files.forgetReads();
+  }
+  return point;
+}
+function redoTurn(session) {
+  const entry = redoPoint(session.undo, session.messages);
+  if (entry !== void 0) {
+    session.journal?.write({ type: "redo" });
+    session.files.forgetReads();
+  }
+  return entry;
+}
+function addAssistantResponse(session, response, step, costUsd) {
+  if (response.usageReported === false) {
+    session.costIncomplete = true;
+    costUsd = void 0;
+    addCost(session, reportedUsage(response), session.costUsd === void 0 ? void 0 : 0);
+  } else addCost(session, reportedUsage(response), costUsd);
+  session.contextTokens = contextSize(response.usage);
+  if (response.content.length > 0) {
+    session.messages.push({ role: "assistant", content: response.content });
+  }
+  session.journal?.write({
+    type: "assistant",
+    step,
+    response,
+    ...costUsd === void 0 ? {} : { costUsd }
+  });
+}
+function addToolResults(session, results, calls, synthetic = false) {
+  const message = { role: "user", content: results };
+  session.messages.push(message);
+  session.journal?.write({
+    type: "tool_results",
+    message,
+    calls,
+    ...synthetic ? { synthetic } : {}
+  });
+}
+function addContinuation(session, text, maxTokens) {
+  const message = { role: "user", content: [{ type: "text", text }] };
+  session.messages.push(message);
+  session.journal?.write({ type: "continue", message, maxTokens });
+}
+function addCost(session, usage, costUsd) {
+  session.usage = addUsage(session.usage, usage);
+  session.costUsd = session.costUsd === void 0 || costUsd === void 0 ? void 0 : session.costUsd + costUsd;
+}
+function closeOpenToolCalls(session) {
+  const last = session.messages.at(-1);
+  if (last?.role !== "assistant") return 0;
+  const open = last.content.filter((b) => b.type === "tool_use");
+  if (open.length === 0) return 0;
+  session.files.forgetReads();
+  addToolResults(
+    session,
+    open.map((call) => ({
+      type: "tool_result",
+      toolUseId: call.id,
+      content: "Error: this call was interrupted. It may or may not have run. Check before you retry.",
+      isError: true
+    })),
+    open.map((call) => ({ toolUseId: call.id, name: call.name, durationMs: 0 })),
+    true
+  );
+  return open.length;
+}
+function addUnreported(session, tokens) {
+  if (tokens <= 0) return;
+  session.unreportedTokens += tokens;
+  session.costIncomplete = true;
+  session.journal?.write({ type: "unreported", tokens });
+}
+function budgetSpent(session) {
+  return totalTokens(session.usage) + session.unreportedTokens + pendingChildTokens(session);
+}
+function pendingChildTokens(session) {
+  let tokens = 0;
+  for (const value of session.childDebits.values()) tokens += value;
+  return tokens;
+}
+function isCostIncomplete(session) {
+  return session.costIncomplete || pendingChildTokens(session) > 0;
+}
+function addChildDebit(session, childSessionId, tokens) {
+  if (tokens <= 0) return;
+  session.childDebits.set(childSessionId, (session.childDebits.get(childSessionId) ?? 0) + tokens);
+  session.journal?.write({ type: "child_debit", childSessionId, tokens });
+}
+function addChildReport(session, report) {
+  addCost(session, report.usage, report.costUsd);
+  if (report.costIncomplete === true) session.costIncomplete = true;
+  settleChildDebits(session.childDebits, report);
+}
+function settleChildDebits(debits, report) {
+  const rest = Math.max(0, (debits.get(report.sessionId) ?? 0) - totalTokens(report.usage));
+  if (rest === 0) debits.delete(report.sessionId);
+  else debits.set(report.sessionId, rest);
+}
+function addSideUsage(session, purpose, response, costUsd) {
+  if (response.usageReported === false) return;
+  addCost(session, response.usage, costUsd);
+  session.journal?.write({
+    type: "side_usage",
+    purpose,
+    usage: response.usage,
+    ...costUsd === void 0 ? {} : { costUsd }
+  });
+}
+
+// src/permissions/projectSettings.ts
+import { createHash as createHash2 } from "crypto";
+function settingsRisk(settings) {
+  const risk = {
+    executorHost: settings.executor === "host",
+    allow: settings.allow.map(formatRule),
+    writePaths: [...settings.sandbox?.writePaths ?? []],
+    envAllow: [...settings.envAllow],
+    allowLocalhost: settings.web?.allowLocalhost === true
+  };
+  const formatterCommands = Object.entries(settings.formatters?.commands ?? {}).flatMap(
+    ([name, f]) => f === false ? [] : [`${name}: ${f.command.join(" ")}`]
+  );
+  if (formatterCommands.length > 0) risk.formatterCommands = formatterCommands;
+  const none = !risk.executorHost && risk.allow.length === 0 && risk.writePaths.length === 0 && risk.envAllow.length === 0 && !risk.allowLocalhost && risk.formatterCommands === void 0;
+  return none ? void 0 : risk;
+}
+function settingsRiskHash(risk) {
+  return createHash2("sha256").update(JSON.stringify(risk)).digest("hex");
+}
+function settingsRiskLines(risk) {
+  const lines = [];
+  if (risk.executorHost) lines.push('executor: "host" (commands run with no OS sandbox)');
+  if (risk.allow.length > 0) {
+    lines.push(`permissions.allow (no question for these): ${risk.allow.join(", ")}`);
+  }
+  if (risk.writePaths.length > 0) {
+    lines.push(`sandbox.writePaths (commands may write there): ${risk.writePaths.join(", ")}`);
+  }
+  if (risk.envAllow.length > 0) {
+    lines.push(`env.allow (commands see these variables): ${risk.envAllow.join(", ")}`);
+  }
+  if (risk.allowLocalhost) lines.push("web.allowLocalhost (web_fetch may reach this machine)");
+  if (risk.formatterCommands !== void 0) {
+    lines.push(
+      `formatters.commands (run after each edit): ${risk.formatterCommands.map(cleanLine).join("; ")}`
+    );
+  }
+  return lines;
+}
+function withoutRisk(settings) {
+  const { sandbox, web, formatters, ...rest } = settings;
+  const { writePaths: _writePaths, ...sandboxRest } = sandbox ?? {};
+  const keptCommands = Object.fromEntries(
+    Object.entries(formatters?.commands ?? {}).filter(([, f]) => f === false)
+  );
+  return {
+    ...rest,
+    ...formatters === void 0 ? {} : { formatters: { ...formatters, commands: keptCommands } },
+    executor: settings.executor === "host" ? "auto" : settings.executor,
+    allow: [],
+    envAllow: [],
+    ...sandbox === void 0 ? {} : { sandbox: sandboxRest },
+    ...web === void 0 ? {} : { web: { ...web, allowLocalhost: false } }
+  };
+}
+async function gateProjectSettings(options) {
+  const risk = settingsRisk(options.settings);
+  if (risk === void 0) return { settings: options.settings };
+  const hash2 = settingsRiskHash(risk);
+  const known = options.trust?.settingsHash(options.root);
+  if (known === hash2) return { settings: options.settings };
+  const lines = settingsRiskLines(risk);
+  if (options.ask !== void 0) {
+    const choice = await options.ask({
+      tool: "settings",
+      target: { kind: "input", json: "" },
+      title: "Project settings that loosen safety",
+      preview: [
+        `This project's .garuda/settings.json ${known === void 0 ? "asks for" : "changed and now asks for"}:`,
+        ...lines.map((line) => `  - ${line}`),
+        "A cloned repository can ship this file. Without your yes, Garuda uses safe defaults for these",
+        "parts; the rest of the file applies."
+      ].join("\n"),
+      isolation: options.isolation ?? "os",
+      question: "Use these project settings?",
+      choices: ["once", "session", "deny"],
+      labels: {
+        once: "Yes, for this run",
+        session: "Yes, and remember (asks again when they change)",
+        deny: "No, use safe defaults"
+      }
+    });
+    if (choice === "session") await options.trust?.setSettingsHash(options.root, hash2);
+    if (choice !== "deny") return { settings: options.settings };
+  }
+  return {
+    settings: withoutRisk(options.settings),
+    notice: [
+      `Project settings not applied (not approved): ${lines.join("; ")}.`,
+      "Start the chat in a terminal and answer yes to use them."
+    ].join(" ")
+  };
+}
+
+export {
+  FileTracker,
+  FileSessionStore,
+  parseRecords,
+  newSessionId,
+  emptyUndoState,
+  pushPoint,
+  popPoint,
+  redoPoint,
+  compacted,
+  newUserMessage,
+  createSession,
+  addUserMessage,
+  addSnapshot,
+  undoTurn,
+  redoTurn,
+  addAssistantResponse,
+  addToolResults,
+  addContinuation,
+  addCost,
+  closeOpenToolCalls,
+  addUnreported,
+  budgetSpent,
+  pendingChildTokens,
+  isCostIncomplete,
+  addChildDebit,
+  addChildReport,
+  settleChildDebits,
+  addSideUsage,
+  gateProjectSettings
+};
+//# sourceMappingURL=chunk-735BKABA.js.map

package/dist/{chunk-B6FA4I7Q.js → chunk-7TH3NHCQ.js}

@@ -6,7 +6,7 @@ import {
 } from "./chunk-EU7PA45O.js";
 import {
   DEFAULT_ENV_ALLOWLIST
-} from "./chunk-GXZACJUI.js";
+} from "./chunk-B4SJY7KT.js";
 
 // src/lsp/install.ts
 import { mkdir } from "fs/promises";
@@ -70,4 +70,4 @@ export {
   installCommand,
   installServer
 };
-//# sourceMappingURL=chunk-B6FA4I7Q.js.map
+//# sourceMappingURL=chunk-7TH3NHCQ.js.map

package/dist/{chunk-OUCV3FCT.js → chunk-AOGFYUKG.js}

@@ -178,8 +178,8 @@ function parseReview(text) {
   const m = /^\s*VERDICT:\s*(ready|needs a look)\b/im.exec(text);
   return { verdict: m?.[1]?.toLowerCase() === "ready" ? "ready" : "needs-look", text: text.trim() };
 }
-function jobVerdict(flags, review) {
-  if (flags.some((f) => f.level === "stop")) return "needs-look";
+function jobVerdict(flags, review, reviewFailed = false) {
+  if (reviewFailed || flags.some((f) => f.level === "stop")) return "needs-look";
   return review ?? (flags.length === 0 ? "ready" : "needs-look");
 }
 function tail(text, lines = TEST_TAIL_LINES) {
@@ -202,4 +202,4 @@ export {
   jobVerdict,
   tail
 };
-//# sourceMappingURL=chunk-OUCV3FCT.js.map
+//# sourceMappingURL=chunk-AOGFYUKG.js.map