@saadnvd1/agent-os 0.3.700 → 0.3.723

package/lib/analyst/forward.ts

@@ -0,0 +1,109 @@
+import { sendChat } from "../chat/runner";
+import { ASK_AGAIN } from "./brief";
+import { digestPrefix } from "./pushDigest";
+import {
+  decideRecommendation,
+  getLink,
+  getRecommendation,
+  markDigestPending,
+  reopenRecommendation,
+} from "./store";
+import { AnalystError, type AnalystLink, type Recommendation } from "./types";
+
+// A prompt into the coding agent's chat as the reader's decision, by id,
+// so a repeat is a no-op. It waits in the queue while a turn runs.
+export async function forwardToCoder(
+  coderSessionId: string,
+  input: { text: string; id: string; label: string; fromSessionId: string }
+): Promise<void> {
+  await sendChat(coderSessionId, {
+    text: input.text,
+    id: input.id,
+    queue: true,
+    origin: {
+      kind: "decision",
+      label: input.label,
+      sessionId: input.fromSessionId,
+    },
+  });
+}
+
+function liveLink(linkId: string): AnalystLink {
+  const link = getLink(linkId);
+  if (!link) throw new AnalystError("Pairing not found", 404);
+  if (link.endedAt) throw new AnalystError("This pairing has ended", 409);
+  return link;
+}
+
+function cardOf(link: AnalystLink, recId: string): Recommendation {
+  const rec = getRecommendation(recId);
+  if (!rec || rec.linkId !== link.id)
+    throw new AnalystError("Recommendation not found", 404);
+  return rec;
+}
+
+export const sentItemId = (recId: string) => `user-analyst-rec-${recId}`;
+
+// Send to Coding Agent: the analyst's prompt, or the reader's edit of it.
+export async function sendRecommendation(
+  linkId: string,
+  recId: string,
+  edited?: string
+): Promise<Recommendation> {
+  const link = liveLink(linkId);
+  const rec = cardOf(link, recId);
+  const text = (edited ?? rec.prompt ?? "").trim();
+  if (!text) throw new AnalystError("There is no prompt to send", 400);
+  const id = sentItemId(rec.id);
+  const isEdit = edited !== undefined && edited.trim() !== rec.prompt?.trim();
+  // Claimed first, so two presses send once.
+  if (
+    !decideRecommendation(rec.id, "sent", { text, itemId: id, edited: isEdit })
+  )
+    throw new AnalystError(`This recommendation was already ${rec.state}`, 409);
+  try {
+    await forwardToCoder(link.coderSessionId, {
+      text,
+      id,
+      label: "Analyst",
+      fromSessionId: link.analystSessionId,
+    });
+  } catch (error) {
+    reopenRecommendation(rec.id);
+    throw error;
+  }
+  return getRecommendation(rec.id)!;
+}
+
+export function dismissRecommendation(
+  linkId: string,
+  recId: string
+): Recommendation {
+  const link = liveLink(linkId);
+  const rec = cardOf(link, recId);
+  if (!decideRecommendation(rec.id, "dismissed"))
+    throw new AnalystError(`This recommendation was already ${rec.state}`, 409);
+  return getRecommendation(rec.id)!;
+}
+
+// Ask again, on a card whose reply had no valid block: the analyst gets a
+// short correction, answered like the digest it replaces.
+export async function askAgain(linkId: string, recId: string): Promise<void> {
+  const link = liveLink(linkId);
+  const rec = cardOf(link, recId);
+  if (rec.state !== "invalid")
+    throw new AnalystError(
+      "Only a reply with no recommendation is asked again",
+      409
+    );
+  const id = `${digestPrefix(link.id)}again-${rec.id}`;
+  const through = rec.coderThrough ?? link.reviewedThrough;
+  if (through && link.digestSignals)
+    markDigestPending(link.id, id, through, link.digestSignals);
+  await sendChat(link.analystSessionId, {
+    text: ASK_AGAIN,
+    id,
+    queue: true,
+    origin: { kind: "system", label: "AgentOS" },
+  });
+}

package/lib/analyst/index.ts

@@ -0,0 +1,16 @@
+export * from "./types";
+export { createLink, coderRefusal } from "./createLink";
+export { endLink, endLinkOf, setPaused } from "./endLink";
+export { linkView, sessionLinkView } from "./linkView";
+export { pushDigest } from "./pushDigest";
+export {
+  askAgain,
+  dismissRecommendation,
+  forwardToCoder,
+  sendRecommendation,
+} from "./forward";
+export { analystTurnEndHook, resumeAnalystLinks } from "./resume";
+export { buildDigest } from "./buildDigest";
+export { turnSignals, signalLine, latestChecks } from "./signals";
+export { parseReview, REVIEW_FENCE } from "./parseReview";
+export { getLink, getLinkOrThrow } from "./store";

