@saadnvd1/agent-os 0.3.556 → 0.3.558

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/lib/recipes/settle.ts

@@ -11,6 +11,7 @@ import { blockedReason } from "../tasks/state";
 import { runClaude, type ClaudeRunner } from "../orchestrator/claude-cli";
 import { releasePieces } from "../plans/release";
 import { queueEvent } from "../orchestrator/events";
+import { sessionEnded } from "../experiments/hooks";
 import { untrusted } from "../orchestrator/untrusted";
 import {
   cleanOutputs,
@@ -172,8 +173,10 @@ function finish(
       run.id
     ).changes;
   idleSince.delete(run.id);
-  if (changed)
+  if (changed) {
     tell(run, status, summary, result, session?.pr_number ?? run.pr_number);
+    if (run.session_id) void sessionEnded(run.session_id, "recipe-settled");
+  }
   return changed === 1;
 }
 

package/lib/settings-store.ts

@@ -0,0 +1,22 @@
+import { getDb } from "@/lib/db";
+
+// The settings table: a key and a string, shared by every feature.
+export function getSetting(key: string): string | null {
+  const row = getDb()
+    .prepare(`SELECT value FROM settings WHERE key = ?`)
+    .get(key) as { value: string } | undefined;
+  return row?.value ?? null;
+}
+
+export function putSetting(key: string, value: string | null): void {
+  if (value === null) {
+    getDb().prepare(`DELETE FROM settings WHERE key = ?`).run(key);
+    return;
+  }
+  getDb()
+    .prepare(
+      `INSERT INTO settings (key, value) VALUES (?, ?)
+       ON CONFLICT(key) DO UPDATE SET value = excluded.value`
+    )
+    .run(key, value);
+}

package/lib/settings-url.ts

@@ -16,6 +16,7 @@ export const SETTINGS_SECTIONS = [
   "audits",
   "setup",
   "updates",
+  "experiments",
 ] as const;
 
 export type SettingsSection = (typeof SETTINGS_SECTIONS)[number];

package/lib/tasks/finish.ts

@@ -26,6 +26,7 @@ import { canSignOff } from "./state";
 import { forgetPR, getTaskSession, prFor, projectPathFor } from "./session";
 import { dropSessionDatabase } from "../project-config/database";
 import { captureMergedTask } from "../session-logs";
+import { sessionEnded } from "../experiments/hooks";
 
 // Never deleted, whatever a setting says.
 export const PROTECTED_BRANCHES = new Set(["main", "master", "HEAD"]);
@@ -163,6 +164,7 @@ export async function signOffTask(
   pushMerged(id);
   // Reads the plan file now: cleanup below removes the worktree.
   void captureMergedTask(id, { head: opts.head ?? pr!.head ?? null });
+  void sessionEnded(id, "merged");
   const head = opts.head ?? pr!.head;
   resolveMergedTaskAsks(
     id,

package/lib/tasks/session.ts

@@ -16,6 +16,7 @@ import { findPRStrict } from "./gh";
 import { currentBranch, git } from "../git-exec";
 import { lookupPR } from "./pr-poll";
 import { captureMergedTask } from "../session-logs";
+import { sessionEnded } from "../experiments/hooks";
 import { getOrchestrator } from "../orchestrator/home";
 import {
   pushCiFailed,
@@ -211,6 +212,7 @@ export async function prFor(
     if (pr.state === "MERGED") {
       if (session.pr_status !== "merged") pushMerged(session.id);
       void captureMergedTask(session.id, { head: pr.head });
+      void sessionEnded(session.id, "merged");
     }
   }
   // Only an answer just read from GitHub: a cached one may predate a

package/lib/updates/settings.ts

@@ -1,4 +1,4 @@
-import { getDb } from "@/lib/db";
+import { getSetting, putSetting } from "../settings-store";
 
 // Whether this server shows the update banner, and the checks behind it.
 // AGENTOS_UPDATE_BANNER=off pins it off, like the network settings.
@@ -17,22 +17,4 @@ export function bannerEnabled(env: Env = process.env): boolean {
 export const setBannerEnabled = (on: boolean) =>
   putSetting(KEY, on ? "1" : "0");
 
-export function getSetting(key: string): string | null {
-  const row = getDb()
-    .prepare(`SELECT value FROM settings WHERE key = ?`)
-    .get(key) as { value: string } | undefined;
-  return row?.value ?? null;
-}
-
-export function putSetting(key: string, value: string | null): void {
-  if (value === null) {
-    getDb().prepare(`DELETE FROM settings WHERE key = ?`).run(key);
-    return;
-  }
-  getDb()
-    .prepare(
-      `INSERT INTO settings (key, value) VALUES (?, ?)
-       ON CONFLICT(key) DO UPDATE SET value = excluded.value`
-    )
-    .run(key, value);
-}
+export { getSetting, putSetting } from "../settings-store";

package/package.json

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