@saadnvd1/agent-os 0.3.470 → 0.3.472

package/lib/tasks/code-review.ts

@@ -1,27 +1,13 @@
-// The "Code review" section every task's PR body carries (the task brief
-// asks for it, after /do-code-review). Merges refuse a PR without one for
-// its head commit. No imports: CI runs this file on its own
-// (scripts/check-code-review.ts).
-
-export interface CodeReviewSection {
-  // The commit the review covered, as written in the section.
-  sha: string | null;
-  // A "Restacked: <from> -> <to>" line AgentOS wrote after rebasing the
-  // branch itself. Only CI reads it: AgentOS's own gates go by what it
-  // recorded, never by what a body says.
-  restacked?: Restacked;
-  // What kind of AI attribution the body carries, when it does: a fixed
-  // label, never the body's own text, which goes into gate messages.
-  attribution?: AttributionKind;
-}
+// The code-review gate, the same for every PR: a passing independent
+// review (lib/orchestrator/review) of its exact head, and a body with no AI
+// attribution. Tasks don't write a review section in the body any more: the
+// orchestrator's review is the one review.
 
 // Matched one line at a time, never across lines: the body is written by
 // the task, and a regex that backtracks over it would block the server.
 // Only what renders counts: fenced code and HTML comments are skipped, so an
-// example of the section isn't read as the section.
+// example isn't read as the real thing.
 const MAX_BODY = 65_536;
