@saadnvd1/agent-os 0.3.556 → 0.3.558

package/lib/learning-cards/analyze.ts

@@ -0,0 +1,228 @@
+// The end-of-session hook: scripts first (free); a helper-model call only
+// on a hit, through the experiments meter, never on the transcript.
+
+import os from "os";
+import { runClaude, type ClaudeRunner } from "../orchestrator/claude-cli";
+import { getOrchestrator } from "../orchestrator/home";
+import { addNote } from "../orchestrator/notes";
+import { untrusted, UNTRUSTED_RULE } from "../orchestrator/untrusted";
+import { isRemoteHost } from "../hosts";
+import { getProject } from "../projects";
+import { getRecipe } from "../recipes/store";
+import { draftRequest, parseDraft, recipePrefill } from "../recipes/draft";
+import { countEvent, experimentRun, hasEvent } from "../experiments/meter";
+import { experimentOn } from "../experiments";
+import type { EndHow } from "../experiments/hooks";
+import { readSession } from "./input";
+import { correctionPairs } from "./pairs";
+import { recipeSignals } from "./signals";
+import { insertCard } from "./store";
+import type { Destination, Pair, SessionInput } from "./types";
+
+const ID = "learning-cards" as const;
+const LESSON_MAX = 200;
+const TASK_MAX = 600;
+
+const inFlight = new Set<string>();
+
+const LESSON_SYSTEM = `You judge whether a few corrections from one finished agent session are worth keeping for next time. Reply reusable=false for anything specific to that one piece of work. Otherwise give one plain line (the lesson, under ${LESSON_MAX} characters) and where it belongs:
+- "recipe": the session ran from a saved recipe and the lesson is about running that recipe.
+- "claude_md": a fact about the repository (how to build, test, run or avoid breaking it) that every future agent there should know.
+- "check": better caught by a script or automated check; put a short task brief for it in taskPrompt instead of a lesson.
+- "rule": only a preference about how work is done in this workspace (process, style, when to ask), never a fact about code.
+${UNTRUSTED_RULE}`;
+const LESSON_SCHEMA = {
+  type: "object",
+  properties: {
+    reusable: { type: "boolean" },
+    lesson: { type: "string" },
+    destination: { enum: ["recipe", "claude_md", "check", "rule"] },
+    taskPrompt: { type: "string" },
+  },
+  required: ["reusable", "lesson", "destination"],
+};
+
+interface Where {
+  recipe: { id: string; name: string } | null;
+  project: { id: string; name: string } | null;
+  repo: boolean;
+  workspaceId: string | null;
+}
+
+function whereOf(input: SessionInput): Where {
+  const project = input.projectId ? getProject(input.projectId) : null;
+  const usable = project && !project.is_uncategorized ? project : null;
+  const recipe = input.run ? getRecipe(input.run.recipeId) : null;
+  return {
+    recipe: recipe ? { id: recipe.id, name: recipe.name } : null,
+    project: usable ? { id: usable.id, name: usable.name } : null,
+    repo: !!usable && input.inRepo && !isRemoteHost(usable.host_id),
+    workspaceId: input.workspaceId,
+  };
+}
+
+export interface Verdict {
+  reusable?: unknown;
+  lesson?: unknown;
+  destination?: unknown;
+  taskPrompt?: unknown;
+}
+
+// What the model said, held to what the session can actually do. Null: no card.
+export function checkLesson(
+  v: Verdict | null,
+  where: Where
+): { lesson: string; destination: Destination; taskPrompt?: string } | null {
+  if (!v || v.reusable !== true || typeof v.lesson !== "string") return null;
+  const lesson = v.lesson.replace(/\s+/g, " ").trim().slice(0, LESSON_MAX);
+  const task =
+    typeof v.taskPrompt === "string"
+      ? v.taskPrompt.trim().slice(0, TASK_MAX)
+      : "";
+  let destination = v.destination as Destination;
+  // Not run from a recipe: its lesson is a repo fact, if there is a repo.
+  if (destination === "recipe" && !where.recipe) destination = "claude_md";
+  switch (destination) {
+    case "recipe":
+      return lesson ? { lesson, destination } : null;
+    case "claude_md":
+      return lesson && where.repo && where.project
+        ? { lesson, destination }
+        : null;
+    case "check":
+      return task && where.project
+        ? {
+            lesson: lesson || task.slice(0, LESSON_MAX),
+            destination,
+            taskPrompt: task,
+          }
+        : null;
+    case "rule":
+      return lesson && where.workspaceId ? { lesson, destination } : null;
+    default:
+      return null;
+  }
+}
+
+const pairsText = (pairs: Pair[]) =>
+  pairs
+    .map((p, i) => `${i + 1}. [${p.kind}] ${p.before}\n   then: ${p.after}`)
+    .join("\n");
+
+export async function analyzeSession(
+  sessionId: string,
+  how: EndHow,
+  runner: ClaudeRunner = runClaude
+): Promise<void> {
+  if (!experimentOn(ID)) return;
+  if (
+    inFlight.has(sessionId) ||
+    hasEvent(ID, sessionId, "script", "session-end")
+  )
+    return;
+  inFlight.add(sessionId);
+  try {
+    const input = await readSession(sessionId);
+    if (!input || input.skip) return;
+    // A recipe run's session ends before the run settles; its settle comes.
+    if (input.run && !input.run.settled && how !== "recipe-settled") return;
+
+    const ctx = { sessionId, workspaceId: input.workspaceId };
+    const recipe = recipeSignals(input);
+    const pairs = correctionPairs(input);
+    countEvent(ID, "script", {
+      ...ctx,
+      trigger: "session-end",
+      detail: `signals: ${recipe.signals.join(",") || "none"}; pairs: ${pairs.length}`,
+    });
+
+    let made = 0;
+    if (recipe.hit && input.workspaceId) {
+      try {
+        recipePrefill(sessionId);
+        const out = await experimentRun(
+          ID,
+          { ...ctx, trigger: "recipe-draft" },
+          {
+            ...draftRequest(input.brief, input.final, true),
+            workspaceId: input.workspaceId,
+          },
+          runner
+        );
+        const draft = parseDraft(out);
+        if (
+          (out as { repeatable?: unknown } | null)?.repeatable === true &&
+          draft
+        )
+          made += insertCard({
+            sessionId,
+            workspaceId: input.workspaceId,
+            kind: "recipe",
+            payload: { signals: recipe.signals, ...draft },
+          })
+            ? 1
+            : 0;
+      } catch (error) {
+        console.warn("[learning-cards] recipe draft:", error);
+      }
+    }
+
+    if (pairs.length) {
+      try {
+        const where = whereOf(input);
+        const out = (await experimentRun(
+          ID,
+          { ...ctx, trigger: "lesson" },
+          {
+            cwd: os.tmpdir(),
+            system: LESSON_SYSTEM,
+            prompt: [
+              where.recipe
+                ? `The session ran from the recipe "${where.recipe.name}".`
+                : "The session did not run from a recipe.",
+              untrusted("session corrections", pairsText(pairs)),
+            ].join("\n\n"),
+            schema: LESSON_SCHEMA,
+            tools: [],
+            role: "helper",
+            timeoutMs: 20_000,
+            workspaceId: input.workspaceId ?? undefined,
+          },
+          runner
+        )) as Verdict | null;
+        const ok = checkLesson(out, where);
+        if (ok)
+          made += insertCard({
+            sessionId,
+            workspaceId: input.workspaceId,
+            kind: "lesson",
+            destination: ok.destination,
+            payload: {
+              ...ok,
+              recipeId: where.recipe?.id,
+              recipeName: where.recipe?.name,
+              projectId: where.project?.id,
+              projectName: where.project?.name,
+              pairs: pairs.length,
+            },
+          })
+            ? 1
+            : 0;
+      } catch (error) {
+        console.warn("[learning-cards] lesson:", error);
+      }
+    }
+
+    if (made && input.workspaceId && getOrchestrator(input.workspaceId))
+      addNote(
+        input.workspaceId,
+        `Learning card on ${input.name}: ${
+          made > 1
+            ? "save as a recipe and keep a lesson"
+            : "a suggestion to save or keep"
+        }? Open the session to decide.`
+      );
+  } finally {
+    inFlight.delete(sessionId);
+  }
+}

