@saadnvd1/agent-os 0.3.557 → 0.3.558

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;
+}

package/lib/learning-cards/signals.ts

@@ -0,0 +1,98 @@
+// Zero-token check for "this session is probably a recipe".
+
+import { parseResult } from "../recipes/result";
+import type { SessionInput } from "./types";
+
+// First words of a command that reach outside the repo.
+export const EXTERNAL_CLIS = [
+  "asc",
+  "eas",
+  "tv",
+  "gh api",
+  "gh release",
+  "xcrun",
+  "fastlane",
+  "curl",
+  "aws",
+  "gcloud",
+  "kubectl",
+];
+
+export interface RecipeSignals {
+  hit: boolean;
+  signals: string[];
+}
+
+// "cd x && FOO=1 npx eas submit" -> "eas submit".
+export function commandStart(command: string): string {
+  const parts = command.split(/\s*(?:&&|;)\s*/).map((p) => p.trim());
+  const real = parts.find((p) => p && !/^cd\s/.test(p)) ?? "";
+  return real
+    .replace(/^(?:[A-Za-z_][A-Za-z0-9_]*=\S*\s+)+/, "")
+    .replace(/^(?:npx|bunx|sudo|time)\s+/, "");
+}
+
+export const isExternal = (command: string): boolean => {
+  const start = commandStart(command);
+  return EXTERNAL_CLIS.some((c) => start === c || start.startsWith(`${c} `));
+};
+
+const FACT_PATTERNS = [
+  /\b(?:build|run|release)\s*#?\d+/i,
+  /#\d{2,}/,
+  /\b\d+\.\d+\.\d+\b/,
+  /\b[0-9a-f]{7,}\b/i,
+  /^\s*[-*]?\s*[A-Za-z][\w ]{1,24}:\s+\S+/m,
+];
+
+export function hasFacts(final: string): boolean {
+  if (parseResult(final)) return true;
+  return FACT_PATTERNS.filter((p) => p.test(final)).length >= 2;
+}
+
+const STOP = new Set(
+  "a an and are as at be but by do for from has have in into is it its of on or that the this to was we with you your please then than so if not can will just all any also".split(
+    " "
+  )
+);
+
+export function words(text: string): Set<string> {
+  return new Set(
+    text
+      .toLowerCase()
+      .split(/[^a-z0-9]+/)
+      .filter((w) => w.length > 1 && !STOP.has(w) && !/^\d+$/.test(w))
+  );
+}
+
+export function jaccard(a: Set<string>, b: Set<string>): number {
+  if (!a.size || !b.size) return 0;
+  let both = 0;
+  for (const w of a) if (b.has(w)) both++;
+  return both / (a.size + b.size - both);
+}
+
+export const REPEAT_AT = 0.6;
+const MIN_WORDS = 4;
+
+export function repeats(brief: string, earlier: string[]): boolean {
+  const mine = words(brief);
+  if (mine.size < MIN_WORDS) return false;
+  return earlier.some((b) => jaccard(mine, words(b)) >= REPEAT_AT);
+}
+
+export function recipeSignals(input: SessionInput): RecipeSignals {
+  if (input.skip || input.run) return { hit: false, signals: [] };
+  const signals: string[] = [];
+  const external = input.steps.some(
+    (s) => s.kind === "tool" && s.name === "Bash" && isExternal(s.command)
+  );
+  if (external) signals.push("external");
+  if (!input.inRepo) signals.push("outside-repo");
+  if (hasFacts(input.final)) signals.push("facts");
+  if (repeats(input.brief, input.recentBriefs)) signals.push("repeat");
+  const hit =
+    signals.includes("repeat") ||
+    ((external || !input.inRepo) && signals.includes("facts"));
+  return { hit, signals };
+}

package/lib/learning-cards/store.ts

