@saadnvd1/agent-os 0.3.557 → 0.3.560

package/lib/plans/pieces.ts

@@ -37,6 +37,12 @@ export interface PiecesResult {
   pieces: Piece[];
   folded: Folded[];
   warnings: string[];
+  // Items the plan's Pieces block lists (0 when it has none), however well
+  // they parsed: a plan that builds as fewer than it listed is never silent.
+  listed: number;
+  // Problems that must stop a task from building on a guess: the pieces
+  // returned are then the one-piece fallback, for a person to approve or fix.
+  errors: string[];
 }
 
 interface Raw {
@@ -51,7 +57,10 @@ interface Raw {
 
 const HEADING = /^##\s+pieces\s*$/i;
 const ITEM = /^\s{0,3}(\d+)[.)]\s+(.*\S)\s*$/;
-const AFTER = /^\s*after:\s*(\d+)\s+is\s+(merged|deployed)\s*$/i;
+// An item as a person might write it, to count what the plan listed even
+// when the strict parser rejects the block.
+const LOOSE_ITEM = /^\s{0,3}(?:[-*+]\s+)?\**\d+[.)]/;
+const AFTER = /^\s*after:\s*(?:piece\s+)?(\d+)\s+is\s+(merged|deployed)\b.*$/i;
 const WHY = /^\s*why split:\s*(.+?)\s*$/i;
 const OWNS = /^\s*owns:\s*(.+?)\s*$/i;
 
@@ -70,6 +79,14 @@ function block(text: string): string[] | null {
   return out;
 }
 
+// Bullets and bold around the numbers and keys a model sometimes adds
+// ("- **after:** 1 is merged") don't change what a line says.
+function plain(line: string): string {
+  return line
+    .replace(/^(\s*)[-*+]\s+(?=\**(?:\d+[.)]|after|why split|owns))/i, "$1")
+    .replace(/\*\*|__/g, "");
+}
+
 function parseItem(position: number, rest: string): Raw {
   let repo: string | null = null;
   const withRepo = rest.match(/^(.*?)\s*\(repo:\s*([^)]+)\)\s*$/i);
