@garuda-agent/garuda 0.18.0 → 0.18.2

package/dist/brief-RWKESOPT.js

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+import {
+  parseTestCount
+} from "./chunk-4QRTTRVK.js";
+import {
+  formatCost,
+  jobCost,
+  sumCosts
+} from "./chunk-3MRQJKUO.js";
+import "./chunk-AOGFYUKG.js";
+import {
+  JOBS_DIR,
+  listJobs
+} from "./chunk-VTMD5IHD.js";
+import "./chunk-UIRJOQQS.js";
+import "./chunk-4LFJFDCF.js";
+import "./chunk-3NJNVZTK.js";
+
+// src/jobs/brief.ts
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { join } from "path";
+var BRIEF_FILE = "brief.seen";
+var FIRST_BRIEF_MS = 24 * 36e5;
+function testsText(job) {
+  const proof = job.result?.proof;
+  const after = proof?.after;
+  if (after === void 0) return "no tests";
+  const count = (tail) => tail === void 0 ? void 0 : parseTestCount(tail)?.total;
+  const before = count(proof?.before?.tail);
+  const now = count(after.tail);
+  const passed = after.exitCode === 0 && !after.timedOut;
+  if (before !== void 0 && now !== void 0 && passed) return `tests ${before} \u2192 ${now}`;
+  return passed ? "tests pass" : "tests fail after the change";
+}
+function jobLine(job, paint) {
+  const verdict = job.result?.proof?.verdict;
+  const ok = job.status === "done" && verdict === "ready";
+  const mark = ok ? paint("green", "\u2713") : paint("red", "\u2717");
+  const what = verdict === "ready" ? "ready to merge" : verdict === "needs-look" ? "needs a look" : job.status === "done" ? "done, no verdict" : job.status;
+  const title = job.title.length > 32 ? `${job.title.slice(0, 31)}\u2026` : job.title;
+  return `  ${mark} ${title.padEnd(32)}  ${what.padEnd(16)}  ${testsText(job).padEnd(26)}  ${paint("dim", job.branch)}`;
+}
+function briefText(jobs, paint) {
+  if (jobs.length === 0) return void 0;
+  const cost = sumCosts(jobs.flatMap((j) => j.result === void 0 ? [] : [jobCost(j.result)]));
+  return [
+    paint(
+      "bold",
+      `While you were away: ${jobs.length} job${jobs.length === 1 ? "" : "s"} ran (${formatCost(cost)})`
+    ),
+    ...jobs.map((j) => jobLine(j, paint)),
+    paint(
+      "dim",
+      "  /jobs <id> shows a job's report and review \xB7 git diff <base>...<branch> shows its change"
+    )
+  ].join("\n");
+}
+function endedSince(jobs, since) {
+  return jobs.filter((j) => j.endedAt !== void 0 && Date.parse(j.endedAt) > since).filter((j) => j.status === "done" || j.status === "stopped" || j.status === "failed").sort((a, b) => Date.parse(a.endedAt ?? "") - Date.parse(b.endedAt ?? ""));
+}
+async function morningBrief(root, paint, now = Date.now()) {
+  const dir = join(root, JOBS_DIR);
+  const file = join(dir, BRIEF_FILE);
+  let since = now - FIRST_BRIEF_MS;
+  try {
+    const data = JSON.parse(await readFile(file, "utf8"));
+    if (typeof data.seenAt === "string" && !Number.isNaN(Date.parse(data.seenAt))) {
+      since = Date.parse(data.seenAt);
+    }
+  } catch {
+  }
+  const jobs = endedSince(await listJobs(root), since);
+  if (jobs.length === 0) return void 0;
+  try {
+    await mkdir(dir, { recursive: true });
+    await writeFile(file, `${JSON.stringify({ seenAt: new Date(now).toISOString() })}
+`);
+  } catch {
+  }
+  return briefText(jobs, paint);
+}
+export {
+  BRIEF_FILE,
+  FIRST_BRIEF_MS,
+  briefText,
+  endedSince,
+  jobLine,
+  morningBrief,
+  testsText
+};
+//# sourceMappingURL=brief-RWKESOPT.js.map

