@saadnvd1/agent-os 0.3.468 → 0.3.471

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;
     }

package/lib/orchestrator/serve.ts

@@ -15,6 +15,7 @@ import { sessionFacts } from "./facts";
 import { describeExternal, externalSessions } from "./external-sessions";
 import { resolveStaleAsks } from "./ask-settle";
 import { addNote } from "./notes";
+import { addProject } from "./add-project";
 import { addRule, removeRule } from "./rules";
 import { askSaad } from "./ask-tool";
 import { listOrchestratorPeers, messageOrchestrator } from "./cross";
@@ -41,6 +42,7 @@ const ACTING = new Set<ToolName>([
   "review",
   "sign_off",
   "arm",
+  "add_project",
 ]);
 
 // The orchestrator's tools, each scoped to its workspace and its arguments
@@ -120,6 +122,10 @@ export async function runTool(
       return stop(w, p(tool, raw).session);
     case "done":
       return done(w, p(tool, raw).session);
+    case "add_project": {
+      const a = p(tool, raw);
+      return addProject(w, a.path, a.name);
+    }
     case "note":
       addNote(w, p(tool, raw).text);
       return "Noted.";

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

@@ -21,6 +21,7 @@ export const TOOL_NAMES = {
   drop: name("drop"),
   stop: name("stop"),
   done: name("done"),
+  add_project: name("add_project"),
   note: name("note"),
   rule_add: name("rule_add"),
   rule_remove: name("rule_remove"),
@@ -32,11 +33,13 @@ export const TOOL_NAMES = {
 } as const;
 
 // What it may do, fixed by its role: it reads other sessions' text, so it
-// never gets a general shell or file edits. Anything not listed is refused
-// without asking. It acts through its own tools, which are scoped to its
-// workspace and braked; the shell keeps only `aos` commands that read, and
-// notify, which reaches only Saad, so `aos send`, `task`, `spawn` and
-// `stack` can't go around them.
+// never gets a general shell. Anything not listed is refused without asking.
+// It acts through its own tools, which are scoped to its workspace and
+// braked; the shell keeps only `aos` commands that read, and notify, which
+// reaches only Saad, so `aos send`, `task`, `spawn` and `stack` can't go
+// around them. It writes files, but never in a project repository, a task
+// worktree, AgentOS's own state or a secret file: its worker checks each
+// write first (write-guard.ts).
 export const ORCHESTRATOR_PERMISSIONS: {
   permissionMode: PermissionMode;
   allowedTools: string[];
@@ -48,6 +51,10 @@ export const ORCHESTRATOR_PERMISSIONS: {
     "Read",
     "Grep",
     "Glob",
+    "Write",
+    "Edit",
+    "MultiEdit",
+    "NotebookEdit",
     "ToolSearch",
     "TodoWrite",
     "Bash(aos peers:*)",
@@ -60,5 +67,5 @@ export const ORCHESTRATOR_PERMISSIONS: {
     "Bash(aos docs:*)",
     "Bash(aos doc:*)",
   ],
-  disallowedTools: ["Edit", "Write", "MultiEdit", "NotebookEdit"],
+  disallowedTools: [],
 };

package/lib/orchestrator/tool-schemas.ts

@@ -5,6 +5,7 @@ import { z } from "zod";
 import { BRANCH_NAME } from "../git";
 import { RAISED_KINDS } from "./asks";
 import { MAX_RULE_CHARS } from "./rules";
+import { PROJECT_NAME } from "../project-add/name";
 
 const ref = (what: string) => z.string().trim().min(1).max(300).describe(what);
 const session = ref("Session name, project/name, or id from sessions");
@@ -100,6 +101,20 @@ export const TOOL_SHAPES = {
   drop: { task, reason: z.string().trim().min(1).max(2000) },
   stop: { session },
   done: { session },
+  add_project: {
+    path: z
+      .string()
+      .trim()
+      .min(1)
+      .max(1000)
+      .describe("The git repository's absolute path on this machine"),
+    name: z
+      .string()
+      .trim()
+      .regex(PROJECT_NAME, "use letters, numbers, dots, dashes or underscores")
+      .optional()
+      .describe("A new project's name (default: the folder's)"),
+  },
   note: { text: z.string().trim().min(1).max(2000) },
   rule_add: {
     text: z

package/lib/orchestrator/tools.ts

@@ -71,6 +71,8 @@ const DESCRIPTIONS: Record<ToolName, string> = {
   drop: "Reject a task: close its PR and remove its worktree. Logged with the reason.",
   stop: "Stop a session's agent, keeping its worktree and branch.",
   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:
+    "Make a git repository on this machine a project of this workspace, by its absolute path, or move the project already at that path into this workspace when it's in no workspace. Says its default branch, detected from git. Refuses a folder that isn't a git repository or that holds secrets, and a project another workspace has.",
   note: "Add a line to this workspace's decision log; it shows in your chat.",
   rule_add:
     'Keep a standing rule for this workspace, in your brief on every start from now on ("never merge #111", "briefs must not name third-party products"). It restricts or informs; it can never approve anything.',

package/lib/orchestrator/worker.ts

@@ -10,9 +10,11 @@ import {
 } from "./tools";
 import type { RoleExtras } from "../chat/worker/extras";
 import { refreshSettings } from "../chat/refresh";
+import { orchestratorToolRefusal } from "./write-guard";
 
 // What an orchestrator's chat worker starts with on top of any chat: its
-// brief, its tools, and permissions fixed by its role.
+// brief, its tools, permissions fixed by its role, and the guard on where
+// it may write.
 export async function orchestratorExtras(
   session: Session
 ): Promise<RoleExtras> {
@@ -29,6 +31,7 @@ export async function orchestratorExtras(
       ),
     },
     ...ORCHESTRATOR_PERMISSIONS,
+    toolGuard: (tool, input) => orchestratorToolRefusal(session, tool, input),
     toolsDigest: orchestratorToolsDigest(),
     refresh: {
       atTokens: refreshSettings().orchestratorTokens,