@saadnvd1/agent-os 0.3.533 → 0.3.534

package/lib/orchestrator/recipe-tools.ts

@@ -0,0 +1,159 @@
+/**
+ * The orchestrator's recipe tools: list, run, save and edit. A recipe is a
+ * saved brief, never an approval: a run goes through the same brakes, gates,
+ * Pause and task queue as a task the orchestrator started itself. It sets no
+ * trigger; timers are Saad's.
+ */
+
+import { formatRunTime } from "../schedules/cron";
+import { workspaceProject } from "./targets";
+import { getOrchestrator } from "./home";
+import { untrusted } from "./untrusted";
+import {
+  AlreadyRunning,
+  createRecipe,
+  findRecipe,
+  getTimer,
+  listRecipes,
+  listRuns,
+  startRun,
+  updateRecipe,
+  type Recipe,
+  type RecipeRun,
+} from "../recipes";
+import { outputsText } from "../recipes/result";
+
+const when = (iso: string | null) =>
+  iso
+    ? formatRunTime(Date.parse(`${iso.replace(" ", "T")}Z`) || Date.now())
+    : "?";
+
+function runLine(r: RecipeRun, recipe: Recipe): string {
+  const facts = outputsText(r.outputs);
+  const bits = [facts, r.summary].filter(Boolean).join(". ");
+  const text = bits ? `: ${untrusted(recipe.name, bits)}` : "";
+  const pr = r.pr_number ? ` PR #${r.pr_number}` : "";
+  const by =
+    r.trigger === "timer" || r.trigger === "catch-up"
+      ? "timer"
+      : r.trigger === "tool"
+        ? "you"
+        : "Saad";
+  return `#${r.seq} ${r.status} (${when(r.ended_at ?? r.started_at ?? r.created_at)}, by ${by})${pr}${text}`;
+}
+
+function summaryLine(recipe: Recipe): string {
+  const [last] = listRuns(recipe.id, { limit: 1 });
+  const timer = getTimer(recipe.id);
+  const next =
+    timer?.enabled && timer.nextRunAt
+      ? `, next ${formatRunTime(timer.nextRunAt, timer.timezone)}`
+      : "";
+  return `- "${recipe.name}" (${recipe.kind}${last ? `; last ${runLine(last, recipe)}` : "; never run"}${next})`;
+}
+
+// `recipes`: every recipe, or one in full with its brief and recent runs.
+export function recipesText(w: string, name?: string): string {
+  if (name) {
+    const r = findRecipe(w, name);
+    const timer = getTimer(r.id);
+    const runs = listRuns(r.id, { limit: 5 });
+    return [
+      `Recipe "${r.name}" (${r.kind}, ${r.view}, project ${projectName(w, r)})${r.model ? `, model ${r.model}` : ""}${r.max_minutes ? `, time limit ${r.max_minutes} min` : ""}.`,
+      timer
+        ? `Timer: ${timer.description} ${timer.timezone}${timer.enabled ? "" : " (off)"}, set by Saad.`
+        : "No timer.",
+      `Brief:\n${r.brief}`,
+      runs.length
+        ? `Recent runs:\n${runs.map((x) => `- ${runLine(x, r)}`).join("\n")}`
+        : "Never run.",
+    ].join("\n");
+  }
+  const all = listRecipes(w);
+  if (!all.length)
+    return "No recipes yet. Save one with recipe_save when a job comes up a second time.";
+  return all.map(summaryLine).join("\n");
+}
+
+const projectName = (w: string, r: Recipe) =>
+  workspaceProject(w, r.project_id).name;
+
+export async function runRecipe(
+  w: string,
+  name: string,
+  note?: string
+): Promise<string> {
+  const recipe = findRecipe(w, name);
+  const orchestrator = getOrchestrator(w);
+  try {
+    const { run, queued } = await startRun(recipe.id, {
+      trigger: "tool",
+      actorSessionId: orchestrator?.id ?? null,
+      note,
+    });
+    return queued
+      ? `Queued run #${run.seq} of "${recipe.name}" behind the task limit; it starts by itself. You'll get an event when it finishes.`
+      : `Started run #${run.seq} of "${recipe.name}" (${recipe.kind}). You'll get an event when it finishes${recipe.kind === "task" ? "; its PR goes through the gates like any task's" : ""}.`;
+  } catch (error) {
+    if (error instanceof AlreadyRunning)
+      return `"${recipe.name}" already has run #${error.run.seq} going. Not starting another; you'll get an event when it finishes.`;
+    throw error;
+  }
+}
+
+export function saveRecipe(
+  w: string,
+  a: {
+    name: string;
+    project: string;
+    kind: "task" | "session";
+    brief: string;
+    model?: string;
+    view?: "chat" | "terminal";
+  }
+): string {
+  const project = workspaceProject(w, a.project);
+  const orchestrator = getOrchestrator(w);
+  const recipe = createRecipe(
+    {
+      workspaceId: w,
+      projectId: project.id,
+      name: a.name,
+      kind: a.kind,
+      brief: a.brief,
+      model: a.model,
+      view: a.view,
+    },
+    orchestrator?.id ?? null
+  );
+  return `Saved recipe "${recipe.name}" (${recipe.kind}, ${project.name}). Run it with run_recipe; Saad sees it in Recipes and sets any timer.`;
+}
+
+export function updateRecipeTool(
+  w: string,
+  a: {
+    name: string;
+    brief?: string;
+    new_name?: string;
+    model?: string;
+    view?: "chat" | "terminal";
+    auto_done?: boolean;
+    max_minutes?: number;
+  }
+): string {
+  const recipe = findRecipe(w, a.name);
+  const orchestrator = getOrchestrator(w);
+  updateRecipe(
+    recipe.id,
+    {
+      brief: a.brief,
+      name: a.new_name,
+      model: a.model,
+      view: a.view,
+      autoDone: a.auto_done,
+      maxMinutes: a.max_minutes,
+    },
+    orchestrator?.id ?? null
+  );
+  return `Updated recipe "${a.new_name ?? recipe.name}". Earlier versions of the brief are kept; Saad sees the change.`;
+}

