@saadnvd1/agent-os 0.3.485 → 0.3.487

package/README.md

@@ -464,7 +464,9 @@ default; set it in **Settings → Workspaces**, or `PATCH /api/workspaces/<id>`
 worktree or agent yet, and starts by itself in line order when one finishes
 (merged, dropped or done). `aos task --after <task|any>` (and the
 orchestrator's `start_task` with `after`) holds a task until a named task
-finishes, or until any task running now does. Pause stops automatic starts,
+finishes, or until any task still working now does (a running task whose PR
+was closed or merged doesn't count; with none, it starts at once). The
+orchestrator's `drop` removes a queued task by its id. Pause stops automatic starts,
 and the orchestrator's brakes still apply when its queued tasks start. The
 line is kept in the database across restarts (`GET /api/tasks/queue`; start
 now, move up or down, or remove with `/api/tasks/queue/<id>`). The sidebar
@@ -494,8 +496,13 @@ The most specific setting wins: a task's own model, then its workspace's
 `AGENTOS_REVIEW_MODEL` (gate review and scope check) and
 `AGENTOS_TITLE_MODEL` (helpers) in the server's environment still replace a
 role's default where Settings names none. A
-Claude session started without a model (the orchestrator's `start_session`,
-the API) runs on the interactive role's; one you pick a model for keeps it.
+Claude session you start without a model runs on the interactive role's. One
+an orchestrator starts (its `start_session`, or `aos spawn` run from an
+orchestrator) is recorded as started by it (`started_by`) and runs on the
+implementation role instead, so delegated work doesn't use Opus by default;
+`start_session` takes a `model` (`"provider/model"`, checked like a task's:
+gate roles can't be set, other providers must be enabled). One you pick a
+model for keeps it.
 
 **Plan, then implement.** A chat task whose planning and implementation
 models differ starts with a plan step: its first turn runs on the planning
@@ -503,7 +510,13 @@ model and writes the plan to `.agentos/plan.md` in its worktree (ignored by
 git), changing nothing else. When that turn ends, the same conversation
 switches to the implementation model (a live model switch, or a resume with
 `--model` when the provider changes) and is told to follow the plan. Turn it
-off in Settings, or per task with `plan: false`. Terminal tasks skip it.
+off in Settings, or per task with `plan: false`. Terminal tasks skip it. An
+orchestrator decides it for every task: `start_task` requires `plan` and a
+short `plan_reason`, stored on the task and shown on its card ("Planned:
+touches 6 files across gates and UI" / "No plan: one-line default change"),
+and **Usage → Compare** splits cost into planned and not. When the plan step
+finishes, the orchestrator gets one event with the plan file's path and a
+3-5 line summary; the handoff to implementation stays automatic.
 
 **Per task.** The task draft has a **Model** chip ("Routed by role", or one
 model); `POST /api/tasks` and the orchestrator's `start_task` take `model`, as
@@ -1044,6 +1057,11 @@ it may do on its own, and the lines that always come back to you as asks.
   approve, answer an ask or pass a gate. The route
   they call answers only the orchestrator's worker, by a per-orchestrator
   secret. Its shell runs only `aos` commands that read.
+- **Triage:** its brief has it decide each job: small and clear is a task with
+  `plan: false` and the steps written into the brief; big, unclear or
+  cross-cutting is `plan: true`; work outside a repository is a
+  `start_session` (Sonnet) with the steps in the prompt. It puts
+  implementation on Opus only when the work needs deep reasoning, and says why.
 - **Files:** it reads anywhere and writes (Write, Edit, NotebookEdit) anywhere
   except a project repository, a task worktree (`~/.agent-os/worktrees`),
   AgentOS's own install and state (all of `~/.agent-os` but its own folder),
@@ -1113,7 +1131,11 @@ it may do on its own, and the lines that always come back to you as asks.
   nothing uncommitted, AgentOS rebases it in the task's worktree and pushes
   only its branch with `--force-with-lease`, and the orchestrator's review
   carries over when the PR's own patch is
-  unchanged (same `git patch-id`; a fresh review starts otherwise). Not
+  unchanged (same `git patch-id`; a fresh review starts otherwise). Your
+  merge approval carries over a rebase the same way (any rebase, the task's
+  own included): when the PR's patch is unchanged it follows the new head,
+  else you're asked again, naming the new head and what changed, and an open
+  merge ask follows its PR's head. Not
   clean: the task is asked once to rebase. Either way, one event. Main and
   other tasks' branches are never written.
 - **Tasks woken on CI failures and reviews:** a check failing on a task's

package/app/api/bus/spawn/route.ts

@@ -4,6 +4,17 @@ import { createTask } from "@/lib/tasks";
 import { startOrQueue } from "@/lib/tasks/queue";
 import { hostIdNamed } from "@/lib/hosts";
 import { startView } from "@/lib/sessions/launch";
+import { db } from "@/lib/db";
+
+// The calling session, when it's an orchestrator: what it starts runs on the
+// implementation model. A made-up `from` can only pick that cheaper role.
+function orchestratorFrom(from: unknown): string | null {
+  if (typeof from !== "string" || !from) return null;
+  const row = db
+    .prepare(`SELECT 1 FROM sessions WHERE id = ? AND role = 'orchestrator'`)
+    .get(from);
+  return row ? from : null;
+}
 
 // mode "session" starts an interactive agent; "task" starts one that ends in
 // a PR, or queues it (over the workspace's limit, or with `after`).
@@ -18,7 +29,9 @@ export async function POST(request: NextRequest) {
       on,
       after,
       view,
+      from,
     } = await request.json();
+    const startedBy = orchestratorFrom(from);
     const given = typeof name === "string" ? name : undefined;
     if (after !== undefined && mode !== "task")
       throw new Error("--after works for tasks only");
@@ -30,6 +43,7 @@ export async function POST(request: NextRequest) {
         model,
         hostId: on ? hostIdNamed(String(on)) : undefined,
         view: startView(view),
+        startedBy,
       };
       const out = await startOrQueue(
         { ...task, after: typeof after === "string" ? after : undefined },
@@ -44,6 +58,7 @@ export async function POST(request: NextRequest) {
       prompt,
       name: given,
       model,
+      startedBy,
     });
     return NextResponse.json({ session }, { status: 201 });
   } catch (error) {

package/app/api/tasks/route.ts

@@ -35,6 +35,7 @@ export async function POST(request: NextRequest) {
       after,
       view,
       plan,
+      plan_reason,
     } = await request.json();
     if (id !== undefined && !isSessionId(id)) throw new Error("Bad task id");
     const pid =
@@ -47,6 +48,10 @@ export async function POST(request: NextRequest) {
       // Checked now, so a queued task can't fail on it later.
       model: parseOverride(model) ?? undefined,
       plan: typeof plan === "boolean" ? plan : undefined,
+      planReason:
+        typeof plan_reason === "string" && plan_reason.trim()
+          ? plan_reason.trim().slice(0, 200)
+          : undefined,
       name: typeof name === "string" ? name : undefined,
       hostId: typeof hostId === "string" && hostId ? hostId : undefined,
       baseBranch: typeof baseBranch === "string" ? baseBranch : undefined,

package/components/Tasks/TaskRow.tsx

@@ -47,6 +47,12 @@ export function TaskRow({ task }: { task: TaskView }) {
             {task.model &&
               ` · ${task.model}${task.planning ? " (planning)" : ""}`}
           </p>
+          {task.plan && (
+            <p className="text-muted-foreground truncate text-[11px]">
+              {task.plan.planned ? "Planned" : "No plan"}
+              {task.plan.reason && `: ${task.plan.reason}`}
+            </p>
+          )}
           {task.cardUrl && (
             <a
               href={task.cardUrl}

package/components/Usage/CompareView.tsx

@@ -197,14 +197,26 @@ function CompareTables({ data }: { data: Comparison }) {
         }))}
         total={sumSpend(data.roles)}
       />
+      {data.plans.length > 0 && (
+        <SpendTable
+          title="Planned · not planned"
+          rows={data.plans.map((r) => ({
+            ...r.spend,
+            key: r.key,
+            label: `${{ planned: "Planned", unplanned: "No plan", unstated: "Not stated" }[r.key]} · ${r.tasks} ${r.tasks === 1 ? "task" : "tasks"}`,
+          }))}
+          total={sumSpend(data.plans.map((r) => r.spend))}
+        />
+      )}
       <p className="text-muted-foreground text-[11px]">
         A task counts under the provider its own turns ran on (anthropic is the
         baseline); its reviews and checks count toward its cost. Dollars are
         list-price estimates; for Claude, the plan&apos;s real measure is its
         5-hour window, shared out by how far each turn moved it (an estimate).
-        Outcomes come from the orchestrator&apos;s checks, so only its tasks
-        have them. Under 10 tasks a column is a small sample: read it as a hint,
-        not a result.
+        Planned or not is the orchestrator&apos;s own call, recorded when it
+        started the task. Outcomes come from the orchestrator&apos;s checks, so
+        only its tasks have them. Under 10 tasks a column is a small sample:
+        read it as a hint, not a result.
       </p>
     </>
   );

package/lib/agents/spawn.ts

@@ -3,6 +3,8 @@ import os from "os";
 import { db, queries, type Session } from "../db";
 import { getProject, getAllProjects } from "../projects";
 import { resolveModelForAgent } from "../model-catalog";
+import { parseOverride, resolveRole, setSessionModel } from "../models/resolve";
+import { ANTHROPIC } from "../models/roles";
 import { launchClaude } from "./launch";
 import { nameFor } from "../session-titles";
 
@@ -29,7 +31,10 @@ export async function spawnSession(opts: {
   prompt: string;
   // Its name; generated from the prompt when absent.
   name?: string;
-  model?: string;
+  model?: string | null;
+  // The orchestrator session that starts it: the implementation role's
+  // model unless `model` is given.
+  startedBy?: string | null;
 }): Promise<Session> {
   const prompt = opts.prompt.trim();
   if (!prompt) throw new Error("Give the new session a prompt");
@@ -41,10 +46,17 @@ export async function spawnSession(opts: {
 
   const id = randomUUID();
   const tmuxName = `claude-${id}`;
-  const model = resolveModelForAgent(
-    "claude",
-    opts.model || project.default_model
-  );
+  const routed = opts.startedBy
+    ? resolveRole("implement", {
+        workspaceId: project.workspace_id,
+        override: parseOverride(opts.model),
+      })
+    : null;
+  if (routed && routed.provider.id !== ANTHROPIC)
+    throw new Error("Another provider's models run only as a chat");
+  const model = routed
+    ? routed.model
+    : resolveModelForAgent("claude", opts.model || project.default_model);
   const cwd = project.working_directory.replace(/^~/, os.homedir());
   const naming = await nameFor(prompt, cwd, opts.name);
 
@@ -64,10 +76,10 @@ export async function spawnSession(opts: {
       project.id,
       "local"
     );
-  db.prepare(`UPDATE sessions SET name_source = ? WHERE id = ?`).run(
-    naming.source,
-    id
-  );
+  db.prepare(
+    `UPDATE sessions SET name_source = ?, started_by = ? WHERE id = ?`
+  ).run(naming.source, opts.startedBy ?? null, id);
+  if (routed) setSessionModel(id, routed);
   void naming.refine?.(id);
   await launchClaude({ sessionId: id, tmuxName, cwd, model, prompt });
   return queries.getSession(db).get(id) as Session;

package/lib/db/migrations.ts

@@ -1472,6 +1472,27 @@ const migrations: Migration[] = [
         db.exec(`ALTER TABLE chat_compactions ADD COLUMN phase TEXT`);
     },
   },
+  {
+    id: 65,
+    name: "orchestrator_triage",
+    up: (db) => {
+      // started_by: the orchestrator session that started this one (null: a
+      // person). plan_decided: 1 planned, 0 no plan, null not stated.
+      const add = (table: string, col: string, type: string) => {
+        const columns = db.prepare(`PRAGMA table_info(${table})`).all() as {
+          name: string;
+        }[];
+        if (!columns.some((c) => c.name === col))
+          db.exec(`ALTER TABLE ${table} ADD COLUMN ${col} ${type}`);
+      };
+      add("sessions", "started_by", "TEXT");
+      add("sessions", "plan_decided", "INTEGER");
+      add("sessions", "plan_reason", "TEXT");
+      add("task_queue", "plan", "INTEGER");
+      add("task_queue", "plan_reason", "TEXT");
+      add("task_queue", "started_by", "TEXT");
+    },
+  },
 ];
 
 // `upTo`: stop after this id (tests that start from an older database).

package/lib/db/types.ts

@@ -20,6 +20,11 @@ export interface Session {
   model_overrides?: string | null;
   // A task's plan step: planning on the planning model, then implementing.
   plan_phase?: "planning" | "implementing" | null;
+  // The orchestrator session that started this one; null for a person.
+  started_by?: string | null;
+  // 1 planned, 0 no plan, null not stated; why, in the starter's words.
+  plan_decided?: number | null;
+  plan_reason?: string | null;
   system_prompt: string | null;
   group_path: string; // Deprecated - use project_id
   project_id: string | null;

package/lib/models/plan-step.ts

@@ -18,6 +18,7 @@ import {
   taskOverride,
 } from "./resolve";
 import { ANTHROPIC } from "./roles";
+import { queueEvent } from "../orchestrator/events";
 
 export const PLAN_FILE = ".agentos/plan.md";
 
@@ -41,6 +42,52 @@ export function preparePlanDir(worktree: string): void {
   fs.writeFileSync(path.join(dir, ".gitignore"), "*\n");
 }
 
+const SUMMARY_LINE = 120;
+
+// The plan's first few headings and bullets, trimmed: what the orchestrator
+// needs to know what was decided, with no model call.
+export function planSummary(text: string, max = 5): string[] {
+  const clean = (l: string) =>
+    l
+      .replace(/^\s*(?:#+|[-*+]|\d+[.)])\s+/, "")
+      .replace(/[*`_]/g, "")
+      .trim();
+  const trim = (l: string) =>
+    l.length > SUMMARY_LINE ? `${l.slice(0, SUMMARY_LINE - 1)}…` : l;
+  const lines: { text: string; key: boolean }[] = [];
+  let fenced = false;
+  for (const raw of text.split("\n")) {
+    if (/^\s*```/.test(raw)) {
+      fenced = !fenced;
+      continue;
+    }
+    if (fenced || !raw.trim() || /^\s*(?:---+|\|)/.test(raw)) continue;
+    const t = clean(raw);
+    if (t)
+      lines.push({ text: t, key: /^\s*(?:#+|[-*+]|\d+[.)])\s+/.test(raw) });
+  }
+  const keyed = lines.filter((l) => l.key);
+  const picked = (keyed.length >= 3 ? keyed : lines).slice(0, max);
+  return picked.map((l) => trim(l.text));
+}
+
+// Tells the orchestrator that started a task its plan is written, once.
+function announcePlan(s: Session, ref: string): void {
+  if (!s.started_by) return;
+  const workspaceId = sessionWorkspace(s);
+  if (!workspaceId || !s.worktree_path) return;
+  const file = path.join(s.worktree_path, PLAN_FILE);
+  let head = `Task "${s.name}": no plan file was written; implementing on ${ref} anyway.`;
+  try {
+    const summary = planSummary(fs.readFileSync(file, "utf8"));
+    head = `Task "${s.name}": plan written to ${file}; implementing on ${ref}.`;
+    if (summary.length) head += `\n${summary.map((l) => `- ${l}`).join("\n")}`;
+  } catch {
+    // No plan file: the line says so.
+  }
+  queueEvent(workspaceId, `plan-done:${s.id}`, s.id, head);
+}
+
 export const implementMessageId = (sessionId: string) =>
   `implement-${sessionId}`;
 
@@ -88,6 +135,11 @@ export async function handoffAfterPlan(
     return true;
   })();
   if (!claimed) return false;
+  try {
+    announcePlan(s, routed.ref);
+  } catch (e) {
+    console.error("plan-done event failed:", e);
+  }
   await applySessionModel(sessionId, s.model_provider ?? ANTHROPIC, routed);
   await send(sessionId, id);
   return true;

package/lib/models/roles.ts

@@ -91,8 +91,11 @@ export function sessionRole(session: {
   role?: string | null;
   task_status?: string | null;
   plan_phase?: string | null;
+  started_by?: string | null;
 }): ModelRole {
   if (session.role === "orchestrator") return "orchestrator";
-  if (!session.task_status) return "interactive";
+  // Work an orchestrator started is implementation, not a person's session.
+  if (!session.task_status)
+    return session.started_by ? "implement" : "interactive";
   return session.plan_phase === "planning" ? "plan" : "implement";
 }

package/lib/orchestrator/act.ts

@@ -4,7 +4,11 @@
  * the brakes.
  */
 
-import { parseOverride, type ModelOverride } from "../models/resolve";
+import {
+  parseOverride,
+  sessionModelRef,
+  type ModelOverride,
+} from "../models/resolve";
 import { sendMessage } from "../bus";
 import { chatState } from "../chat/runner";
 import { stopSession } from "../sessions/stop";
@@ -16,7 +20,12 @@ import {
   type StartView,
 } from "../sessions/launch";
 import { createTask, dropTask } from "../tasks";
-import { startOrQueue } from "../tasks/queue";
+import {
+  findQueued,
+  queuedLabel,
+  removeQueued,
+  startOrQueue,
+} from "../tasks/queue";
 import { getStack, previewStack, startStack } from "../stacks";
 import { treeOrder } from "../stacks/tree";
 import type { StackItemView } from "../stacks/types";
@@ -88,10 +97,12 @@ export async function startTask(
     after?: string;
     model?: ModelOverride;
     plan?: boolean;
+    planReason?: string;
   } = {}
 ): Promise<string> {
   const project = workspaceProject(workspaceId, projectRef);
   const model = parseOverride(opts.model) ?? undefined;
+  const startedBy = orchestratorId(workspaceId);
   // Its brakes read this machine's usage, not the other machine's account.
   if (isRemoteHost(project.host_id))
     throw new Error(
@@ -107,6 +118,9 @@ export async function startTask(
       name: opts.name,
       view,
       model,
+      plan: opts.plan,
+      planReason: opts.planReason,
+      startedBy,
       baseBranch: opts.base || undefined,
       after: opts.after,
       originWorkspaceId: workspaceId,
@@ -124,6 +138,8 @@ export async function startTask(
             view,
             model,
             plan: opts.plan,
+            planReason: opts.planReason,
+            startedBy,
           }),
         (s) => s.id
       )
@@ -133,16 +149,24 @@ export async function startTask(
     return `Queued (position ${queued.position}) task "${queued.name}" (id ${queued.id.slice(0, 8)}) in ${project.name}${queued.after ? `, after ${queued.after}` : ""}. It starts by itself; you'll get an event when it does.`;
   }
   const task = out.started;
-  return `Started task "${task.name}" (id ${task.id.slice(0, 8)}, ${view}) in ${project.name} on ${task.branch_name} (from ${task.base_branch}). It ends in a PR; you'll get an event when it opens.`;
+  const skipped =
+    opts.plan && task.plan_phase !== "planning"
+      ? ` Plan step skipped: ${view === "terminal" ? "a terminal task has none" : "planning and implementation use the same model"}.`
+      : "";
+  return `Started task "${task.name}" (id ${task.id.slice(0, 8)}, ${view}) in ${project.name} on ${task.branch_name} (from ${task.base_branch}). It ends in a PR; you'll get an event when it opens.${skipped}`;
 }
 
 export async function startSession(
   workspaceId: string,
   projectRef: string,
   prompt: string,
-  opts: { name?: string; view?: StartView } = {}
+  opts: { name?: string; view?: StartView; model?: string } = {}
 ): Promise<string> {
   const project = workspaceProject(workspaceId, projectRef);
+  const startedBy = orchestratorId(workspaceId);
+  const model = parseOverride(opts.model);
+  if (model && typeof model !== "string")
+    throw new Error(`model: a session takes one "provider/model"`);
   const view = opts.view ?? DEFAULT_START_VIEW;
   if (view === "chat" && isRemoteHost(project.host_id))
     throw new Error("Spawning on other machines isn't supported yet");
@@ -159,12 +183,20 @@ export async function startSession(
               name: opts.name,
               view,
               access: "full",
+              model,
+              startedBy,
             })
           ).session
-        : spawnSession({ project: project.id, prompt, name: opts.name }),
+        : spawnSession({
+            project: project.id,
+            prompt,
+            name: opts.name,
+            model,
+            startedBy,
+          }),
     (s) => s.id
   );
-  return `Started session "${session.name}" (id ${session.id.slice(0, 8)}, ${session.view}) in ${project.name}.`;
+  return `Started session "${session.name}" (id ${session.id.slice(0, 8)}, ${session.view}) in ${project.name} on ${sessionModelRef(session)}.`;
 }
 
 function itemLine(i: StackItemView): string {
@@ -208,7 +240,27 @@ export async function drop(
   reason: string
 ): Promise<string> {
   if (!reason.trim()) throw new Error("Say why it's dropped");
-  const task = workspaceTask(workspaceId, ref);
+  // A task still in the queue has no session yet: its id removes it.
+  const removeQueuedTask = (
+    queued: NonNullable<ReturnType<typeof findQueued>>
+  ) => {
+    removeQueued(queued.id);
+    addNote(
+      workspaceId,
+      `Removed queued task ${queuedLabel(queued)} before it started: ${reason.trim()}`
+    );
+    return `Removed queued task "${queuedLabel(queued)}" (id ${queued.id.slice(0, 8)}) from the queue; it never started.`;
+  };
+  const byId = findQueued(workspaceId, ref);
+  if (byId) return removeQueuedTask(byId);
+  let task;
+  try {
+    task = workspaceTask(workspaceId, ref);
+  } catch (error) {
+    const byName = findQueued(workspaceId, ref, { byName: true });
+    if (byName) return removeQueuedTask(byName);
+    throw error;
+  }
   await dropTask(task.id);
   addNote(workspaceId, `Dropped task ${task.name}: ${reason.trim()}`);
   return `Dropped ${task.name}: its PR is closed and its worktree removed.`;

package/lib/orchestrator/approval-carry.ts

@@ -0,0 +1,48 @@
+// Saad's merge approval across a rebase. He approved a commit; the task
+// rebased onto the base (only to renumber a migration, say) and its head
+// moved. The approval was for the PR's patch, so it follows the head when
+// that patch is unchanged (the check the review's carry-over uses, patch.ts),
+// and otherwise is asked again, with a note on what changed.
+
+import type { AskRow } from "./asks";
+import { getAsk } from "./asks";
+import { rebindApproval } from "./ask-approvals";
+import { addNote } from "./notes";
+import { comparePatches } from "./patch";
+import { fetchRefs } from "./repo";
+import type { Session } from "../db";
+
+const short = (sha: string) => sha.slice(0, 7);
+
+export async function carryApproval(
+  workspaceId: string,
+  work: {
+    name: string;
+    repo: string;
+    refs: Pick<Session, "base_branch" | "branch_name">;
+  },
+  approval: AskRow & { sha: string },
+  head: string
+): Promise<{ approval: AskRow | null; note: string }> {
+  let base: string;
+  try {
+    base = await fetchRefs(work.repo, work.refs);
+  } catch {
+    return { approval: null, note: "its base couldn't be fetched to compare" };
+  }
+  const { same, note } = await comparePatches(
+    work.repo,
+    base,
+    approval.sha,
+    head
+  );
+  if (!same) return { approval: null, note };
+  const line = `Carried to ${short(head)}: same patch as ${short(approval.sha)} (rebased onto ${base}).`;
+  if (rebindApproval(approval.id, approval.sha, head, line))
+    addNote(
+      workspaceId,
+      `Saad's approval of ${work.name} at ${short(approval.sha)} carries to ${short(head)}: same patch, rebased onto ${base}.`
+    );
+  const now = getAsk(workspaceId, approval.id);
+  return { approval: now?.sha === head && !now.used_at ? now : null, note };
+}

package/lib/orchestrator/ask-approvals.ts

@@ -1,7 +1,7 @@
 // Spending Saad's approvals: each covers one item, once.
 
 import { db } from "../db";
-import type { AskRow } from "./asks";
+import { MAX_DETAIL, type AskRow } from "./asks";
 
 // An approval on the subject not spent yet, newer than maxAgeMs if given.
 export function unspentApproval(
@@ -104,3 +104,22 @@ export function voidApprovalsOn(subject: string): number {
     )
     .run(subject).changes;
 }
+
+// Moves an approval Saad gave to the commit it was rebased into, when the
+// patch is the same: it stays one approval, spent once. Compare-and-swap on
+// the old commit, so two judgements racing move it once.
+export function rebindApproval(
+  id: number,
+  from: string,
+  to: string,
+  line: string
+): boolean {
+  return (
+    db
+      .prepare(
+        `UPDATE orchestrator_asks SET sha = ?, detail = substr(detail || char(10) || ?, 1, ?)
+         WHERE id = ? AND sha = ? AND status = 'approved' AND used_at IS NULL`
+      )
+      .run(to, line, MAX_DETAIL, id, from).changes === 1
+  );
+}

package/lib/orchestrator/ask-heads.ts

@@ -0,0 +1,47 @@
+// An open merge ask follows its PR's head. A task that rebases or pushes
+// while the ask waits would otherwise show Saad a commit that's already
+// gone; the ask is moved to the head it would merge, with a line on whether
+// the PR's patch changed. The approve button is bound to the commit shown,
+// so an answer from a screen that predates the move is refused (asks.ts).
+
+import { db, type Session } from "../db";
+import { hostLink } from "../hosts/remote-api";
+import { moveAskHead, openAsks, taskSubject } from "./asks";
+import type { SessionFacts } from "./facts";
+import { addNote } from "./notes";
+import { comparePatches } from "./patch";
+import { fetchRefs, repoOf } from "./repo";
+
+const short = (sha: string) => sha.slice(0, 7);
+
+// Tasks only: a PR no task owns has no facts here.
+export async function followAskHeads(
+  workspaceId: string,
+  facts: SessionFacts[]
+): Promise<void> {
+  for (const ask of openAsks(workspaceId)) {
+    const f = facts.find((x) => taskSubject(x.id) === ask.subject);
+    const pr = f?.task?.pr;
+    if (!ask.sha || pr?.state !== "OPEN" || !pr.head || pr.head === ask.sha)
+      continue;
+    const task = db
+      .prepare(`SELECT * FROM sessions WHERE id = ?`)
+      .get(f!.id) as Session | undefined;
+    if (!task || hostLink(task.host_id)) continue;
+    try {
+      const repo = repoOf(task);
+      const base = await fetchRefs(repo, task);
+      const { same, note } = await comparePatches(repo, base, ask.sha, pr.head);
+      const what = same ? `same patch (rebased onto ${base})` : note;
+      const line = `Head moved from ${short(ask.sha)} to ${short(pr.head)}: ${what}. Approving merges ${short(pr.head)}.`;
+      if (moveAskHead(ask.id, ask.sha, pr.head, line))
+        addNote(
+          workspaceId,
+          `Saad's ask on ${task.name} now names ${short(pr.head)} (${same ? "same patch" : "patch changed"}).`,
+          "ask"
+        );
+    } catch (error) {
+      console.error(`Following ${task.name}'s head in its ask:`, error);
+    }
+  }
+}

package/lib/orchestrator/asks.ts

@@ -330,3 +330,29 @@ export function resolveAsks(
     )
     .run(why, workspaceId, subject).changes;
 }
+
+// An open ask about a commit that has since been replaced (a rebase, a push)
+// now names the head, with a line saying what happened to it. Only while it
+// still names `from`, so a re-raise in between isn't overwritten.
+export function moveAskHead(
+  id: number,
+  from: string,
+  to: string,
+  line: string
+): boolean {
+  const ask = db
+    .prepare(`SELECT detail FROM orchestrator_asks WHERE id = ?`)
+    .get(id) as { detail: string } | undefined;
+  if (!ask) return false;
+  const rest = ask.detail.split(/\n?Head moved from /)[0];
+  const room = Math.max(0, MAX_DETAIL - line.length - 1);
+  const detail = `${rest.slice(0, room)}\n${line}`.trim();
+  return (
+    db
+      .prepare(
+        `UPDATE orchestrator_asks SET sha = ?, detail = ?
+         WHERE id = ? AND status = 'open' AND sha = ?`
+      )
+      .run(to, detail, id, from).changes === 1
+  );
+}