package/lib/learning-cards/apply.ts

@@ -0,0 +1,196 @@
+// What a tap on a card does. The only place a lesson is written anywhere.
+
+import fs from "fs";
+import path from "path";
+import { db } from "../db";
+import { countEvent } from "../experiments/meter";
+import { experimentOn } from "../experiments";
+import { getOrchestrator } from "../orchestrator/home";
+import { quickPR, startQuickChange } from "../orchestrator/quick";
+import { addRule } from "../orchestrator/rules";
+import { isRemoteHost } from "../hosts";
+import { getProject } from "../projects";
+import { createRecipe, getRecipe, updateRecipe } from "../recipes/store";
+import { recipePrefill } from "../recipes/draft";
+import { createTask } from "../tasks";
+import { claimCard, getCard, releaseCard, settleCard } from "./store";
+import type { Card, LessonPayload, RecipePayload } from "./types";
+
+const ID = "learning-cards" as const;
+const HEADING = "## Lessons";
+
+export class CardRefused extends Error {}
+
+export interface Edits {
+  lesson?: string;
+  brief?: string;
+  taskPrompt?: string;
+}
+
+// CLAUDE.md with the line under "## Lessons" (the heading made if missing).
+export function withLesson(text: string, line: string): string {
+  const bullet = `- ${line.replace(/\s+/g, " ").trim()}`;
+  const lines = text.replace(/\s+$/, "").split("\n");
+  const at = lines.findIndex((l) => l.trim() === HEADING);
+  if (at === -1)
+    return `${text.trim() ? `${lines.join("\n")}\n\n` : ""}${HEADING}\n\n${bullet}\n`;
+  let end = at + 1;
+  while (end < lines.length && !/^#{1,6}\s/.test(lines[end])) end++;
+  while (end > at + 1 && !lines[end - 1].trim()) end--;
+  if (lines.slice(at + 1, end).some((l) => l.trim() === bullet))
+    return `${lines.join("\n")}\n`;
+  lines.splice(end, 0, ...(end === at + 1 ? ["", bullet] : [bullet]));
+  return `${lines.join("\n")}\n`;
+}
+
+const clean = (s: string | undefined, max: number) =>
+  (s ?? "").replace(/\s+/g, " ").trim().slice(0, max);
+
+async function toClaudeMd(card: Card, p: LessonPayload, line: string) {
+  const project = p.projectId ? getProject(p.projectId) : null;
+  if (!project) throw new CardRefused("That project is gone");
+  const workspaceId = card.workspace_id;
+  const source = (
+    db
+      .prepare(`SELECT name FROM sessions WHERE id = ?`)
+      .get(card.session_id) as { name: string } | undefined
+  )?.name;
+  if (
+    workspaceId &&
+    getOrchestrator(workspaceId) &&
+    !isRemoteHost(project.host_id)
+  ) {
+    const quick = await startQuickChange(
+      workspaceId,
+      project.id,
+      "Add a lesson to CLAUDE.md"
+    );
+    const file = path.join(quick.worktreePath, "CLAUDE.md");
+    const before = fs.existsSync(file) ? fs.readFileSync(file, "utf8") : "";
+    fs.writeFileSync(file, withLesson(before, line));
+    await quickPR(
+      workspaceId,
+      quick.id,
+      "docs: add a lesson to CLAUDE.md",
+      `${line}${source ? `\n\nFrom the session "${source}".` : ""}`
+    );
+    return quick.id;
+  }
+  const task = await createTask({
+    projectId: project.id,
+    prompt: `Add exactly this line under a "${HEADING}" heading in CLAUDE.md at the repository root, creating the file and heading if missing, and change nothing else: ${line}`,
+    startedBy: null,
+  });
+  return task.id;
+}
+
+async function applyLesson(card: Card, p: LessonPayload, edits: Edits) {
+  const line = clean(edits.lesson, 200) || p.lesson;
+  switch (p.destination) {
+    case "recipe": {
+      const recipe = p.recipeId ? getRecipe(p.recipeId) : null;
+      if (!recipe || recipe.archived_at)
+        throw new CardRefused("That recipe is gone");
+      updateRecipe(
+        recipe.id,
+        { brief: `${recipe.brief}\n\nLesson: ${line}` },
+        null
+      );
+      return recipe.id;
+    }
+    case "claude_md":
+      return toClaudeMd(card, p, line);
+    case "check": {
+      const prompt = clean(edits.taskPrompt, 600) || p.taskPrompt;
+      if (!prompt || !p.projectId)
+        throw new CardRefused("There's no task to start");
+      return (
+        await createTask({ projectId: p.projectId, prompt, startedBy: null })
+      ).id;
+    }
+    case "rule":
+      if (!card.workspace_id)
+        throw new CardRefused("There's no workspace for a rule");
+      return String(addRule(card.workspace_id, line, "saad").id);
+  }
+}
+
+async function applyRecipe(card: Card, p: RecipePayload, edits: Edits) {
+  const base = recipePrefill(card.session_id);
+  const recipe = createRecipe(
+    {
+      workspaceId: base.workspaceId,
+      projectId: base.projectId,
+      name: base.name,
+      kind: base.kind,
+      brief: edits.brief?.trim() || p.brief,
+      model: base.model ?? undefined,
+      view: base.view,
+      sourceSessionId: card.session_id,
+    },
+    null
+  );
+  return recipe.id;
+}
+
+function pending(cardId: number): Card {
+  if (!experimentOn(ID)) throw new CardRefused("Learning cards are off");
+  const card = getCard(cardId);
+  if (!card) throw new CardRefused("No such card");
+  if (card.status !== "pending") throw new CardRefused("Already decided");
+  return card;
+}
+
+const meter = (card: Card, event: "accepted" | "dismissed") =>
+  countEvent(
+    ID,
+    event,
+    {
+      trigger: "card-apply",
+      sessionId: card.session_id,
+      workspaceId: card.workspace_id,
+      detail: card.kind === "lesson" ? `lesson: ${card.destination}` : "recipe",
+    },
+    true
+  );
+
+export async function applyCard(
+  cardId: number,
+  edits: Edits = {}
+): Promise<Card> {
+  const card = pending(cardId);
+  if (!claimCard(cardId)) throw new CardRefused("Already decided");
+  try {
+    const ref =
+      card.kind === "recipe"
+        ? await applyRecipe(card, card.payload as RecipePayload, edits)
+        : await applyLesson(card, card.payload as LessonPayload, edits);
+    settleCard(cardId, "accepted", ref);
+  } catch (error) {
+    releaseCard(cardId);
+    throw error;
+  }
+  meter(card, "accepted");
+  return getCard(cardId)!;
+}
+
+export function dismissCard(cardId: number): Card {
+  const card = pending(cardId);
+  settleCard(cardId, "dismissed", null);
+  meter(card, "dismissed");
+  return getCard(cardId)!;
+}
+
+// The recipe form saved a recipe from this session: its card is taken.
+export function acceptRecipeCardFor(sessionId: string, recipeId: string): void {
+  if (!experimentOn(ID)) return;
+  const row = db
+    .prepare(
+      `SELECT id FROM learning_cards WHERE session_id = ? AND kind = 'recipe' AND status = 'pending'`
+    )
+    .get(sessionId) as { id: number } | undefined;
+  if (!row || !claimCard(row.id)) return;
+  const card = getCard(row.id)!;
+  settleCard(row.id, "accepted", recipeId);
+  meter(card, "accepted");
+}

package/lib/learning-cards/index.ts

@@ -0,0 +1,29 @@
+import { experimentOn } from "../experiments";
+import { countEvent } from "../experiments/meter";
+import { listCards, markShown } from "./store";
+import type { Card, RecipePayload } from "./types";
+
+const ID = "learning-cards" as const;
+
+// A session's pending cards. Nothing, and no work, while the experiment is off.
+export function cardsFor(sessionId: string): Card[] {
+  if (!experimentOn(ID)) return [];
+  const cards = listCards(sessionId, "pending");
+  for (const c of cards)
+    if (markShown(c.id))
+      countEvent(ID, "shown", {
+        trigger: "card-view",
+        sessionId,
+        workspaceId: c.workspace_id,
+        detail: c.kind,
+      });
+  return cards;
+}
+
+// The brief a pending recipe card drafted, so Edit needn't draft it again.
+export function pendingRecipeDraft(sessionId: string) {
+  if (!experimentOn(ID)) return undefined;
+  const card = listCards(sessionId, "pending").find((c) => c.kind === "recipe");
+  const p = card?.payload as RecipePayload | undefined;
+  return p ? { brief: p.brief, summary: p.summary } : undefined;
+}

package/lib/learning-cards/input.ts

@@ -0,0 +1,116 @@
+// Reads one finished session into the plain object the scripts take: the
+// brief, the final report and the tool and user steps, each cut down.
+// Never the transcript.
+
+import { db, queries, type Session } from "../db";
+import { itemsOfKind, itemsOfKinds } from "../chat/store";
+import { isGitRepo } from "../git";
+import { getProject } from "../projects";
+import { finalMessage } from "../session-logs/gather";
+import { getRecipe, listRuns, runForSession } from "../recipes/store";
+import { isLive, type RecipeRun } from "../recipes/types";
+import type { RunInfo, SessionInput, Step } from "./types";
+
+const CUT = 300;
+const BRIEF = 1500;
+const FINAL = 2000;
+const RECENT_DAYS = 60;
+const RECENT_BRIEFS = 200;
+
+const cut = (s: string, n = CUT) => s.slice(0, n);
+
+function stepOf(item: ReturnType<typeof itemsOfKinds>[number]): Step | null {
+  if (item.kind === "user") {
+    const byPerson = !item.peer && !item.from && !item.origin;
+    return { kind: "user", text: cut(item.text), byPerson };
+  }
+  if (item.kind !== "tool") return null;
+  const input = (item.input ?? {}) as Record<string, unknown>;
+  const command = typeof input.command === "string" ? input.command : "";
+  const path = typeof input.file_path === "string" ? input.file_path : "";
+  return {
+    kind: "tool",
+    name: item.name,
+    ok: item.status === "done",
+    failed: item.status === "error",
+    command: cut(command),
+    path,
+    input: cut(command || path || JSON.stringify(item.input ?? "")),
+    output: (item.output ?? "").slice(-CUT),
+  };
+}
+
+const runInfo = (r: RecipeRun): RunInfo => ({
+  status: r.status,
+  summary: r.summary ?? "",
+  error: r.error ?? "",
+  settled: !isLive(r.status),
+});
+
+export async function readSession(id: string): Promise<SessionInput | null> {
+  const s = queries.getSession(db).get(id) as Session | undefined;
+  if (!s) return null;
+  const project = s.project_id ? getProject(s.project_id) : null;
+  const workspaceId = project?.workspace_id ?? s.workspace_id ?? null;
+  const steps = itemsOfKinds(id, ["user", "tool"])
+    .map(stepOf)
+    .filter((x): x is Step => !!x);
+  const final = finalMessage(id) ?? "";
+  const brief = (s.task_prompt || itemsOfKind(id, "user")[0]?.text || "").slice(
+    0,
+    BRIEF
+  );
+  let skip: string | null = null;
+  if (s.role === "orchestrator") skip = "orchestrator";
+  else if (s.quick_of) skip = "quick change";
+  else if (!steps.length && !final) skip = "no conversation";
+
+  const run = runForSession(id);
+  const previous = run
+    ? listRuns(run.recipe_id, { before: run.id, limit: 5 }).find(
+        (r) =>
+          !isLive(r.status) &&
+          r.status !== "cancelled" &&
+          r.status !== "skipped"
+      )
+    : undefined;
+  const recipe = run ? getRecipe(run.recipe_id) : null;
+
+  const recentBriefs = workspaceId
+    ? (
+        db
+          .prepare(
+            `SELECT s.task_prompt AS p FROM sessions s JOIN projects p ON p.id = s.project_id
+             WHERE p.workspace_id = ? AND s.id != ? AND s.quick_of IS NULL
+               AND s.task_prompt IS NOT NULL
+               AND s.created_at >= datetime('now', ?)
+             ORDER BY s.created_at DESC LIMIT ?`
+          )
+          .all(workspaceId, id, `-${RECENT_DAYS} days`, RECENT_BRIEFS) as {
+          p: string;
+        }[]
+      ).map((r) => r.p)
+    : [];
+
+  return {
+    id,
+    name: s.name,
+    workspaceId,
+    projectId: s.project_id ?? null,
+    skip,
+    brief,
+    final: final.slice(-FINAL),
+    steps,
+    reviews: db
+      .prepare(
+        `SELECT status, COALESCE(detail, '') AS detail FROM orchestrator_checks
+         WHERE session_id = ? AND kind = 'review' ORDER BY created_at, id`
+      )
+      .all(id) as { status: string; detail: string }[],
+    // The project's own folder: a task's worktree is gone once it's merged.
+    inRepo: await isGitRepo(project?.working_directory ?? s.working_directory),
+    run: run && recipe ? { ...runInfo(run), recipeId: recipe.id } : null,
+    previousRun: previous ? runInfo(previous) : null,
+    recentBriefs,
+  };
+}

package/lib/learning-cards/pairs.ts

@@ -0,0 +1,111 @@
+// Zero-token extraction of correction pairs: a thing that went wrong and
+// what fixed it, a few hundred characters each.
+
+import type { Pair, SessionInput, Step } from "./types";
+
+const SIDE = 300;
+const MAX_PAIRS = 4;
+const MAX_TOTAL = 6000;
+const LOOKAHEAD = 6;
+
+const clip = (s: string, n = SIDE) => {
+  const one = s.replace(/\s+/g, " ").trim();
+  return one.length > n ? `${one.slice(0, n - 1)}…` : one;
+};
+
+type Tool = Extract<Step, { kind: "tool" }>;
+
+const firstWord = (c: string) => c.trim().split(/\s+/)[0] ?? "";
+
+// Same tool, same job (the command's first word or the file), different input.
+function sameJobDifferently(bad: Tool, good: Tool): boolean {
+  if (bad.name !== good.name || bad.input === good.input) return false;
+  if (bad.name === "Bash")
+    return !!bad.command && firstWord(bad.command) === firstWord(good.command);
+  return !!bad.path && bad.path === good.path;
+}
+
+const CORRECTION =
+  /^\s*(?:no\b|nope\b|wrong\b|not that\b|actually\b|stop\b|don'?t\b|do not\b)|\binstead\b|\buse\b.{1,60}\bnot\b|\bthat'?s (?:wrong|not)\b/i;
+const CHANGES = new Set(["Edit", "Write", "MultiEdit", "Bash"]);
+
+function toolRetries(steps: Step[]): Pair[] {
+  const out: Pair[] = [];
+  const tools = steps.filter((s): s is Tool => s.kind === "tool");
+  tools.forEach((bad, i) => {
+    if (!bad.failed) return;
+    const good = tools
+      .slice(i + 1, i + 1 + LOOKAHEAD)
+      .find((t) => t.ok && sameJobDifferently(bad, t));
+    if (!good) return;
+    out.push({
+      kind: "tool-retry",
+      before: clip(`${bad.name}: ${bad.input} -> ${bad.output}`),
+      after: clip(`${good.name}: ${good.input}`),
+    });
+  });
+  return out;
+}
+
+function reviewPair(input: SessionInput): Pair[] {
+  const at = input.reviews.findIndex((r) => r.status === "block");
+  if (at === -1) return [];
+  if (!input.reviews.slice(at + 1).some((r) => r.status === "pass")) return [];
+  return [
+    {
+      kind: "review",
+      before: clip(input.reviews[at].detail || "review blocked"),
+      after: "the next review passed",
+    },
+  ];
+}
+
+function userCorrections(steps: Step[]): Pair[] {
+  const out: Pair[] = [];
+  const firstUser = steps.findIndex((s) => s.kind === "user");
+  steps.forEach((s, i) => {
+    if (s.kind !== "user" || i === firstUser || !s.byPerson) return;
+    if (!CORRECTION.test(s.text)) return;
+    const fix = steps
+      .slice(i + 1)
+      .find((n): n is Tool => n.kind === "tool" && n.ok && CHANGES.has(n.name));
+    if (!fix) return;
+    out.push({
+      kind: "user-correction",
+      before: clip(s.text),
+      after: clip(`${fix.name}: ${fix.input}`),
+    });
+  });
+  return out;
+}
+
+function recipePair(input: SessionInput): Pair[] {
+  const { run, previousRun: prev } = input;
+  if (!run || !prev || run.status !== "succeeded") return [];
+  if (prev.status !== "failed" && prev.status !== "timed_out") return [];
+  return [
+    {
+      kind: "recipe-retry",
+      before: clip(prev.error || prev.summary || prev.status),
+      after: clip(run.summary || "succeeded"),
+    },
+  ];
+}
+
+export function correctionPairs(input: SessionInput): Pair[] {
+  const all = [
+    ...recipePair(input),
+    ...reviewPair(input),
+    ...userCorrections(input.steps),
+    ...toolRetries(input.steps),
+  ];
+  const out: Pair[] = [];
+  let total = 0;
+  for (const p of all) {
+    const size = p.before.length + p.after.length;
+    if (out.length >= MAX_PAIRS || total + size > MAX_TOTAL) break;
+    total += size;
+    out.push(p);
+  }
+  return out;
+}