package/lib/analyst/linkView.ts

@@ -0,0 +1,38 @@
+import { db } from "../db";
+import { lastItems } from "../chat/store";
+import { getLink, listRecommendations, liveLinkFor } from "./store";
+import type { AnalystLinkView, PaneSession } from "./types";
+
+function pane(id: string): PaneSession {
+  const r = db
+    .prepare(
+      `SELECT id, name, agent_type, model FROM session_rows WHERE id = ?`
+    )
+    .get(id) as
+    | { id: string; name: string; agent_type: string; model: string | null }
+    | undefined;
+  return {
+    id,
+    name: r?.name ?? "Ended session",
+    agentType: r?.agent_type ?? "claude",
+    model: r?.model ?? null,
+  };
+}
+
+export function linkView(linkId: string): AnalystLinkView | null {
+  const link = getLink(linkId);
+  if (!link) return null;
+  return {
+    ...link,
+    coder: pane(link.coderSessionId),
+    analyst: pane(link.analystSessionId),
+    coderLastTurn: lastItems(link.coderSessionId, 1, "turn_end")[0]?.id ?? null,
+    recommendations: listRecommendations(link.id),
+  };
+}
+
+// The live pairing a session is in, as either side.
+export function sessionLinkView(sessionId: string): AnalystLinkView | null {
+  const link = liveLinkFor(sessionId);
+  return link ? linkView(link.id) : null;
+}

package/lib/analyst/onTurnEnd.ts

@@ -0,0 +1,119 @@
+import type { ChatItem } from "../chat/events";
+import { lastItems } from "../chat/store";
+import { parseReview, REVIEW_FENCE } from "./parseReview";
+import { digestPrefix, pushDigest } from "./pushDigest";
+import {
+  getLink,
+  insertRecommendation,
+  liveLinkFor,
+  recommendationFor,
+  settleDigest,
+} from "./store";
+import type { AnalystLink, Recommendation } from "./types";
+
+// Enough of the analyst's chat to hold one reply and the digest before it.
+const REPLY_ITEMS = 80;
+
+// The coding agent finished a turn: the analyst gets it, unless it's busy
+// with a digest (then it comes with the next one).
+export async function onCoderTurnEnd(sessionId: string): Promise<void> {
+  const link = liveLinkFor(sessionId);
+  if (link?.coderSessionId !== sessionId) return;
+  await pushDigest(link.id);
+}
+
+interface Reply {
+  // The message the turn answered.
+  prompt: Extract<ChatItem, { kind: "user" }> | null;
+  text: string;
+  // The item the review block is in (its card renders there), else the
+  // turn's end.
+  itemId: string;
+}
+
+function lastReply(sessionId: string, turnEndId: string): Reply | null {
+  const items = lastItems(sessionId, REPLY_ITEMS);
+  const end = items.findLastIndex((i) => i.id === turnEndId);
+  if (end < 0) return null;
+  const start = items.slice(0, end).findLastIndex((i) => i.kind === "user");
+  const turn = items.slice(start + 1, end);
+  const said = turn.filter(
+    (i): i is Extract<ChatItem, { kind: "assistant" }> => i.kind === "assistant"
+  );
+  const prompt = start >= 0 ? items[start] : null;
+  return {
+    prompt: prompt?.kind === "user" ? prompt : null,
+    text: said.map((i) => i.text).join("\n\n"),
+    itemId:
+      said.findLast((i) => i.text.includes(REVIEW_FENCE))?.id ??
+      said[said.length - 1]?.id ??
+      turnEndId,
+  };
+}
+
+// Turns the analyst's reply into a card: a recommendation when it carries a
+// valid block, an invalid one when it answered a digest without one.
+export function recordReply(
+  link: AnalystLink,
+  reply: Reply
+): Recommendation | null {
+  const digest =
+    !!reply.prompt?.id.startsWith(digestPrefix(link.id)) ||
+    reply.prompt?.id === link.pendingDigestId;
+  const parsed = parseReview(reply.text);
+  if (!parsed.ok && !digest) return null;
+  if (recommendationFor(link.id, reply.itemId)) return null;
+  const about = {
+    linkId: link.id,
+    analystItemId: reply.itemId,
+    coderThrough: link.pendingThrough ?? link.reviewedThrough,
+    signals: link.digestSignals,
+  };
+  return parsed.ok
+    ? insertRecommendation({
+        ...about,
+        verdict: parsed.review.verdict,
+        summary: parsed.review.summary,
+        issues: parsed.review.issues,
+        prompt: parsed.review.prompt ?? null,
+        state: "open",
+      })
+    : insertRecommendation({
+        ...about,
+        verdict: null,
+        summary: "",
+        issues: [],
+        prompt: null,
+        state: "invalid",
+        error: parsed.error,
+      });
+}
+
+// The analyst finished a turn: its review becomes a card, the digest it
+// answered counts as reviewed, and turns that ended meanwhile go next.
+export async function onAnalystTurnEnd(
+  sessionId: string,
+  turnEnd: Extract<ChatItem, { kind: "turn_end" }>
+): Promise<void> {
+  const link = liveLinkFor(sessionId);
+  if (link?.analystSessionId !== sessionId) return;
+  const reply = lastReply(sessionId, turnEnd.id);
+  if (!reply) return;
+  recordReply(link, reply);
+  const answered = reply.prompt?.id;
+  if (answered && answered === link.pendingDigestId)
+    settleDigest(link.id, answered);
+  if (getLink(link.id)?.pendingDigestId) return;
+  await pushDigest(link.id);
+}
+
+// What the chat hook calls for every finished turn.
+export async function onTurnEnd(
+  sessionId: string,
+  item: Extract<ChatItem, { kind: "turn_end" }>
+): Promise<void> {
+  const link = liveLinkFor(sessionId);
+  if (!link) return;
+  if (link.coderSessionId === sessionId) await onCoderTurnEnd(sessionId);
+  else await onAnalystTurnEnd(sessionId, item);
+}