package/dist/buildCheck-HB46NWLX.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+import {
+  CHAT_STALE,
+  garudaCommit,
+  staleBuildNote
+} from "./chunk-YAQ6QLKB.js";
+import "./chunk-QXTHEFKP.js";
+import "./chunk-LMKGSYJC.js";
+import "./chunk-BHZ6G65V.js";
+import "./chunk-P6XWWIEK.js";
+import "./chunk-UIRJOQQS.js";
+import "./chunk-4LFJFDCF.js";
+import "./chunk-3NJNVZTK.js";
+export {
+  CHAT_STALE,
+  garudaCommit,
+  staleBuildNote
+};
+//# sourceMappingURL=buildCheck-HB46NWLX.js.map

package/dist/buildInfo-Z4P7QAQL.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+import {
+  BUILD_COMMIT
+} from "./chunk-E6YRCDSF.js";
+export {
+  BUILD_COMMIT
+};
+//# sourceMappingURL=buildInfo-Z4P7QAQL.js.map

package/dist/chunk-2OYTNNUJ.js

@@ -0,0 +1,216 @@
+#!/usr/bin/env node
+import {
+  budgetSpent,
+  isCostIncomplete,
+  pendingChildTokens
+} from "./chunk-NLS7GMF7.js";
+import {
+  totalTokens
+} from "./chunk-7KBOIPUT.js";
+
+// src/cli/report.ts
+function formatTokens(n) {
+  if (n < 1e3) return String(n);
+  if (n < 1e6) return `${(n / 1e3).toFixed(1)}k`;
+  return `${(n / 1e6).toFixed(1)}M`;
+}
+function formatUsd(usd, incomplete = false) {
+  if (usd === void 0) return "cost unknown";
+  const amount = usd < 0.01 ? `$${usd.toFixed(4)}` : `$${usd.toFixed(2)}`;
+  return incomplete ? `\u2265 ${amount} (incomplete)` : amount;
+}
+function budgetNote(session) {
+  const unreported = session.unreportedTokens;
+  const children = pendingChildTokens(session);
+  if (unreported <= 0 && children <= 0) return void 0;
+  const parts = [
+    ...unreported > 0 ? [`${formatTokens(unreported)} reserved without reported usage`] : [],
+    ...children > 0 ? [`${formatTokens(children)} from subagents with no report`] : []
+  ];
+  return `budget ${formatTokens(budgetSpent(session))} tokens (${parts.join(", ")})`;
+}
+function usageLine(result, session, runCostUsd, contextWindow, runCostIncomplete = false) {
+  const u = result.usage;
+  const input = u.inputTokens + u.cacheReadTokens + u.cacheWriteTokens;
+  const percent = Math.round(session.contextTokens / contextWindow * 100);
+  return [
+    `${result.stopReason} \xB7 ${result.steps} step(s)`,
+    `${budgetNote(session) !== void 0 ? "reported " : ""}${formatTokens(input)} in (${formatTokens(u.cacheReadTokens)} cached) / ${formatTokens(u.outputTokens)} out`,
+    formatUsd(runCostUsd, runCostIncomplete),
+    `context ${percent}% of ${formatTokens(contextWindow)}`,
+    `session ${formatTokens(totalTokens(session.usage))} tokens, ${formatUsd(session.costUsd, isCostIncomplete(session))}`,
+    ...budgetNote(session) === void 0 ? [] : [budgetNote(session)]
+  ].join(" \xB7 ");
+}
+function stopMessage(reason, limits) {
+  switch (reason) {
+    case "done":
+      return void 0;
+    case "max_steps":
+      return `Stopped: the run reached the step limit (${limits.maxSteps}). Use --resume to continue, or raise limits.maxSteps in .garuda/settings.json.`;
+    case "token_budget":
+      return `Stopped: the session used its token budget (${formatTokens(limits.tokenBudget)} tokens). Raise limits.tokenBudget in .garuda/settings.json to continue.`;
+    case "repeated_calls":
+      return "Stopped: the agent made the same tool call 3 times in a row, so it may be stuck. Use --resume with a hint to continue.";
+    case "max_tokens":
+      return "Stopped: the response reached the output token limit.";
+    case "refusal":
+      return "Stopped: the model refused the request.";
+  }
+}
+function chatStopMessage(reason, limits) {
+  switch (reason) {
+    case "max_steps":
+      return `\u25A0 Stopped at the step limit (${limits.maxSteps}). The task is not finished.`;
+    case "repeated_calls":
+      return "\u25A0 Stopped: the agent made the same tool call 3 times in a row, so it may be stuck. Type a hint as your next message, and it goes on from there.";
+    default:
+      return stopMessage(reason, limits);
+  }
+}
+
+// src/cli/receiptView.ts
+function screenReaderMode(env = process.env) {
+  return env.GARUDA_SCREEN_READER === "1";
+}
+var RECEIPT_BOX_MIN_COLUMNS = 60;
+var RECEIPT_MAX_WIDTH = 76;
+var seconds = (ms) => `${Math.max(0, Math.round(ms / 1e3))} s`;
+var plural = (n, word) => `${n} ${word}${n === 1 ? "" : "s"}`;
+function cells(text) {
+  let n = 0;
+  for (const ch of text) {
+    const c = ch.codePointAt(0) ?? 0;
+    const wide = c >= 4352 && c <= 4447 || c >= 11904 && c <= 42191 || c >= 44032 && c <= 55203 || c >= 63744 && c <= 64255 || c >= 65072 && c <= 65103 || c >= 65280 && c <= 65376 || c >= 65504 && c <= 65510 || c >= 127744 && c <= 129791 || c >= 131072 && c <= 262141;
+    n += wide ? 2 : 1;
+  }
+  return n;
+}
+function cut(text, width) {
+  if (cells(text) <= width) return text;
+  let out = "";
+  for (const ch of text) {
+    if (cells(out + ch) > width - 1) break;
+    out += ch;
+  }
+  return `${out}\u2026`;
+}
+function filesParts(receipt, room) {
+  const files = receipt.files;
+  if (files === void 0) return [["undo is off: no file list", "dim"]];
+  if (files.length === 0) return [["no file changed", "dim"]];
+  const shown = [];
+  for (const [i, f] of files.entries()) {
+    const lines = f.added === void 0 ? " (binary)" : ` +${f.added} \u2212${f.removed ?? 0}`;
+    const item = `${f.path}${lines}`;
+    const rest = files.length - i - 1;
+    const tail = rest > 0 ? ` \xB7 ${rest} more` : "";
+    const next = [...shown, item].join(" \xB7 ");
+    if (shown.length > 0 && cells(next + tail) > room) {
+      shown.push(`${files.length - i} more`);
+      return [[shown.join(" \xB7 ")]];
+    }
+    shown.push(item);
+  }
+  return [[shown.join(" \xB7 ")]];
+}
+function testsParts(receipt) {
+  const t = receipt.tests;
+  if (t === void 0) return void 0;
+  const count = t.total === void 0 ? "" : t.passed ? ` (${plural(t.total, "test")}${t.previousTotal !== void 0 && t.previousTotal !== t.total ? `, was ${t.previousTotal}` : ""})` : (t.failed ?? 0) > 0 ? ` (${t.failed} of ${t.total})` : ` (${plural(t.total, "test")})`;
+  return t.passed ? [[`${t.command} `], ["\u2713 passed", "green"], [count]] : [[`${t.command} `], [t.timedOut === true ? "\u2717 timed out" : "\u2717 failed", "red"], [count]];
+}
+function sandboxParts(receipt) {
+  const c = receipt.commands;
+  if (c.sandboxed + c.outside === 0) return void 0;
+  const parts = [
+    [`\u26E8 ${plural(c.sandboxed, "command")} in the sandbox \xB7 `],
+    c.outside > 0 ? [`${c.outside} outside`, "yellow"] : [`${c.outside} outside`]
+  ];
+  return parts;
+}
+function rows(receipt, room) {
+  const out = [{ label: "Files", parts: filesParts(receipt, room) }];
+  const tests = testsParts(receipt);
+  if (tests !== void 0) out.push({ label: "Tests", parts: tests });
+  const sandbox = sandboxParts(receipt);
+  if (sandbox !== void 0) out.push({ label: "Sandbox", parts: sandbox });
+  const hosts = receipt.commands.blockedHosts;
+  if (hosts.length > 0) {
+    out.push({ label: "Network", parts: [[`blocked ${hosts.join(", ")}`, "yellow"]] });
+  }
+  const changed = receipt.files?.length ?? 0;
+  if (changed > 0)
+    out.push({ label: "Undo", parts: [[`/undo puts back ${plural(changed, "file")}`]] });
+  return out;
+}
+function headText(receipt) {
+  return `Turn ${receipt.turn} \xB7 ${receipt.stopReason} \xB7 ${plural(receipt.steps, "step")} \xB7 ${seconds(receipt.durationMs)}`;
+}
+function footText(receipt) {
+  const parts = [`context ${receipt.contextPercent}%`];
+  if (receipt.sessionCostUsd !== void 0) {
+    parts.push(
+      `session ${formatUsd(receipt.sessionCostUsd, receipt.sessionCostIncomplete === true)}`
+    );
+  }
+  const kept = receipt.keptChanges ?? 0;
+  if (kept > 0) {
+    parts.push(plural(kept, "kept change"));
+    if (receipt.sessionCostUsd !== void 0) {
+      const each = formatUsd(receipt.sessionCostUsd / kept, receipt.sessionCostIncomplete === true);
+      parts.push(`${each} each`);
+    }
+  }
+  return parts.join(" \xB7 ");
+}
+function receiptText(receipt, options = {}) {
+  const paint = options.paint ?? ((_style, text) => text);
+  const draw = (parts) => parts.map(([text, style]) => style === void 0 ? text : paint(style, text)).join("");
+  const cost = formatUsd(receipt.costUsd, receipt.costIncomplete === true);
+  const columns = options.columns;
+  if (options.screenReader === true || columns === void 0 || columns < RECEIPT_BOX_MIN_COLUMNS) {
+    const lines = [`${headText(receipt)} \xB7 ${cost}`];
+    for (const row of rows(receipt, 200)) lines.push(`${row.label}: ${draw(row.parts)}`);
+    lines.push(footText(receipt));
+    return lines.join("\n");
+  }
+  const width = Math.min(columns, RECEIPT_MAX_WIDTH);
+  const label = 9;
+  const room = width - 4 - label;
+  const border = (text) => paint("yellow", text);
+  const edge = (left, text, right, end) => {
+    const tail = right === "" ? "" : ` ${right} \u2500`;
+    const head = cut(text, width - 4 - cells(tail) - cells(end) - 1);
+    const fill = width - 3 - cells(head) - 1 - cells(tail) - cells(end);
+    return `${border(`${left}\u2500 `)}${head} ${border("\u2500".repeat(Math.max(1, fill)))}${right === "" ? "" : ` ${right} ${border("\u2500")}`}${border(end)}`;
+  };
+  const out = [edge("\u256D", headText(receipt), cost, "\u256E")];
+  for (const row of rows(receipt, room)) {
+    const plain = row.parts.map(([text]) => text).join("");
+    let parts = row.parts;
+    if (cells(plain) > room) parts = [[cut(plain, room)]];
+    const shown = parts.map(([text]) => text).join("");
+    const pad = " ".repeat(Math.max(0, room - cells(shown)));
+    out.push(
+      `${border("\u2502")} ${paint("dim", row.label.padEnd(label))}${draw(parts)}${pad} ${border("\u2502")}`
+    );
+  }
+  out.push(edge("\u2570", footText(receipt), "", "\u256F"));
+  return out.join("\n");
+}
+
+export {
+  formatTokens,
+  formatUsd,
+  budgetNote,
+  usageLine,
+  stopMessage,
+  chatStopMessage,
+  screenReaderMode,
+  RECEIPT_BOX_MIN_COLUMNS,
+  RECEIPT_MAX_WIDTH,
+  cells,
+  receiptText
+};
+//# sourceMappingURL=chunk-2OYTNNUJ.js.map