@@ -93,8 +110,9 @@ function parseItem(position: number, rest: string): Raw {
 
 function parseBlock(lines: string[]): Raw[] | null {
   const items: Raw[] = [];
-  for (const line of lines) {
-    if (!line.trim()) continue;
+  for (const original of lines) {
+    if (!original.trim()) continue;
+    const line = plain(original);
     const item = line.match(ITEM);
     if (item) {
       items.push(parseItem(Number(item[1]), item[2]));
@@ -123,6 +141,8 @@ function parseBlock(lines: string[]): Raw[] | null {
         .split(/[,;]/)
         .map((o) => o.trim().toLowerCase())
         .filter(Boolean);
+    // A wrapped slice: an indented line that is none of the keys.
+    else if (/^\s{2,}\S/.test(original)) current.slice += ` ${line.trim()}`;
     else return null;
   }
   if (!items.length || items.some((it, i) => it.position !== i + 1))
@@ -136,7 +156,13 @@ export interface CheckContext {
   find: (name: string) => ProjectRef | null;
 }
 
-function one(text: string, ctx: CheckContext, warnings: string[]) {
+function one(
+  text: string,
+  ctx: CheckContext,
+  warnings: string[],
+  listed = 0,
+  errors: string[] = []
+): PiecesResult {
   return {
     pieces: [
       {
@@ -152,30 +178,41 @@ function one(text: string, ctx: CheckContext, warnings: string[]) {
     ],
     folded: [] as Folded[],
     warnings,
+    listed,
+    errors,
   };
 }
 
 export function checkPieces(text: string, ctx: CheckContext): PiecesResult {
   const lines = block(text);
   if (!lines) return one("", ctx, []);
+  const listed = lines.filter((l) => LOOSE_ITEM.test(l)).length;
   const raw = parseBlock(lines);
   if (!raw)
-    return one("", ctx, [
-      "The Pieces block couldn't be read, so this is one piece.",
+    return one("", ctx, [], listed, [
+      "the Pieces block couldn't be read (a numbered item followed by anything but after:, why split: and owns: lines)",
+    ]);
+  if (raw.length !== listed)
+    return one("", ctx, [], listed, [
+      `the Pieces block lists ${listed} items but ${raw.length} were read`,
     ]);
   if (raw.length > MAX_PIECES)
-    return one("", ctx, [
-      `${raw.length} pieces is past the limit of ${MAX_PIECES}; built as one piece.`,
+    return one("", ctx, [], listed, [
+      `${raw.length} pieces is past the limit of ${MAX_PIECES}`,
     ]);
 
   const warnings: string[] = [];
+  const errors: string[] = [];
   const projects = raw.map((r) => {
     if (!r.repo) return ctx.own;
     const found = ctx.find(r.repo);
     if (!found)
-      warnings.push(`"${r.name}": no project named ${r.repo}; using this one.`);
+      errors.push(
+        `"${r.name}": (repo: ${r.repo}) is not a project of this workspace`
+      );
     return found ?? ctx.own;
   });
+  if (errors.length) return one("", ctx, [], listed, errors);
 
   // Where each original piece ended up, for `after:` lines that pointed at a
   // piece that was folded.
@@ -212,12 +249,15 @@ export function checkPieces(text: string, ctx: CheckContext): PiecesResult {
     }
 
     let reasons = r.reasons;
-    if (!reasons.length) return fold("no reason for a separate piece");
+    if (!reasons.length)
+      return fold("no `why split:` line naming one of (a) to (d)");
+    const lost: string[] = [];
 
     if (reasons.includes("a")) {
       const others = projects.filter((_, j) => j !== i);
       if (others.some((p) => p.id === project.id)) {
         reasons = reasons.filter((x) => x !== "a");
+        lost.push("(a) shares a repo with another piece");
         warnings.push(
           `"${r.name}" claimed (a) but shares a repo with another piece.`
         );
@@ -240,8 +280,10 @@ export function checkPieces(text: string, ctx: CheckContext): PiecesResult {
       const dep = afterPosition ? pieces[afterPosition - 1] : null;
       if (afterKind !== "deployed" || !dep) {
         reasons = reasons.filter((x) => x !== "b");
+        lost.push("(b) needs `after: N is deployed`, not merged");
       } else if (!dep.project.deploys) {
         reasons = reasons.filter((x) => x !== "b");
+        lost.push(`(b) waits on a deploy ${dep.project.name} can't check`);
         afterKind = "merged";
         warnings.push(
           `"${r.name}" waits on a deploy that ${dep.project.name} can't check; it waits for the merge instead.`
@@ -252,7 +294,8 @@ export function checkPieces(text: string, ctx: CheckContext): PiecesResult {
       if (!dep?.project.deploys) afterKind = "merged";
     }
 
-    if (!reasons.length) return fold("its reason didn't hold");
+    if (!reasons.length)
+      return fold(`its reason didn't hold: ${lost.join("; ")}`);
 
     keep({
       name: r.name,
@@ -274,7 +317,15 @@ export function checkPieces(text: string, ctx: CheckContext): PiecesResult {
       else seen.set(o, p.position);
     }
 
-  return { pieces, folded, warnings };
+  return { pieces, folded, warnings, listed, errors };
+}
+
+// What a task that builds fewer pieces than its plan listed is told, so the
+// folded work is built here and not left for pieces that will never start.
+export function foldedBrief(
+  result: Pick<PiecesResult, "listed" | "folded">
+): string {
+  return `The plan listed ${result.listed} pieces; they're built as ONE here (${result.folded.map((f) => `${f.name}: ${f.why}`).join("; ")}). Build all of it in this PR, including the folded pieces: ${result.folded.map((f) => f.name).join(", ")}. Nothing else will build them.`;
 }
 
 export const PIECES_PROMPT = `At the end of the plan, add a \`## Pieces\` block. The default is exactly one piece, which is what almost every task is, and one piece needs no more than:
@@ -292,14 +343,15 @@ Diff size is never a reason. A later piece looks like:
    after: 1 is merged   (or: 1 is deployed)
    why split: (a) + (b)
    owns: migration 81
-A shared resource (a migration id, a new table, a config key) goes on exactly one piece's \`owns:\` line. A piece with no valid reason is folded into the one before it.`;
+A shared resource (a migration id, a new table, a config key) goes on exactly one piece's \`owns:\` line. A piece with no valid reason is folded into the one before it. Reason (b) needs \`after: N is deployed\`; \`after: N is merged\` alone is only ordering, not a reason. A piece in another project runs as its own task in that project; this task builds only the pieces in its own repository.`;
 
 // Shown to a piece's agent in place of the whole plan.
 export function pieceBrief(
   total: number,
   piece: Pick<Piece, "position" | "name" | "slice" | "owns">,
   planPath: string,
-  before: string[] = []
+  before: string[] = [],
+  project?: string
 ): string {
   const owns = piece.owns.length
     ? `\nThis piece owns: ${piece.owns.join(", ")}. No other piece touches it.`
@@ -307,7 +359,10 @@ export function pieceBrief(
   const earlier = before.length
     ? `\nPieces before you: ${before.join("; ")}.`
     : "";
-  return `Build piece ${piece.position} of ${total} only, "${piece.name}": ${piece.slice}${owns}${earlier}\nThe rest of the plan is other pieces' work; don't start it. Full plan: ${planPath}`;
+  const where = project
+    ? `\nWork only in this task's repository (${project}) and its worktree. Don't create worktrees, branches or PRs in another repository: AgentOS starts the pieces that belong there as their own tasks.`
+    : "";
+  return `Build piece ${piece.position} of ${total} only, "${piece.name}": ${piece.slice}${owns}${earlier}${where}\nThe rest of the plan is other pieces' work; don't start it. Full plan: ${planPath}`;
 }
 
 export interface PlanEdits {

package/lib/plans/release.ts

@@ -8,7 +8,7 @@ import { loadProjectConfig } from "../project-config";
 import { createTask } from "../tasks";
 import { startOrQueue } from "../tasks/queue";
 import { braked, BrakeRefused } from "../orchestrator/brakes";
-import { queueEvent } from "../orchestrator/events";
+import { queueEvent, queueEventOnce } from "../orchestrator/events";
 import { amendBrief } from "../orchestrator/amendments";
 import { usageRows } from "../session-logs/gather";
 import { pieceBrief } from "./pieces";
@@ -190,7 +190,8 @@ async function releaseOne(
     )
     .run((piece.session_id ??= randomUUID()), piece.id).changes;
   if (!claimed) return;
-  const prompt = `[Feature "${feature.name}", piece ${piece.position} of ${all.length}, started by AgentOS from an approved plan]\n${pieceBrief(all.length, { position: piece.position, name: piece.name, slice: piece.slice, owns: piece.owns ? piece.owns.split(", ") : [] }, planPathOf(feature.id), beforeLines(all, piece.position))}`;
+  const project = getProject(piece.project_id);
+  const prompt = `[Feature "${feature.name}", piece ${piece.position} of ${all.length}, started by AgentOS from an approved plan]\n${pieceBrief(all.length, { position: piece.position, name: piece.name, slice: piece.slice, owns: piece.owns ? piece.owns.split(", ") : [] }, planPathOf(feature.id), beforeLines(all, piece.position), project?.name)}`;
   try {
     const id = await deps.start(feature, piece, prompt, piece.session_id);
     if (id !== piece.session_id)
@@ -246,16 +247,56 @@ function close(feature: Feature, all: FeaturePiece[], deps: ReleaseDeps): void {
     )
     .run(cost, ended > started ? ended - started : null, feature.id).changes;
   if (!claimed) return;
+  // A plan that listed more than it built is told, not closed quietly.
+  const listed = feature.listed ?? live.length;
+  const left = [
+    feature.folded ? `folded: ${feature.folded.split("\n").join("; ")}` : "",
+    all.some((p) => p.status === "dropped")
+      ? `dropped: ${all
+          .filter((p) => p.status === "dropped")
+          .map((p) => p.name)
+          .join(", ")}`
+      : "",
+  ].filter(Boolean);
+  const short =
+    listed > live.length || left.length
+      ? ` Its plan listed ${listed}; check the rest landed (${left.join("; ") || "not built as pieces"}).`
+      : "";
   say(
     feature,
     `done-${feature.id}`,
-    `Feature "${feature.name}" is merged: ${live.length} ${live.length === 1 ? "PR" : "PRs"}.`
+    `Feature "${feature.name}" is merged: ${live.length} ${live.length === 1 ? "PR" : "PRs"}.${short}`
   );
   deps.pushFeatureMerged(feature);
 }
 
+// A dependency merged and the piece after it still hasn't started: the sweep
+// that should have started it is stuck, or the start keeps being held.
+export const STUCK_PIECE_MS = 30 * 60 * 1000;
+
+function stuckPieces(feature: Feature, all: FeaturePiece[], now: number): void {
+  for (const piece of all) {
+    if (piece.status !== "waiting" || !piece.after_position) continue;
+    const dep = all.find((p) => p.position === piece.after_position);
+    const merged = dep ? sessionOf(dep.session_id)?.merged_at : null;
+    if (!dep || dep.status !== "merged" || !merged) continue;
+    const since = Date.parse(`${merged}Z`);
+    const wait =
+      piece.after_kind === "deployed" ? STUCK_PIECE_MS * 2 : STUCK_PIECE_MS;
+    if (now - since < wait) continue;
+    queueEventOnce(
+      feature.workspace_id,
+      `feature:stuck-${piece.id}-${since}`,
+      feature.plan_session_id,
+      `Feature "${feature.name}": piece ${piece.position} ${piece.name} is still waiting ${Math.floor((now - since) / 60000)}m after ${dep.position} ${dep.name} merged. Release it anyway or drop it.`,
+      now
+    );
+  }
+}
+
 export async function releasePieces(
-  deps: ReleaseDeps = realDeps
+  deps: ReleaseDeps = realDeps,
+  now = Date.now()
 ): Promise<void> {
   const features = db
     .prepare(`SELECT * FROM features WHERE status = 'building'`)
@@ -267,6 +308,7 @@ export async function releasePieces(
       await releaseOne(feature, piecesOf(feature.id), piece, deps).catch((e) =>
         console.error(`[features] piece ${piece.id}:`, e)
       );
+    stuckPieces(feature, piecesOf(feature.id), now);
     close(feature, piecesOf(feature.id), deps);
   }
 }

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

@@ -459,6 +459,9 @@ export function startSettling(): void {
     busy = true;
     void settleRuns()
       .then(() => releasePieces())
+      .then(async () =>
+        (await import("../orchestrator/reconcile")).reconcileSweep()
+      )
       .catch((e) => console.error("[recipes] settle:", e))
       .finally(() => {
         busy = false;

package/lib/sidebar/shelves.ts

@@ -209,13 +209,12 @@ function wokeUnread(
 }
 
 // When a row went to Done: marked by hand, quiet for 3 days, or (a task)
-// last changed.
+// when it was finished, else last changed.
 export function doneAtMs(row: SidebarRow): number {
-  return row.settled === "manual"
-    ? ms(row.session.settled_at)
-    : row.settled === "auto"
-      ? row.activeAt
-      : ms(row.session.updated_at);
+  if (row.settled === "manual") return ms(row.session.settled_at);
+  if (row.settled === "auto") return row.activeAt;
+  const { settled_at, merged_at, updated_at } = row.session;
+  return ms(settled_at) || ms(merged_at) || ms(updated_at);
 }
 
 const OPEN_RUN = ["queued", "starting", "running"];

package/package.json

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