package/lib/orchestrator/review.ts

@@ -10,6 +10,7 @@
  * the orchestrator hears the verdict as an event.
  */
 
+import { reviewGoal } from "../plans/features";
 import { pushReviewBlocked, pushReviewReady } from "../notify/push/events";
 import { db, type Session } from "../db";
 import { amendmentsOf } from "./amendments";
@@ -319,7 +320,7 @@ export function taskReviewTarget(task: Session, pr: TaskPR): ReviewTarget {
     id: task.id,
     name: task.name,
     label: `task ${task.name}`,
-    goal: task.task_prompt ?? task.name,
+    goal: reviewGoal(task.id) ?? task.task_prompt ?? task.name,
     repo: repoOf(task),
     refs: task,
     pr,

package/lib/orchestrator/serve.ts

@@ -32,6 +32,13 @@ import { land } from "./signoff";
 import { arm, disarm } from "./armed";
 import { quickChange, quickPR } from "./quick";
 import { review } from "./review";
+import { planPiecesText } from "./plan-pieces";
+import {
+  recipesText,
+  runRecipe,
+  saveRecipe,
+  updateRecipeTool,
+} from "./recipe-tools";
 import { cancelReminder, listReminders, remindMe } from "./reminders";
 import { parseArgs as p, type ToolName } from "./tool-schemas";
 
@@ -44,6 +51,9 @@ const ACTING = new Set<ToolName>([
   "start_task",
   "set_task_model",
   "start_session",
+  "run_recipe",
+  "recipe_save",
+  "recipe_update",
   "quick_change",
   "quick_pr",
   "stack",
@@ -51,6 +61,7 @@ const ACTING = new Set<ToolName>([
   "drop",
   "move",
   "approve_plan",
+  "plan_pieces",
   "stop",
   "done",
   "review",
@@ -126,6 +137,10 @@ export async function runTool(
       const task = workspaceTask(w, a.task);
       return approveTaskPlan(task, a.message);
     }
+    case "plan_pieces": {
+      const a = p(tool, raw);
+      return planPiecesText(workspaceTask(w, a.task), a.merge, a.drop);
+    }
     case "set_task_model": {
       const a = p(tool, raw);
       const task = workspaceTask(w, a.task);
@@ -196,6 +211,16 @@ export async function runTool(
       const a = p(tool, raw);
       return remindMe(w, a.at, a.prompt, a.name);
     }
+    case "recipes":
+      return recipesText(w, p(tool, raw).name);
+    case "run_recipe": {
+      const a = p(tool, raw);
+      return runRecipe(w, a.name, a.note);
+    }
+    case "recipe_save":
+      return saveRecipe(w, p(tool, raw));
+    case "recipe_update":
+      return updateRecipeTool(w, p(tool, raw));
     case "reminders":
       return listReminders(w);
     case "cancel_reminder":

package/lib/orchestrator/tool-names.ts

@@ -23,6 +23,7 @@ export const TOOL_NAMES = {
   stack_status: name("stack_status"),
   land: name("land"),
   approve_plan: name("approve_plan"),
+  plan_pieces: name("plan_pieces"),
   drop: name("drop"),
   move: name("move"),
   stop: name("stop"),
@@ -38,6 +39,10 @@ export const TOOL_NAMES = {
   arm: name("arm"),
   disarm: name("disarm"),
   remind_me: name("remind_me"),
+  recipes: name("recipes"),
+  run_recipe: name("run_recipe"),
+  recipe_save: name("recipe_save"),
+  recipe_update: name("recipe_update"),
   reminders: name("reminders"),
   cancel_reminder: name("cancel_reminder"),
   ask_saad: name("ask_saad"),

package/lib/orchestrator/tool-schemas.ts

@@ -210,6 +210,17 @@ export const TOOL_SHAPES = {
         "Amends the plan: recorded on the task's brief as a scope change, so its review judges the PR against it. Only for a change Saad made"
       ),
   },
+  plan_pieces: {
+    task,
+    merge: z
+      .array(z.number().int().min(2).max(6))
+      .optional()
+      .describe("Waiting pieces to fold into the piece before them"),
+    drop: z
+      .array(z.number().int().min(2).max(6))
+      .optional()
+      .describe("Waiting pieces to leave out; pieces after them are held"),
+  },
   drop: { task, reason: z.string().trim().min(1).max(2000) },
   move: {
     task,
@@ -275,6 +286,49 @@ export const TOOL_SHAPES = {
       .describe("What to remind yourself of, in words you'll understand later"),
     name: z.string().trim().min(1).max(80).optional(),
   },
+  recipes: {
+    name: ref("A recipe's name or id; leave out to list them all").optional(),
+  },
+  run_recipe: {
+    name: ref("The recipe's name or id, from recipes"),
+    note: z
+      .string()
+      .trim()
+      .min(1)
+      .max(1000)
+      .optional()
+      .describe(
+        'A one-off line for this run only ("Includes #87"); the brief stays as saved'
+      ),
+  },
+  recipe_save: {
+    name: z.string().trim().min(1).max(80).describe("2-6 words, no quotes"),
+    project,
+    kind: z
+      .enum(["task", "session"])
+      .describe(
+        "task ends in a PR through the gates; session changes no code and has no PR"
+      ),
+    brief: z
+      .string()
+      .trim()
+      .min(1)
+      .max(4000)
+      .describe(
+        "Short: what to run and how to judge it. The steps belong in a script in the repo"
+      ),
+    model: modelRef.optional(),
+    view,
+  },
+  recipe_update: {
+    name: ref("The recipe's name or id"),
+    brief: z.string().trim().min(1).max(4000).optional(),
+    new_name: z.string().trim().min(1).max(80).optional(),
+    model: modelRef.optional(),
+    view,
+    auto_done: z.boolean().optional(),
+    max_minutes: z.number().int().min(1).max(1440).optional(),
+  },
   reminders: {},
   cancel_reminder: { id: ref("The reminder's id, from reminders") },
   review: {

package/lib/orchestrator/tools.ts

@@ -77,6 +77,8 @@ const DESCRIPTIONS: Record<ToolName, string> = {
   land: "Merge a whole stack bottom-up, each PR through the sign-off gates at its current head.",
   approve_plan:
     'Approve the plan of a plan_only task that is waiting ("plan ready"): it continues on the implementation model, once. An optional message amends the plan and is recorded on the task\'s brief as a scope change. Reject a plan with drop.',
+  plan_pieces:
+    "A task whose plan split into pieces: each piece, its repo, what it waits on and its state. With merge or drop (position numbers) it edits the pieces still waiting: a merged piece's slice goes to the piece before it, a dropped one is left out and anything waiting on it is held. It can't add pieces or change reasons.",
   drop: "Reject a task: close its PR and remove its worktree. A task still waiting in the queue is removed by its id. Logged with the reason.",
   move: 'Carry a running task to a linked machine, or back with "here": for heavy test or build work. It keeps its branch, conversation and plan; the gates, events, read, send, stop, done and drop work the same wherever it runs, and the machine it lands on can\'t merge it. Takes a few minutes and runs in the background; an event says when it lands. Refused while paused, for a task waiting on Saad (an escalation or open ask), and for card and stacked tasks.',
   stop: "Stop a session's agent mid-turn, even while it's thinking, keeping its conversation, worktree and branch; your next message runs as its next turn.",
@@ -90,6 +92,14 @@ const DESCRIPTIONS: Record<ToolName, string> = {
     "Remove a standing rule you kept, by its id, only when Saad says so or it no longer applies (the PR it names merged or closed). Saad's rules are his to remove.",
   remind_me:
     "Set a one-off reminder for yourself in this workspace: at the time given it reaches you once as a scheduled prompt (not an approval), even if AgentOS was off then. At least 10 minutes ahead; a few at a time at most.",
+  recipes:
+    "This workspace's recipes: saved briefs for jobs that come up again (a TestFlight build, an audit, a report), each with its last run and next timer. With a name, one recipe in full: its brief and recent runs.",
+  run_recipe:
+    "Run a recipe now: a fresh task or session starts from its saved brief, plus the last run's reported facts and an optional one-off note. Braked, queued and gated like start_task and start_session. A recipe is never an approval. One run at a time; while it is going this says so. You get an event when it finishes.",
+  recipe_save:
+    "Save a recipe when a job comes up a second time. A short brief (the steps belong in a script in the repo), a kind (task: ends in a PR; session: no PR) and a project. It sets no timer: Saad does.",
+  recipe_update:
+    "Change a recipe's brief or settings (never its timer). Earlier versions are kept and Saad sees the change.",
   reminders:
     "List this workspace's upcoming reminders and the last few that ran.",
   cancel_reminder:

package/lib/plans/features.ts

@@ -0,0 +1,200 @@
+// A plan that split into pieces: the feature, its pieces, and the one-time
+// checks that turn a plan file into rows. A one-piece plan makes none.
+
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { randomUUID } from "crypto";
+import { db, type Session } from "../db";
+import { loadProjectConfig } from "../project-config";
+import {
+  applyEdits,
+  checkPieces,
+  parseEdits,
+  type CheckContext,
+  type PiecesResult,
+  type Piece,
+  type ProjectRef,
+} from "./pieces";
+
+export type PieceStatus =
+  | "waiting"
+  | "building"
+  | "merged"
+  | "blocked"
+  | "dropped";
+
+export interface Feature {
+  id: string;
+  workspace_id: string;
+  name: string;
+  plan_session_id: string;
+  plan_text: string;
+  status: "building" | "done" | "dropped";
+  done_at: string | null;
+  cost_usd: number | null;
+  duration_ms: number | null;
+  created_at: string;
+}
+
+export interface FeaturePiece {
+  id: number;
+  feature_id: string;
+  position: number;
+  name: string;
+  slice: string;
+  project_id: string;
+  after_position: number | null;
+  after_kind: "merged" | "deployed" | null;
+  reasons: string | null;
+  owns: string | null;
+  status: PieceStatus;
+  session_id: string | null;
+  note: string | null;
+}
+
+const expandHome = (p: string) => p.replace(/^~/, os.homedir());
+
+export const plansDir = () =>
+  process.env.AGENTOS_PLANS_DIR ||
+  path.join(os.homedir(), ".agent-os", "plans");
+export const planPathOf = (featureId: string) =>
+  path.join(plansDir(), `${featureId}.md`);
+
+function ref(id: string): ProjectRef | null {
+  const p = db
+    .prepare(`SELECT id, name, working_directory FROM projects WHERE id = ?`)
+    .get(id) as
+    | { id: string; name: string; working_directory: string }
+    | undefined;
+  if (!p) return null;
+  const deploy = loadProjectConfig(expandHome(p.working_directory)).config
+    .deploy;
+  return { id: p.id, name: p.name, deploys: !!deploy?.deployed };
+}
+
+export function checkContext(
+  s: Pick<Session, "project_id">
+): CheckContext | null {
+  const own = s.project_id ? ref(s.project_id) : null;
+  if (!own) return null;
+  const rows = db
+    .prepare(
+      `SELECT id, name FROM projects
+       WHERE workspace_id = (SELECT workspace_id FROM projects WHERE id = ?)`
+    )
+    .all(own.id) as { id: string; name: string }[];
+  return {
+    own,
+    find: (name) => {
+      const hit = rows.find(
+        (r) => r.name.toLowerCase() === name.trim().toLowerCase()
+      );
+      return hit ? ref(hit.id) : null;
+    },
+  };
+}
+
+// The plan's pieces after the checker, with Saad's edits applied. Null when
+// there's no plan file or no project: one piece, as always.
+export function planFor(s: Session, text: string): PiecesResult | null {
+  const ctx = checkContext(s);
+  return ctx ? checkPieces(text, ctx) : null;
+}
+
+export function getFeature(id: string): Feature | undefined {
+  return db.prepare(`SELECT * FROM features WHERE id = ?`).get(id) as
+    | Feature
+    | undefined;
+}
+
+export function piecesOf(featureId: string): FeaturePiece[] {
+  return db
+    .prepare(
+      `SELECT * FROM feature_pieces WHERE feature_id = ? ORDER BY position`
+    )
+    .all(featureId) as FeaturePiece[];
+}
+
+export function pieceOfSession(sessionId: string): FeaturePiece | undefined {
+  return db
+    .prepare(`SELECT * FROM feature_pieces WHERE session_id = ?`)
+    .get(sessionId) as FeaturePiece | undefined;
+}
+
+export function featureOfPlan(sessionId: string): Feature | undefined {
+  return db
+    .prepare(`SELECT * FROM features WHERE plan_session_id = ?`)
+    .get(sessionId) as Feature | undefined;
+}
+
+export interface Split {
+  pieces: Piece[];
+  notBuilding: string[];
+}
+
+// The pieces to build for a plan (one, when it isn't split). Edits Saad
+// made on the plan view apply only here, at approval.
+export function splitOf(s: Session, text: string): Split | null {
+  const result = planFor(s, text);
+  if (!result || result.pieces.length < 2) return null;
+  const { pieces, notBuilding } = applyEdits(result, parseEdits(s.plan_edits));
+  return { pieces, notBuilding };
+}
+
+// One transaction: the feature, its pieces, and the plan kept past the
+// worktree. Piece 1 is the planning task's own.
+export function createFeature(
+  s: Session,
+  text: string,
+  pieces: Piece[],
+  workspaceId: string
+): Feature {
+  const id = randomUUID();
+  fs.mkdirSync(plansDir(), { recursive: true });
+  fs.writeFileSync(planPathOf(id), text);
+  db.transaction(() => {
+    db.prepare(
+      `INSERT INTO features (id, workspace_id, name, plan_session_id, plan_text, status)
+       VALUES (?, ?, ?, ?, ?, 'building')`
+    ).run(id, workspaceId, s.name, s.id, text);
+    const insert = db.prepare(
+      `INSERT INTO feature_pieces
+         (feature_id, position, name, slice, project_id, after_position, after_kind,
+          reasons, owns, status, session_id)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    );
+    for (const p of pieces)
+      insert.run(
+        id,
+        p.position,
+        p.name,
+        p.slice,
+        p.project.id,
+        p.afterPosition,
+        p.afterKind,
+        p.reasons.join("+") || null,
+        p.owns.join(", ") || null,
+        p.position === 1 ? "building" : "waiting",
+        p.position === 1 ? s.id : null
+      );
+  })();
+  return getFeature(id)!;
+}
+
+const PLAN_IN_REVIEW = 20_000;
+
+// What a piece's review judges the diff against: its slice, not the whole
+// task. The last piece standing is also asked whether the plan is done.
+export function reviewGoal(sessionId: string): string | null {
+  const piece = pieceOfSession(sessionId);
+  const feature = piece ? getFeature(piece.feature_id) : undefined;
+  if (!piece || !feature) return null;
+  const all = piecesOf(feature.id);
+  const live = all.filter((p) => p.status !== "dropped");
+  const owns = piece.owns ? `\nThis piece owns: ${piece.owns}.` : "";
+  const head = `Piece ${piece.position} of ${live.length}, "${piece.name}": ${piece.slice}${owns}`;
+  const last = live.every((p) => p.id === piece.id || p.status === "merged");
+  if (!last || live.length < 2) return head;
+  return `${head}\n\nThis is the last piece. Also check that the plan as a whole is now done, and list anything in it that no piece built. The plan:\n${feature.plan_text.slice(0, PLAN_IN_REVIEW)}`;
+}