package/lib/analyst/parseReview.ts

@@ -0,0 +1,41 @@
+import { reviewSchema, type Review } from "./types";
+
+export const REVIEW_FENCE = "agentos-review";
+
+const FENCE = new RegExp(
+  "(`{3,}|~{3,})[ \\t]*" + REVIEW_FENCE + "[^\\n]*\\n([\\s\\S]*?)\\n?\\1",
+  "g"
+);
+
+export type ParsedReview =
+  { ok: true; review: Review } | { ok: false; error: string };
+
+// The last agentos-review block in the analyst's reply, validated.
+export function parseReview(text: string): ParsedReview {
+  const blocks = [...text.matchAll(FENCE)];
+  if (!blocks.length)
+    return { ok: false, error: "The reply had no agentos-review block" };
+  return parseReviewJson(blocks[blocks.length - 1][2]);
+}
+
+export function parseReviewJson(raw: string): ParsedReview {
+  let json: unknown;
+  try {
+    json = JSON.parse(raw.trim());
+  } catch {
+    return { ok: false, error: "The agentos-review block isn't valid JSON" };
+  }
+  const got = reviewSchema.safeParse(json);
+  if (!got.success) {
+    const issue = got.error.issues[0];
+    return {
+      ok: false,
+      error: `The agentos-review block is invalid: ${issue.path.join(".") || "block"} ${issue.message}`,
+    };
+  }
+  const review = got.data;
+  return {
+    ok: true,
+    review: { ...review, prompt: review.prompt?.trim() || null },
+  };
+}

package/lib/analyst/pushDigest.ts

