@gobing-ai/spur 0.4.0 → 0.4.2

package/plugins/sp/scripts/run-summary.mjs

@@ -2,19 +2,24 @@
 // @bun
 
 // plugins/sp/scripts/run-summary.ts
-import { readFileSync } from "fs";
+import { readFileSync as readFileSync2 } from "fs";
 
 // plugins/sp/lib/env.ts
 function getEnvVars() {
   return process.env;
 }
 
+// plugins/sp/lib/run-summary-core.ts
+import { existsSync as existsSync2, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join as join2 } from "node:path";
+
 // plugins/sp/lib/transcript.ts
 import { existsSync, readdirSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 var SESSION_ID = /^[A-Za-z0-9_-]+$/;
-var OPERATOR_TOOLS = new Set(["AskUserQuestion"]);
+var OPERATOR_TOOLS = new Set(["AskUserQuestion", "ask_user_question"]);
+var PI_ROLES = new Set(["user", "assistant", "toolResult"]);
 var zeroTokens = () => ({ input: 0, cacheCreate: 0, cacheRead: 0, output: 0 });
 function formatDuration(ms) {
   const s = Math.round(ms / 1000);
@@ -35,6 +40,20 @@ function formatTokenSplit(t) {
   return `${formatTokens(nonCached + t.cacheRead)} / ${formatTokens(nonCached)}`;
 }
 function promptText(row) {
+  if (row.type === "custom_message") {
+    if (row.display === false)
+      return;
+    const text = typeof row.content === "string" ? row.content.trim() : "";
+    return text === "" ? undefined : text;
+  }
+  if (row.type === "message") {
+    if (row.message?.role !== "user")
+      return;
+    const text = firstTextContent(row);
+    if (text === undefined)
+      return;
+    return skillInvocationPrompt(text) ?? text;
+  }
   if (row.type !== "user" || row.isMeta || row.isCompactSummary)
     return;
   const content = row.message?.content;
@@ -44,6 +63,22 @@ function promptText(row) {
     return;
   return content.find((b) => b.type === "text")?.text;
 }
+function firstTextContent(row) {
+  const content = row.message?.content;
+  if (typeof content === "string")
+    return content;
+  if (!Array.isArray(content))
+    return;
+  return content.find((b) => b.type === "text")?.text;
+}
+function skillInvocationPrompt(text) {
+  const name = /^\s*<skill name="([^"]+)"/.exec(text)?.[1];
+  if (name === undefined)
+    return;
+  const close = text.lastIndexOf("</skill>");
+  const args = close < 0 ? "" : text.slice(close + "</skill>".length).trim();
+  return args === "" ? `/${name}` : `/${name} ${args}`;
+}
 function sumTokens(all) {
   const total = zeroTokens();
   for (const t of all)
@@ -64,10 +99,37 @@ var newAcc = (ts) => ({
   askMs: 0,
   asks: new Map,
   toolIds: new Set,
-  messages: new Map
+  messages: new Map,
+  compactions: 0
 });
 function accumulate(acc, row, ts) {
   acc.last = Math.max(acc.last, ts);
+  if (row.type === "message") {
+    const m = row.message;
+    if (m?.role === "assistant") {
+      const blocks2 = Array.isArray(m.content) ? m.content : [];
+      for (const b of blocks2) {
+        if (b.type === "toolCall" && b.id) {
+          acc.toolIds.add(b.id);
+          if (b.name && OPERATOR_TOOLS.has(b.name))
+            acc.asks.set(b.id, ts);
+        }
+      }
+      const u2 = m.usage;
+      if (u2 && row.id)
+        acc.messages.set(row.id, {
+          input: u2.input ?? 0,
+          cacheCreate: u2.cacheWrite ?? 0,
+          cacheRead: u2.cacheRead ?? 0,
+          output: u2.output ?? 0
+        });
+    } else if (m?.role === "toolResult" && m.toolCallId && acc.asks.has(m.toolCallId)) {
+      acc.askMs += ts - (acc.asks.get(m.toolCallId) ?? ts);
+    }
+    return;
+  }
+  if (row.type === "compaction")
+    acc.compactions++;
   const blocks = Array.isArray(row.message?.content) ? row.message.content : [];
   for (const b of blocks) {
     if (b.type === "tool_use" && b.id) {
@@ -88,6 +150,18 @@ function accumulate(acc, row, ts) {
     });
   }
 }
+function isCompaction(row) {
+  return row.type === "compaction" || row.type === "system" && row.subtype === "compact_boundary";
+}
+function sniffFormat(rows) {
+  for (const row of rows) {
+    if (row.type === "message" && PI_ROLES.has(row.message?.role ?? ""))
+      return "pi";
+    if (row.type === "user" || row.type === "assistant")
+      return "claude";
+  }
+  return "unknown";
+}
 function parseRows(lines) {
   const rows = [];
   let skippedLines = 0;
@@ -105,14 +179,22 @@ function parseRows(lines) {
     if (!Number.isNaN(ts))
       rows.push([row, ts]);
   }
-  return { rows, skippedLines };
+  return { rows, skippedLines, format: sniffFormat(rows.map(([r]) => r)) };
 }
 function resolveTranscript(env, projectsRoot = join(homedir(), ".claude", "projects"), override) {
   if (override)
     return existsSync(override) ? { ok: true, path: override } : { ok: false, reason: "no transcript" };
   const id = env.CLAUDE_CODE_SESSION_ID;
-  if (!id)
-    return { ok: false, reason: "no host session id (CLAUDE_CODE_SESSION_ID); pass --transcript <path>" };
+  if (!id) {
+    const piFile = env.PI_SESSION_FILE;
+    if (piFile !== undefined && piFile !== "") {
+      return existsSync(piFile) ? { ok: true, path: piFile } : { ok: false, reason: `PI_SESSION_FILE ${piFile} does not exist` };
+    }
+    return {
+      ok: false,
+      reason: "no host session id; pass --transcript <path> (pi: ~/.pi/agent/sessions/<cwd-slug>/<file>.jsonl, " + "or set PI_SESSION_FILE)"
+    };
+  }
   if (!SESSION_ID.test(id))
     return { ok: false, reason: "refusing a session id with path characters" };
   if (!existsSync(projectsRoot))
@@ -125,7 +207,151 @@ function resolveTranscript(env, projectsRoot = join(homedir(), ".claude", "proje
   return { ok: false, reason: `no transcript for session ${id}` };
 }
 
-// plugins/sp/scripts/run-summary.ts
+// plugins/sp/lib/env.ts
+function getEnvVars2() {
+  return process.env;
+}
+
+// plugins/sp/lib/run-summary-core.ts
+var IDLE_GAP_MS = 300000;
+var SHELL_TOOLS = new Set(["bash", "shell", "exec", "exec_command", "run_command", "command"]);
+var SUBAGENT_TOOLS = new Set(["agent", "task", "invoke_subagent", "subagent", "dispatch_agent"]);
+var OPERATOR_TOOLS2 = new Set(["askuserquestion", "ask_user_question"]);
+var ACTOR_PRECEDENCE = ["operator", "subagent", "shell", "other"];
+function actorOf(tool) {
+  const t = tool.toLowerCase().replace(/[^a-z_]/g, "");
+  if (OPERATOR_TOOLS2.has(t))
+    return "operator";
+  if (SUBAGENT_TOOLS.has(t))
+    return "subagent";
+  if (SHELL_TOOLS.has(t))
+    return "shell";
+  return "other";
+}
+function unionMs(spans, start, end) {
+  const clipped = spans.map(([a, b]) => [Math.max(a, start), Math.min(b, end)]).filter(([a, b]) => b > a).sort((x, y) => x[0] - y[0]);
+  let total = 0;
+  let cursor = Number.NaN;
+  let openUntil = Number.NaN;
+  for (const [a, b] of clipped) {
+    if (!Number.isFinite(cursor)) {
+      cursor = a;
+      openUntil = b;
+      continue;
+    }
+    if (a > openUntil) {
+      total += openUntil - cursor;
+      cursor = a;
+      openUntil = b;
+    } else {
+      openUntil = Math.max(openUntil, b);
+    }
+  }
+  if (Number.isFinite(cursor))
+    total += openUntil - cursor;
+  return total;
+}
+function subtract(spans, claimed) {
+  let free = spans;
+  for (const [ca, cb] of claimed) {
+    const next = [];
+    for (const [a, b] of free) {
+      if (cb <= a || ca >= b) {
+        next.push([a, b]);
+        continue;
+      }
+      if (ca > a)
+        next.push([a, ca]);
+      if (cb < b)
+        next.push([cb, b]);
+    }
+    free = next;
+  }
+  return free;
+}
+function actorSplit(rows, start, end) {
+  const empty = {
+    operatorMs: 0,
+    longestOperatorWaitMs: 0,
+    modelMs: 0,
+    shellMs: 0,
+    subagentMs: 0,
+    otherToolMs: 0,
+    idleMs: 0,
+    compactions: 0,
+    subagentErrors: 0
+  };
+  const window = end - start;
+  if (window <= 0)
+    return empty;
+  const calls = new Map;
+  const results = new Map;
+  const eventTs = [];
+  let compactions = 0;
+  for (const [row, ts] of rows) {
+    if (ts < start || ts > end)
+      continue;
+    eventTs.push(ts);
+    if (isCompaction(row))
+      compactions++;
+    const blocks = Array.isArray(row.message?.content) ? row.message?.content : [];
+    if (row.message?.role === "toolResult" && row.message.toolCallId !== undefined) {
+      results.set(row.message.toolCallId, { ts, isError: row.message.isError === true });
+    }
+    for (const b of blocks) {
+      if ((b.type === "tool_use" || b.type === "toolCall") && b.id !== undefined && b.name !== undefined) {
+        calls.set(b.id, { id: b.id, actor: actorOf(b.name), ts });
+      } else if (b.type === "tool_result" && b.tool_use_id !== undefined) {
+        results.set(b.tool_use_id, { ts, isError: b.is_error === true });
+      }
+    }
+  }
+  let subagentErrors = 0;
+  const resolved = [];
+  for (const call of calls.values()) {
+    const result = results.get(call.id);
+    if (result?.isError === true && call.actor === "subagent")
+      subagentErrors++;
+    resolved.push({ ...call, end: Math.min(result?.ts ?? end, end) });
+  }
+  const claimed = [];
+  const byActor = new Map;
+  for (const actor of ACTOR_PRECEDENCE) {
+    const mine = resolved.filter((r) => r.actor === actor).map((r) => [r.ts, r.end]);
+    const free = subtract(mine, claimed);
+    for (const span of free)
+      claimed.push(span);
+    const ms = unionMs(free, start, end);
+    byActor.set(actor, ms);
+    if (actor === "operator") {
+      empty.longestOperatorWaitMs = Math.max(0, ...mine.map(([a, b]) => b - a));
+    }
+  }
+  const boundaries = [...new Set([start, end, ...eventTs, ...claimed.flat()])].sort((a, b) => a - b);
+  const claimedSorted = [...claimed].sort((a, b) => a[0] - b[0]);
+  let idleMs = 0;
+  for (let i = 0;i < boundaries.length - 1; i++) {
+    const a = boundaries[i];
+    const b = boundaries[i + 1];
+    if (b - a < IDLE_GAP_MS)
+      continue;
+    if (claimedSorted.some(([ca, cb]) => ca < b && cb > a))
+      continue;
+    idleMs += b - a;
+  }
+  const accounted = (byActor.get("operator") ?? 0) + (byActor.get("subagent") ?? 0) + (byActor.get("shell") ?? 0) + (byActor.get("other") ?? 0) + idleMs;
+  return {
+    ...empty,
+    operatorMs: byActor.get("operator") ?? 0,
+    subagentMs: byActor.get("subagent") ?? 0,
+    shellMs: byActor.get("shell") ?? 0,
+    otherToolMs: byActor.get("other") ?? 0,
+    idleMs,
+    modelMs: Math.max(0, window - accounted),
+    compactions,
+    subagentErrors
+  };
+}
 function attemptWindow(attempts) {
   const starts = attempts.map((a) => Date.parse(a.startedAt ?? "")).filter((n) => !Number.isNaN(n));
   const ends = attempts.map((a) => Date.parse(a.completedAt ?? "")).filter((n) => !Number.isNaN(n));
@@ -144,7 +370,7 @@ function summaryRow(stage, status, span, measured) {
     token: formatTokenSplit(measured ? span.tokens : null)
   };
 }
-function buildRunSummary(lines, inputs, since) {
+function buildRunSummary(lines, inputs, since, until) {
   const windows = [];
   for (const { label, progress } of inputs) {
     const states = (progress.states ?? []).flatMap((s) => {
@@ -192,6 +418,9 @@ function buildRunSummary(lines, inputs, since) {
       if (ts >= sinceMs)
         totalEnd = Math.max(totalEnd, ts);
   }
+  const untilMs = until ? Date.parse(until) : Number.NaN;
+  if (!Number.isNaN(untilMs) && untilMs > totalStart)
+    totalEnd = untilMs;
   const stageRows = windows.map((w) => {
     const { span, measured } = measure(w.start, w.end);
     return summaryRow(w.stage, w.status, span, measured);
@@ -209,33 +438,195 @@ function buildRunSummary(lines, inputs, since) {
   };
   if (!overlaps && overhead.workMs > 0)
     stageRows.push(summaryRow("driver overhead", "", overhead, totalMeasure.measured));
-  return { available: true, rows: stageRows, total, skippedLines };
+  return {
+    available: true,
+    rows: stageRows,
+    total,
+    actors: actorSplit(rows, totalStart, totalEnd),
+    gate: { ms: null, reason: "no matching check receipt" },
+    skippedLines
+  };
 }
 function renderSummaryMarkdown(summary) {
   const line = (r, bold = false) => {
     const stage = bold ? `**${r.stage}**` : r.stage;
     return `| ${stage} | ${r.status} | ${r.time} | ${r.wait} | ${r.toolCalls ?? "n/a"} | ${r.token} |`;
   };
+  const a = summary.actors;
+  const window = summary.total.workMs + summary.total.waitMs;
+  const share = (ms) => window > 0 ? `${Math.round(ms / window * 100)}%` : "n/a";
+  const gate = summary.gate.ms === null ? `n/a (${summary.gate.reason})` : formatDuration(summary.gate.ms);
   return [
     "| Stage | Status | Time | Wait | Tool calls | Token (total / non-cached) |",
     "| --- | --- | ---: | ---: | ---: | ---: |",
     ...summary.rows.map((r) => line(r)),
-    line(summary.total, true)
+    line(summary.total, true),
+    "",
+    "| Actor | Time | Share |",
+    "| --- | ---: | ---: |",
+    `| operator wait (longest ${formatDuration(a.longestOperatorWaitMs)}) | ${formatDuration(a.operatorMs)} | ${share(a.operatorMs)} |`,
+    `| model | ${formatDuration(a.modelMs)} | ${share(a.modelMs)} |`,
+    `| shell | ${formatDuration(a.shellMs)} | ${share(a.shellMs)} |`,
+    `|   of which gate (informational) | ${gate} | — |`,
+    `| subagent | ${formatDuration(a.subagentMs)} | ${share(a.subagentMs)} |`,
+    `| other tools | ${formatDuration(a.otherToolMs)} | ${share(a.otherToolMs)} |`,
+    `| idle / unattributed | ${formatDuration(a.idleMs)} | ${share(a.idleMs)} |`,
+    "",
+    `Compactions: ${a.compactions} · Subagent errors: ${a.subagentErrors}`
   ].join(`
 `);
 }
-var RUN_SUMMARY_USAGE = "usage: run-summary --progress [<label>=]<file> [--progress ...] [--transcript <path>] [--since <iso>] [--markdown]";
+function renderRollupMarkdown(rows) {
+  const line = (label, r, actors, bold = false) => {
+    const name = bold ? `**${label}**` : label;
+    return `| ${name} | ${r.status} | ${r.time} | ${r.wait} | ${r.toolCalls ?? "n/a"} | ${r.token} | ${formatDuration(actors.operatorMs)} | ${formatDuration(actors.subagentMs)} |`;
+  };
+  const total = rows.reduce((acc, { summary }) => ({
+    workMs: acc.workMs + summary.total.workMs,
+    waitMs: acc.waitMs + summary.total.waitMs,
+    toolCalls: (acc.toolCalls ?? 0) + (summary.total.toolCalls ?? 0),
+    tokens: sumTokens([acc.tokens, summary.total.tokens ?? zeroTokens()])
+  }), { workMs: 0, waitMs: 0, toolCalls: 0, tokens: zeroTokens() });
+  const totalRow = {
+    stage: "Batch total",
+    status: "",
+    workMs: total.workMs,
+    waitMs: total.waitMs,
+    toolCalls: total.toolCalls,
+    tokens: total.tokens,
+    time: formatDuration(total.workMs),
+    wait: formatDuration(total.waitMs),
+    token: formatTokenSplit(total.tokens)
+  };
+  const totalActors = {
+    operatorMs: 0,
+    longestOperatorWaitMs: 0,
+    modelMs: 0,
+    shellMs: 0,
+    subagentMs: 0,
+    otherToolMs: 0,
+    idleMs: 0,
+    compactions: 0,
+    subagentErrors: 0
+  };
+  for (const { summary } of rows) {
+    totalActors.operatorMs += summary.actors.operatorMs;
+    totalActors.subagentMs += summary.actors.subagentMs;
+    totalActors.compactions += summary.actors.compactions;
+    totalActors.subagentErrors += summary.actors.subagentErrors;
+  }
+  const out = [
+    "| Run | Status | Time | Wait | Tool calls | Token (total / non-cached) | Operator wait | Subagent |",
+    "| --- | --- | ---: | ---: | ---: | ---: | ---: | ---: |",
+    ...rows.map(({ label, summary }) => line(label, summary.total, summary.actors)),
+    line("Batch total", totalRow, totalActors, true)
+  ];
+  const starts = rows.map((r) => Date.parse(r.summary.startedAt ?? "")).filter((n) => !Number.isNaN(n));
+  const ends = rows.map((r) => Date.parse(r.summary.completedAt ?? "")).filter((n) => !Number.isNaN(n));
+  const overlaps = starts.length === rows.length && rows.some((r, i) => rows.some((o, j) => i !== j && Date.parse(r.summary.startedAt ?? "") < Date.parse(o.summary.completedAt ?? "") && Date.parse(o.summary.startedAt ?? "") < Date.parse(r.summary.completedAt ?? "")));
+  if (overlaps && starts.length > 0 && ends.length > 0) {
+    out.push("", `Wall span: ${new Date(Math.min(...starts)).toISOString()} → ${new Date(Math.max(...ends)).toISOString()}`);
+  }
+  return out.join(`
+`);
+}
+function writeCloseSummary(run, opts = {}) {
+  const cwd = opts.cwd ?? process.cwd();
+  const runDir = join2(cwd, ".spur", "run");
+  const rel = join2(".spur", "run", `${run.runId}-summary.md`);
+  const abs = join2(cwd, rel);
+  const na = (reason) => {
+    mkdirSync(runDir, { recursive: true });
+    writeFileSync(abs, `Execution summary: n/a (${reason})
+`);
+    return rel;
+  };
+  try {
+    if (run.startedAt === undefined)
+      return na("run row has no started_at");
+    const resolved = resolveTranscript(opts.env ?? getEnvVars2(), opts.projectsRoot);
+    if (!resolved.ok)
+      return na(resolved.reason);
+    const lines = readFileSync(resolved.path, "utf8").split(`
+`);
+    const summary = buildRunSummary(lines, [{ progress: run.progress }], run.startedAt, run.completedAt);
+    if (summary.rows.length === 0)
+      return na("no timed attempts");
+    mkdirSync(runDir, { recursive: true });
+    writeFileSync(abs, `${renderSummaryMarkdown(summary)}
+`);
+    writeFileSync(join2(runDir, `${run.runId}-summary.json`), JSON.stringify({ ...summary, runId: run.runId, startedAt: run.startedAt, completedAt: run.completedAt }, null, 2));
+    return rel;
+  } catch (error) {
+    return na(error instanceof Error ? error.message : String(error));
+  }
+}
+function gateFromReceipt(cwd, runId) {
+  const path = join2(cwd, ".spur", "run", `${runId}-check-receipt.json`);
+  if (!existsSync2(path))
+    return { ms: null, reason: "no matching check receipt" };
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    if (parsed.runId !== runId)
+      return { ms: null, reason: "check receipt belongs to another run" };
+    const ms = parsed.gateRuntimeMs;
+    if (typeof ms !== "number" || !Number.isFinite(ms))
+      return { ms: null, reason: "check receipt has no gate time" };
+    return { ms };
+  } catch {
+    return { ms: null, reason: "check receipt is unreadable" };
+  }
+}
+
+// plugins/sp/lib/transcript.ts
+import { existsSync as existsSync3, readdirSync as readdirSync2 } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { join as join3 } from "node:path";
+var SESSION_ID2 = /^[A-Za-z0-9_-]+$/;
+var OPERATOR_TOOLS3 = new Set(["AskUserQuestion", "ask_user_question"]);
+var PI_ROLES2 = new Set(["user", "assistant", "toolResult"]);
+function resolveTranscript2(env, projectsRoot = join3(homedir2(), ".claude", "projects"), override) {
+  if (override)
+    return existsSync3(override) ? { ok: true, path: override } : { ok: false, reason: "no transcript" };
+  const id = env.CLAUDE_CODE_SESSION_ID;
+  if (!id) {
+    const piFile = env.PI_SESSION_FILE;
+    if (piFile !== undefined && piFile !== "") {
+      return existsSync3(piFile) ? { ok: true, path: piFile } : { ok: false, reason: `PI_SESSION_FILE ${piFile} does not exist` };
+    }
+    return {
+      ok: false,
+      reason: "no host session id; pass --transcript <path> (pi: ~/.pi/agent/sessions/<cwd-slug>/<file>.jsonl, " + "or set PI_SESSION_FILE)"
+    };
+  }
+  if (!SESSION_ID2.test(id))
+    return { ok: false, reason: "refusing a session id with path characters" };
+  if (!existsSync3(projectsRoot))
+    return { ok: false, reason: `no transcript root ${projectsRoot}` };
+  for (const dir of readdirSync2(projectsRoot)) {
+    const path = join3(projectsRoot, dir, `${id}.jsonl`);
+    if (existsSync3(path))
+      return { ok: true, path };
+  }
+  return { ok: false, reason: `no transcript for session ${id}` };
+}
+
+// plugins/sp/scripts/run-summary.ts
+var RUN_SUMMARY_USAGE = "usage: run-summary (--progress [<label>=]<file> [--progress ...] | --rollup [<label>=]<summary.json> [--rollup ...]) [--transcript <path>] [--since <iso>] [--markdown]";
 function main(argv, env = getEnvVars(), write = (s) => process.stdout.write(s), projectsRoot) {
   let transcript;
   let since;
   let markdown = false;
   const progressArgs = [];
+  const rollupArgs = [];
   for (let i = 0;i < argv.length; i++) {
     const arg = argv[i];
     if (arg === "--transcript" && argv[i + 1])
       transcript = argv[++i];
     else if (arg === "--progress" && argv[i + 1])
       progressArgs.push(argv[++i]);
+    else if (arg === "--rollup" && argv[i + 1])
+      rollupArgs.push(argv[++i]);
     else if (arg === "--since" && argv[i + 1])
       since = argv[++i];
     else if (arg === "--markdown")
@@ -244,6 +635,28 @@ function main(argv, env = getEnvVars(), write = (s) => process.stdout.write(s),
       i++;
     else {
       process.stderr.write(`${RUN_SUMMARY_USAGE}
+`);
+      return 2;
+    }
+  }
+  if (rollupArgs.length > 0 && (progressArgs.length > 0 || since !== undefined || transcript !== undefined)) {
+    process.stderr.write(`${RUN_SUMMARY_USAGE}
+`);
+    return 2;
+  }
+  if (rollupArgs.length > 0) {
+    try {
+      const inputs = rollupArgs.map((arg) => {
+        const eq = arg.indexOf("=");
+        const [label, file] = eq > 0 ? [arg.slice(0, eq), arg.slice(eq + 1)] : [undefined, arg];
+        const summary = JSON.parse(readFileSync2(file, "utf8"));
+        return { label: label ?? summary.runId ?? file, summary };
+      });
+      write(`${renderRollupMarkdown(inputs)}
+`);
+      return 0;
+    } catch (error) {
+      process.stderr.write(`run-summary: ${error.message}
 `);
       return 2;
     }
@@ -253,7 +666,7 @@ function main(argv, env = getEnvVars(), write = (s) => process.stdout.write(s),
 `);
     return 2;
   }
-  const resolved = resolveTranscript(env, projectsRoot, transcript);
+  const resolved = resolveTranscript2(env, projectsRoot, transcript);
   if (!resolved.ok) {
     const out = markdown ? `Execution summary: n/a (${resolved.reason})` : JSON.stringify({ available: false, reason: resolved.reason });
     write(`${out}
@@ -264,10 +677,11 @@ function main(argv, env = getEnvVars(), write = (s) => process.stdout.write(s),
     const inputs = progressArgs.map((arg) => {
       const eq = arg.indexOf("=");
       const [label, file] = eq > 0 ? [arg.slice(0, eq), arg.slice(eq + 1)] : [undefined, arg];
-      return { label, progress: JSON.parse(readFileSync(file, "utf8")) };
+      return { label, progress: JSON.parse(readFileSync2(file, "utf8")) };
     });
-    const summary = buildRunSummary(readFileSync(resolved.path, "utf8").split(`
+    const summary = buildRunSummary(readFileSync2(resolved.path, "utf8").split(`
 `), inputs, since);
+    summary.gate = gateFromReceipt(process.cwd(), inputs[0]?.progress.runId ?? "");
     write(`${markdown ? renderSummaryMarkdown(summary) : JSON.stringify({ ...summary, transcript: resolved.path })}
 `);
     return 0;
@@ -279,8 +693,12 @@ function main(argv, env = getEnvVars(), write = (s) => process.stdout.write(s),
 }
 process.exit(main(process.argv.slice(2)));
 export {
+  writeCloseSummary,
   renderSummaryMarkdown,
+  renderRollupMarkdown,
   main,
+  gateFromReceipt,
   buildRunSummary,
+  actorSplit,
   RUN_SUMMARY_USAGE
 };