-const HEADING = /^ {0,3}(#{1,6}) *code review *:?$/i;
-const ANY_HEADING = /^ {0,3}(#{1,6}) +\S/;
 const FENCE = /^ {0,3}(`{3,}|~{3,})/;
 // AI attribution ("Co-Authored-By: Claude", "Generated with [Claude Code]").
 // The same rule as the commit-msg hook's ATTRIBUTION_ERE in
@@ -45,10 +31,6 @@ function attributionKind(line: string): AttributionKind | undefined {
   if (/^claude-session:/i.test(line)) return "a Claude-Session link";
   return 'a "Generated with" AI footer';
 }
-const REVIEWED =
-  /^[>*_ -]*reviewed(?: (?:commit|sha|at))?[*_ ]*:[*_` ]*([0-9a-f]{12,40})\b/i;
-const RESTACKED =
-  /^[>*_ -]*restacked[*_ ]*:[*_` ]*([0-9a-f]{40})[*_` ]*(?:->|→)[*_` ]*([0-9a-f]{40})\b/i;
 
 export function renderedLines(body: string): string[] {
   let text = body.slice(0, MAX_BODY);
@@ -70,45 +52,7 @@ export function renderedLines(body: string): string[] {
   return lines;
 }
 
-// The last Code review section that names a commit (or the last one, when
-// none does); null when the body has none. A section runs to the next
-// heading of its level or higher, so its own subheadings stay inside it.
-export function parseCodeReview(
-  body: string | null | undefined
-): CodeReviewSection | null {
-  if (!body) return null;
-  const sections: CodeReviewSection[] = [];
-  let level = 0;
-  let attribution: AttributionKind | undefined;
-  for (const line of renderedLines(body)) {
-    attribution ??= attributionKind(line.trimStart());
-    const heading = HEADING.exec(line);
-    if (heading) {
-      level = heading[1].length;
-      sections.push({ sha: null });
-      continue;
-    }
-    const other = ANY_HEADING.exec(line);
-    if (other && other[1].length <= level) level = 0;
-    const current = sections.at(-1);
-    if (!level || !current) continue;
-    if (current.sha) {
-      const moved = RESTACKED.exec(line);
-      if (moved)
-        current.restacked = {
-          from: moved[1].toLowerCase(),
-          to: moved[2].toLowerCase(),
-        };
-      continue;
-    }
-    const sha = REVIEWED.exec(line)?.[1];
-    if (sha) current.sha = sha.toLowerCase();
-  }
-  const found = sections.findLast((s) => s.sha) ?? sections.at(-1) ?? null;
-  return found && attribution ? { ...found, attribution } : found;
-}
-
-// The AI attribution a body carries anywhere, Code review section or not.
+// The AI attribution a body carries anywhere.
 export function attributionIn(
   body: string | null | undefined
 ): AttributionKind | undefined {
@@ -119,57 +63,75 @@ export function attributionIn(
   }
 }
 
-// A branch AgentOS rebased itself (a stack restack): the head the task
-// pushed and reviewed, and the head the restack left.
+// A branch AgentOS rebased itself (a stack restack, or the automatic
+// rebase onto its base): the head the task pushed, and the head AgentOS
+// left.
 export interface Restacked {
   from: string | null;
   to: string | null;
 }
 
-// Why a PR can't merge on its code review, or null when it can. Fails
-// closed: an unread body or an unknown head refuses. A review of the head
-// the task pushed still counts after AgentOS restacked it, but only while
-// the head is exactly the one the restack left: a push by the task after
-// that needs a new review.
-export function codeReviewRefusal(
-  section: CodeReviewSection | null | undefined,
-  head: string | undefined,
-  restacked?: Restacked | null,
-  fix = "the task has to run /do-code-review and put a Code review section naming the reviewed commit in the PR body"
-): string | null {
-  if (section === undefined) return `the PR body couldn't be read: ${fix}`;
-  if (!head) return `the PR's head commit is unknown: ${fix}`;
-  if (!section) return `the PR body has no Code review section: ${fix}`;
-  if (section.attribution)
-    return `the PR body carries AI attribution (${section.attribution}): remove it with \`gh pr edit --body-file\``;
-  if (!section.sha)
-    return `the PR's Code review section doesn't name the reviewed commit ("Reviewed: <sha>"): ${fix}`;
-  const covers = (sha: string | null | undefined) =>
-    !!sha && sha.toLowerCase().startsWith(section.sha!);
-  if (covers(head)) return null;
-  if (restacked?.to === head && covers(restacked.from)) return null;
-  return `the PR's code review covers ${section.sha.slice(0, 7)}, not its head ${head.slice(0, 7)}: ${fix}`;
+export interface ReviewState {
+  sha: string;
+  status: "running" | "pass" | "block" | "error";
+}
+
+export interface CodeReviewGate {
+  // Fails the gate: counts against the task.
+  refusal: string | null;
+  // Not covered yet, but a review will cover it.
+  wait: string | null;
+  // A review covering the head finished, passing or not. Saad's approval
+  // of the commit overrides what it found, never whether one ran.
+  ran?: boolean;
 }
 
-// The body with its Code review section saying AgentOS rebased the
-// reviewed head `from` to `to`: a "Restacked:" line right after the
-// section's "Reviewed:" line, replacing one already there. Null when the
-// body has no section, or its review isn't of `from`.
-export function withRestackedLine(
-  body: string,
-  from: string,
-  to: string
+const short = (sha: string) => sha.slice(0, 7);
+
+// Fails closed: an unread body or an unknown head refuses. A review of the
+// head the task pushed still counts after AgentOS restacked or rebased it
+// cleanly, but only while the head is exactly the one AgentOS left: a push
+// by the task after that needs a new review.
+export function codeReviewGate(opts: {
+  head: string | undefined;
+  // The AI attribution in the PR body (attributionIn): null for none,
+  // undefined when the body couldn't be read.
+  attribution: AttributionKind | null | undefined;
+  review: (sha: string) => ReviewState | null;
+  restacked?: Restacked | null;
+}): CodeReviewGate {
+  const { head, restacked } = opts;
+  const no = (refusal: string) => ({ refusal, wait: null });
+  const { attribution } = opts;
+  if (attribution === undefined) return no("the PR body couldn't be read");
+  if (!head) return no("the PR's head commit is unknown");
+  if (attribution)
+    return no(
+      `the PR body carries AI attribution (${attribution}): remove it with \`gh pr edit --body-file\``
+    );
+  // The reviews that cover the head: its own, and the one of the head the
+  // task pushed while the head is the one AgentOS left.
+  const covering = [
+    opts.review(head),
+    restacked?.to === head && restacked.from
+      ? opts.review(restacked.from)
+      : null,
+  ];
+  if (covering.some((r) => r?.status === "pass"))
+    return { refusal: null, wait: null, ran: true };
+  const now = covering[0];
+  return {
+    refusal: null,
+    wait: `no passing independent review of ${short(head)}${now?.status === "running" ? " yet (it's running)" : now?.status === "block" ? " (it has blocking findings)" : ": call review"}`,
+    ran: covering.some((r) => r?.status === "block"),
+  };
+}
+
+// The gate as one reason, for paths that only merge or refuse (a stack
+// landing, an approved merge): a wait refuses there too.
+export function codeReviewRefusal(
+  opts: Parameters<typeof codeReviewGate>[0]
 ): string | null {
-  const section = parseCodeReview(body);
-  if (!section?.sha || !from.toLowerCase().startsWith(section.sha)) return null;
-  const lines = body.split("\n");
-  const at = lines.findLastIndex(
-    (l) =>
-      REVIEWED.exec(l.replace(/\t/g, " "))?.[1]?.toLowerCase() === section.sha
-  );
-  if (at < 0) return null;
-  const line = `Restacked: ${from} -> ${to} (AgentOS rebased the reviewed commit onto its base; the PR's own changes are the ones reviewed)`;
-  const next = lines[at + 1]?.replace(/\t/g, " ") ?? "";
-  lines.splice(at + 1, RESTACKED.test(next) ? 1 : 0, line);
-  return lines.join("\n");
+  const gate = codeReviewGate(opts);
+  return gate.refusal ?? gate.wait;
 }

package/lib/tasks/gh.ts

@@ -1,7 +1,7 @@
 import { execFile } from "child_process";
 import { promisify } from "util";
 import { git } from "../git-exec";
-import { parseCodeReview } from "./code-review";
+import { attributionIn } from "./code-review";
 import { parseScopeChange } from "./scope-change";
 import { assertGhAllowed, noteGhFailure, noteGhSuccess } from "./gh-limit";
 import {
@@ -114,7 +114,8 @@ export async function toTaskPR(repoDir: string, pr: ListedPR): Promise<TaskPR> {
     failing: failingCheck(rollup),
     failingUrl: failingUrl(rollup),
     checkCount: (pr.statusCheckRollup ?? []).length,
-    codeReview: pr.body === undefined ? undefined : parseCodeReview(pr.body),
+    attribution:
+      pr.body === undefined ? undefined : (attributionIn(pr.body) ?? null),
     scopeChange: parseScopeChange(pr.body),
     ...(pr.mergeable && { mergeable: pr.mergeable }),
   };

package/lib/tasks/index.ts

@@ -4,6 +4,14 @@
  * drops it.
  */
 
+import {
+  parseOverride,
+  resolveRole,
+  sessionModelRef,
+  type ModelOverride,
+} from "../models/resolve";
+import { effectiveModels } from "../models/config";
+import { ANTHROPIC } from "../models/roles";
 import { processTable, runsSomething } from "../process-table";
 import { randomUUID } from "crypto";
 import { db, queries, type Session } from "../db";
@@ -19,7 +27,6 @@ import {
   isBranchName,
   slugify,
 } from "../git";
-import { resolveModelForAgent } from "../model-catalog";
 import { getProvider } from "../providers";
 import { statusDetector } from "../status-detector";
 import { buildTaskBrief, type StackedOn } from "./brief";
@@ -49,7 +56,7 @@ import { chatStateNow } from "../chat/runner";
 import { saidSinceLastMessage } from "../chat/store";
 
 export * from "./state";
-export { codeReviewRefusal, parseCodeReview } from "./code-review";
+export { codeReviewGate, codeReviewRefusal } from "./code-review";
 export { signOffTask, dropTask, signingOff, mergeSettled } from "./finish";
 export { prFor as taskPR } from "./session";
 export { moveTask } from "./move-flow";
@@ -85,6 +92,10 @@ export interface TaskView {
   hostError: string | null;
   // Merges by itself once every gate passes (orchestrator/armed.ts).
   armed?: boolean;
+  // What it runs on now, "provider/model", and whether it's still in its
+  // plan step (lib/models).
+  model?: string;
+  planning?: boolean;
 }
 
 export async function createTask(opts: {
@@ -92,7 +103,12 @@ export async function createTask(opts: {
   prompt: string;
   // Its name; generated from the prompt when absent.
   name?: string;
-  model?: string;
+  // Its own model: "provider/model" (or an Anthropic alias) for all its
+  // roles, or a map of role to one (lib/models). Its workspace's and
+  // Settings' role models otherwise.
+  model?: ModelOverride;
+  // Plan first on the planning model (Settings' default otherwise).
+  plan?: boolean;
   // Started from this LumifyHub card, which the task then moves.
   cardId?: string;
   // Stacked: cut from another task's pushed branch, at this exact commit.
@@ -169,7 +185,7 @@ async function startTask(
       id,
       prompt,
       name: opts.name,
-      model: opts.model,
+      model: typeof opts.model === "string" ? opts.model : undefined,
       baseBranch: opts.baseBranch,
       view,
     });
@@ -179,6 +195,12 @@ async function startTask(
 
   if (opts.baseBranch !== undefined && !isBranchName(opts.baseBranch))
     throw new Error(`"${opts.baseBranch}" isn't a branch name`);
+  const routing = taskRouting(
+    project.workspace_id,
+    view,
+    opts.model,
+    opts.plan
+  );
   const projectPath = expandHome(project.working_directory);
   const naming = await nameFor(prompt, projectPath, opts.name);
   const feature = `${slugify(naming.name.split(/\s+/).slice(0, 6).join(" "))}-${id.slice(0, 4)}`;
@@ -198,10 +220,7 @@ async function startTask(
   });
 
   const provider = getProvider("claude");
-  const model = resolveModelForAgent(
-    "claude",
-    opts.model || project.default_model
-  );
+  const model = routing.first.model;
   const tmuxName = `${provider.id}-${id}`;
 
   queries
@@ -225,7 +244,8 @@ async function startTask(
     .run(wt.worktreePath, wt.branchName, baseBranch, null, id);
   // 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 = ? WHERE id = ?`
+    `UPDATE sessions SET task_prompt = ?, task_brief = ?, task_status = 'running', setup_status = 'running', name_source = ?, view = ?,
+       model_provider = ?, model_overrides = ?, plan_phase = ? WHERE id = ?`
   ).run(
     prompt,
     buildTaskBrief({
@@ -235,6 +255,9 @@ async function startTask(
     }),
     naming.source,
     view,
+    routing.first.provider.id === ANTHROPIC ? null : routing.first.provider.id,
+    routing.override ? JSON.stringify(routing.override) : null,
+    routing.plan ? "planning" : null,
     id
   );
   opts.onCreated?.(id);
@@ -340,6 +363,8 @@ export async function taskView(session: Session): Promise<TaskView> {
     hostName: null,
     hostError: null,
     armed: !!session.merge_armed_at,
+    model: sessionModelRef(session),
+    planning: session.plan_phase === "planning",
   };
 }
 
@@ -365,3 +390,29 @@ export async function listTasks(): Promise<TaskView[]> {
     b.createdAt.localeCompare(a.createdAt)
   );
 }
+
+// The model a task starts on, and whether it plans first: only as a chat,
+// where the handoff can follow the end of its plan turn, and only when
+// planning and implementing are on different models. Both roles resolve
+// now, so a bad override or a provider that's off fails the start.
+export function taskRouting(
+  workspaceId: string | null,
+  view: StartView,
+  model: unknown,
+  plan?: boolean
+) {
+  const override = parseOverride(model);
+  const models = effectiveModels();
+  const opts = { workspaceId, override };
+  const implement = resolveRole("implement", opts, models);
+  const planning = resolveRole("plan", opts, models);
+  const planStep =
+    view === "chat" &&
+    (plan ?? models.planStep) &&
+    planning.ref !== implement.ref;
+  return {
+    override,
+    plan: planStep,
+    first: planStep ? planning : implement,
+  };
+}

package/lib/tasks/queue.ts

@@ -11,6 +11,7 @@
  * is deleted: a started or removed row stays as history.
  */
 
+import type { ModelOverride } from "../models/resolve";
 import { randomUUID } from "crypto";
 import { db, type Session } from "../db";
 import { getProject } from "../projects";
@@ -41,6 +42,8 @@ export interface QueueRow {
   prompt: string;
   name: string | null;
   model: string | null;
+  // A per-role model map (lib/models), when that's what it was given.
+  model_overrides: string | null;
   view: "chat" | "terminal" | null;
   base_branch: string | null;
   host_id: string | null;
@@ -200,7 +203,7 @@ export interface QueueRequest {
   projectId: string;
   prompt: string;
   name?: string;
-  model?: string;
+  model?: ModelOverride;
   view?: "chat" | "terminal";
   baseBranch?: string;
   hostId?: string;
@@ -247,9 +250,9 @@ export function queueIfNeeded(req: QueueRequest): QueuedTaskView | 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, view, base_branch,
+    `INSERT INTO task_queue (id, project_id, prompt, name, model, model_overrides, view, base_branch,
        host_id, after_task, after_any, origin_workspace_id, position)
-     VALUES (@id, @project_id, @prompt, @name, @model, @view, @base_branch,
+     VALUES (@id, @project_id, @prompt, @name, @model, @model_overrides, @view, @base_branch,
        @host_id, @after_task, @after_any, @origin,
        (SELECT COALESCE(MAX(position), 0) + 1 FROM task_queue))`
   ).run({
@@ -257,7 +260,11 @@ export function queueIfNeeded(req: QueueRequest): QueuedTaskView | null {
     project_id: project.id,
     prompt: req.prompt.trim(),
     name: req.name?.trim() || null,
-    model: req.model || null,
+    model: typeof req.model === "string" ? req.model || null : null,
+    model_overrides:
+      req.model && typeof req.model === "object"
+        ? JSON.stringify(req.model)
+        : null,
     view: req.view ?? null,
     base_branch: req.baseBranch || null,
     host_id: req.hostId || null,
@@ -429,7 +436,9 @@ async function startRow(
     projectId: r.project_id,
     prompt: r.prompt,
     name: r.name ?? undefined,
-    model: r.model ?? undefined,
+    model: r.model_overrides
+      ? (JSON.parse(r.model_overrides) as ModelOverride)
+      : (r.model ?? undefined),
     view: r.view ?? undefined,
     baseBranch: r.base_branch ?? undefined,
     hostId: r.host_id ?? undefined,

package/lib/tasks/start.ts

@@ -23,6 +23,7 @@ import { deleteQueued, enqueue, listQueue } from "../chat/queued";
 import { sendQueuedNow } from "../chat/runner";
 import { hasItem } from "../chat/store";
 import { firstMessageId, launchPending } from "./launch-gate";
+import { planPrompt, preparePlanDir } from "../models/plan-step";
 
 export { firstMessageId, launchPending };
 import { expandHome } from "./session";
@@ -136,7 +137,10 @@ export async function finishTaskStart(
       ms: setup.ms,
       error: "Not launched: the task was closed during setup",
     });
-  const prompt = (session.task_prompt ?? "") + setupNote(setup);
+  const task = (session.task_prompt ?? "") + setupNote(setup);
+  const planning = session.plan_phase === "planning";
+  if (planning) preparePlanDir(session.worktree_path);
+  const prompt = planning ? planPrompt(task) : task;
   try {
     if (session.view === "chat") await launchChat(sessionId, prompt);
     else {
@@ -148,6 +152,7 @@ export async function finishTaskStart(
         tmuxName: session.tmux_name,
         cwd: session.worktree_path,
         model: session.model,
+        provider: session.model_provider,
         prompt,
         brief: session.task_brief ?? undefined,
       });
@@ -190,7 +195,7 @@ function earlierSetup(row: SetupColumns): TaskSetup | undefined {
   return undefined;
 }
 
-const killTmux = (name: string) =>
+export const killTmux = (name: string) =>
   execFileAsync("tmux", ["kill-session", "-t", `=${name}`], {
     timeout: 5000,
   }).catch(() => undefined);

package/lib/tasks/state.ts

@@ -1,4 +1,4 @@
-import type { CodeReviewSection } from "./code-review";
+import type { AttributionKind } from "./code-review";
 
 export type TaskStatus =
   | "running"
@@ -22,9 +22,9 @@ export interface TaskPR {
   failingUrl?: string | null;
   // How many checks are registered on the head.
   checkCount?: number;
-  // The body's Code review section: null when it has none, undefined
-  // when the body wasn't read.
-  codeReview?: CodeReviewSection | null;
+  // The AI attribution the body carries (tasks/code-review.ts): null for
+  // none, undefined when the body wasn't read.
+  attribution?: AttributionKind | null;
   // The body's "Scope change" note (tasks/scope-change.ts), when it has one.
   scopeChange?: string | null;
   // GitHub's word on merging it into its base: CONFLICTING once the base

package/lib/usage/by-model.ts

@@ -0,0 +1,105 @@
+/**
+ * Spend by model and by role over a window: tokens of each kind, turns,
+ * and the estimated cost from the price table (lib/usage/cost).
+ */
+
+import { estimateCost, rowModel, UNRECORDED, type PricedRow } from "./cost";
+import type { ModelPrice } from "../models/providers";
+
+export interface ModelTurnRow extends PricedRow {
+  at: number;
+  role: string | null;
+}
+
+export interface TokenSpend {
+  inputTokens: number;
+  outputTokens: number;
+  cacheReadTokens: number;
+  cacheWriteTokens: number;
+  turns: number;
+  costUsd: number;
+  // Some of its turns are on a model the price table doesn't list.
+  unpriced: boolean;
+}
+
+export interface ModelSpend extends TokenSpend {
+  provider: string;
+  model: string;
+}
+
+export interface RoleSpend extends TokenSpend {
+  role: string;
+}
+
+export interface SpendByModel {
+  since: number;
+  total: TokenSpend;
+  models: ModelSpend[];
+  roles: RoleSpend[];
+}
+
+export const emptySpend = (): TokenSpend => ({
+  inputTokens: 0,
+  outputTokens: 0,
+  cacheReadTokens: 0,
+  cacheWriteTokens: 0,
+  turns: 0,
+  costUsd: 0,
+  unpriced: false,
+});
+
+export function addRow(
+  s: TokenSpend,
+  r: PricedRow,
+  prices: Record<string, ModelPrice>
+): void {
+  const cost = estimateCost(r, prices);
+  s.inputTokens += r.input_tokens;
+  s.outputTokens += r.output_tokens;
+  s.cacheReadTokens += r.cache_read_tokens;
+  s.cacheWriteTokens += r.cache_write_tokens;
+  s.turns += 1;
+  s.costUsd += cost.usd;
+  s.unpriced ||= !cost.priced;
+}
+
+export function spendByModel(
+  rows: ModelTurnRow[],
+  since: number,
+  prices: Record<string, ModelPrice>
+): SpendByModel {
+  const total = emptySpend();
+  const models = new Map<string, ModelSpend>();
+  const roles = new Map<string, RoleSpend>();
+  for (const r of rows) {
+    if (r.at < since) continue;
+    const { provider, model } = rowModel(r);
+    const mk = `${provider}/${model}`;
+    if (!models.has(mk)) models.set(mk, { ...emptySpend(), provider, model });
+    const role = r.role ?? UNRECORDED;
+    if (!roles.has(role)) roles.set(role, { ...emptySpend(), role });
+    for (const s of [total, models.get(mk)!, roles.get(role)!])
+      addRow(s, r, prices);
+  }
+  const byCost = (a: TokenSpend, b: TokenSpend) => b.costUsd - a.costUsd;
+  return {
+    since,
+    total,
+    models: [...models.values()].sort(byCost),
+    roles: [...roles.values()].sort(byCost),
+  };
+}
+
+export function sumSpend(xs: TokenSpend[]): TokenSpend {
+  const t = emptySpend();
+  for (const x of xs) {
+    t.inputTokens += x.inputTokens;
+    t.outputTokens += x.outputTokens;
+    t.cacheReadTokens += x.cacheReadTokens;
+    t.cacheWriteTokens += x.cacheWriteTokens;
+    t.turns += x.turns;
+    t.costUsd += x.costUsd;
+    t.unpriced ||= x.unpriced;
+  }
+  return t;
+}