@@ -0,0 +1,143 @@
+import type { ChatItem } from "../chat/events";
+import { hasItem, itemsAfter, lastItems } from "../chat/store";
+import { listQueue } from "../chat/queued";
+import { sendChat } from "../chat/runner";
+import { db } from "../db";
+import { buildDigest } from "./buildDigest";
+import { dropPendingDigest, getLink, markDigestPending } from "./store";
+import type { AnalystLink } from "./types";
+
+// How far back a first review, or a review of the same turn again, reads.
+const LAST_TURN_ITEMS = 400;
+
+export const digestPrefix = (linkId: string) => `user-analyst-${linkId}-`;
+
+const sessionName = (id: string) =>
+  (
+    db.prepare(`SELECT name FROM sessions WHERE id = ?`).get(id) as
+      { name: string } | undefined
+  )?.name ?? "coding agent";
+
+const lastTurnEnd = (items: ChatItem[]) =>
+  items.findLastIndex((i) => i.kind === "turn_end");
+
+// The latest finished turn: from after the turn_end before it.
+function lastTurn(sessionId: string): ChatItem[] {
+  const items = lastItems(sessionId, LAST_TURN_ITEMS);
+  const end = lastTurnEnd(items);
+  if (end < 0) return [];
+  const before = items
+    .slice(0, end)
+    .findLastIndex((i) => i.kind === "turn_end");
+  return items.slice(before + 1, end + 1);
+}
+
+// The coding agent's finished turns the analyst hasn't reviewed.
+export function unreviewedTurns(link: AnalystLink): ChatItem[] {
+  if (!link.reviewedThrough) return lastTurn(link.coderSessionId);
+  const items = itemsAfter(link.coderSessionId, link.reviewedThrough);
+  return items.slice(0, lastTurnEnd(items) + 1);
+}
+
+// The turns a pending digest covers: after the cursor, up to its end.
+function pendingTurns(link: AnalystLink): ChatItem[] {
+  const items = link.reviewedThrough
+    ? itemsAfter(link.coderSessionId, link.reviewedThrough)
+    : lastItems(link.coderSessionId, LAST_TURN_ITEMS);
+  const end = items.findIndex((i) => i.id === link.pendingThrough);
+  if (end < 0) return [];
+  if (link.reviewedThrough) return items.slice(0, end + 1);
+  const before = items
+    .slice(0, end)
+    .findLastIndex((i) => i.kind === "turn_end");
+  return items.slice(before + 1, end + 1);
+}
+
+const taken = (sessionId: string, id: string) =>
+  hasItem(sessionId, id) || listQueue(sessionId).some((q) => q.id === id);
+
+// A pending digest the analyst will never answer: lost before it arrived,
+// or answered by a turn whose end this server didn't see (a crash).
+export function pendingIsStale(link: AnalystLink): boolean {
+  const id = link.pendingDigestId;
+  if (!id) return false;
+  if (!taken(link.analystSessionId, id)) return true;
+  // Still queued: it waits its turn.
+  if (!hasItem(link.analystSessionId, id)) return false;
+  return itemsAfter(link.analystSessionId, id, 200).some(
+    (i) => i.kind === "turn_end"
+  );
+}
+
+async function send(link: AnalystLink, id: string, items: ChatItem[]) {
+  const through = items[items.length - 1].id;
+  const digest = buildDigest(items, {
+    coderName: sessionName(link.coderSessionId),
+    through,
+  });
+  markDigestPending(link.id, id, through, digest.signals);
+  await sendChat(link.analystSessionId, {
+    text: digest.text,
+    id,
+    queue: true,
+    origin: {
+      kind: "event",
+      label: "Coding agent",
+      sessionId: link.coderSessionId,
+      body: digest.label,
+    },
+  });
+}
+
+export type PushResult =
+  "sent" | "nothing" | "paused" | "busy" | "ended" | "interrupted";
+
+/**
+ * Sends the analyst the coding agent's turns since it last reviewed, once:
+ * turns that end while it is still on a digest wait for the next one, and
+ * a turn the user stopped rides along with the turn after it. `force`
+ * (Review now) sends even when paused, busy or stopped, and with nothing
+ * new reviews the last turn again.
+ */
+export async function pushDigest(
+  linkId: string,
+  opts: { force?: boolean } = {}
+): Promise<PushResult> {
+  let link = getLink(linkId);
+  if (!link || link.endedAt) return "ended";
+  if (link.pendingDigestId && (opts.force || pendingIsStale(link))) {
+    dropPendingDigest(link.id);
+    link = getLink(linkId)!;
+  }
+  if (!opts.force) {
+    if (link.paused) return "paused";
+    if (link.pendingDigestId) return "busy";
+  }
+  const items = unreviewedTurns(link);
+  const end = items[items.length - 1];
+  if (end?.kind === "turn_end") {
+    if (end.interrupted && !opts.force) return "interrupted";
+    await send(link, `${digestPrefix(link.id)}${end.id}`, items);
+    return "sent";
+  }
+  if (!opts.force) return "nothing";
+  const again = lastTurn(link.coderSessionId);
+  if (!again.length) return "nothing";
+  await send(link, `${digestPrefix(link.id)}again-${Date.now()}`, again);
+  return "sent";
+}
+
+// After a restart: a digest marked pending is sent again under its id (a
+// no-op when it landed).
+export async function resendPending(linkId: string): Promise<boolean> {
+  const link = getLink(linkId);
+  if (!link?.pendingDigestId || link.endedAt) return false;
+  if (taken(link.analystSessionId, link.pendingDigestId)) return false;
+  const items = pendingTurns(link);
+  if (!items.length) {
+    dropPendingDigest(link.id);
+    return false;
+  }
+  await send(link, link.pendingDigestId, items);
+  return true;
+}

