@saadnvd1/agent-os 0.3.558 → 0.3.560

package/app/api/sessions/route.ts

@@ -10,9 +10,9 @@ import { isProjectRef } from "@/lib/tasks/project-ref";
 export async function GET() {
   try {
     const db = getDb();
-    // Merged and dropped tasks live in the Tasks panel (a moved one lives on
-    // the machine it moved to), archived sessions
-    // in the Archived view: neither is in the sidebar.
+    // Merged tasks are listed (the sidebar files them under Done). Dropped
+    // tasks live in the Tasks panel, a moved one on the machine it moved to,
+    // and archived sessions in the Archived view: none is in the sidebar.
     const sessions = queries.getSidebarSessions(db).all() as Session[];
     const groups = queries.getAllGroups(db).all() as Group[];
 

package/lib/db/migrations.ts

@@ -2087,6 +2087,33 @@ const migrations: Migration[] = [
       `);
     },
   },
+  {
+    id: 87,
+    name: "plan_pieces_reconcile",
+    up: (db) => {
+      // How many pieces a plan listed and what the checker folded, so a plan
+      // that builds as fewer than it listed is never silent; the PRs agents
+      // opened (from their `gh pr create` output) so one outside its task's
+      // repo is noticed.
+      const columns = db.prepare(`PRAGMA table_info(features)`).all() as {
+        name: string;
+      }[];
+      if (!columns.some((c) => c.name === "listed"))
+        db.exec(`ALTER TABLE features ADD COLUMN listed INTEGER`);
+      if (!columns.some((c) => c.name === "folded"))
+        db.exec(`ALTER TABLE features ADD COLUMN folded TEXT`);
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS agent_prs (
+          url TEXT PRIMARY KEY,
+          session_id TEXT NOT NULL,
+          repo TEXT NOT NULL,
+          number INTEGER NOT NULL,
+          seen_at TEXT NOT NULL DEFAULT (datetime('now')),
+          told_at TEXT
+        );
+      `);
+    },
+  },
 ];
 
 // `upTo`: stop after this id (tests that start from an older database).

package/lib/db/queries.ts

@@ -56,15 +56,16 @@ export const queries = {
       `SELECT ${sessionListColumns(db)} FROM sessions ORDER BY updated_at DESC`
     ),
 
-  // The sidebar's sessions: not archived, and not a task that is over or
-  // lives on another machine.
+  // The sidebar's sessions: not archived, and not a dropped task (a
+  // rejection, not finished work) or one that lives on another machine.
+  // Merged tasks stay: they are the Done shelf.
   getSidebarSessions: (db: Database.Database) =>
     getStmt(
       db,
       `SELECT ${sessionListColumns(db)} FROM sessions
          WHERE archived_at IS NULL
            AND (task_status IS NULL
-                OR task_status NOT IN ('merged', 'dropped', 'moved'))
+                OR task_status NOT IN ('dropped', 'moved'))
          ORDER BY updated_at DESC`
     ),
 

package/lib/models/plan-step.ts

@@ -22,8 +22,14 @@ import { queueEvent } from "../orchestrator/events";
 import { noApprovalsOn, recordAutoApproval } from "../approvals/no-approvals";
 import { addNote } from "../orchestrator/notes";
 import { amendBrief, amendmentsOf } from "../orchestrator/amendments";
-import { PIECES_PROMPT, pieceBrief } from "../plans/pieces";
-import { createFeature, planFor, planPathOf, splitOf } from "../plans/features";
+import { PIECES_PROMPT, foldedBrief, pieceBrief } from "../plans/pieces";
+import {
+  createFeature,
+  ownPieceOf,
+  planFor,
+  planPathOf,
+  splitOf,
+} from "../plans/features";
 
 export const PLAN_FILE = ".agentos/plan.md";
 