package/dist/chunk-4BELTWP4.js

@@ -0,0 +1,156 @@
+#!/usr/bin/env node
+import {
+  summariseCall,
+  summariseResult
+} from "./chunk-AX3A5KPH.js";
+import {
+  receiptText
+} from "./chunk-2OYTNNUJ.js";
+import {
+  hasReceipt
+} from "./chunk-4QRTTRVK.js";
+import {
+  serverCallText,
+  serverResultSummary
+} from "./chunk-A2QAIRQL.js";
+
+// src/cli/exportHtml.ts
+function escapeHtml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+var OUTPUT_CHARS = 4e3;
+var cutOutput = (text) => text.length <= OUTPUT_CHARS ? text : `${text.slice(0, OUTPUT_CHARS)}
+\u2026 ${text.length - OUTPUT_CHARS} more characters in the session file.`;
+function callChange(call) {
+  const input = call.input ?? {};
+  const lines = (text, sign) => typeof text === "string" ? text.split("\n").map((l) => `${sign}${l}`) : [];
+  if (call.name === "edit_file") {
+    return [...lines(input.old_string, "-"), ...lines(input.new_string, "+")].join("\n");
+  }
+  if (call.name === "write_file") return lines(input.content, "+").join("\n");
+  return void 0;
+}
+function diffHtml(text) {
+  return text.split("\n").map((line) => {
+    const cls = line.startsWith("+") ? "add" : line.startsWith("-") ? "del" : "ctx";
+    return `<span class="${cls}">${escapeHtml(line)}</span>`;
+  }).join("\n");
+}
+var STYLE = `
+:root { --bg: #fbf7ef; --fg: #222; --dim: #6b6b6b; --line: #e4dccb; --accent: #d97706;
+  --add: #e6f4e6; --addfg: #17602a; --del: #fbe7e7; --delfg: #8f1d1d; --you: #0e7490; }
+@media (prefers-color-scheme: dark) { :root { --bg: #1d1d1b; --fg: #e8e4dc; --dim: #a19c92;
+  --line: #3a3833; --add: #183522; --addfg: #9ee2ad; --del: #3b1d1d; --delfg: #f4a9a9; } }
+body { background: var(--bg); color: var(--fg); font: 15px/1.55 system-ui, sans-serif;
+  max-width: 920px; margin: 32px auto; padding: 0 16px; }
+h1 { font-size: 20px; } .meta { color: var(--dim); font-size: 13px; }
+.you { border-left: 4px solid var(--you); padding: 4px 12px; margin: 24px 0 8px; font-weight: 600;
+  white-space: pre-wrap; }
+.answer { white-space: pre-wrap; margin: 8px 0; }
+.answer::before { content: "\u2726 "; color: var(--accent); }
+details { border: 1px solid var(--line); border-radius: 6px; margin: 6px 0; padding: 4px 10px; }
+summary { cursor: pointer; font-family: ui-monospace, monospace; font-size: 13px; }
+pre { font: 12.5px/1.45 ui-monospace, monospace; white-space: pre-wrap; overflow-wrap: anywhere;
+  margin: 6px 0; }
+.add { background: var(--add); color: var(--addfg); display: inline-block; width: 100%; }
+.del { background: var(--del); color: var(--delfg); display: inline-block; width: 100%; }
+.receipt { border: 1px solid var(--accent); border-radius: 6px; padding: 6px 10px; }
+.note { color: var(--dim); font-style: italic; }
+.failed summary { color: var(--delfg); }
+`;
+function sessionHtml(records, sessionId) {
+  const body = [];
+  const start = records.find((r) => r.type === "start");
+  body.push(`<h1>Garuda session ${escapeHtml(sessionId)}</h1>`);
+  if (start?.type === "start") {
+    body.push(
+      `<p class="meta">${escapeHtml(start.root)} \xB7 ${escapeHtml(start.model)} \xB7 ${escapeHtml(start.t)}</p>`
+    );
+  }
+  const calls = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    switch (record.type) {
+      case "user": {
+        const prompt = record.message.content[0];
+        body.push(
+          `<div class="you">${escapeHtml(prompt?.type === "text" ? prompt.text : "")}</div>`
+        );
+        break;
+      }
+      case "assistant":
+        for (const block of record.response.content) {
+          if (block.type === "text" && block.text.trim() !== "") {
+            body.push(`<div class="answer">${escapeHtml(block.text.trim())}</div>`);
+          }
+          if (block.type === "tool_use") calls.set(block.id, block);
+          if (block.type === "server_tool_result") {
+            const call = record.response.content.find(
+              (b) => b.type === "server_tool_use" && b.id === block.toolUseId
+            );
+            const query = call?.type === "server_tool_use" ? ` ${serverCallText(call)}` : "";
+            const pages = block.results.map((r) => `${r.title}
+  ${r.url}`).join("\n");
+            body.push(
+              `<details><summary>${escapeHtml(`\u25CF ${block.name} (Claude)${query} \u2192 ${serverResultSummary(block)}`)}</summary><pre>${escapeHtml(pages)}</pre></details>`
+            );
+          }
+        }
+        break;
+      case "tool_results":
+        for (const block of record.message.content) {
+          if (block.type !== "tool_result") continue;
+          const call = calls.get(block.toolUseId);
+          if (call === void 0) continue;
+          const summary = summariseResult(call, { content: block.content, isError: block.isError });
+          const head = `\u25CF ${[call.name, summariseCall(call)].filter((p) => p !== "").join(" ")} \u2192 ${block.isError ? `failed: ${summary}` : summary}`;
+          const change = callChange(call);
+          const inner = change === void 0 ? `<pre>${escapeHtml(cutOutput(block.content))}</pre>` : `<pre>${diffHtml(cutOutput(change))}</pre>`;
+          body.push(
+            `<details${block.isError ? ' class="failed"' : ""}><summary>${escapeHtml(head)}</summary>${inner}</details>`
+          );
+        }
+        break;
+      case "receipt":
+        if (hasReceipt(record.receipt)) {
+          body.push(`<pre class="receipt">${escapeHtml(receiptText(record.receipt))}</pre>`);
+        }
+        break;
+      case "undo":
+        body.push('<p class="note">/undo: the last turn was taken back.</p>');
+        break;
+      case "redo":
+        body.push('<p class="note">/redo: the turn came back.</p>');
+        break;
+      case "compaction":
+        body.push('<p class="note">The conversation was compacted here.</p>');
+        break;
+      case "fork":
+        body.push(
+          `<p class="note">This session starts as a fork of session ${escapeHtml(record.from.sessionId)}, at turn ${record.from.turn}.</p>`
+        );
+        break;
+      default:
+        break;
+    }
+  }
+  return [
+    "<!doctype html>",
+    '<html lang="en"><head><meta charset="utf-8">',
+    '<meta name="viewport" content="width=device-width, initial-scale=1">',
+    // No script may run, and nothing loads from outside: the page's own policy says so too.
+    `<meta http-equiv="Content-Security-Policy" content="default-src 'none'; style-src 'unsafe-inline'">`,
+    `<title>Garuda session ${escapeHtml(sessionId)}</title>`,
+    `<style>${STYLE}</style></head><body>`,
+    ...body,
+    "</body></html>",
+    ""
+  ].join("\n");
+}
+
+export {
+  escapeHtml,
+  OUTPUT_CHARS,
+  callChange,
+  sessionHtml
+};
+//# sourceMappingURL=chunk-4BELTWP4.js.map