package/lib/analyst/resume.ts

@@ -0,0 +1,35 @@
+import { onTurnEnd } from "./onTurnEnd";
+import { pushDigest, resendPending } from "./pushDigest";
+import { liveLinks } from "./store";
+import type { ChatItem } from "../chat/events";
+import { FLUSH_MS } from "../chat/store";
+
+// The worker writes a turn's items a moment after reporting its end.
+export const SETTLE_MS = 4 * FLUSH_MS;
+
+// The chat registry's hook for every finished turn: read once the items
+// have landed. Never throws into the chat path.
+export function analystTurnEndHook(
+  sessionId: string,
+  item: Extract<ChatItem, { kind: "turn_end" }>
+): void {
+  setTimeout(() => {
+    onTurnEnd(sessionId, item).catch((error) =>
+      console.error("[analyst] turn end:", error)
+    );
+  }, SETTLE_MS);
+}
+
+// After a restart: digests marked pending go again under their ids (a
+// no-op where they landed), and turns that ended while the server was down
+// are sent.
+export async function resumeAnalystLinks(): Promise<void> {
+  for (const link of liveLinks()) {
+    try {
+      if (link.pendingDigestId) await resendPending(link.id);
+      else await pushDigest(link.id);
+    } catch (error) {
+      console.error(`[analyst] resuming ${link.id}:`, error);
+    }
+  }
+}

package/lib/analyst/route.ts

@@ -0,0 +1,50 @@
+import { NextResponse } from "next/server";
+import type { z } from "zod";
+import { ModelUnavailableError } from "../models/agent-binding";
+import { AnalystError } from "./types";
+
+// An analyst action for a route: a body that fails its schema is a 400, an
+// AnalystError its status, a role model that's down a 409 with its fallback.
+export async function analystRoute<S extends z.ZodType>(
+  request: Request,
+  schema: S,
+  act: (body: z.infer<S>) => unknown
+): Promise<NextResponse> {
+  const raw = await request.text().catch(() => "");
+  let json: unknown = {};
+  try {
+    json = raw.trim() ? JSON.parse(raw) : {};
+  } catch {
+    return NextResponse.json({ error: "Bad JSON" }, { status: 400 });
+  }
+  const parsed = schema.safeParse(json);
+  if (!parsed.success)
+    return NextResponse.json(
+      { error: parsed.error.issues[0]?.message ?? "Bad request" },
+      { status: 400 }
+    );
+  return run(() => act(parsed.data));
+}
+
+export async function run(act: () => unknown): Promise<NextResponse> {
+  try {
+    return NextResponse.json(await act());
+  } catch (err) {
+    if (err instanceof AnalystError)
+      return NextResponse.json({ error: err.message }, { status: err.status });
+    if (err instanceof ModelUnavailableError)
+      return NextResponse.json(
+        {
+          code: err.code,
+          role: err.role,
+          ref: err.ref,
+          fallback: err.fallback ?? null,
+          error: err.message,
+        },
+        { status: 409 }
+      );
+    const message = err instanceof Error ? err.message : String(err);
+    console.error("[analyst]", message);
+    return NextResponse.json({ error: message }, { status: 400 });
+  }
+}

package/lib/analyst/signals.ts

