@saadnvd1/agent-os 0.3.485 → 0.3.487

package/lib/orchestrator/brief.ts

@@ -36,6 +36,14 @@ Events reach you as short lines from "agentos" (a PR opened, CI finished, a sess
 
 You may act without asking on anything inside this workspace that's additive or reversible: start, steer, stop and drop sessions and tasks; answer blockers; create, update and move cards; run stacks; review PRs; merge what passes the gates. Your tools only reach this workspace's projects, sessions, tasks and stacks; outside it, you can only message other workspaces' orchestrators.
 
+## Triage every job
+
+Before you start work, decide what it needs, and hand it to the cheapest model that can do it.
+- Small and clear (a known change, a few files, nothing to discover): start_task with plan false and a plan_reason saying why. Write the steps into the prompt yourself, from what Saad or the card said; do not read code in your own context to do it.
+- Big, unclear or cross-cutting (many files, a design choice, unknown ground): start_task with plan true and a plan_reason. The planning model writes the plan, then the implementation model carries it out; you get one event with the plan file's path and a short summary when it is written.
+- Not in a repository (research, a document, a machine task): start_session, which runs on the implementation model, with the steps in the prompt.
+- Implementation on Opus only when the work needs deep reasoning (a subtle concurrency or security change, say). Pass model and say why. Sonnet is the default.
+
 ## Merging: the gates
 
 Merge only through the gates: \`arm\` or \`sign_off\`. \`sign_off\` merges a task's PR, with the project's merge method (squash unless set otherwise), only if all of these hold, and otherwise refuses naming the gate:
@@ -93,9 +101,9 @@ Reading:
 Acting:
 - \`${TOOL_NAMES.send}\` (session, message, scope_change?): message a session; it arrives as its next prompt. scope_change records it on the task's brief for its review.
 - \`${TOOL_NAMES.message_orchestrator}\` (workspace, message): message another workspace's orchestrator, the only thing you reach outside this workspace. Use it to hand over a bug or ask for something in its projects; it decides what to do there.
-- \`${TOOL_NAMES.start_task}\` (project, prompt, base?, name?, view?, after?, model?, plan?): a task in its own worktree that ends in a PR. Write the prompt as a full brief; name it in 2-6 words, or it's named from the prompt. It runs as a chat; pass view terminal only when the job needs a TUI. Pass after (a task's id or name, or "any") to hold it until that task finishes, instead of remembering it in your notes. Over the workspace's running task limit it's queued too: the result says "Queued (position N)", it starts by itself, and you get an event when it does. Its models follow the role settings (it plans on the planning model, then implements on the implementation one); pass model ("provider/model", or a map of role to one) only when Saad asks for one, and another provider than anthropic only then.
+- \`${TOOL_NAMES.start_task}\` (project, prompt, base?, name?, view?, after?, model?, plan, plan_reason): a task in its own worktree that ends in a PR. Write the prompt as a full brief; name it in 2-6 words, or it's named from the prompt. It runs as a chat; pass view terminal only when the job needs a TUI. Pass after (a task's id or name, or "any") to hold it until that task finishes, instead of remembering it in your notes. Over the workspace's running task limit it's queued too: the result says "Queued (position N)", it starts by itself, and you get an event when it does. Its models follow the role settings (it plans on the planning model, then implements on the implementation one); State plan and plan_reason for every task (see "Triage every job"). Pass model ("provider/model", or a map of role to one) only when Saad asks for one, or to put implementation on Opus when the work needs deep reasoning (say why in plan_reason or a note); another provider than anthropic only when Saad asks.
 - \`${TOOL_NAMES.set_task_model}\` (task, model, message?): move a paused task to another model and carry on in the same conversation and worktree; it keeps that model from then on. Only when Saad asks.
-- \`${TOOL_NAMES.start_session}\` (project, prompt, name?, view?): an interactive session, a chat unless view is terminal.
+- \`${TOOL_NAMES.start_session}\` (project, prompt, name?, view?, model?): a session without a worktree or PR, a chat unless view is terminal. It runs on the implementation model (Sonnet) unless you pass model; use it for work outside a repository, with the steps in the prompt.
 - \`${TOOL_NAMES.quick_change}\` (project, name): a worktree and branch cut from the project's default branch for a small, low-risk edit you make yourself: a typo, a config value, a one-file fix. It returns the worktree's path; edit there with Write and Edit, and run git there only as \`git -C <path> <status|diff|log|show|add|rm|mv|restore|reset>\`. Anything that needs real work, tests or a long investigation is a task: start_task. At most a few open at once.
 - \`${TOOL_NAMES.quick_pr}\` (change, title, body): commit everything in a quick change, push its branch (never the default branch) and open its PR, or push to the PR it has; its review starts at once. Then it's gated like any task: CI, that review (also its code-review gate), scope, then sign_off or arm. It's in \`sessions\` as your quick change; drop it to throw it away, and it's cleaned up like a task when it merges or is dropped.
 - \`${TOOL_NAMES.stack}\` (target, plan_only?): run a board's open cards as stacked tasks; plan_only shows the plan without starting.

package/lib/orchestrator/describe.ts

@@ -37,6 +37,10 @@ function sessionLine(f: SessionFacts): string {
       task += `, BLOCKED: ${untrusted(f.name, f.task.blocked)}`;
     parts.push(task);
   }
+  if (f.plan)
+    parts.push(
+      `${f.plan.planned ? "planned" : "no plan"}${f.plan.reason ? `: ${untrusted(f.name, f.plan.reason)}` : ""}`
+    );
   if (f.stack) {
     const card = f.stack.ticket ? ` ${f.stack.ticket}` : "";
     parts.push(

package/lib/orchestrator/facts.ts

@@ -41,6 +41,8 @@ export interface SessionFacts {
   branch: string | null;
   // A quick change the orchestrator makes itself (quick.ts): no agent.
   quick?: boolean;
+  // The orchestrator's call on a plan step, with its reason, when stated.
+  plan?: { planned: boolean; reason: string | null } | null;
   task: {
     state: TaskState;
     pr: TaskPR | null;
@@ -279,6 +281,10 @@ export async function sessionFacts(
         ),
         branch: s.branch_name,
         quick: !!s.quick_of,
+        plan:
+          s.plan_decided == null
+            ? null
+            : { planned: !!s.plan_decided, reason: s.plan_reason ?? null },
         task,
         stack: stackOf(s.id),
       };

package/lib/orchestrator/held.ts

@@ -14,14 +14,15 @@ export function heldVerdict(
   held: FailureRow[],
   url: string,
   sha: string,
-  pr: number
+  pr: number,
+  moved?: string
 ): Verdict {
   // One the orchestrator raised was judged before this (signoff.ts).
   const approval = latestApproval(workspaceId, workSubject(task.id));
   if (approval?.sha === sha)
     return { ok: true, sha, pr, approval: approval.id };
   if (approval) {
-    const why = `Saad approved ${approval.sha ? short(approval.sha) : "an earlier commit"}, but PR #${pr}'s head is now ${short(sha)}`;
+    const why = `Saad approved ${approval.sha ? short(approval.sha) : "an earlier commit"}, but PR #${pr}'s head is now ${short(sha)}${moved ? ` and ${moved}` : ""}`;
     try {
       raiseAsk({
         workspaceId,

package/lib/orchestrator/patch.ts

@@ -0,0 +1,98 @@
+// Whether two commits carry the same patch against a base, as `git
+// patch-id` sees it. The one check behind both carry-overs of a decision
+// across a rebase: the orchestrator's review (rebase.ts) and Saad's merge
+// approval (approval-carry.ts).
+
+import { git, gitFetch, gitOk } from "../git-exec";
+
+const diffOf = (repo: string, base: string, head: string) =>
+  git(repo, [
+    "diff",
+    "--no-color",
+    "--no-ext-diff",
+    "--full-index",
+    `${base}...${head}`,
+  ]).catch(() => null);
+
+async function idOf(repo: string, diff: string): Promise<string | null> {
+  return git(repo, ["patch-id", "--verbatim"], {
+    input: diff,
+    timeout: 30000,
+  }).then(
+    (out) => out.split(" ")[0] || null,
+    () => null
+  );
+}
+
+// A diff split by file, each without what a rebase legitimately changes
+// (blob ids, line offsets), so two diffs can be compared file by file.
+function byFile(diff: string): Map<string, string> {
+  const files = new Map<string, string>();
+  for (const part of diff.split(/^(?=diff --git )/m)) {
+    const name = part.match(/^diff --git a\/(.+?) b\//)?.[1];
+    if (!name) continue;
+    files.set(
+      name,
+      part
+        .split("\n")
+        .filter((l) => !l.startsWith("index "))
+        .map((l) =>
+          l.replace(/^(@@ )-\d+(?:,\d+)? \+\d+(?:,\d+)?( @@)/, "$1$2")
+        )
+        .join("\n")
+    );
+  }
+  return files;
+}
+
+const names = (list: string[]) =>
+  list.slice(0, 5).join(", ") +
+  (list.length > 5 ? ` and ${list.length - 5} more` : "");
+
+// What differs between two diffs, in a few words.
+export function describeChange(before: string, after: string): string {
+  const a = byFile(before);
+  const b = byFile(after);
+  const added = [...b.keys()].filter((f) => !a.has(f));
+  const removed = [...a.keys()].filter((f) => !b.has(f));
+  const changed = [...b.keys()].filter(
+    (f) => a.has(f) && a.get(f) !== b.get(f)
+  );
+  const parts = [
+    added.length && `now also touches ${names(added)}`,
+    removed.length && `no longer touches ${names(removed)}`,
+    changed.length && `changes differ in ${names(changed)}`,
+  ].filter(Boolean);
+  return parts.length
+    ? `its patch changed: ${parts.join("; ")}`
+    : "its patch changed";
+}
+
+// `from` and `to` against `base`: the same patch, or else a note on why not.
+// Fails closed: a commit or diff that can't be read is never "the same".
+export async function comparePatches(
+  repo: string,
+  base: string,
+  from: string,
+  to: string
+): Promise<{ same: boolean; note: string }> {
+  if (!(await gitOk(repo, ["cat-file", "-e", `${from}^{commit}`]))) {
+    await gitFetch(repo, ["--quiet", "--", "origin", from], {
+      timeout: 30000,
+    }).catch(() => undefined);
+    if (!(await gitOk(repo, ["cat-file", "-e", `${from}^{commit}`])))
+      return {
+        same: false,
+        note: `the earlier commit ${from.slice(0, 7)} can't be read here, so the patches can't be compared`,
+      };
+  }
+  const [before, after] = await Promise.all([
+    diffOf(repo, base, from),
+    diffOf(repo, base, to),
+  ]);
+  if (!before || !after)
+    return { same: false, note: "its patch can't be read to compare" };
+  const [x, y] = await Promise.all([idOf(repo, before), idOf(repo, after)]);
+  if (x && x === y) return { same: true, note: "same patch" };
+  return { same: false, note: describeChange(before, after) };
+}

package/lib/orchestrator/rebase.ts

@@ -29,6 +29,7 @@ import type { TaskPR } from "../tasks/state";
 import { run } from "../tasks/gh";
 import { isAllowedBase } from "../tasks/session";
 import { git as runGit, gitFetch, revParse } from "../git-exec";
+import { comparePatches } from "./patch";
 import { outputOf, type Runner } from "../stacks/git";
 import { restackedHeads, stackNotice } from "../stacks/restack";
 import { getCheck, putCheck } from "./checks";
@@ -306,25 +307,6 @@ async function rebaseAt(
   }
 }
 
-// The PR's own patch against the base, as `git patch-id` sees it.
-async function patchId(repo: string, range: string): Promise<string | null> {
-  const diff = await runGit(repo, [
-    "diff",
-    "--no-color",
-    "--no-ext-diff",
-    "--full-index",
-    range,
-  ]).catch(() => null);
-  if (!diff) return null;
-  return runGit(repo, ["patch-id", "--verbatim"], {
-    input: diff,
-    timeout: 30000,
-  }).then(
-    (out) => out.split(" ")[0] || null,
-    () => null
-  );
-}
-
 // The review of the head before the rebase, carried to the new head when
 // the PR's own patch is the same, else a fresh review of the new head.
 async function carryReview(
@@ -339,11 +321,7 @@ async function carryReview(
   const prior = getCheck(task.id, from, "review");
   const scope = getCheck(task.id, from, "scope");
   const repo = repoOf(task);
-  const [before, after] = await Promise.all([
-    patchId(repo, `${onto}...${from}`),
-    patchId(repo, `${onto}...${to}`),
-  ]);
-  const same = !!before && before === after;
+  const { same } = await comparePatches(repo, onto, from, to);
   if (
     same &&
     prior?.status === "pass" &&

package/lib/orchestrator/serve.ts

@@ -107,6 +107,7 @@ export async function runTool(
         after: a.after,
         model: a.model,
         plan: a.plan,
+        planReason: a.plan_reason,
       });
     }
     case "set_task_model": {
@@ -122,6 +123,7 @@ export async function runTool(
       return startSession(w, a.project, a.prompt, {
         name: a.name,
         view: a.view,
+        model: a.model,
       });
     }
     case "quick_change": {

package/lib/orchestrator/signoff.ts

@@ -29,6 +29,7 @@ import { evaluateGates, holdingEscalations, type GateInput } from "./gates";
 import { addNote } from "./notes";
 import { latestApproval, refundApproval, spendApproval } from "./ask-approvals";
 import { workSubject } from "./asks";
+import { carryApproval } from "./approval-carry";
 import { heldVerdict } from "./held";
 import { mergeApprovalsOn } from "./merge-approvals";
 import { isPaused } from "./pause";
@@ -170,7 +171,20 @@ export async function gateVerdict(
   // its stack parent merged: the orchestrator wrote that ask, and no answer
   // to it stands in for those. An approval of the gates' own ask on a held
   // task merges as it always has (heldVerdict).
-  const approval = latestApproval(workspaceId, workSubject(work.id));
+  let approval = latestApproval(workspaceId, workSubject(work.id));
+  // The head moved since he approved: his approval follows it when the PR's
+  // own patch is unchanged (a rebase), else the re-ask says what changed.
+  let moved: string | undefined;
+  if (approval?.sha && approval.sha !== sha) {
+    const carried = await carryApproval(
+      workspaceId,
+      work,
+      { ...approval, sha: approval.sha },
+      sha
+    );
+    if (carried.approval) approval = carried.approval;
+    else moved = carried.note;
+  }
   if (
     approval?.sha === sha &&
     (approval.raised_by === "orchestrator" || !held.length)
@@ -187,7 +201,7 @@ export async function gateVerdict(
     return { ok: true, sha, pr: pr.number, approval: approval.id };
   }
   if (held.length)
-    return heldVerdict(workspaceId, work, held, pr.url, sha, pr.number);
+    return heldVerdict(workspaceId, work, held, pr.url, sha, pr.number, moved);
 
   const base = await fetchRefs(repo, work.refs);
   const files = await changedFiles(repo, base, sha);

package/lib/orchestrator/tool-schemas.ts

@@ -105,9 +105,16 @@ export const TOOL_SHAPES = {
     model: modelOverride,
     plan: z
       .boolean()
-      .optional()
       .describe(
-        "Plan first on the planning model, then implement on the implementation model (default: Settings)"
+        "Your decision for this job: true to plan first on the planning model, then implement on the implementation model; false to skip the plan and put the steps in the prompt yourself"
+      ),
+    plan_reason: z
+      .string()
+      .trim()
+      .min(3)
+      .max(200)
+      .describe(
+        'Why, in a few words Saad reads on the task card: "touches 6 files across gates and UI", "one-line default change"'
       ),
   },
   set_task_model: {
@@ -134,6 +141,11 @@ export const TOOL_SHAPES = {
       .optional()
       .describe("A short name, 2-6 words (default: one made from the prompt)"),
     view,
+    model: modelRef
+      .optional()
+      .describe(
+        'One model for the session, "provider/model"; default: the implementation model. Opus only when the work needs deep reasoning'
+      ),
   },
   quick_change: {
     project,

package/lib/orchestrator/tools.ts

@@ -61,11 +61,11 @@ const DESCRIPTIONS: Record<ToolName, string> = {
   message_orchestrator:
     "Message another workspace's orchestrator, by workspace name; never any other session there. It arrives as its next prompt, marked as from you and fenced as untrusted.",
   start_task:
-    "Start a task: an agent in its own worktree that ends in a PR. It runs as a chat unless view is terminal (only for a job that needs a TUI). With after (a task's id or name, or \"any\"), or over the workspace's running task limit, it's queued and starts by itself; the result says Queued (position N). Its models follow the role settings (planning, implementation, review, scope); give model only when Saad asks for one. Refused while a brake holds.",
+    "Start a task: an agent in its own worktree that ends in a PR. It runs as a chat unless view is terminal (only for a job that needs a TUI). With after (a task's id or name, or \"any\"), or over the workspace's running task limit, it's queued and starts by itself; the result says Queued (position N). Its models follow the role settings (planning, implementation, review, scope); give model only when Saad asks for one. Always state plan (true or false) and plan_reason: plan true for a big, unclear or cross-cutting job, false for a small, clear one whose steps you write into the prompt. Refused while a brake holds.",
   set_task_model:
     'Resume a paused task on another model ("provider/model", or a map of role to one), keeping its conversation and worktree; it\'s told to carry on (or message). Refused mid-turn.',
   start_session:
-    "Start an interactive agent session in a project with a prompt. It runs as a chat unless view is terminal (only for a job that needs a TUI). Refused while a brake holds.",
+    'Start an agent session in a project with a prompt, for work that isn\'t a PR task. It runs on the implementation model unless you give model (one "provider/model"; Opus only when the work needs deep reasoning), as a chat unless view is terminal (only for a job that needs a TUI). Refused while a brake holds.',
   quick_change:
     "Make a small, low-risk edit yourself (a typo, a config value, a one-file fix): cuts a worktree and branch from the project's default branch and returns its path. You may write there (Write, Edit) and run git there as `git -C <path> ...` (status, diff, add, rm, mv, restore, reset, log, show); nowhere else in a project. Anything needing real work, tests or an investigation is a task (start_task).",
   quick_pr:
@@ -74,7 +74,7 @@ const DESCRIPTIONS: Record<ToolName, string> = {
     "Run a LumifyHub board's open cards as stacked tasks (each start braked), or with plan_only just show the plan.",
   stack_status: "One stack's items, PRs and progress.",
   land: "Merge a whole stack bottom-up, each PR through the sign-off gates at its current head.",
-  drop: "Reject a task: close its PR and remove its worktree. Logged with the reason.",
+  drop: "Reject a task: close its PR and remove its worktree. A task still waiting in the queue is removed by its id. Logged with the reason.",
   stop: "Stop a session's agent mid-turn, even while it's thinking, keeping its conversation, worktree and branch; your next message runs as its next turn.",
   done: "Finish a session whose work is complete: a task's open PR merges through the sign-off gates first (refused naming the failing gate), then its agent stops, its worktree is removed if nothing would be lost, and it's archived. Not a rejection.",
   add_project:

package/lib/orchestrator/watcher.ts

@@ -16,6 +16,7 @@ import { BRAKE_SUBJECT, openAsks } from "./asks";
 import { settleStaleAsks } from "./ask-settle";
 import { brakesOn, liftBrake } from "./brakes";
 import { anyArmed, mergeArmed } from "./armed";
+import { followAskHeads } from "./ask-heads";
 import { rebaseConflicting } from "./rebase";
 import { wakeTasks } from "./pr-wake";
 import { awayTick } from "../away/run";
@@ -75,6 +76,9 @@ function mergePipeline(workspaceId: string, facts: SessionFacts[]): void {
     await wakeTasks(workspaceId, facts).catch((error) =>
       console.error(`Waking tasks in ${workspaceId}:`, error)
     );
+    await followAskHeads(workspaceId, facts).catch((error) =>
+      console.error(`Following ask heads in ${workspaceId}:`, error)
+    );
     await rebaseConflicting(workspaceId, facts);
     await mergeArmed(workspaceId, facts);
   })()

package/lib/sessions/launch.ts

@@ -11,7 +11,7 @@ import { db, queries, type Session } from "../db";
 import type { AgentType } from "../providers";
 import type { ChatAccess, ChatImage } from "../chat/events";
 import { resolveModelForAgent } from "../model-catalog";
-import { resolveRole, setSessionModel } from "../models/resolve";
+import { parseOverride, resolveRole, setSessionModel } from "../models/resolve";
 import { ANTHROPIC } from "../models/roles";
 import { getProject } from "../projects";
 import { getHost, isRemoteHost } from "../hosts";
@@ -71,6 +71,9 @@ export interface LaunchInput {
   name?: string | null;
   view?: "chat" | "terminal";
   parentSessionId?: string | null;
+  // The orchestrator session that starts it: it runs on the implementation
+  // role's model (or `model`), not the interactive one's.
+  startedBy?: string | null;
   groupPath?: string;
   systemPrompt?: string | null;
 }
@@ -222,10 +225,20 @@ async function launch(input: LaunchInput, id: string): Promise<Launched> {
       : DEFAULT_START_VIEW;
   // Claude with no model picked runs on the interactive role's, here; on
   // another provider only as a chat, whose worker carries its endpoint.
+  const role = input.startedBy ? "implement" : "interactive";
+  // An orchestrator's explicit model is validated like a task's.
+  const picked = input.startedBy ? parseOverride(input.model) : null;
+  if (picked && typeof picked !== "string")
+    throw new Error(`model: a session takes one "provider/model"`);
   const routed =
-    agentType === "claude" && !input.model?.trim() && !remote
-      ? resolveRole("interactive", { workspaceId: project?.workspace_id })
+    agentType === "claude" && (picked || !input.model?.trim()) && !remote
+      ? resolveRole(role, {
+          workspaceId: project?.workspace_id,
+          override: picked,
+        })
       : null;
+  if (picked && routed && routed.provider.id !== ANTHROPIC && view !== "chat")
+    throw new Error("Another provider's models run only as a chat");
   const interactive =
     routed && (routed.provider.id === ANTHROPIC || view === "chat")
       ? routed
@@ -264,8 +277,14 @@ async function launch(input: LaunchInput, id: string): Promise<Launched> {
       runOn
     );
   db.prepare(
-    `UPDATE sessions SET view = ?, name_source = ?, setup_status = ? WHERE id = ?`
-  ).run(view, naming.source, useWorktree ? "running" : null, id);
+    `UPDATE sessions SET view = ?, name_source = ?, setup_status = ?, started_by = ? WHERE id = ?`
+  ).run(
+    view,
+    naming.source,
+    useWorktree ? "running" : null,
+    input.startedBy ?? null,
+    id
+  );
   if (interactive) setSessionModel(id, interactive);
   if (input.access)
     db.prepare(`UPDATE sessions SET chat_access = ? WHERE id = ?`).run(

package/lib/tasks/index.ts

@@ -96,6 +96,8 @@ export interface TaskView {
   // plan step (lib/models).
   model?: string;
   planning?: boolean;
+  // What its starter decided about a plan step, and why; null if unstated.
+  plan?: { planned: boolean; reason: string | null } | null;
   // A quick change: the orchestrator session that makes it (no agent).
   quickOf?: string | null;
 }
@@ -111,6 +113,10 @@ export async function createTask(opts: {
   model?: ModelOverride;
   // Plan first on the planning model (Settings' default otherwise).
   plan?: boolean;
+  // Why the starter chose to plan or not: shown on the task's card.
+  planReason?: string | null;
+  // The orchestrator session that started it (null: a person).
+  startedBy?: string | null;
   // Started from this LumifyHub card, which the task then moves.
   cardId?: string;
   // Stacked: cut from another task's pushed branch, at this exact commit.
@@ -247,7 +253,8 @@ async function startTask(
   // Everything the launch needs is on the row, so a restart can resume it.
   db.prepare(
     `UPDATE sessions SET task_prompt = ?, task_brief = ?, task_status = 'running', setup_status = 'running', name_source = ?, view = ?,
-       model_provider = ?, model_overrides = ?, plan_phase = ? WHERE id = ?`
+       model_provider = ?, model_overrides = ?, plan_phase = ?,
+       plan_decided = ?, plan_reason = ?, started_by = ? WHERE id = ?`
   ).run(
     prompt,
     buildTaskBrief({
@@ -260,6 +267,9 @@ async function startTask(
     routing.first.provider.id === ANTHROPIC ? null : routing.first.provider.id,
     routing.override ? JSON.stringify(routing.override) : null,
     routing.plan ? "planning" : null,
+    opts.plan === undefined ? null : opts.plan ? 1 : 0,
+    opts.planReason?.trim() || null,
+    opts.startedBy ?? null,
     id
   );
   opts.onCreated?.(id);
@@ -376,6 +386,13 @@ export async function taskView(session: Session): Promise<TaskView> {
     armed: !!session.merge_armed_at,
     model: sessionModelRef(session),
     planning: session.plan_phase === "planning",
+    plan:
+      session.plan_decided == null
+        ? null
+        : {
+            planned: !!session.plan_decided,
+            reason: session.plan_reason ?? null,
+          },
     quickOf: session.quick_of ?? null,
   };
 }

package/lib/tasks/queue.ts

@@ -44,6 +44,11 @@ export interface QueueRow {
   model: string | null;
   // A per-role model map (lib/models), when that's what it was given.
   model_overrides: string | null;
+  // The starter's plan decision (1/0, null: not stated), its reason, and the
+  // orchestrator session that started it.
+  plan: number | null;
+  plan_reason: string | null;
+  started_by: string | null;
   view: "chat" | "terminal" | null;
   base_branch: string | null;
   host_id: string | null;
@@ -156,11 +161,19 @@ export function hasFinished(taskId: string): boolean {
   return !q || (q.status !== "queued" && q.status !== "starting");
 }
 
+// Still something to wait for under "any": in flight, and not a task whose
+// PR was closed or merged and which nobody finished (that one never will).
+function stillWorking(taskId: string): boolean {
+  if (hasFinished(taskId)) return false;
+  const s = sessionOf(taskId);
+  return !s || (s.pr_status !== "closed" && s.pr_status !== "merged");
+}
+
 export function afterMet(r: QueueRow): boolean {
   if (r.after_task && !hasFinished(r.after_task)) return false;
   if (r.after_any) {
     const ids = JSON.parse(r.after_any) as string[];
-    if (ids.length && !ids.some(hasFinished)) return false;
+    if (ids.length && !ids.some((id) => !stillWorking(id))) return false;
   }
   return true;
 }
@@ -205,6 +218,9 @@ export interface QueueRequest {
   prompt: string;
   name?: string;
   model?: ModelOverride;
+  plan?: boolean;
+  planReason?: string | null;
+  startedBy?: string | null;
   view?: "chat" | "terminal";
   baseBranch?: string;
   hostId?: string;
@@ -236,9 +252,17 @@ export function queueIfNeeded(req: QueueRequest): QueuedTaskView | null {
   let afterTask: string | null = null;
   let afterAny: string[] | null = null;
   const after = req.after?.trim();
-  if (after && after.toLowerCase() === "any")
-    afterAny = runningIn({ workspaceId, projectId: project.id });
-  else if (after)
+  // "any" with nothing working is nothing to wait for: it starts at once.
+  let waits = !!after;
+  if (after && after.toLowerCase() === "any") {
+    afterAny = runningIn({ workspaceId, projectId: project.id }).filter(
+      stillWorking
+    );
+    if (!afterAny.length) {
+      afterAny = null;
+      waits = false;
+    }
+  } else if (after)
     afterTask = resolveAfter(after, req.originWorkspaceId ?? workspaceId).id;
   const full =
     limit !== null &&
@@ -247,13 +271,13 @@ export function queueIfNeeded(req: QueueRequest): QueuedTaskView | null {
       startingIn(workspaceId) >=
       limit ||
       waitingIn(workspaceId) > 0);
-  if (!after && !full) return null;
+  if (!waits && !full) return null;
   if (!req.prompt.trim()) throw new Error("Describe the task");
   const id = randomUUID();
   db.prepare(
-    `INSERT INTO task_queue (id, project_id, prompt, name, model, model_overrides, view, base_branch,
+    `INSERT INTO task_queue (id, project_id, prompt, name, model, model_overrides, plan, plan_reason, started_by, view, base_branch,
        host_id, after_task, after_any, origin_workspace_id, position)
-     VALUES (@id, @project_id, @prompt, @name, @model, @model_overrides, @view, @base_branch,
+     VALUES (@id, @project_id, @prompt, @name, @model, @model_overrides, @plan, @plan_reason, @started_by, @view, @base_branch,
        @host_id, @after_task, @after_any, @origin,
        (SELECT COALESCE(MAX(position), 0) + 1 FROM task_queue))`
   ).run({
@@ -266,6 +290,9 @@ export function queueIfNeeded(req: QueueRequest): QueuedTaskView | null {
       req.model && typeof req.model === "object"
         ? JSON.stringify(req.model)
         : null,
+    plan: req.plan === undefined ? null : req.plan ? 1 : 0,
+    plan_reason: req.planReason?.trim() || null,
+    started_by: req.startedBy ?? null,
     view: req.view ?? null,
     base_branch: req.baseBranch || null,
     host_id: req.hostId || null,
@@ -440,6 +467,9 @@ async function startRow(
     model: r.model_overrides
       ? (JSON.parse(r.model_overrides) as ModelOverride)
       : (r.model ?? undefined),
+    plan: r.plan == null ? undefined : !!r.plan,
+    planReason: r.plan_reason,
+    startedBy: r.started_by,
     view: r.view ?? undefined,
     baseBranch: r.base_branch ?? undefined,
     hostId: r.host_id ?? undefined,
@@ -574,6 +604,36 @@ export async function startQueuedNow(id: string): Promise<StartOutcome> {
   return startRow(r, { force: true });
 }
 
+// A task still waiting in the line (or failed to start) by id, an id prefix
+// of 4+ characters or, when asked, its name; in one workspace.
+export function findQueued(
+  workspaceId: string,
+  ref: string,
+  opts: { byName?: boolean } = {}
+): QueueRow | null {
+  const want = ref.trim();
+  const rows = db
+    .prepare(
+      `SELECT q.* FROM task_queue q JOIN projects p ON p.id = q.project_id
+       WHERE p.workspace_id = ? AND q.status IN ('queued', 'failed')`
+    )
+    .all(workspaceId) as QueueRow[];
+  const lower = want.toLowerCase();
+  const hits = rows.filter(
+    (r) =>
+      r.id === want ||
+      (want.length >= 4 && r.id.startsWith(want)) ||
+      (opts.byName && label(r).toLowerCase() === lower)
+  );
+  if (hits.length > 1)
+    throw new Error(
+      `"${ref}" matches ${hits.length} queued tasks: ${hits.map((h) => `${label(h)} (${h.id.slice(0, 8)})`).join(", ")}`
+    );
+  return hits[0] ?? null;
+}
+
+export const queuedLabel = label;
+
 export function removeQueued(id: string): void {
   const changed = db
     .prepare(