package/dist/chunk-4QRTTRVK.js

@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+
+// src/app/receipt.ts
+function hasReceipt(receipt) {
+  return (receipt.files?.length ?? 0) > 0 || receipt.tests !== void 0 || receipt.commands.outside > 0 || receipt.commands.blockedHosts.length > 0;
+}
+var RUNNERS = /(^|[\s;&|(/])(vitest|jest|pytest|py\.test|mvn|mvnw|gradle|gradlew|go\s+test|node\s+--test|(npm|pnpm|yarn|bun)\s+(run\s+)?test|cargo\s+test|tox|nox)\b/;
+function isTestCommand(command, projectTest) {
+  const text = command.trim();
+  if (projectTest !== void 0 && projectTest !== "" && text.includes(projectTest)) return true;
+  if (/(^|[\s;&|])(mvn|mvnw|gradle|gradlew)\b/.test(text) && !/\b(test|verify|check)\b/.test(text)) {
+    return false;
+  }
+  return RUNNERS.test(text);
+}
+function parseTestCount(output) {
+  const num = (s) => s === void 0 ? 0 : Number(s);
+  const vitest = /^\s*Tests\s+(.*\b(?:passed|failed|skipped)\b.*?)\s+\((\d+)\)\s*$/m.exec(output);
+  if (vitest !== null) {
+    return { total: num(vitest[2]), failed: num(/(\d+) failed/.exec(vitest[1] ?? "")?.[1]) };
+  }
+  const jest = /^Tests:\s+(?:(\d+) failed, )?.*?(\d+) total\s*$/m.exec(output);
+  if (jest !== null) return { total: num(jest[2]), failed: num(jest[1]) };
+  const nodeTotal = /^(?:#|ℹ) tests (\d+)\s*$/m.exec(output);
+  if (nodeTotal !== null) {
+    return { total: num(nodeTotal[1]), failed: num(/^(?:#|ℹ) fail (\d+)\s*$/m.exec(output)?.[1]) };
+  }
+  const pytest = /^=+ (.*\b(?:passed|failed)\b.*) in [\d.]+s(?: \([^)]*\))? =+\s*$/m.exec(output);
+  if (pytest !== null) {
+    const part = (word) => num(new RegExp(`(\\d+) ${word}\\b`).exec(pytest[1] ?? "")?.[1]);
+    const failed = part("failed") + part("errors?");
+    return { total: part("passed") + failed, failed };
+  }
+  const maven = [...output.matchAll(/Tests run: (\d+), Failures: (\d+), Errors: (\d+)/g)].at(-1);
+  if (maven !== void 0) {
+    return { total: num(maven[1]), failed: num(maven[2]) + num(maven[3]) };
+  }
+  const passes = output.match(/^\s*--- PASS: /gm)?.length ?? 0;
+  const fails = output.match(/^\s*--- FAIL: /gm)?.length ?? 0;
+  if (passes + fails > 0) return { total: passes + fails, failed: fails };
+  return void 0;
+}
+var ReceiptCollector = class {
+  constructor(projectTest) {
+    this.projectTest = projectTest;
+  }
+  projectTest;
+  calls = /* @__PURE__ */ new Map();
+  sandboxed = 0;
+  outside = 0;
+  blockedHosts = /* @__PURE__ */ new Set();
+  tests;
+  onEvent(event) {
+    if (event.type === "tool_call") {
+      const command = event.call.input.command;
+      if (typeof command === "string") this.calls.set(event.call.id, command);
+      return;
+    }
+    if (event.type !== "tool_result" || event.outcome.command === void 0) return;
+    this.add(this.calls.get(event.call.id) ?? "", event.outcome.command, event.outcome.content);
+  }
+  /** One command's facts; `output` is the text that the model got (for the test count). */
+  add(command, facts, output) {
+    if (facts.sandboxed) this.sandboxed++;
+    else this.outside++;
+    for (const host of facts.blockedHosts) this.blockedHosts.add(host);
+    if (!isTestCommand(command, this.projectTest)) return;
+    const count = parseTestCount(output);
+    const passed = facts.exitCode === 0 && !facts.timedOut;
+    this.tests = {
+      command: shortCommand(command),
+      passed,
+      ...facts.timedOut ? { timedOut: true } : {},
+      ...count === void 0 ? {} : { total: count.total, failed: count.failed }
+    };
+  }
+};
+function shortCommand(command) {
+  const line = command.trim().split("\n")[0] ?? "";
+  return line.length > 40 ? `${line.slice(0, 39)}\u2026` : line;
+}
+
+export {
+  hasReceipt,
+  parseTestCount,
+  ReceiptCollector
+};
+//# sourceMappingURL=chunk-4QRTTRVK.js.map

package/dist/chunk-6JQTPW3P.js

@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+import {
+  garudaCommit
+} from "./chunk-YAQ6QLKB.js";
+import {
+  BUILD_COMMIT
+} from "./chunk-E6YRCDSF.js";
+import {
+  byTask,
+  consistency,
+  costPerPass,
+  failureSummary,
+  passInterval,
+  spread,
+  stepsSd,
+  unexpectedChanges
+} from "./chunk-A5DLAXB4.js";
+import {
+  VERSION
+} from "./chunk-CFDRP6XW.js";
+
+// src/evals/report.ts
+import { createHash } from "crypto";
+import { arch, platform, release } from "os";
+var REPORT_SCHEMA = 2;
+function taskHash(task) {
+  const sorted = (record) => Object.fromEntries(Object.entries(record).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0));
+  const data = {
+    prompt: task.prompt,
+    files: sorted(task.files),
+    check: task.check,
+    protect: task.protect ?? null,
+    solution: sorted(task.solution),
+    allowChanges: task.allowChanges ?? null,
+    repo: task.repo === void 0 ? null : { base: task.repo.base, sha: task.repo.sha ?? null, tests: task.repo.tests }
+  };
+  return createHash("sha256").update(JSON.stringify(data)).digest("hex");
+}
+function buildFields(build, checkout) {
+  const commit = build ?? checkout;
+  return {
+    version: VERSION,
+    ...commit === void 0 ? {} : { commit },
+    ...build !== void 0 && checkout !== void 0 && checkout !== build ? { checkout } : {}
+  };
+}
+async function reportV2(meta, tasks, results) {
+  return {
+    schema: REPORT_SCHEMA,
+    garuda: buildFields(BUILD_COMMIT, await garudaCommit()),
+    spec: meta.model,
+    agent: meta.agent ?? { name: "garuda" },
+    provider: meta.provider,
+    // Evals set no effort: each model's default applies.
+    effort: "model default",
+    isolation: meta.isolation,
+    os: { platform: platform(), release: release(), arch: arch(), node: process.versions.node },
+    seed: meta.seed,
+    shuffle: meta.shuffle,
+    split: meta.split ?? "dev",
+    addendum: meta.addendum === void 0 ? null : {
+      file: meta.addendum.file,
+      chars: meta.addendum.text.length,
+      sha256: createHash("sha256").update(meta.addendum.text).digest("hex")
+    },
+    mcp: meta.mcp === void 0 ? null : {
+      server: meta.mcp.server,
+      ...meta.mcp.prepare === void 0 ? {} : { prepare: meta.mcp.prepare }
+    },
+    order: results.map((r) => ({ id: r.id, attempt: r.attempt ?? 1 })),
+    tasks: Object.fromEntries(tasks.map((t) => [t.id, taskHash(t)])),
+    evidence: {
+      interval: passInterval(results, { seed: meta.seed }) ?? null,
+      consistency: consistency(results),
+      spread: spread(results) ?? null,
+      stepsSd: Object.fromEntries(byTask(results).map((t) => [t.id, stepsSd(t.results) ?? null])),
+      costPerAcceptedChange: costPerPass(results),
+      unexpected: unexpectedChanges(results),
+      failures: failureSummary(results)
+    }
+  };
+}
+
+export {
+  taskHash,
+  reportV2
+};
+//# sourceMappingURL=chunk-6JQTPW3P.js.map