@@ -0,0 +1,103 @@
+import { db } from "../db";
+import type {
+  Card,
+  CardKind,
+  CardStatus,
+  Destination,
+  LessonPayload,
+  RecipePayload,
+} from "./types";
+
+interface Row extends Omit<Card, "payload"> {
+  payload: string;
+}
+
+const toCard = (r: Row): Card => ({ ...r, payload: JSON.parse(r.payload) });
+
+export function getCard(id: number): Card | null {
+  const row = db
+    .prepare(`SELECT * FROM learning_cards WHERE id = ?`)
+    .get(id) as Row | undefined;
+  return row ? toCard(row) : null;
+}
+
+export function listCards(sessionId: string, status?: CardStatus): Card[] {
+  const rows = db
+    .prepare(
+      `SELECT * FROM learning_cards WHERE session_id = ?
+       AND (? IS NULL OR status = ?) ORDER BY id`
+    )
+    .all(sessionId, status ?? null, status ?? null) as Row[];
+  return rows.map(toCard);
+}
+
+// One card per kind per session; a second insert is ignored.
+export function insertCard(c: {
+  sessionId: string;
+  workspaceId: string | null;
+  kind: CardKind;
+  payload: RecipePayload | LessonPayload;
+  destination?: Destination;
+}): Card | null {
+  const { lastInsertRowid, changes } = db
+    .prepare(
+      `INSERT OR IGNORE INTO learning_cards
+         (session_id, workspace_id, kind, payload, destination, created_at)
+       VALUES (?, ?, ?, ?, ?, ?)`
+    )
+    .run(
+      c.sessionId,
+      c.workspaceId,
+      c.kind,
+      JSON.stringify(c.payload),
+      c.destination ?? null,
+      Date.now()
+    );
+  return changes ? getCard(Number(lastInsertRowid)) : null;
+}
+
+// Takes the card for deciding; false when someone else already did.
+export function claimCard(id: number): boolean {
+  return (
+    db
+      .prepare(
+        `UPDATE learning_cards SET status = 'accepted' WHERE id = ? AND status = 'pending'`
+      )
+      .run(id).changes === 1
+  );
+}
+
+export function releaseCard(id: number): void {
+  db.prepare(
+    `UPDATE learning_cards SET status = 'pending' WHERE id = ? AND status = 'accepted' AND decided_at IS NULL`
+  ).run(id);
+}
+
+export function settleCard(
+  id: number,
+  status: "accepted" | "dismissed",
+  appliedRef: string | null,
+  payload?: RecipePayload | LessonPayload
+): void {
+  db.prepare(
+    `UPDATE learning_cards SET status = ?, applied_ref = ?, decided_at = ?,
+       payload = COALESCE(?, payload) WHERE id = ?`
+  ).run(
+    status,
+    appliedRef,
+    Date.now(),
+    payload ? JSON.stringify(payload) : null,
+    id
+  );
+}
+
+// First time a card is read: stamp it, and say whether this call did.
+export function markShown(id: number): boolean {
+  return (
+    db
+      .prepare(
+        `UPDATE learning_cards SET shown_at = ? WHERE id = ? AND shown_at IS NULL`
+      )
+      .run(Date.now(), id).changes === 1
+  );
+}

package/lib/learning-cards/types.ts