@@ -52,10 +58,11 @@ export function implementPrompt(
   amendment?: string,
   piece?: string
 ): string {
+  const where = ` Work only in this task's repository; if part of the work belongs in another repository, say so in your final message instead of doing it there.`;
   const base = piece
-    ? `The plan is in \`${PLAN_FILE}\`. ${piece}\nFinish it as the task's instructions above say. Where the plan turns out wrong, do what's right and say so.`
+    ? `The plan is in \`${PLAN_FILE}\`. ${piece}\nFinish it as the task's instructions above say. Where the plan turns out wrong, do what's right and say so.${where}`
     : planned
-      ? `The plan is in \`${PLAN_FILE}\`. Implement it now, finishing the task as its instructions above say. Where the plan turns out wrong, do what's right and say so.`
+      ? `The plan is in \`${PLAN_FILE}\`. Implement it now, finishing the task as its instructions above say. Where the plan turns out wrong, do what's right and say so.${where}`
       : `No plan was written to \`${PLAN_FILE}\`. Plan briefly, then implement the task, finishing it as its instructions above say.`;
   return amendment
     ? `${base}\n\nThe plan was approved with this change, which is now part of the task's scope:\n${amendment}`
@@ -104,7 +111,7 @@ function piecesLine(r: NonNullable<ReturnType<typeof planFor>>): string {
       ? ` after ${p.afterPosition} is ${p.afterKind}`
       : "";
     const why = p.reasons.length ? ` (${p.reasons.join("+")})` : "";
-    return `${p.position} ${p.name}${after}${why}`;
+    return `${p.position} ${p.name} [${p.project.name}]${after}${why}`;
   });
   const folded = r.folded.length ? `, ${r.folded.length} folded` : "";
   return `${r.pieces.length} pieces${folded}: ${parts.join("; ")}`;
@@ -130,6 +137,8 @@ function announcePlan(s: Session, ref: string | null, retried = false): void {
     if (summary.length) head += `\n${summary.map((l) => `- ${l}`).join("\n")}`;
     const pieces = planFor(s, fs.readFileSync(file, "utf8"));
     if (pieces && pieces.pieces.length > 1) head += `\n${piecesLine(pieces)}`;
+    if (pieces?.folded.length)
+      head += `\nPlan listed ${pieces.listed} pieces, building ${pieces.pieces.length}: ${pieces.folded.map((f) => `${f.name} folded (${f.why})`).join("; ")}`;
   } catch {
     // No plan file: the line says so.
   }
@@ -143,6 +152,46 @@ function announcePlan(s: Session, ref: string | null, retried = false): void {
   queueEvent(workspaceId!, `plan-done:${s.id}`, s.id, head);
 }
 
