@saadnvd1/agent-os 0.3.470 → 0.3.472

package/lib/orchestrator/rebase.ts

@@ -8,11 +8,10 @@
  * only while its agent is idle with nothing uncommitted, and pushed to the
  * task's own branch with a lease on the commit fetched (the restack's code,
  * stacks/git.ts). The base itself and every other branch are never written.
- * The heads are recorded so the task's Code review section still covers
- * the new head (tasks/code-review.ts), and the section gets a "Restacked:"
- * line for CI. When the PR's own patch is unchanged (same `git patch-id`
- * against the base before and after), the orchestrator's review of the old
- * head carries over; otherwise a fresh one starts.
+ * The heads are recorded, and when the PR's own patch is unchanged (same
+ * `git patch-id` against the base before and after), the orchestrator's
+ * review of the old head carries over to the new one (tasks/code-review.ts);
+ * otherwise a fresh one starts.
  *
  * Not clean, or not rebasable (uncommitted work, commits only on origin):
  * the task is asked once, per head, to rebase by hand. The orchestrator
@@ -28,7 +27,6 @@ import { hostLink } from "../hosts/remote-api";
 import type { TaskPR } from "../tasks/state";
 import { run } from "../tasks/gh";
 import { git as runGit, gitFetch, revParse } from "../git-exec";
-import { withRestackedLine } from "../tasks/code-review";
 import { outputOf, type Runner } from "../stacks/git";
 import { restackedHeads, stackNotice } from "../stacks/restack";
 import { getCheck, putCheck } from "./checks";
@@ -53,37 +51,6 @@ export interface RebaseDeps {
     pr: TaskPR,
     sha: string
   ) => Promise<unknown>;
-  // Add the Restacked line to the PR body's Code review section.
-  editBody: (
-    repo: string,
-    pr: number,
-    from: string,
-    to: string
-  ) => Promise<void>;
-}
-
-async function editBody(repo: string, pr: number, from: string, to: string) {
-  const body = await run(
-    "gh",
-    ["pr", "view", String(pr), "--json", "body", "--jq", ".body"],
-    repo,
-    15000
-  );
-  const next = withRestackedLine(body.replace(/\n$/, ""), from, to);
-  if (!next) return;
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "aos-body-"));
-  const file = path.join(dir, "body.md");
-  try {
-    fs.writeFileSync(file, next);
-    await run(
-      "gh",
-      ["pr", "edit", String(pr), "--body-file", file],
-      repo,
-      30000
-    );
-  } finally {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
 }
 
 const defaults: RebaseDeps = {
@@ -94,7 +61,6 @@ const defaults: RebaseDeps = {
   idle: async (task) => (await statusOf(task)).status === "idle",
   review: (w, task, pr, sha) =>
     reviewAt(w, taskReviewTarget(task, { ...pr, head: sha }), sha),
-  editBody,
 };
 
 // The (head, base tip) pairs already rebased or found not to need it, so a
@@ -263,11 +229,6 @@ async function rebaseOne(
       deps
     );
   }
-  if (heads.restacked_from && heads.restacked_to)
-    await deps
-      .editBody(repo, pr.number, heads.restacked_from, heads.restacked_to)
-      .catch(() => {});
-
   // The task's worktree follows while it's still idle and untouched;
   // otherwise the task is told how to catch up.
   const follows =