@@ -0,0 +1,79 @@
+export type CardKind = "recipe" | "lesson";
+export type CardStatus = "pending" | "accepted" | "dismissed";
+export type Destination = "recipe" | "claude_md" | "check" | "rule";
+
+export interface RecipePayload {
+  signals: string[];
+  brief: string;
+  summary: string;
+}
+
+export interface LessonPayload {
+  lesson: string;
+  destination: Destination;
+  recipeId?: string;
+  recipeName?: string;
+  projectId?: string;
+  projectName?: string;
+  taskPrompt?: string;
+  pairs: number;
+}
+
+export interface Card {
+  id: number;
+  session_id: string;
+  workspace_id: string | null;
+  kind: CardKind;
+  status: CardStatus;
+  payload: RecipePayload | LessonPayload;
+  destination: Destination | null;
+  applied_ref: string | null;
+  shown_at: number | null;
+  decided_at: number | null;
+  created_at: number;
+}
+
+// One step of a session, cut down to what the scripts read.
+export type Step =
+  | { kind: "user"; text: string; byPerson: boolean }
+  | {
+      kind: "tool";
+      name: string;
+      ok: boolean;
+      failed: boolean;
+      command: string;
+      path: string;
+      input: string;
+      output: string;
+    };
+
+export interface RunInfo {
+  status: string;
+  summary: string;
+  error: string;
+  // Settled: not queued, starting or running.
+  settled: boolean;
+}
+
+// What the scripts know about one session. Never the transcript.
+export interface SessionInput {
+  id: string;
+  name: string;
+  workspaceId: string | null;
+  projectId: string | null;
+  skip: string | null;
+  brief: string;
+  final: string;
+  steps: Step[];
+  reviews: { status: string; detail: string }[];
+  inRepo: boolean;
+  run: (RunInfo & { recipeId: string }) | null;
+  previousRun: RunInfo | null;
+  recentBriefs: string[];
+}
+
+export interface Pair {
+  kind: "tool-retry" | "review" | "user-correction" | "recipe-retry";
+  before: string;
+  after: string;
+}

package/lib/orchestrator/quick.ts

@@ -53,6 +53,15 @@ export async function quickChange(
   projectRef: string,
   name: string
 ): Promise<string> {
+  return (await startQuickChange(workspaceId, projectRef, name)).text;
+}
+
+// The same, for a caller that needs the new session's id and worktree.
+export async function startQuickChange(
+  workspaceId: string,
+  projectRef: string,
+  name: string
+): Promise<{ id: string; worktreePath: string; text: string }> {
   const owner = ownerOf(workspaceId);
   const project = workspaceProject(workspaceId, projectRef);
   if (isRemoteHost(project.host_id))
@@ -107,7 +116,11 @@ export async function quickChange(
     workspaceId,
     `Quick change "${label}" in ${project.name} on ${wt.branchName}.`
   );
-  return `Quick change "${label}" (id ${id.slice(0, 8)}) in ${project.name}: worktree ${wt.worktreePath} on ${wt.branchName}, cut from ${baseBranch}. Edit files there with Write and Edit; git there only as \`git -C ${wt.worktreePath} <status|diff|add|...>\`. Then quick_pr commits, pushes and opens its PR.`;
+  return {
+    id,
+    worktreePath: wt.worktreePath,
+    text: `Quick change "${label}" (id ${id.slice(0, 8)}) in ${project.name}: worktree ${wt.worktreePath} on ${wt.branchName}, cut from ${baseBranch}. Edit files there with Write and Edit; git there only as \`git -C ${wt.worktreePath} <status|diff|add|...>\`. Then quick_pr commits, pushes and opens its PR.`,
+  };
 }
 
 // A quick change of this workspace's orchestrator, by name, id or PR.

package/lib/recipes/draft.ts

@@ -40,10 +40,10 @@ const SCHEMA = {
   required: ["brief", "summary"],
 };
 