+// Plans that build as other than one piece in this repository say so, once.
+function sayHowItSplit(
+  s: Session,
+  workspaceId: string,
+  split: NonNullable<ReturnType<typeof splitOf>>,
+  nothingOwn: boolean
+): void {
+  if (nothingOwn)
+    queueEvent(
+      workspaceId,
+      `plan-routed:${s.id}`,
+      s.id,
+      `Task "${s.name}" split its plan into ${split.pieces.length} ${split.pieces.length === 1 ? "piece" : "pieces"} and none is first in its own repository, so it builds nothing itself and ends; each piece starts as its own task: ${split.pieces.map((p) => `${p.position} ${p.name} [${p.project.name}]`).join("; ")}.`
+    );
+  else if (split.folded.length)
+    queueEvent(
+      workspaceId,
+      `plan-folded:${s.id}`,
+      s.id,
+      `Plan of "${s.name}" listed ${split.listed} pieces, building ${split.pieces.length}: ${split.folded.map((f) => `${f.name} folded into ${f.into} (${f.why})`).join("; ")}. The task was told to build the folded work too.`
+    );
+}
+
+// A planning task with no piece of its own is finished: its pieces are
+// started as tasks in their projects, now rather than on the next sweep.
+async function handOffToPieces(s: Session): Promise<void> {
+  try {
+    const { doneSession } = await import("../done");
+    await doneSession(s.id, { by: "direct", noMerge: true });
+  } catch (e) {
+    console.error(`Ending planning task ${s.id} failed:`, e);
+  }
+  try {
+    const { releasePieces } = await import("../plans/release");
+    await releasePieces();
+  } catch (e) {
+    console.error("Starting the pieces failed:", e);
+  }
+}
+
 function readPlan(s: Session): string | null {
   try {
     return fs.readFileSync(path.join(s.worktree_path!, PLAN_FILE), "utf8");
@@ -180,8 +229,14 @@ async function startImplementing(
   });
   const id = implementMessageId(sessionId);
   const planText = readPlan(s);
-  const split = planText ? splitOf(s, planText) : null;
+  let split = planText ? splitOf(s, planText) : null;
   const workspaceId = sessionWorkspace(s);
+  // Approved despite pieces that couldn't be registered: built as one piece,
+  // and told so, rather than guessing which repository each belongs to.
+  const unreadable = split?.errors.length ? split.errors : null;
+  if (unreadable) split = null;
+  let nothingOwn = false;
+  let featureId: string | null = null;
   const claimed = db.transaction(() => {
     const changed = db
       .prepare(
@@ -193,18 +248,38 @@ async function startImplementing(
     setSessionModel(sessionId, routed);
     let piece: string | undefined;
     let note = amendment;
+    if (unreadable)
+      note = [
+        amendment,
+        `The plan's pieces couldn't be registered (${unreadable.join("; ")}); build the whole plan as one piece in this repository.`,
+      ]
+        .filter(Boolean)
+        .join("\n");
     if (split?.notBuilding.length)
       note = [amendment, `Not building: ${split.notBuilding.join("; ")}`]
         .filter(Boolean)
         .join("\n");
-    if (split && split.pieces.length > 1 && planText && workspaceId) {
-      const feature = createFeature(s, planText, split.pieces, workspaceId);
-      piece = pieceBrief(
-        split.pieces.length,
-        split.pieces[0],
-        planPathOf(feature.id)
-      );
+    if (split?.feature && planText && workspaceId) {
+      const feature = createFeature(s, planText, split.pieces, workspaceId, {
+        listed: split.listed,
+        folded: split.folded,
+      });
+      featureId = feature.id;
+      const own = ownPieceOf(split.pieces, s.project_id);
+      if (!own) nothingOwn = true;
+      else if (split.pieces.length === 1 && split.folded.length)
+        piece = foldedBrief(split);
+      else
+        piece = pieceBrief(
+          split.pieces.length,
+          own,
+          planPathOf(feature.id),
+          [],
+          own.project.name
+        );
     }
+    // Every piece is another task's: nothing for this one to implement.
+    if (nothingOwn) return true;
     enqueue(sessionId, {
       id,
       text: implementPrompt(
@@ -224,6 +299,12 @@ async function startImplementing(
       console.error("plan-done event failed:", e);
     }
   }
+  if (split?.feature && featureId && workspaceId)
+    sayHowItSplit(s, workspaceId, split, nothingOwn);
+  if (nothingOwn) {
+    await handOffToPieces(s);
+    return routed.ref;
+  }
   await applySessionModel(sessionId, s.model_provider ?? ANTHROPIC, routed);
   await send(sessionId, id);
   return routed.ref;
@@ -342,9 +423,12 @@ export async function handoffAfterPlan(
   deleteQueued(sessionId, planRetryMessageId(sessionId));
   const retried = waiting.get(sessionId)?.retried ?? false;
   forget(sessionId);
-  // No approvals mode doesn't stop at the plan to wait for one.
+  // No approvals mode doesn't stop at the plan to wait for one. Pieces that
+  // couldn't be registered always do: building on a guess is the bug.
   const auto = !!s.plan_only && noApprovalsOn();
-  if (!s.plan_only || auto) {
+  const planText = readPlan(s);
+  const pieceErrors = (planText ? splitOf(s, planText)?.errors : null) ?? [];
+  if ((!s.plan_only || auto) && !pieceErrors.length) {
     const ref = await startImplementing(
       s,
       "planning",
@@ -374,6 +458,14 @@ export async function handoffAfterPlan(
   } catch (e) {
     console.error("plan-done event failed:", e);
   }
+  const workspaceId = sessionWorkspace(s);
+  if (pieceErrors.length && workspaceId)
+    queueEvent(
+      workspaceId,
+      `plan-pieces:${s.id}`,
+      s.id,
+      `Plan of "${s.name}": couldn't register its pieces: ${pieceErrors.join("; ")}. It is held, not building. Message the task to fix the plan, or approve_plan to build it as one piece.`
+    );
   try {
     const text = readPlan(s);
     const planned = text ? planFor(s, text) : null;

package/lib/orchestrator/conditions.ts

@@ -39,7 +39,9 @@ export interface StackFacts {
   }[];
 }
 
-export const IDLE_NO_PR_MS = 30 * 60 * 1000;
+// How long after a task's turn ended with no PR before it is news: longer
+// than the open-PR cache, so a PR it just opened is seen first.
+export const NO_PR_AFTER_TURN_MS = 2 * 60 * 1000;
 
 function hash(text: string): string {
   let h = 0;
@@ -133,17 +135,23 @@ function sessionConditions(
   const shouldPR = (!!f.task || !!f.branch) && !f.quick && !runForSession(f.id);
   const finished = !!f.task && isFinished(f.task.state);
   const idleFor = now - f.lastActive;
+  // A turn that ended with no PR and nothing blocked is stuck: it may
+  // have opened a PR somewhere AgentOS doesn't look, or be waiting on
+  // nothing. Keyed on when it last did anything, so it is one event per
+  // stall and anything it does after makes the next stall a new one.
   if (
     shouldPR &&
     !pr &&
     !finished &&
     !f.plan?.awaiting &&
     f.status !== "running" &&
-    idleFor >= IDLE_NO_PR_MS
+    blocked === null &&
+    idleFor >= NO_PR_AFTER_TURN_MS
   )
     add(
-      "idle",
-      `${who}: idle ${Math.floor(idleFor / 60000)}m, no PR`,
+      `no-pr:${f.lastActive}`,
+      `${who}: ended its turn ${Math.floor(idleFor / 60000)}m ago with no PR${f.activity ? ` (last: ${untrusted(f.name, f.activity)})` : ""}. If it opened a PR in another repository, or finished without one, nothing tracks it.`,
+      false,
       false,
       true
     );

package/lib/orchestrator/events.ts

@@ -182,6 +182,29 @@ export function queueEvent(
   ).run(workspaceId, `${ONCE}${key}`, subject, line, ARMED, iso(now));
 }
 
+// Like queueEvent, for a line a sweep would otherwise repeat: a key that
+// already exists, delivered or not, is left alone. Put the state in the key
+// so a change of state is a new line.
+export function queueEventOnce(
+  workspaceId: string,
+  key: string,
+  subject: string | null,
+  line: string,
+  now = Date.now()
+): boolean {
+  return (
+    db
+      .prepare(
+        `INSERT INTO orchestrator_events
+           (workspace_id, key, subject, line, sticky, low, hits, created_at, delivered_at)
+         VALUES (?, ?, ?, ?, 1, 0, ?, ?, NULL)
+         ON CONFLICT(workspace_id, key) DO NOTHING`
+      )
+      .run(workspaceId, `${ONCE}${key}`, subject, line, ARMED, iso(now))
+      .changes > 0
+  );
+}
+
 // A condition the orchestrator has been told about another way (a one-off
 // event said it), so a later diff doesn't send it again.
 export function markTold(

package/lib/orchestrator/reconcile.ts

@@ -0,0 +1,201 @@
+// A task's agent opened a PR in a repository that isn't its task's: nothing
+// polls that repository for the task's branch, so no task owns the PR and no
+// CI or review gate runs. The PRs agents open are read back from their
+// stored `gh pr create` calls, and one outside its task's repository is
+// raised to the orchestrator once.
+
+import { db, type Session } from "../db";
+import { getSetting, putSetting } from "../settings-store";
+import { sessionWorkspace } from "../models/resolve";
+import { run } from "../tasks/gh";
+import { expandHome } from "../tasks/session";
+import { workspaceProjects } from "./brief";
+import { queueEventOnce } from "./events";
+import { repoSlug } from "./repo-slug";
+
+const MARK = "reconcile.chat_items_rowid";
+// An item is stored when its tool call starts and updated when it ends, so a
+// call that finished after the mark moved past it is still inside the window.
+const OVERLAP = 2000;
+const BATCH = 500;
+const EVERY_MS = 2 * 60 * 1000;
+const PR_URL = /https:\/\/github\.com\/([\w.-]+)\/([\w.-]+)\/pull\/(\d+)/g;
+const CREATE = /\bgh\s+pr\s+create\b/;
+
+export interface ReconcileDeps {
+  slugOf: (dir: string) => Promise<string | null>;
+  // The PR's state and head branch, or null when it can't be read.
+  view: (url: string) => Promise<{ state: string; head: string } | null>;
+}
+
+export const realReconcileDeps: ReconcileDeps = {
+  slugOf: repoSlug,
+  view: async (url) => {
+    try {
+      const out = await run(
+        "gh",
+        ["pr", "view", url, "--json", "state,headRefName"],
+        process.cwd(),
+        15000
+      );
+      const pr = JSON.parse(out) as { state: string; headRefName: string };
+      return { state: pr.state, head: pr.headRefName };
+    } catch {
+      return null;
+    }
+  },
+};
+
+// Stores every PR URL an agent's `gh pr create` printed since last time.
+export function recordAgentPrs(): number {
+  const top =
+    (
+      db.prepare(`SELECT MAX(rowid) AS m FROM chat_items`).get() as {
+        m: number | null;
+      }
+    ).m ?? 0;
+  const mark = Number(getSetting(MARK) ?? top - OVERLAP);
+  const rows = db
+    .prepare(
+      `SELECT rowid AS rid, session_id, data FROM chat_items
+       WHERE rowid > ? AND data LIKE '%pr create%' AND data LIKE '%/pull/%'
+       ORDER BY rowid LIMIT ?`
+    )
+    .all(mark - OVERLAP, BATCH) as {
+    rid: number;
+    session_id: string;
+    data: string;
+  }[];
+  const insert = db.prepare(
+    `INSERT OR IGNORE INTO agent_prs (url, session_id, repo, number) VALUES (?, ?, ?, ?)`
+  );
+  let added = 0;
+  for (const row of rows) {
+    let item: { kind?: string; input?: unknown; output?: unknown };
+    try {
+      item = JSON.parse(row.data);
+    } catch {
+      continue;
+    }
+    if (
+      item.kind !== "tool" ||
+      typeof item.output !== "string" ||
+      !CREATE.test(JSON.stringify(item.input ?? ""))
+    )
+      continue;
+    for (const m of item.output.matchAll(PR_URL))
+      added += insert.run(
+        m[0],
+        row.session_id,
+        `${m[1]}/${m[2]}`.toLowerCase(),
+        Number(m[3])
+      ).changes;
+  }
+  putSetting(MARK, String(rows.length === BATCH ? rows[BATCH - 1].rid : top));
+  return added;
+}
+
+interface AgentPr {
+  url: string;
+  session_id: string;
+  repo: string;
+  number: number;
+}
+
+const told = (url: string) =>
+  db
+    .prepare(`UPDATE agent_prs SET told_at = datetime('now') WHERE url = ?`)
+    .run(url);
+
+async function ownedBy(
+  pr: AgentPr,
+  head: string,
+  deps: ReconcileDeps
+): Promise<boolean> {
+  const rows = db
+    .prepare(
+      `SELECT s.pr_url, s.branch_name, p.working_directory FROM sessions s
+       LEFT JOIN projects p ON p.id = s.project_id
+       WHERE s.task_status IS NOT NULL AND (LOWER(s.pr_url) = ? OR s.branch_name = ?)`
+    )
+    .all(pr.url.toLowerCase(), head) as {
+    pr_url: string | null;
+    branch_name: string | null;
+    working_directory: string | null;
+  }[];
+  for (const r of rows) {
+    if (r.pr_url?.toLowerCase() === pr.url.toLowerCase()) return true;
+    if (
+      r.working_directory &&
+      (await deps.slugOf(expandHome(r.working_directory))) === pr.repo
+    )
+      return true;
+  }
+  return false;
+}
+
+// Raises each unclaimed agent PR outside its task's repository, once.
+export async function classifyAgentPrs(
+  deps: ReconcileDeps = realReconcileDeps,
+  now = Date.now()
+): Promise<number> {
+  const open = db
+    .prepare(`SELECT * FROM agent_prs WHERE told_at IS NULL`)
+    .all() as AgentPr[];
+  let raised = 0;
+  for (const pr of open) {
+    const task = db
+      .prepare(`SELECT * FROM sessions WHERE id = ?`)
+      .get(pr.session_id) as Session | undefined;
+    const workspaceId = task ? sessionWorkspace(task) : null;
+    if (!task || !workspaceId) {
+      told(pr.url);
+      continue;
+    }
+    const projects = workspaceProjects(workspaceId);
+    const slugs = await Promise.all(
+      projects.map(async (p) => ({
+        name: p.name,
+        id: p.id,
+        slug: await deps.slugOf(expandHome(p.working_directory)),
+      }))
+    );
+    const own = slugs.find((p) => p.id === task.project_id);
+    // Its own repository is polled for its branch like any task's.
+    if (own?.slug === pr.repo) {
+      told(pr.url);
+      continue;
+    }
+    const view = await deps.view(pr.url);
+    // Unreadable now: look again next time.
+    if (!view) continue;
+    if (view.state !== "OPEN" || (await ownedBy(pr, view.head, deps))) {
+      told(pr.url);
+      continue;
+    }
+    const where = slugs.find((p) => p.slug === pr.repo);
+    queueEventOnce(
+      workspaceId,
+      `stray-pr:${pr.url}`,
+      task.id,
+      `Task "${task.name}" opened a PR outside its repo: ${pr.url} (${where ? `project ${where.name} of this workspace` : "not a repository of this workspace"}). No task owns it, so no CI or review gate runs on it: review and sign it off as an external PR, or drop it.`,
+      now
+    );
+    told(pr.url);
+    raised++;
+  }
+  return raised;
+}
+
+let last = 0;
+
+// From the settle loop; reads stored chat items, so a restart loses nothing.
+export async function reconcileSweep(
+  now = Date.now(),
+  deps: ReconcileDeps = realReconcileDeps
+): Promise<void> {
+  if (now - last < EVERY_MS) return;
+  last = now;
+  recordAgentPrs();
+  await classifyAgentPrs(deps, now);
+}

package/lib/plans/features.ts

@@ -12,6 +12,7 @@ import {
   checkPieces,
   parseEdits,
   type CheckContext,
+  type Folded,
   type PiecesResult,
   type Piece,
   type ProjectRef,
@@ -35,6 +36,9 @@ export interface Feature {
   cost_usd: number | null;
   duration_ms: number | null;
   created_at: string;
+  // Items the plan's Pieces block listed, and what the checker folded.
+  listed: number | null;
+  folded: string | null;
 }
 
 export interface FeaturePiece {
@@ -131,33 +135,82 @@ export function featureOfPlan(sessionId: string): Feature | undefined {
 export interface Split {
   pieces: Piece[];
   notBuilding: string[];
+  listed: number;
+  folded: Folded[];
+  // Why the plan's pieces can't be registered; when set, nothing is built
+  // on a guess.
+  errors: string[];
+  // Whether the plan needs a feature: false for one piece in the task's own
+  // repository that only has edits to carry.
+  feature: boolean;
 }
 
-// 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.
+// The pieces to build for a plan, or null when it is one piece in the task's
+// own repository, as almost every plan is. A plan that lists more than it
+// builds, or whose one piece belongs to another project, is not null: it
+// gets a feature so nothing it listed goes missing. 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;
+  if (!result) return null;
   const { pieces, notBuilding } = applyEdits(result, parseEdits(s.plan_edits));
-  return { pieces, notBuilding };
+  const elsewhere = pieces.some((p) => p.project.id !== s.project_id);
+  const feature = pieces.length > 1 || elsewhere || result.folded.length > 0;
+  if (!feature && !notBuilding.length && !result.errors.length) return null;
+  return {
+    pieces,
+    notBuilding,
+    listed: result.listed,
+    folded: result.folded,
+    errors: result.errors,
+    feature,
+  };
+}
+
+// The piece the planning task builds itself: the first one in its own
+// repository that doesn't wait on another. Every other piece starts as its own
+// task in its own project.
+export function ownPieceOf(
+  pieces: Piece[],
+  ownProjectId: string | null
+): Piece | undefined {
+  return pieces.find(
+    (p) => p.project.id === ownProjectId && p.afterPosition === null
+  );
 }
 
 // One transaction: the feature, its pieces, and the plan kept past the
-// worktree. Piece 1 is the planning task's own.
+// worktree. The planning task's own piece (if it has one) is already
+// building; the rest wait to start as tasks of their own.
 export function createFeature(
   s: Session,
   text: string,
   pieces: Piece[],
-  workspaceId: string
+  workspaceId: string,
+  meta: { listed: number; folded: Folded[] } = {
+    listed: pieces.length,
+    folded: [],
+  }
 ): Feature {
+  const own = ownPieceOf(pieces, s.project_id)?.position;
   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);
+      `INSERT INTO features (id, workspace_id, name, plan_session_id, plan_text, status, listed, folded)
+       VALUES (?, ?, ?, ?, ?, 'building', ?, ?)`
+    ).run(
+      id,
+      workspaceId,
+      s.name,
+      s.id,
+      text,
+      meta.listed,
+      meta.folded.length
+        ? meta.folded.map((f) => `${f.name}: ${f.why}`).join("\n")
+        : null
+    );
     const insert = db.prepare(
       `INSERT INTO feature_pieces
          (feature_id, position, name, slice, project_id, after_position, after_kind,
@@ -175,8 +228,8 @@ export function createFeature(
         p.afterKind,
         p.reasons.join("+") || null,
         p.owns.join(", ") || null,
-        p.position === 1 ? "building" : "waiting",
-        p.position === 1 ? s.id : null
+        p.position === own ? "building" : "waiting",
+        p.position === own ? s.id : null
       );
   })();
   return getFeature(id)!;
@@ -195,6 +248,9 @@ export function reviewGoal(sessionId: string): string | null {
   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)}`;
+  const folded = feature.folded
+    ? ` Pieces the plan listed that were built into others: ${feature.folded}.`
+    : "";
+  if (!last || (live.length < 2 && !feature.folded)) return head;
+  return `${head}\n\nThis is the last piece.${folded} 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)}`;
 }

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/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.558",
+  "version": "0.3.560",
   "description": "Self-hosted web UI for managing Claude Code sessions",
   "bin": {
     "agent-os": "scripts/agent-os"