@@ -277,7 +238,7 @@ async function rebaseOne(
   if (!follows)
     await deps.send(
       task.id,
-      `AgentOS rebased your branch ${task.branch_name} onto ${branch} on origin (now ${short(to)}), because PR #${pr.number} conflicted with it. Your worktree is still on the old head: before changing anything, run \`git fetch origin && git reset --keep origin/${task.branch_name}\` (commit your work first). Your Code review section still covers it.`
+      `AgentOS rebased your branch ${task.branch_name} onto ${branch} on origin (now ${short(to)}), because PR #${pr.number} conflicted with it. Your worktree is still on the old head: before changing anything, run \`git fetch origin && git reset --keep origin/${task.branch_name}\` (commit your work first). Its review carries over when its own patch didn't change.`
     );
   const reviewed = await carryReview(workspaceId, task, pr, onto, to, deps);
   queueEvent(
@@ -422,6 +383,6 @@ async function askToRebase(
   );
   await deps.send(
     task.id,
-    `Your PR #${pr.number} conflicts with ${base}, and AgentOS couldn't rebase it for you: ${why.slice(0, 300)}. At your next stopping point: commit your work, run \`git fetch origin && git rebase origin/${base}\`, resolve the conflicts, re-run your checks, push with \`git push --force-with-lease\`, then run /do-code-review again and update the Code review section for the new head.`
+    `Your PR #${pr.number} conflicts with ${base}, and AgentOS couldn't rebase it for you: ${why.slice(0, 300)}. At your next stopping point: commit your work, run \`git fetch origin && git rebase origin/${base}\`, resolve the conflicts, re-run your checks, push with \`git push --force-with-lease\`. The orchestrator reviews the new head.`
   );
 }

package/lib/orchestrator/review.ts

@@ -38,6 +38,11 @@ import {
   toVerdict,
 } from "./review-prompt";
 import { checkScope } from "./scope";
+import {
+  checkRunRecorder,
+  checkRunTotals,
+  describeCheckRuns,
+} from "../usage/check-runs";
 import { workspaceTask } from "./targets";
 import { untrusted } from "./untrusted";
 
@@ -52,10 +57,8 @@ export function describeReview(row: CheckRow): string {
   if (row.status === "running") return `The review of ${at} is still running.`;
   if (row.status === "error")
     return `The review of ${at} couldn't run: ${row.detail}`;
-  const head =
-    row.status === "pass"
-      ? `Review of ${at}: pass.`
-      : `Review of ${at}: blocking findings.`;
+  const cost = checkRunTotals(row.session_id, row.sha);
+  const head = `${row.status === "pass" ? `Review of ${at}: pass.` : `Review of ${at}: blocking findings.`}${cost ? ` (${describeCheckRuns(cost)})` : ""}`;
   return row.detail ? `${head}\n${untrusted("reviewer", row.detail)}` : head;
 }
 
@@ -115,6 +118,14 @@ async function reviewJob(
   const amendments = task ? amendmentsOf(task.id).map((a) => a.text) : [];
   const scope = task ? { amendments, scopeClaim: pr.scopeChange ?? null } : {};
   const dir = await checkout(repo, sha);
+  const onUsage = checkRunRecorder({
+    workspaceId,
+    sessionId: target.id,
+    label: target.label,
+    prNumber: pr.number,
+    sha,
+    kind: "review",
+  });
   try {
     const verdicts = [];
     for (const [i, part] of parts.entries()) {
@@ -143,6 +154,9 @@ async function reviewJob(
         schema: REVIEW_SCHEMA,
         tools: ["Read", "Grep", "Glob"],
         allow: [`Read(/${dir}/**)`, `Grep(/${dir}/**)`, `Glob(/${dir}/**)`],
+        onUsage,
+        role: "review",
+        workspaceId,
       });
       verdicts.push(toVerdict(answer));
     }
@@ -246,11 +260,12 @@ export async function reviewAt(
           : done.status === "block"
             ? "found blocking issues"
             : "couldn't run";
+      const cost = checkRunTotals(target.id, sha);
       queueEvent(
         workspaceId,
         `review:${target.id}:${sha}`,
         target.id,
-        `${target.label}: review of ${short(sha)} ${said}${countVerdicts(workspaceId, target, sha)}`
+        `${target.label}: review of ${short(sha)} ${said}${cost ? ` (${describeCheckRuns(cost)})` : ""}${countVerdicts(workspaceId, target, sha)}`
       );
       return done;
     });

package/lib/orchestrator/scope.ts

@@ -8,6 +8,7 @@ import { connectedClient } from "../lumifyhub/connection";
 import { promptFromCard } from "../lumifyhub/task-cards";
 import { putCheck, type CheckRow } from "./checks";
 import type { ClaudeRunner } from "./claude-cli";
+import { checkRunRecorder } from "../usage/check-runs";
 import type { ChangedFile } from "./diff";
 import { fence } from "./review-prompt";
 
@@ -78,6 +79,16 @@ export async function checkScope(input: {
         prompt: `The card, as data:\n${fence("card", card)}${amended}\n\nFiles changed:\n${list}\n\n${label}\n${fence("diff", part)}`,
         schema: SCOPE_SCHEMA,
         tools: [],
+        onUsage: checkRunRecorder({
+          workspaceId,
+          sessionId: task.id,
+          label: `task ${task.name}`,
+          prNumber: task.pr_number ?? null,
+          sha,
+          kind: "scope",
+        }),
+        role: "scope",
+        workspaceId,
       })) as { within?: boolean; reason?: string };
       if (answer.within !== true) break;
     }

package/lib/orchestrator/serve.ts

