@saadnvd1/agent-os 0.3.533 → 0.3.534

package/README.md

@@ -99,6 +99,11 @@ conversation in **Messages** and can join in. [More](#agent-network)
   section in the agent's brief. [More](#project-config-agentosjson)
 - **Schedules.** Start tasks, chats or orchestrator prompts on a timer, or
   check in on a session, with run history. [More](#schedules)
+- **Recipes.** Save a job that comes up again (a build, an audit, a report);
+  each run is a fresh task or session that is told what the last run
+  reported. [More](#recipes)
+- **Plans in pieces.** A plan splits into several PRs only for a real reason,
+  checked by AgentOS; later pieces start by themselves. [More](#plans-in-pieces)
 - **Stacks.** Run a board's cards as stacked PRs that merge bottom-up.
   [More](#stacks)
 - **Machine load.** A gauge in the sidebar, each session's share of CPU and
@@ -896,6 +901,66 @@ for a running turn, and refuses, naming the card, if it doesn't end), and
 what it's sent during the land waits in its queue. A conflict stops on
 that card with the exact command to fix it.
 
+### Recipes
+
+A recipe is a saved brief: a project, a kind (a **task**, which ends in a PR
+and goes through the merge gates, or a **session**, which has no PR), and a
+short brief that says what to run and how to judge it. The steps belong in a
+script in the repo; the recipe says "run this, judge the result". Every run
+is a fresh task or session, so nothing piles up in one long conversation.
+
+Open **Settings → Recipes** (the sidebar's **⋯** menu, the workspace menu, or
+⌘K → Recipes or "Run recipe: …"). **Run** takes an optional one-off note and
+shows exactly what will be sent. **Save as recipe** on a session's menu or a
+finished task prefills the form from what it did, with a suggested brief to
+use or ignore.
+
+- **Carried between runs.** A run ends with one line,
+  `RESULT: ok|fail key=value … | one sentence`. The next run's brief gets a
+  short block (at most 600 characters) with the last run's outcome and
+  those values, such as a build number; after a failure it also carries the
+  last good run. With no line, a cheap model summarises the run, and with
+  that unavailable the state alone is recorded. **Start the next run fresh**
+  drops the block.
+- **One run at a time.** A run while another is going is refused, and a
+  double tap starts one run.
+- **Timers.** A recipe can run hourly, daily, on weekdays, weekly or on a
+  cron expression, never more than once an hour; a timer that fires while a
+  run is going is skipped. Only you set timers: the orchestrator can't.
+- **Orchestrator.** `recipes`, `run_recipe`, `recipe_save` and `recipe_update`
+  tools, and the workspace's recipes in its brief and digest. A run goes
+  through the same brakes, Pause and task queue as a task it started
+  itself, and a recipe is never an approval: it can't pass a gate. The
+  orchestrator gets an event when a run it started finishes, and for any
+  failure.
+- **History.** Each recipe lists its runs: when, how triggered and by whom,
+  outcome, the reported values, cost, duration, and links to the session and
+  PR, with totals.
+
+### Plans in pieces
+
+A plan ends with a `## Pieces` block, one piece by default. AgentOS accepts
+more only for one of four reasons, written on the piece: (a) it spans
+repositories, (b) one part must be live (merged and deployed) before the
+other can merge, (c) one part needs you mid-way, (d) one part must be
+revertible on its own (a migration that rewrites rows, or an auth change
+mixed with other work). Diff size is never a reason. A piece without a
+standing reason is folded into the one before it, and a repository with no
+deploy check can't claim (b); this is a deterministic check, not the model's
+word.
+
+A one-piece plan behaves as always. With several, piece 1 continues in the
+planning task with only its slice, and the rest wait as rows (no worktree,
+port or queue slot) until what they wait on has merged or deployed, then start
+as tasks through the usual brakes and queue. A plan waiting for approval
+shows its pieces: **Merge into ①** or **Drop** a piece (undoable until you
+approve), **Approve with note…**, or **Reject**. Each piece's review judges
+its slice; the last also checks the whole plan was built. **Tasks** shows
+the feature's pieces and what each waits on, with **Release anyway** for one
+held by a dropped or failed predecessor. A plan-only task that reaches
+approval sends a "Plan ready: name, N pieces" push, and a finished feature
+sends one "Feature merged" push naming it.
+
 ### Schedules
 
 A schedule starts agent work at set times without you opening AgentOS:
@@ -1017,7 +1082,8 @@ line at the bottom of Schedules), one of:
 
 A machine linked to Connect sends to the paired phones that have registered
 for push, instead of Telegram. A push is generic: the title "AgentOS", a
-category word and a link to open, no session or task text (the payload is a
+category word and a link to open, with no session or task text (a plan's or
+feature's name is the one exception, scrubbed to a single line) (the payload is a
 versioned envelope, so an encrypted body can replace it later). It goes
 through the Connect relay, signed with the machine key; AgentOS keeps a
 `push_outbox` that retries with backoff, forgets tokens the relay reports as
@@ -1025,7 +1091,7 @@ dead, and caps alerting pushes at 10 an hour per device (one summary after).
 
 - **What pushes**: an ask raised, a session waiting on you for a minute,
   a task ready for review, CI or a review failing, a plan ready to approve,
-  and the Away digest. Merged is off by default. Each device picks its
+  a feature merged, and the Away digest. Merged is off by default. Each device picks its
   categories (`PATCH /api/devices/me/push`). A task mirrored from another
   machine never pushes from here.
 - **Quiet rules**: waiting, review, CI and merged don't push while you're at

package/app/api/features/pieces/[id]/release/route.ts

@@ -0,0 +1,16 @@
+import { NextResponse } from "next/server";
+import { releaseAnyway } from "@/lib/plans/release";
+
+// A blocked piece stops waiting on what held it and starts on the next sweep.
+export async function POST(
+  _request: Request,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const id = Number((await params).id);
+  if (!Number.isInteger(id) || !releaseAnyway(id))
+    return NextResponse.json(
+      { error: "That piece isn't blocked" },
+      { status: 409 }
+    );
+  return NextResponse.json({ success: true });
+}

package/app/api/features/route.ts

@@ -0,0 +1,8 @@
+import { NextRequest, NextResponse } from "next/server";
+import { featureViews } from "@/lib/plans/view";
+
+export async function GET(request: NextRequest) {
+  return NextResponse.json({
+    features: featureViews(request.nextUrl.searchParams.get("workspace")),
+  });
+}

package/app/api/recipes/[id]/carry/clear/route.ts

@@ -0,0 +1,20 @@
+import { NextRequest, NextResponse } from "next/server";
+import { clearCarry } from "@/lib/recipes";
+import { failed, resolveRecipe } from "@/lib/recipes/api";
+
+// The next run starts without the last run's summary.
+export async function POST(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  try {
+    const recipe = resolveRecipe(
+      (await params).id,
+      request.nextUrl.searchParams.get("workspace")
+    );
+    clearCarry(recipe.id);
+    return NextResponse.json({ ok: true });
+  } catch (error) {
+    return failed(error);
+  }
+}

package/app/api/recipes/[id]/preview/route.ts

@@ -0,0 +1,19 @@
+import { NextRequest, NextResponse } from "next/server";
+import { previewPrompt } from "@/lib/recipes";
+import { failed, resolveRecipe } from "@/lib/recipes/api";
+
+// What a run started now would send, for the Run sheet.
+export async function GET(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  try {
+    const q = request.nextUrl.searchParams;
+    const recipe = resolveRecipe((await params).id, q.get("workspace"));
+    return NextResponse.json({
+      prompt: previewPrompt(recipe.id, q.get("note")),
+    });
+  } catch (error) {
+    return failed(error, 404);
+  }
+}

package/app/api/recipes/[id]/route.ts

@@ -0,0 +1,51 @@
+import { NextRequest, NextResponse } from "next/server";
+import {
+  archiveRecipe,
+  listRuns,
+  recipeView,
+  setTimer,
+  updateRecipe,
+} from "@/lib/recipes";
+import { failed, resolveRecipe } from "@/lib/recipes/api";
+
+type Params = { params: Promise<{ id: string }> };
+
+const workspaceOf = (request: NextRequest) =>
+  request.nextUrl.searchParams.get("workspace");
+
+export async function GET(request: NextRequest, { params }: Params) {
+  try {
+    const recipe = resolveRecipe((await params).id, workspaceOf(request));
+    return NextResponse.json({
+      recipe: recipeView(recipe),
+      runs: listRuns(recipe.id),
+    });
+  } catch (error) {
+    return failed(error, 404);
+  }
+}
+
+// The timer is Saad's: it can ride along with the settings here.
+export async function PATCH(request: NextRequest, { params }: Params) {
+  try {
+    const recipe = resolveRecipe((await params).id, workspaceOf(request));
+    const body = await request.json();
+    const { timer, ...patch } = body;
+    const updated = updateRecipe(recipe.id, patch);
+    if (timer !== undefined) setTimer(updated, timer);
+    return NextResponse.json({ recipe: recipeView(updated) });
+  } catch (error) {
+    return failed(error);
+  }
+}
+
+// Archives it: off the list and its timer off, its runs kept.
+export async function DELETE(request: NextRequest, { params }: Params) {
+  try {
+    const recipe = resolveRecipe((await params).id, workspaceOf(request));
+    archiveRecipe(recipe.id);
+    return NextResponse.json({ ok: true });
+  } catch (error) {
+    return failed(error);
+  }
+}

package/app/api/recipes/[id]/run/route.ts

@@ -0,0 +1,35 @@
+import { NextRequest, NextResponse } from "next/server";
+import { AlreadyRunning, startRun } from "@/lib/recipes";
+import { failed, resolveRecipe } from "@/lib/recipes/api";
+import { BrakeRefused } from "@/lib/orchestrator/brakes";
+
+type Params = { params: Promise<{ id: string }> };
+
+// Run now. From the UI it is Saad's (manual); `aos recipe run` sends `from`,
+// the session asking, and goes through the brakes like any agent's start.
+export async function POST(request: NextRequest, { params }: Params) {
+  try {
+    const body = await request.json().catch(() => ({}));
+    const recipe = resolveRecipe(
+      (await params).id,
+      request.nextUrl.searchParams.get("workspace")
+    );
+    const from = typeof body.from === "string" ? body.from : null;
+    const { run, queued } = await startRun(recipe.id, {
+      trigger: from ? "cli" : "manual",
+      actorSessionId: from,
+      note: typeof body.note === "string" ? body.note : null,
+      requestId: typeof body.requestId === "string" ? body.requestId : null,
+    });
+    return NextResponse.json({ run, queued }, { status: 201 });
+  } catch (error) {
+    if (error instanceof AlreadyRunning)
+      return NextResponse.json(
+        { error: "It's already running", liveRun: error.run },
+        { status: 409 }
+      );
+    if (error instanceof BrakeRefused)
+      return NextResponse.json({ error: error.message }, { status: 429 });
+    return failed(error);
+  }
+}

package/app/api/recipes/[id]/runs/route.ts

@@ -0,0 +1,23 @@
+import { NextRequest, NextResponse } from "next/server";
+import { listRuns } from "@/lib/recipes";
+import { failed, resolveRecipe } from "@/lib/recipes/api";
+
+export async function GET(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  try {
+    const recipe = resolveRecipe(
+      (await params).id,
+      request.nextUrl.searchParams.get("workspace")
+    );
+    const q = request.nextUrl.searchParams;
+    const runs = listRuns(recipe.id, {
+      before: q.get("before") ? Number(q.get("before")) : undefined,
+      limit: q.get("limit") ? Number(q.get("limit")) : undefined,
+    });
+    return NextResponse.json({ runs });
+  } catch (error) {
+    return failed(error, 404);
+  }
+}

package/app/api/recipes/draft/route.ts

@@ -0,0 +1,14 @@
+import { NextRequest, NextResponse } from "next/server";
+import { recipeDraft } from "@/lib/recipes/draft";
+import { failed } from "@/lib/recipes/api";
+
+// A finished session as a recipe form: prefilled, with a drafted brief when
+// the model could write one. Saves nothing.
+export async function POST(request: NextRequest) {
+  try {
+    const { sessionId } = await request.json();
+    return NextResponse.json(await recipeDraft(String(sessionId ?? "")));
+  } catch (error) {
+    return failed(error);
+  }
+}

package/app/api/recipes/route.ts

@@ -0,0 +1,35 @@
+import { NextRequest, NextResponse } from "next/server";
+import {
+  createRecipe,
+  listRecipeViews,
+  recipeView,
+  setTimer,
+} from "@/lib/recipes";
+import { failed } from "@/lib/recipes/api";
+
+export async function GET(request: NextRequest) {
+  const workspace = request.nextUrl.searchParams.get("workspace");
+  return NextResponse.json({ recipes: listRecipeViews(workspace) });
+}
+
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json();
+    const recipe = createRecipe({
+      workspaceId: body.workspaceId,
+      projectId: body.projectId,
+      name: body.name,
+      kind: body.kind,
+      brief: body.brief,
+      model: body.model,
+      view: body.view,
+      autoDone: body.autoDone,
+      maxMinutes: body.maxMinutes,
+      sourceSessionId: body.sourceSessionId,
+    });
+    if (body.timer) setTimer(recipe, body.timer);
+    return NextResponse.json({ recipe: recipeView(recipe) }, { status: 201 });
+  } catch (error) {
+    return failed(error);
+  }
+}

package/app/api/tasks/[id]/plan-edits/route.ts

@@ -0,0 +1,34 @@
+import { NextRequest, NextResponse } from "next/server";
+import { db, type Session } from "@/lib/db";
+import { notifyStatusChanged } from "@/lib/status/hub";
+
+// Saad's edits to a waiting plan's pieces: which to fold into the one before
+// and which to leave out. Kept on the task and applied when the plan is
+// approved; piece 1 can't be edited.
+export async function PUT(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+  const body = await request.json().catch(() => ({}));
+  const ints = (v: unknown) =>
+    Array.isArray(v)
+      ? [...new Set(v.filter((n) => Number.isInteger(n) && n >= 2 && n <= 6))]
+      : [];
+  const merge = ints(body?.merge);
+  const drop = ints(body?.drop).filter((n) => !merge.includes(n));
+  const session = db
+    .prepare(`SELECT plan_phase FROM sessions WHERE id = ?`)
+    .get(id) as Pick<Session, "plan_phase"> | undefined;
+  if (session?.plan_phase !== "awaiting")
+    return NextResponse.json(
+      { error: "That task isn't waiting for plan approval" },
+      { status: 409 }
+    );
+  db.prepare(`UPDATE sessions SET plan_edits = ? WHERE id = ?`).run(
+    JSON.stringify({ merge, drop }),
+    id
+  );
+  notifyStatusChanged();
+  return NextResponse.json({ success: true, merge, drop });
+}

package/components/CommandPalette/useAppCommands.ts

@@ -4,6 +4,7 @@ import { useSnapshot } from "valtio";
 import { useTheme } from "next-themes";
 import {
   Archive,
+  ChefHat,
   Code,
   FolderGit2,
   FolderPlus,
@@ -22,6 +23,8 @@ import {
 import type { Session } from "@/lib/db";
 import type { PaletteCommand } from "@/lib/palette/registry";
 import { useWorkspacesQuery } from "@/data/workspaces";
+import { useRecipesQuery } from "@/data/recipes";
+import { recipesUiActions } from "@/stores/recipesUi";
 import { usePaletteCommands } from "@/hooks/usePaletteCommands";
 import { archivedUiActions } from "@/stores/archivedUi";
 import { busUiActions } from "@/stores/busUi";
@@ -67,6 +70,7 @@ export function useAppCommands({
   const { workspaceId } = useSnapshot(sidebarUi);
   const current = workspaces.find((w) => w.id === workspaceId) ?? null;
   const dark = resolvedTheme?.startsWith("dark") ?? false;
+  const { data: recipes = [] } = useRecipesQuery(workspaceId ?? null);
   const addProject = useAddProject();
   const addExisting = useAddExistingProject();
 
@@ -134,6 +138,22 @@ export function useAppCommands({
           },
         ]
       : []),
+    {
+      id: "app.recipes",
+      title: "Recipes",
+      group: "Go to",
+      keywords: ["saved", "jobs", "repeat", "testflight"],
+      icon: ChefHat,
+      run: () => recipesUiActions.open(workspaceId ?? null),
+    },
+    ...recipes.map((r) => ({
+      id: `app.recipe.${r.id}`,
+      title: `Run recipe: ${r.name}`,
+      group: "Actions",
+      keywords: ["recipe", "run", r.projectName ?? ""],
+      icon: ChefHat,
+      run: () => recipesUiActions.openRecipe(r.id, true),
+    })),
     {
       id: "app.search-code",
       title: "Search code",

package/components/Features/FeaturesSection.tsx

@@ -0,0 +1,100 @@
+"use client";
+
+import { ArrowUpRight, Check, Layers } from "lucide-react";
+import { Button } from "@/components/ui/button";
+import { useFeaturesQuery, useReleasePiece } from "@/data/features";
+import type { FeatureView } from "@/lib/plans/view";
+import { duration, money } from "@/components/Recipes/format";
+import { sessionOpenActions } from "@/stores/sessionOpen";
+import { tasksUiActions } from "@/stores/tasksUi";
+import { cn } from "@/lib/utils";
+
+function FeatureCard({ f }: { f: FeatureView }) {
+  const release = useReleasePiece();
+  if (f.status === "done")
+    return (
+      <p className="border-border/60 flex min-h-11 items-center gap-2 rounded-xl border px-3 text-sm">
+        <Check className="h-4 w-4 shrink-0 text-emerald-600" />
+        <span className="min-w-0 flex-1 truncate">
+          {f.name} · {f.total} {f.total === 1 ? "PR" : "PRs"}
+          {f.costUsd ? ` · ${money(f.costUsd)}` : ""}
+          {f.durationMs ? ` · ${duration(f.durationMs)}` : ""}
+        </span>
+      </p>
+    );
+  return (
+    <div
+      className={cn(
+        "border-border/60 space-y-1 rounded-xl border p-3",
+        f.urgent && "border-amber-500/50"
+      )}
+    >
+      <p className="text-sm font-medium">
+        {f.name}{" "}
+        <span className="text-muted-foreground font-normal">
+          {f.merged}/{f.total} merged
+        </span>
+      </p>
+      <ul>
+        {f.pieces.map((p) => (
+          <li
+            key={p.id}
+            className={cn(
+              "flex min-h-11 items-center gap-2 text-xs md:min-h-8",
+              p.status === "dropped" && "opacity-50"
+            )}
+          >
+            <span className="w-4 shrink-0 tabular-nums">{p.position}</span>
+            <span className="min-w-0 flex-1 truncate">
+              {p.name} <span className="text-muted-foreground">· {p.line}</span>
+            </span>
+            {p.status === "blocked" && (
+              <Button
+                size="sm"
+                variant="outline"
+                className="h-11 md:h-8"
+                disabled={release.isPending}
+                onClick={() => release.mutate(p.id)}
+              >
+                Release anyway
+              </Button>
+            )}
+            {p.sessionId && p.status !== "merged" && p.status !== "dropped" && (
+              <button
+                type="button"
+                aria-label={`Open ${p.name}`}
+                className="text-primary -mr-2 flex min-h-11 items-center px-2"
+                onClick={() => {
+                  sessionOpenActions.request(p.sessionId!);
+                  tasksUiActions.setPanelOpen(false);
+                }}
+              >
+                <ArrowUpRight className="h-3.5 w-3.5" />
+              </button>
+            )}
+          </li>
+        ))}
+      </ul>
+      {release.error && (
+        <p className="text-destructive text-xs">{release.error.message}</p>
+      )}
+    </div>
+  );
+}
+
+// Plans that split into pieces: how far along, and what each waits on.
+export function FeaturesSection() {
+  const { data: features = [] } = useFeaturesQuery();
+  if (!features.length) return null;
+  return (
+    <div className="space-y-2">
+      <p className="label-mono text-muted-foreground flex items-center gap-1.5 pt-2">
+        <Layers className="h-3 w-3" />
+        Plans in pieces
+      </p>
+      {features.map((f) => (
+        <FeatureCard key={f.id} f={f} />
+      ))}
+    </div>
+  );
+}

package/components/Features/index.ts

@@ -0,0 +1 @@
+export { FeaturesSection } from "./FeaturesSection";