@saadnvd1/agent-os 0.3.557 → 0.3.560

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/quick.ts

@@ -53,6 +53,15 @@ export async function quickChange(
   projectRef: string,
   name: string
 ): Promise<string> {
+  return (await startQuickChange(workspaceId, projectRef, name)).text;
+}
+
+// The same, for a caller that needs the new session's id and worktree.
+export async function startQuickChange(
+  workspaceId: string,
+  projectRef: string,
+  name: string
+): Promise<{ id: string; worktreePath: string; text: string }> {
   const owner = ownerOf(workspaceId);
   const project = workspaceProject(workspaceId, projectRef);
   if (isRemoteHost(project.host_id))
@@ -107,7 +116,11 @@ export async function quickChange(
     workspaceId,
     `Quick change "${label}" in ${project.name} on ${wt.branchName}.`
   );
-  return `Quick change "${label}" (id ${id.slice(0, 8)}) in ${project.name}: worktree ${wt.worktreePath} on ${wt.branchName}, cut from ${baseBranch}. Edit files there with Write and Edit; git there only as \`git -C ${wt.worktreePath} <status|diff|add|...>\`. Then quick_pr commits, pushes and opens its PR.`;
+  return {
+    id,
+    worktreePath: wt.worktreePath,
+    text: `Quick change "${label}" (id ${id.slice(0, 8)}) in ${project.name}: worktree ${wt.worktreePath} on ${wt.branchName}, cut from ${baseBranch}. Edit files there with Write and Edit; git there only as \`git -C ${wt.worktreePath} <status|diff|add|...>\`. Then quick_pr commits, pushes and opens its PR.`,
+  };
 }
 
 // A quick change of this workspace's orchestrator, by name, id or PR.

package/lib/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)}`;
 }