@@ -1,3 +1,5 @@
+import { resumeOnModel } from "../models/resume";
+import { workspaceTask } from "./targets";
 import { getWorkspace } from "../workspaces";
 import {
   done,
@@ -33,6 +35,7 @@ const ACTING = new Set<ToolName>([
   "send",
   "message_orchestrator",
   "start_task",
+  "set_task_model",
   "start_session",
   "stack",
   "land",
@@ -97,8 +100,18 @@ export async function runTool(
         name: a.name,
         view: a.view,
         after: a.after,
+        model: a.model,
+        plan: a.plan,
       });
     }
+    case "set_task_model": {
+      const a = p(tool, raw);
+      const task = workspaceTask(w, a.task);
+      const out = await resumeOnModel(task.id, a.model, a.message);
+      return out.resumed
+        ? `Resumed ${task.name} on ${out.ref}: same conversation and worktree.`
+        : `${task.name} hasn't launched yet; it starts on ${out.ref}.`;
+    }
     case "start_session": {
       const a = p(tool, raw);
       return startSession(w, a.project, a.prompt, {

package/lib/orchestrator/signoff.ts

@@ -9,7 +9,7 @@
 
 import { MERGED_AS, type MergeMethod } from "../tasks/merge-policy";
 import { prFor } from "../tasks/session";
-import { codeReviewRefusal, signOffTask } from "../tasks";
+import { codeReviewGate, signOffTask } from "../tasks";
 import { signOffRefusal } from "../stacks/guard";
 import { getStack, landInBackground } from "../stacks";
 import { LAND_DEFAULTS } from "../stacks/land";
@@ -91,11 +91,12 @@ export async function judge(
       fromCard: !!task.lh_card_id,
       scope: getCheck(task.id, sha, "scope"),
       stackRefusal: landing ? null : signOffRefusal(task.id),
-      codeReviewRefusal: codeReviewRefusal(
-        pr.codeReview,
-        sha,
-        restackedOf(task)
-      ),
+      codeReview: codeReviewGate({
+        head: sha,
+        attribution: pr.attribution,
+        review: (at) => getCheck(task.id, at, "review"),
+        restacked: restackedOf(task),
+      }),
     }),
     opts
   );
@@ -129,7 +130,8 @@ export async function gateVerdict(
   const held = holdingEscalations(work.id);
   // Saad approved merging this exact commit. On an ask the orchestrator
   // raised (ask_saad with its task and sha), held or not, it merges once
-  // whatever the gates say, but only with a code review of that commit and
+  // whatever the gates say, but only once an independent review of that
+  // commit finished (its findings are his to override, not that it ran) and
   // 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).
@@ -139,7 +141,10 @@ export async function gateVerdict(
     (approval.raised_by === "orchestrator" || !held.length)
   ) {
     const i = await inputs();
-    const refusal = i.codeReviewRefusal ?? i.stackRefusal;
+    const refusal =
+      i.codeReview.refusal ??
+      (i.codeReview.ran ? null : i.codeReview.wait) ??
+      i.stackRefusal;
     if (refusal)
       return no(
         `${work.name} (PR #${pr.number} at ${short(sha)}): Saad approved this commit, but ${refusal}`

package/lib/orchestrator/tool-names.ts

@@ -14,6 +14,7 @@ export const TOOL_NAMES = {
   orchestrators: name("orchestrators"),
   message_orchestrator: name("message_orchestrator"),
   start_task: name("start_task"),
+  set_task_model: name("set_task_model"),
   start_session: name("start_session"),
   stack: name("stack"),
   stack_status: name("stack_status"),

package/lib/orchestrator/tool-schemas.ts

@@ -6,6 +6,7 @@ import { BRANCH_NAME } from "../git";
 import { RAISED_KINDS } from "./asks";
 import { MAX_RULE_CHARS } from "./rules";
 import { PROJECT_NAME } from "../project-add/name";
+import { TASK_ROLES, type ModelRole } from "../models/roles";
 
 const ref = (what: string) => z.string().trim().min(1).max(300).describe(what);
 const session = ref("Session name, project/name, or id from sessions");
@@ -19,6 +20,23 @@ const view = z
     "How its agent runs: chat (the default), or terminal only when the job needs a TUI (an interactive program, a full-screen tool)"
   );
 
+const modelRef = z
+  .string()
+  .trim()
+  .regex(/^[a-z0-9][a-z0-9_-]*\/[\w.:@/-]+$/i, 'not "provider/model"');
+const modelOverride = z
+  .union([
+    modelRef,
+    z.partialRecord(
+      z.enum(TASK_ROLES as [ModelRole, ...ModelRole[]]),
+      modelRef
+    ),
+  ])
+  .optional()
+  .describe(
+    "Its own model, as \"provider/model\" (anthropic/claude-sonnet-5-5, deepseek/deepseek-v4-pro) for all its roles, or a map of role (plan, implement, review, scope) to one. Default: the workspace's and Settings' role models; another provider only when asked"
+  );
+
 export const TOOL_SHAPES = {
   sessions: {},
   read: {
@@ -79,6 +97,26 @@ export const TOOL_SHAPES = {
       .describe(
         'Queue it until this task finishes (id or name), or "any" for whichever running task finishes first'
       ),
+    model: modelOverride,
+    plan: z
+      .boolean()
+      .optional()
+      .describe(
+        "Plan first on the planning model, then implement on the implementation model (default: Settings)"
+      ),
+  },
+  set_task_model: {
+    task,
+    model: modelOverride.unwrap(),
+    message: z
+      .string()
+      .trim()
+      .min(1)
+      .max(8000)
+      .optional()
+      .describe(
+        "What it's told on resuming (default: carry on where it left off)"
+      ),
   },
   start_session: {
     project,

package/lib/orchestrator/tools.ts

@@ -61,7 +61,9 @@ 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). 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. 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.",
   stack:

package/lib/pr-generation.ts

@@ -1,3 +1,4 @@
+import { routedRun } from "./models/launch";
 import { execFile } from "child_process";
 import { git as runGit } from "./git-exec";
 import { run } from "./tasks/gh";
@@ -154,13 +155,15 @@ async function generateWithClaude(
 
 // `claude --print` with the prompt on stdin, off the event loop and killed
 // at the ceiling.
-function claudePrint(cwd: string, prompt: string): Promise<string> {
+async function claudePrint(cwd: string, prompt: string): Promise<string> {
+  const routed = await routedRun("helper");
   return new Promise((resolve, reject) => {
     const child = execFile(
       "claude",
-      ["--print"],
+      ["--print", "--model", routed.model],
       {
         cwd,
+        env: { ...process.env, ...routed.env },
         encoding: "utf-8",
         timeout: 30_000,
         killSignal: "SIGKILL",

package/lib/providers/registry.ts

@@ -73,7 +73,7 @@ export const PROVIDERS: ProviderDefinition[] = [
     supportsFork: true,
     resumeArgs: (id) => ["--resume", id],
     forkArgs: (id) => ["--resume", id, "--fork-session"],
-    modelFlag: undefined, // Claude doesn't expose model flag
+    modelFlag: "--model",
     initialPromptFlag: "", // Positional argument
   },
   {

package/lib/session-audit/render.ts

@@ -427,7 +427,7 @@ export function renderSummary(
     )
   );
   out.push(
-    "\nThe reviewer the orchestrator runs (`review`) uses `claude -p --no-session-persistence` and leaves no transcript; reviews are counted from the checks above and from do-code-review subagents."
+    "\nThe reviewer the orchestrator runs (`review`) uses `claude -p --no-session-persistence` and leaves no transcript; each run's tokens are recorded in `check_runs` and shown in Usage."
   );
   return out.join("\n") + "\n";
 }

package/lib/session-titles.ts

@@ -174,7 +174,7 @@ export async function generateTitle(
       prompt: input,
       schema: SCHEMA,
       tools: [],
-      model: process.env.AGENTOS_TITLE_MODEL || "haiku",
+      role: "helper",
       timeoutMs: 30_000,
     })) as { title?: unknown };
     return cleanTitle(out?.title);

package/lib/sessions/launch.ts

@@ -11,6 +11,8 @@ 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 { ANTHROPIC } from "../models/roles";
 import { getProject } from "../projects";
 import { getHost, isRemoteHost } from "../hosts";
 import { hostLink } from "../hosts/remote-api";
@@ -214,14 +216,26 @@ async function launch(input: LaunchInput, id: string): Promise<Launched> {
     await fs.promises.mkdir(SCRATCH_DIR, { recursive: true });
 
   const agentType = input.agentType;
-  const model = resolveModelForAgent(
-    agentType,
-    input.model?.trim() || project?.default_model
-  );
   const view =
     input.view === "terminal" || !supportsChat(agentType) || remote
       ? "terminal"
       : 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 routed =
+    agentType === "claude" && !input.model?.trim() && !remote
+      ? resolveRole("interactive", { workspaceId: project?.workspace_id })
+      : null;
+  const interactive =
+    routed && (routed.provider.id === ANTHROPIC || view === "chat")
+      ? routed
+      : null;
+  const model = interactive
+    ? interactive.model
+    : resolveModelForAgent(
+        agentType,
+        input.model?.trim() || project?.default_model
+      );
   const text = input.prompt?.trim() ?? "";
   const naming: Naming = text
     ? await nameFor(text, projectPath, input.name)
@@ -252,6 +266,7 @@ async function launch(input: LaunchInput, id: string): Promise<Launched> {
   db.prepare(
     `UPDATE sessions SET view = ?, name_source = ?, setup_status = ? WHERE id = ?`
   ).run(view, naming.source, useWorktree ? "running" : null, id);
+  if (interactive) setSessionModel(id, interactive);
   if (input.access)
     db.prepare(`UPDATE sessions SET chat_access = ? WHERE id = ?`).run(
       input.access,

package/lib/settings-url.ts

@@ -7,6 +7,7 @@ export const SETTINGS_PARAM = "settings";
 export const SETTINGS_SECTIONS = [
   "merging",
   "workspaces",
+  "models",
   "devices",
   "notifications",
   "schedules",

package/lib/stacks/land.ts

@@ -1,7 +1,7 @@
 /**
  * Land a stack: merge every PR bottom-up, ported from dispatch's `land`.
- * A preflight checks EVERY PR before anything merges: CI, and a Code review
- * section in its body for its head commit. Each sign-off restacks
+ * A preflight checks EVERY PR before anything merges: CI, and a passing
+ * independent review of its head commit (tasks/code-review.ts). Each sign-off restacks
  * what sits on it, so a restacked PR's checks are waited out again (its green
  * was against the parent's branch). It stops at the first failure and says
  * what landed. A chat item's agent is stopped between turns before anything
@@ -17,6 +17,8 @@ import {
   codeReviewRefusal,
   type TaskPR,
 } from "../tasks";
+import type { ReviewState } from "../tasks/code-review";
+import { getCheck } from "../orchestrator/checks";
 import { itemName } from "./guard";
 import { refreshItems } from "./tick";
 import { outputOf } from "./git";
@@ -34,6 +36,8 @@ export interface LandDeps {
   signOff: (sessionId: string, head?: string) => Promise<void>;
   beforeMerge?: MergeGate;
   prOf: (session: Session) => Promise<TaskPR | null>;
+  // The independent review of a task at a commit.
+  reviewOf: (sessionId: string, sha: string) => ReviewState | null;
   sleep: (ms: number) => Promise<void>;
   refresh: (stackId: string) => Promise<void>;
   waitMs: number;
@@ -52,6 +56,7 @@ export const LAND_DEFAULTS: LandDeps = {
     await signOffTask(id, { wait: true, head });
   },
   prOf: (s) => taskPR(s, true),
+  reviewOf: (id, sha) => getCheck(id, sha, "review"),
   sleep: (ms) => new Promise((r) => setTimeout(r, ms)),
   refresh: refreshItems,
   waitMs: 45 * 60_000,
@@ -90,8 +95,20 @@ async function waitGreen(
   }
 }
 
+// Why an item can't merge on its review: none passed of its head, or of
+// the head the task pushed before a restack moved it.
+function unreviewed(item: StackItemRow, pr: TaskPR, deps: LandDeps) {
+  return codeReviewRefusal({
+    head: pr.head,
+    attribution: pr.attribution,
+    review: (sha) =>
+      item.session_id ? deps.reviewOf(item.session_id, sha) : null,
+    restacked: { from: item.restacked_from, to: item.restacked_to },
+  });
+}
+
 // Without the orchestrator's gate: the item's head right before merging,
-// only if its Code review section covers that commit. A push since the
+// only if a passing review covers that commit. A push since the
 // preflight needs a new review; the merge is pinned to this head.
 async function reviewedHead(
   item: StackItemRow,
@@ -100,12 +117,7 @@ async function reviewedHead(
   const now = q.item(db, item.id) ?? item;
   const session = sessionOf(now.session_id);
   const pr = session ? await deps.prOf(session) : null;
-  const refusal = pr
-    ? codeReviewRefusal(pr.codeReview, pr.head, {
-        from: now.restacked_from,
-        to: now.restacked_to,
-      })
-    : "its PR is gone";
+  const refusal = pr ? unreviewed(now, pr, deps) : "its PR is gone";
   if (refusal) throw new Stop(`stopped at ${itemName(now)}: ${refusal}`);
   return pr!.head!;
 }
@@ -157,14 +169,9 @@ export async function landStack(
       const pr =
         session && item.status === "pr" ? await deps.prOf(session) : null;
       const verdict = canSignOff(pr);
-      const unreviewed =
-        pr &&
-        codeReviewRefusal(pr.codeReview, pr.head, {
-          from: item.restacked_from,
-          to: item.restacked_to,
-        });
+      const refusal = pr && unreviewed(item, pr, deps);
       if (!verdict.ok) missing.push(`${itemName(item)}: ${verdict.reason}`);
-      else if (unreviewed) missing.push(`${itemName(item)}: ${unreviewed}`);
+      else if (refusal) missing.push(`${itemName(item)}: ${refusal}`);
       else if (item.error) missing.push(`${itemName(item)}: ${item.error}`);
       hadChecks.set(item.id, pr?.checks !== "none");
     }

package/lib/tasks/brief.ts

@@ -16,18 +16,9 @@ function stackedLines(baseBranch: string, stack: StackedOn): string {
   return `
 - This task is STACKED on ${stack.name} (${on}), which has not merged. Its commits are already in your branch and are not yours: don't change or revert them.
 - Open your pull request against ${baseBranch} (\`gh pr create --base ${baseBranch}\`) so its diff is only your commits, and start the body with the line "Stacked on ${on} (${stack.name})".
-- Never merge or rebase onto the default branch yourself. When the parent merges, AgentOS rebases your branch and retargets your PR, then tells you; re-run your checks when it does. Your code review still counts for the head AgentOS's restack left; if you push after that, review again and update the section.${also}`;
+- Never merge or rebase onto the default branch yourself. When the parent merges, AgentOS rebases your branch and retargets your PR, then tells you; re-run your checks when it does. AgentOS reviews your PR itself; a review of your head still counts for the head its restack left, and a push after that gets a new one.${also}`;
 }
 
-// What the PR body's review section looks like. lib/tasks/code-review.ts
-// parses it, and merges refuse a PR without one for its head commit.
-export const CODE_REVIEW_SECTION = `
-  ## Code review
-  Reviewed: <the full sha of the commit you reviewed, which is the PR's head>
-  Agents: <the review agents that ran>
-  Fixed: <each finding fixed, one line each, or "none">
-  Deferred: <each finding not fixed and why, or "none">`;
-
 // The system brief every task agent runs under. It finishes by opening a PR
 // and stopping: merging is the human's sign-off, never the agent's.
 export function buildTaskBrief(opts: {
@@ -39,10 +30,8 @@ export function buildTaskBrief(opts: {
 
 - Branch: ${opts.branch} (based on ${opts.baseBranch}). Stay in this directory and on this branch.
 - Do the task fully. Run the project's own checks (typecheck, tests, lint) when they exist and keep them passing.
-- When the work is done, commit with a conventional commit message, then review it before any pull request: run \`/do-code-review\` (the project's skill in .claude/skills/do-code-review; if the project has none, \`/code-review\`). Fix every Blocking and High finding, commit, and review again until none are left (two rounds at most; past that, list what's still open in the PR body).
-- Then run \`git push -u origin ${opts.branch}\` and open a pull request against ${opts.baseBranch} with \`gh pr create\`, using a clear title and a short body that says what changed and how you verified it, and ends with this section:
-${CODE_REVIEW_SECTION}
-  Merges are refused without it, and when its "Reviewed:" commit is not the PR's head: if you push again, review again and update the body (\`gh pr edit --body-file\`). Then stop and wait.
+- When the work is done, commit with a conventional commit message, run \`git push -u origin ${opts.branch}\` and open a pull request against ${opts.baseBranch} with \`gh pr create\`, using a clear title and a short body that says what changed and how you verified it. Then stop and wait.
+- You don't need to review it yourself: AgentOS runs an independent review of the PR's exact head commit before it can merge, and the orchestrator sends you any blocking findings to fix. For a risky change you may still run \`/do-code-review\` (or \`/code-review\`) before the PR.
 - Never merge the pull request, never push to ${opts.baseBranch}, and never delete branches or worktrees. A human reviews and merges.${opts.stack ? stackedLines(opts.baseBranch, opts.stack) : ""}
 - Write scratch files (PR bodies, review notes, logs, test output) outside the worktree, in your scratchpad or \$TMPDIR. Anything uncommitted left in the worktree keeps it from being removed when the task is done.
 - Do not add any AI or assistant attribution to commits or the pull request.