@@ -0,0 +1,121 @@
+import type { ChatItem } from "../chat/events";
+import type { DigestSignals } from "./types";
+
+type Tool = Extract<ChatItem, { kind: "tool" }>;
+
+// A command that checks the work: tests, a build, a typecheck, a lint.
+const CHECK =
+  /\b(?:vitest|jest|pytest|mocha|playwright|rspec|phpunit|tsc|eslint|ruff|mypy|clippy|go\s+(?:test|vet|build)|cargo\s+(?:test|build|check)|swift\s+(?:test|build)|xcodebuild|gradle\w*\s+(?:test|build)|mvn\s+(?:test|verify)|(?:npm|pnpm|yarn|bun)\s+(?:run\s+)?(?:test|build|typecheck|lint|check)|make\s+(?:test|check|build)|scripts\/check|rails\s+test|rake\s+test)\b/;
+
+const WEB_TOOLS = new Set(["WebFetch", "WebSearch"]);
+const EDIT_TOOLS = new Set(["Edit", "Write", "MultiEdit", "NotebookEdit"]);
+// A curl or wget to anything but this machine.
+const REMOTE_FETCH =
+  /\b(?:curl|wget)\b[^|;&]*\bhttps?:\/\/(?!localhost\b|127\.0\.0\.1\b|\[::1\])/;
+
+const input = (t: Tool) =>
+  (t.input && typeof t.input === "object" ? t.input : {}) as Record<
+    string,
+    unknown
+  >;
+
+export const commandOf = (t: Tool): string | null =>
+  t.name === "Bash" && typeof input(t).command === "string"
+    ? (input(t).command as string)
+    : null;
+
+export const isCheckCommand = (command: string) => CHECK.test(command);
+
+function pathOf(t: Tool): string | null {
+  if (t.diff?.path) return t.diff.path;
+  if (!EDIT_TOOLS.has(t.name)) return null;
+  const i = input(t);
+  const p = i.file_path ?? i.notebook_path;
+  return typeof p === "string" ? p : null;
+}
+
+// What the turns did, counted from their items: the same answer whatever
+// the analyst writes about them.
+export function turnSignals(items: ChatItem[]): DigestSignals {
+  const s: DigestSignals = {
+    turns: 0,
+    toolCalls: 0,
+    failedTools: 0,
+    checks: [],
+    filesChanged: [],
+    durationMs: 0,
+    costUsd: 0,
+    interrupted: false,
+    errors: 0,
+    noToolTurns: 0,
+    readWeb: false,
+  };
+  const files = new Set<string>();
+  let toolsThisTurn = 0;
+  for (const item of items) {
+    if (item.kind === "tool") {
+      s.toolCalls++;
+      toolsThisTurn++;
+      if (item.status === "error") s.failedTools++;
+      const command = commandOf(item);
+      if (command && isCheckCommand(command) && item.status !== "running")
+        s.checks.push({
+          command: command.trim().split("\n")[0].slice(0, 200),
+          passed: item.status === "done",
+        });
+      if (
+        WEB_TOOLS.has(item.name) ||
+        item.name.startsWith("mcp__") ||
+        (command && REMOTE_FETCH.test(command))
+      )
+        s.readWeb = true;
+      const path = item.status !== "error" ? pathOf(item) : null;
+      if (path) files.add(path);
+    } else if (item.kind === "error") s.errors++;
+    else if (item.kind === "turn_end") {
+      s.turns++;
+      s.durationMs += item.durationMs ?? 0;
+      s.costUsd += item.costUsd ?? 0;
+      if (item.interrupted) s.interrupted = true;
+      if (!toolsThisTurn && !item.interrupted) s.noToolTurns++;
+      toolsThisTurn = 0;
+    }
+  }
+  s.filesChanged = [...files];
+  return s;
+}
+
+// The last check of each command decides it: a test that failed and then
+// passed counts as passing.
+export function latestChecks(s: DigestSignals) {
+  const by = new Map<string, boolean>();
+  for (const c of s.checks) by.set(c.command, c.passed);
+  return [...by].map(([command, passed]) => ({ command, passed }));
+}
+
+const plural = (n: number, word: string) => `${n} ${word}${n === 1 ? "" : "s"}`;
+
+// One line heading the digest, and the chips the card shows.
+export function signalLine(s: DigestSignals): string {
+  const checks = latestChecks(s);
+  const failed = checks.filter((c) => !c.passed);
+  const parts = [
+    plural(s.toolCalls, "tool call"),
+    s.failedTools ? `${s.failedTools} failed` : "",
+    checks.length
+      ? failed.length
+        ? `checks FAILED (${failed.map((c) => c.command).join("; ")})`
+        : `checks passed (${checks.length})`
+      : "no checks run",
+    s.filesChanged.length
+      ? plural(s.filesChanged.length, "file") + " changed"
+      : "",
+    s.noToolTurns ? `${plural(s.noToolTurns, "turn")} with no tool calls` : "",
+    s.interrupted ? "stopped by the user" : "",
+    s.errors ? plural(s.errors, "error") : "",
+    s.readWeb ? "read web content" : "",
+    s.durationMs ? `${Math.round(s.durationMs / 1000)}s` : "",
+    s.costUsd ? `$${s.costUsd.toFixed(2)}` : "",
+  ];
+  return parts.filter(Boolean).join(" · ");
+}