@saadnvd1/agent-os 0.3.470 → 0.3.471

package/lib/chat/worker/host.ts

@@ -29,7 +29,11 @@ import {
 } from "../store";
 import { claimNext, enqueue, listQueue, moveToFront } from "../queued";
 import { isHeld } from "../hold";
-import { recordTurn, startingTotals } from "../../usage/turns";
+import {
+  recordCompaction,
+  recordTurn,
+  startingTotals,
+} from "../../usage/turns";
 import {
   VISUALS_BRIEF,
   VISUALS_SERVER,
@@ -37,7 +41,7 @@ import {
 } from "../../artifacts/tools";
 import type { RoleExtras } from "./extras";
 import { refreshSettings, refreshedNote } from "../refresh";
-import { staleLabel, staleness, type Staleness } from "../stale";
+import { compactionDue, staleLabel, type Staleness } from "../stale";
 import type { WorkerCommand, WorkerEvent } from "./protocol";
 
 // How soon after a stopped turn ends a turn the agent starts on its own
@@ -127,15 +131,17 @@ export class ChatHost {
   private contextBase: number | null = null;
   // How full the conversation was at its last turn's end (lib/chat/stale).
   private context: ChatContext | null = null;
-  // A compaction run ahead of a message to a stale chat: the message waits
-  // at the front of the queue until it ends (compactFirst).
+  // A compaction run ahead of a message (compactFirst): the message waits
+  // at the front of the queue until it ends.
   private compacting: {
-    idleMs: number;
+    // Set when it ran because the chat was stale.
+    idleMs?: number;
     before: number;
     done?: boolean;
   } | null = null;
   // Its line, until the agent's next measure gives the size after.
   private compactedLine: Extract<ChatItem, { kind: "compacted" }> | null = null;
+  private compactedBy = "threshold";
   // An orchestrator gone stale starts over rather than compacting.
   private staleRefresh: Staleness | null = null;
   readonly done: Promise<void>;
@@ -253,8 +259,10 @@ export class ChatHost {
           // a failed one printed still shows.
           if (this.compacting?.done && e.item.kind === "command_output")
             continue;
-          if (this.compacting && e.item.kind === "compacted")
-            e.item = this.compactedItem(e.item);
+          if (e.item.kind === "compacted") {
+            if (this.compacting) e.item = this.compactedItem(e.item);
+            else this.logCompacted(e.item, e.item.trigger ?? "manual");
+          }
           if ("streaming" in e.item && e.item.streaming)
             this.streaming.set(e.item.id, e.item);
           else this.streaming.delete(e.item.id);
@@ -663,15 +671,19 @@ export class ChatHost {
     this.close();
   }
 
-  // A stale chat (lib/chat/stale) is compacted before the message goes in,
-  // only between turns: the message waits at the front of the queue, and
-  // the compaction's end sends it. "yes" is the reader's choice, made on
-  // what the composer showed; "auto" checks for itself.
+  // A chat over the compact threshold or stale (lib/chat/stale) is
+  // compacted before the message goes in, only between turns: the message
+  // waits at the front of the queue, and the compaction's end sends it.
+  // "yes" is the reader's choice, made on what the composer showed; "auto"
+  // checks for itself.
   private compactFirst(cmd: Extract<WorkerCommand, { type: "send" }>): boolean {
     if (!cmd.compact || this.busy() || this.closed || this.handingOver())
       return false;
     const stale = this.staleNow(cmd.compact);
-    if (!stale) return false;
+    // An orchestrator starts over at its own threshold (lib/chat/refresh);
+    // only one gone stale does it early.
+    if (!stale || (this.session.role === "orchestrator" && !stale.stale))
+      return false;
     try {
       enqueue(this.session.id, cmd);
     } catch {
@@ -692,13 +704,16 @@ export class ChatHost {
       this.retireIfDone();
       return true;
     }
-    this.compacting = { idleMs: stale.idleMs, before: stale.tokens };
+    this.compacting = {
+      idleMs: stale.stale ? stale.idleMs : undefined,
+      before: stale.tokens,
+    };
     this.currentTurn = null;
     this.stopping = null;
     this.conversation.send("/compact");
     this.setState("running");
     console.error(
-      `${new Date().toISOString()} compacting ${this.session.id} before a message: idle ${Math.round(stale.idleMs / 60_000)}m, ${stale.tokens} tokens`
+      `${new Date().toISOString()} compacting ${this.session.id} before a message: ${stale.stale ? `idle ${Math.round(stale.idleMs / 60_000)}m, ` : ""}${stale.tokens} tokens`
     );
     return true;
   }
@@ -707,11 +722,17 @@ export class ChatHost {
     const context = this.context;
     // Only an agent that says which cache it uses has one to lose.
     if (!context?.cacheTtlMs) return null;
-    if (compact === "yes")
-      return { idleMs: Date.now() - context.at, tokens: context.usedTokens };
-    return staleness(context, {
+    if (compact === "yes") {
+      const idleMs = Date.now() - context.at;
+      return {
+        idleMs,
+        tokens: context.usedTokens,
+        stale: idleMs > context.cacheTtlMs,
+      };
+    }
+    return compactionDue(context, {
       state: this.state,
-      thresholdTokens: refreshSettings().staleCompactTokens,
+      thresholdTokens: refreshSettings().compactTokens,
     });
   }
 
@@ -724,8 +745,9 @@ export class ChatHost {
       idleMs: this.compacting?.idleMs,
       before: item.before ?? this.compacting?.before,
     };
+    this.compactedBy = line.idleMs !== undefined ? "stale" : "threshold";
     this.compactedLine = line.after === undefined ? line : null;
-    if (line.after !== undefined) this.logCompacted(line);
+    if (line.after !== undefined) this.logCompacted(line, this.compactedBy);
     return line;
   }
 
@@ -736,13 +758,26 @@ export class ChatHost {
     this.compactedLine = null;
     const settled = { ...line, after: usedTokens };
     this.record(settled);
-    this.logCompacted(settled);
+    this.logCompacted(settled, this.compactedBy);
   }
 
-  private logCompacted(line: { before?: number; after?: number }): void {
+  // Logged, and kept for the usage history (lib/usage/turns).
+  private logCompacted(
+    line: { before?: number; after?: number },
+    trigger: string
+  ): void {
     console.error(
-      `${new Date().toISOString()} compacted ${this.session.id}: ${line.before ?? "?"} -> ${line.after ?? "?"} tokens`
+      `${new Date().toISOString()} compacted ${this.session.id} (${trigger}): ${line.before ?? "?"} -> ${line.after ?? "?"} tokens`
     );
+    try {
+      recordCompaction(this.session, {
+        trigger,
+        before: line.before,
+        after: line.after,
+      });
+    } catch (e) {
+      console.error(`recording ${this.session.id}'s compaction:`, e);
+    }
   }
 
   // Past its threshold, once: it retires at the next turn boundary, as for

package/lib/db/migrations.ts

@@ -1358,6 +1358,48 @@ const migrations: Migration[] = [
       `);
     },
   },
+  {
+    id: 60,
+    name: "check_runs_and_compactions",
+    up: (db) => {
+      // What each run of the independent reviewer and the scope check cost,
+      // from its claude -p result: it leaves no transcript, so this is the
+      // only record. And each compaction a chat's agent made, so tokens per
+      // task can be compared before and after the threshold moved.
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS check_runs (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          workspace_id TEXT NOT NULL,
+          session_id TEXT NOT NULL,
+          label TEXT NOT NULL,
+          pr_number INTEGER,
+          sha TEXT NOT NULL,
+          kind TEXT NOT NULL,
+          model TEXT,
+          input_tokens INTEGER NOT NULL,
+          cache_write_tokens INTEGER NOT NULL,
+          cache_read_tokens INTEGER NOT NULL,
+          output_tokens INTEGER NOT NULL,
+          cost_usd REAL NOT NULL,
+          duration_ms INTEGER,
+          at INTEGER NOT NULL
+        );
+        CREATE INDEX IF NOT EXISTS idx_check_runs_at ON check_runs(at);
+        CREATE INDEX IF NOT EXISTS idx_check_runs_sha ON check_runs(session_id, sha, kind);
+        CREATE TABLE IF NOT EXISTS chat_compactions (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          session_id TEXT NOT NULL,
+          session_name TEXT NOT NULL,
+          workspace_id TEXT,
+          at INTEGER NOT NULL,
+          trigger TEXT NOT NULL,
+          before_tokens INTEGER,
+          after_tokens INTEGER
+        );
+        CREATE INDEX IF NOT EXISTS idx_chat_compactions_at ON chat_compactions(at);
+      `);
+    },
+  },
 ];
 
 // `upTo`: stop after this id (tests that start from an older database).

package/lib/orchestrator/armed.ts

@@ -126,8 +126,7 @@ function fingerprint(
     (f.task?.ciSettleIn ?? 0) > 0,
     getCheck(task.id, head, "review")?.status,
     getCheck(task.id, head, "scope")?.status,
-    pr.codeReview?.sha,
-    pr.codeReview?.attribution,
+    pr.attribution,
     f.task?.blocked,
     f.status,
     f.needsInput,

package/lib/orchestrator/brief.ts

@@ -41,16 +41,16 @@ You may act without asking on anything inside this workspace that's additive or
 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:
 - ci: CI is green on the PR's head commit and has settled (the commit is 2 minutes old and no new check has appeared for 2 minutes). A repository with no CI goes to Saad.
 - review: an independent review of that exact commit passed. Run \`review\` on the task; it starts a fresh read-only reviewer in the background and its verdict reaches you as an event. A new commit needs a new review. The reviewer judges the PR against the task's brief plus every scope change you recorded on it with \`send\` and scope_change; a "Scope change" note in the PR body counts only where one of those backs it. When Saad changes a running task's scope, always tell the task that way.
-- code-review: the PR body has a "Code review" section (from the task's own \`/do-code-review\`) whose "Reviewed:" line names that exact commit, or the commit AgentOS restacked or rebased into it while the head is still the one AgentOS left. A task that pushed after its review has to review again and update the body; tell it so.
+- code-review: a passing review (the gate above) covers that exact commit, or the commit AgentOS restacked or rebased into it while the head is still the one AgentOS left, and the PR body carries no AI attribution. Tasks don't review themselves or write a "Code review" section any more: your review is the one review, so don't ask a task for one.
 - blocked: no BLOCKED: line and no approval or question waiting in the task's chat or terminal.
 - scope: the diff stays in the task's repository, adds no secrets, isn't only lockfiles, and, for a task from a card, a check against the card (run with the review) says it's within what the card asks.
 - stack: a stacked task's parent has merged.
 
-PRs AgentOS didn't open (dispatch on another machine, a person, dependabot) go through the same \`sign_off\` and \`review\`: name one by #N, owner/repo#N or its URL. It must be open, in the repository of one of this workspace's projects (anything else is refused), and not from a fork. It's an external PR: there's no task or session behind it, so the gates read it differently. blocked: a draft isn't ready yet, and a label like "blocked", "do not merge" or "wip" holds it. code-review: a body with no "Code review" section is fine once your \`review\` of that exact head passes (dispatch writes its review up its own way); a section it does have must name the head, like a task's. ci, review, scope, Saad's approvals and his hold are the same as for a task, and a stack never applies. A PR that turns out to be a task's is gated as that task.
+PRs AgentOS didn't open (dispatch on another machine, a person, dependabot) go through the same \`sign_off\` and \`review\`: name one by #N, owner/repo#N or its URL. It must be open, in the repository of one of this workspace's projects (anything else is refused), and not from a fork. It's an external PR: there's no task or session behind it, so the gates read it differently. blocked: a draft isn't ready yet, and a label like "blocked", "do not merge" or "wip" holds it. code-review: your \`review\` of that exact head is what counts, as for a task; a "Code review" section in its body is ignored. ci, review, scope, Saad's approvals and his hold are the same as for a task, and a stack never applies. A PR that turns out to be a task's is gated as that task.
 
 Arm a task once its work is what you want merged, rather than calling \`sign_off\` and waiting: \`arm\` makes AgentOS merge it the moment every gate passes at its head (it starts the review itself once CI is green), and you hear one event, "merged" or the failure. A failure counts like sign_off's, once per head, and the task stays armed for the fix; one that goes to Saad disarms it, as does an open ask_saad about that task (it merges on his answer). Don't poll an armed task with sign_off. \`disarm\` takes it back.
 
-When the base moves and a task's PR conflicts with it, AgentOS rebases it onto the base by itself if that's clean and its agent is idle with nothing uncommitted, pushes only the task's own branch, and tells you with one event. The task's Code review section still covers the rebased head, and your review of the old head carries over when the PR's own patch is unchanged (a fresh one starts otherwise). If it conflicts, the task is asked once to rebase and you get one event; don't send it the same request.
+When the base moves and a task's PR conflicts with it, AgentOS rebases it onto the base by itself if that's clean and its agent is idle with nothing uncommitted, pushes only the task's own branch, and tells you with one event. Your review of the old head carries over when the PR's own patch is unchanged (a fresh one starts otherwise). If it conflicts, the task is asked once to rebase and you get one event; don't send it the same request.
 
 Tasks are woken by AgentOS itself when a check fails on their PR's head (with the failing step and the log around the error) and when a collaborator reviews or comments on their PR, and you get one "task X woken: ..." line for each. Don't message a task about the same failure or review; act only if it doesn't fix it.
 

package/lib/orchestrator/claude-cli.ts

@@ -9,6 +9,7 @@
  */
 
 import { spawn } from "child_process";
+import { runUsageOf, type RunUsage } from "../usage/check-runs";
 
 export interface ClaudeRun {
   cwd: string;
@@ -22,6 +23,8 @@ export interface ClaudeRun {
   timeoutMs?: number;
   // A model alias or id; the review model (or the CLI's default) otherwise.
   model?: string;
+  // What the run cost, from its result, even when it failed.
+  onUsage?: (usage: RunUsage) => void;
 }
 
 export type ClaudeRunner = (run: ClaudeRun) => Promise<unknown>;
@@ -115,6 +118,8 @@ export const runClaude: ClaudeRunner = (run) =>
           result?: string;
           structured_output?: unknown;
         };
+        const usage = runUsageOf(result);
+        if (usage) run.onUsage?.(usage);
         if (result.is_error || result.structured_output === undefined)
           throw new Error(result.result || "No answer");
         resolve(result.structured_output);

package/lib/orchestrator/diff.ts

@@ -93,7 +93,7 @@ const SENSITIVE: { why: string; test: RegExp }[] = [
     // What merges check a PR's code review with: a change that weakens it
     // must not merge through it.
     why: "the code review gate",
-    test: /^(lib\/tasks\/code-review\.ts|scripts\/check-code-review\.ts)$/i,
+    test: /^lib\/tasks\/code-review\.ts$/i,
   },
   {
     why: "secrets handling",

package/lib/orchestrator/external-gates.ts

@@ -12,11 +12,11 @@
 
 import { MERGED_AS, mergePolicy } from "../tasks/merge-policy";
 import { mergePR } from "../tasks/merge-pr";
-import { attributionIn, codeReviewRefusal } from "../tasks/code-review";
+import { attributionIn, codeReviewGate } from "../tasks/code-review";
 import { run } from "../tasks/gh";
 import { refundApproval, spendApproval } from "./ask-approvals";
 import { resolveAsks } from "./asks";
-import { clearStaleRunning, getCheck, type CheckRow } from "./checks";
+import { clearStaleRunning, getCheck } from "./checks";
 import { gateTarget, type ExternalPR } from "./external-pr";
 import { holdingEscalations } from "./gates";
 import { addNote } from "./notes";
@@ -39,44 +39,6 @@ const refsOf = (ext: ExternalPR) => ({
   branch_name: ext.branch,
 });
 
-// The code-review gate: a section in the body must cover the head like a
-// task's; with none, the independent review of the head stands in.
-export function externalCodeReview(
-  ext: Pick<ExternalPR, "name" | "body" | "pr">,
-  sha: string,
-  review: CheckRow | null
-): { refusal: string | null; wait: string | null } {
-  const attribution = attributionIn(ext.body);
-  if (attribution)
-    return {
-      refusal: `the PR body carries AI attribution (${attribution}): remove it with \`gh pr edit --body-file\``,
-      wait: null,
-    };
-  const section = ext.pr.codeReview;
-  if (section !== null)
-    return {
-      refusal: codeReviewRefusal(
-        section,
-        sha,
-        null,
-        `${ext.name}'s "Code review" section has to name ${short(sha)} on a "Reviewed:" line, or come out of the body`
-      ),
-      wait: null,
-    };
-  const none = `${ext.name}'s body has no "Code review" section; for a PR AgentOS didn't open, the orchestrator's own review of ${short(sha)} stands in for it`;
-  if (review?.sha === sha && review.status === "pass")
-    return { refusal: null, wait: null };
-  return {
-    refusal: null,
-    wait:
-      review?.sha === sha && review.status === "running"
-        ? `${none}, and it's still running`
-        : review?.sha === sha && review.status === "block"
-          ? `${none}, and it has blocking findings`
-          : `${none}: call review`,
-  };
-}
-
 export async function judgeExternal(
   workspaceId: string,
   ext: ExternalPR,
@@ -102,7 +64,6 @@ export async function judgeExternal(
     },
     async () => {
       const review = getCheck(ext.id, sha, "review");
-      const code = externalCodeReview(ext, sha, review);
       const label = ext.labels.find((l) => BLOCKED_LABEL.test(l));
       return {
         checks: pr.checks,
@@ -124,8 +85,12 @@ export async function judgeExternal(
         fromCard: false,
         scope: null,
         stackRefusal: null,
-        codeReviewRefusal: code.refusal,
-        codeReviewWait: code.wait,
+        // The same gate as a task's: the review of this exact head.
+        codeReview: codeReviewGate({
+          head: sha,
+          attribution: attributionIn(ext.body) ?? null,
+          review: (at) => getCheck(ext.id, at, "review"),
+        }),
       };
     },
     opts

package/lib/orchestrator/gates.ts

@@ -11,6 +11,7 @@
  */
 
 import { db } from "../db";
+import type { CodeReviewGate } from "../tasks/code-review";
 import type { ChecksVerdict } from "../tasks/state";
 import type { CheckRow } from "./checks";
 import { APPROVAL_GATES, mergeApprovalsOn } from "./merge-approvals";
@@ -45,11 +46,9 @@ export interface GateInput {
   fromCard: boolean;
   scope: CheckRow | null;
   stackRefusal: string | null;
-  // Why the PR body's Code review section doesn't cover this commit.
-  codeReviewRefusal: string | null;
-  // Why it isn't covered yet but will be (an external PR whose own review
-  // of this commit stands in for the section).
-  codeReviewWait?: string | null;
+  // Whether a passing independent review covers this commit, and the body
+  // carries no AI attribution (tasks/code-review.ts).
+  codeReview: CodeReviewGate;
   // A PR no task owns has no session to read: a draft isn't ready yet, and
   // a label saying it's blocked holds it.
   prDraft?: string | null;
@@ -147,11 +146,12 @@ export function evaluateGates(i: GateInput): GateOutcome[] {
   const stack: GateOutcome = i.stackRefusal
     ? { gate: "stack", state: "fail", reason: i.stackRefusal }
     : { gate: "stack", state: "pass" };
-  const codeReview: GateOutcome = i.codeReviewRefusal
-    ? { gate: "code-review", state: "fail", reason: i.codeReviewRefusal }
-    : i.codeReviewWait
-      ? { gate: "code-review", state: "wait", reason: i.codeReviewWait }
-      : { gate: "code-review", state: "pass" };
+  // Its wait is the review gate's own (no passing review of this exact
+  // head), which already holds the merge: only paths without that gate (an
+  // approval, a stack's land) read it.
+  const codeReview: GateOutcome = i.codeReview.refusal
+    ? { gate: "code-review", state: "fail", reason: i.codeReview.refusal }
+    : { gate: "code-review", state: "pass" };
   return [
     ciGate(i),
     checkGate("review", i.review, i.sha),

package/lib/orchestrator/pr-wake.ts

@@ -272,7 +272,7 @@ export function checkMessage(
     : pr.failingUrl
       ? `\n\nIts details: ${untrusted("CI", pr.failingUrl)}`
       : "";
-  return `CI check ${untrusted("CI", pr.failing ?? "")} failed on your PR #${pr.number} at ${short(pr.head)}${step}.${tail}\n\n${UNTRUSTED_RULE}\n\nFix the root cause (not the check), re-run your checks, push, then run /do-code-review again and update the Reviewed: line in the PR body for the new head.`;
+  return `CI check ${untrusted("CI", pr.failing ?? "")} failed on your PR #${pr.number} at ${short(pr.head)}${step}.${tail}\n\n${UNTRUSTED_RULE}\n\nFix the root cause (not the check), re-run your checks, then push.`;
 }
 
 // True once the PR's activity at this fingerprint has been handled.
@@ -374,7 +374,7 @@ export function reviewMessage(pr: TaskPR, events: PREvent[]): string {
         : "";
     return `- ${e.author} ${what}${body}${notes}${more}`;
   });
-  return `New review activity on your PR #${pr.number}:\n${items.join("\n")}\n\n${UNTRUSTED_RULE} Address each point: fix what's right, re-run your checks, push, then run /do-code-review again and update the Reviewed: line for the new head. Where you disagree, reply on the PR (\`gh pr comment ${pr.number}\`) saying why.`;
+  return `New review activity on your PR #${pr.number}:\n${items.join("\n")}\n\n${UNTRUSTED_RULE} Address each point: fix what's right, re-run your checks, then push. Where you disagree, reply on the PR (\`gh pr comment ${pr.number}\`) saying why.`;
 }
 
 // Tests only.

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,7 @@ async function reviewJob(
         schema: REVIEW_SCHEMA,
         tools: ["Read", "Grep", "Glob"],
         allow: [`Read(/${dir}/**)`, `Grep(/${dir}/**)`, `Glob(/${dir}/**)`],
+        onUsage,
       });
       verdicts.push(toVerdict(answer));
     }
@@ -246,11 +258,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,14 @@ 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",
+        }),
       })) as { within?: boolean; reason?: string };
       if (answer.within !== true) break;
     }