-export async function recipeDraft(
-  sessionId: string,
-  run: ClaudeRunner = runClaude
-): Promise<RecipeDraft> {
+export type RecipePrefill = Omit<RecipeDraft, "draft">;
+
+// The form's deterministic part; refuses a session that can't become a recipe.
+export function recipePrefill(sessionId: string): RecipePrefill {
   const s = queries.getSession(db).get(sessionId) as Session | undefined;
   if (!s) throw new Error("Session not found");
   const project = s.project_id ? getProject(s.project_id) : null;
@@ -52,34 +52,6 @@ export async function recipeDraft(
   const first = itemsOfKind(s.id, "user")[0]?.text ?? "";
   const prompt = (s.task_prompt || first).trim().slice(0, MAX_BRIEF);
   if (!prompt) throw new Error("That session has no prompt to save");
-  const final = finalMessage(s.id);
-  let draft: RecipeDraft["draft"] = null;
-  try {
-    const out = (await run({
-      cwd: os.tmpdir(),
-      system: SYSTEM,
-      prompt: [
-        `What it was asked:\n${prompt.slice(0, 1500)}`,
-        final ? `What it ended with:\n${final.slice(-2000)}` : "",
-      ]
-        .filter(Boolean)
-        .join("\n\n"),
-      schema: SCHEMA,
-      tools: [],
-      role: "helper",
-      timeoutMs: 20_000,
-    })) as { brief?: unknown; summary?: unknown };
-    if (typeof out?.brief === "string" && out.brief.trim())
-      draft = {
-        brief: out.brief.trim().slice(0, MAX_BRIEF),
-        summary: typeof out.summary === "string" ? out.summary.trim() : "",
-      };
-  } catch (error) {
-    console.warn(
-      "[recipes] no drafted brief:",
-      error instanceof Error ? error.message : error
-    );
-  }
   return {
     name: recipeNameFrom(s.name),
     workspaceId: project.workspace_id,
@@ -88,6 +60,63 @@ export async function recipeDraft(
     model: s.model_overrides ?? null,
     view: s.view,
     prompt,
-    draft,
   };
 }
+
+export const REPEATABLE_SYSTEM = `${SYSTEM} Also say whether this is a job someone would plausibly run again (repeatable); a one-off fix or a feature built once is not.`;
+const REPEATABLE_SCHEMA = {
+  ...SCHEMA,
+  properties: { ...SCHEMA.properties, repeatable: { type: "boolean" } },
+  required: ["brief", "summary", "repeatable"],
+};
+
+// The model's rewrite of a brief and final report (never the transcript).
+export const draftRequest = (
+  prompt: string,
+  final: string | null,
+  withRepeatable = false
+) => ({
+  cwd: os.tmpdir(),
+  system: withRepeatable ? REPEATABLE_SYSTEM : SYSTEM,
+  prompt: [
+    `What it was asked:\n${prompt.slice(0, 1500)}`,
+    final ? `What it ended with:\n${final.slice(-2000)}` : "",
+  ]
+    .filter(Boolean)
+    .join("\n\n"),
+  schema: withRepeatable ? REPEATABLE_SCHEMA : SCHEMA,
+  tools: [] as string[],
+  role: "helper" as const,
+  timeoutMs: 20_000,
+});
+
+export function parseDraft(out: unknown): RecipeDraft["draft"] {
+  const o = out as { brief?: unknown; summary?: unknown } | null;
+  if (typeof o?.brief !== "string" || !o.brief.trim()) return null;
+  return {
+    brief: o.brief.trim().slice(0, MAX_BRIEF),
+    summary: typeof o.summary === "string" ? o.summary.trim() : "",
+  };
+}
+
+export async function recipeDraft(
+  sessionId: string,
+  run: ClaudeRunner = runClaude,
+  // A brief already drafted for this session (a learning card's).
+  cached?: RecipeDraft["draft"]
+): Promise<RecipeDraft> {
+  const base = recipePrefill(sessionId);
+  if (cached) return { ...base, draft: cached };
+  let draft: RecipeDraft["draft"] = null;
+  try {
+    draft = parseDraft(
+      await run(draftRequest(base.prompt, finalMessage(sessionId)))
+    );
+  } catch (error) {
+    console.warn(
+      "[recipes] no drafted brief:",
+      error instanceof Error ? error.message : error
+    );
+  }
+  return { ...base, draft };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saadnvd1/agent-os",
-  "version": "0.3.557",
+  "version": "0.3.558",
   "description": "Self-hosted web UI for managing Claude Code sessions",
   "bin": {
     "agent-os": "scripts/agent-os"