@saadnvd1/agent-os 0.3.664 → 0.3.672

package/lib/orchestrator/quick.ts

@@ -25,13 +25,16 @@ import { expandHome, forgetPR, prFor, projectPathFor } from "../tasks/session";
 import { inBackground } from "../lumifyhub/task-cards";
 import type { CheckRow } from "./checks";
 import { getOrchestrator } from "./home";
+import { fullAccessOn } from "./full-access";
+import { setupWorktree } from "../env-setup";
 import { addNote } from "./notes";
 import { quickWorktrees } from "./quick-store";
 import { findWorkspaceSession } from "./read";
 import { workspaceProject } from "./targets";
 import { recordPr, setTask } from "../db/session-parts";
 
-// Open quick changes one orchestrator may hold at once.
+// Open quick changes one orchestrator may hold at once, unless its workspace
+// has Orchestrator full access on (the default).
 export const MAX_OPEN_QUICK = 5;
 
 // Git with no hooks: a hook is a script in the project (or one it calls,
@@ -62,7 +65,13 @@ export async function startQuickChange(
   workspaceId: string,
   projectRef: string,
   name: string
-): Promise<{ id: string; worktreePath: string; text: string }> {
+): Promise<{
+  id: string;
+  worktreePath: string;
+  text: string;
+  // Dependencies and the project's setup, running in the background.
+  setup: Promise<void>;
+}> {
   const owner = ownerOf(workspaceId);
   const project = workspaceProject(workspaceId, projectRef);
   if (isRemoteHost(project.host_id))
@@ -70,7 +79,7 @@ export async function startQuickChange(
       `${project.name} runs on another machine; quick changes are made on this one only`
     );
   const open = quickWorktrees(owner.id);
-  if (open.length >= MAX_OPEN_QUICK)
+  if (!fullAccessOn(workspaceId) && open.length >= MAX_OPEN_QUICK)
     throw new Error(
       `You have ${open.length} quick changes open (${MAX_OPEN_QUICK} at most): finish one with quick_pr, or drop it, first`
     );
@@ -122,13 +131,47 @@ export async function startQuickChange(
     workspaceId,
     `Quick change "${label}" in ${project.name} on ${wt.branchName}.`
   );
+  const full = fullAccessOn(workspaceId);
+  const setup = installDependencies(
+    workspaceId,
+    label,
+    wt.worktreePath,
+    projectPath
+  );
+  inBackground(`setup of quick change ${id}`, () => setup);
   return {
     id,
     worktreePath: wt.worktreePath,
-    text: `Quick change "${label}" (id ${id.slice(0, 8)}) in ${project.name}: worktree ${wt.worktreePath} on ${wt.branchName}, cut from ${baseBranch}. Edit files there with Write and Edit; git there only as \`git -C ${wt.worktreePath} <status|diff|add|...>\`. Then quick_pr commits, pushes and opens its PR.`,
+    setup,
+    text: `Quick change "${label}" (id ${id.slice(0, 8)}) in ${project.name}: worktree ${wt.worktreePath} on ${wt.branchName}, cut from ${baseBranch}. Dependencies are installing in the background (a note says when they're ready). Edit files there with Write and Edit; ${full ? "run any git there" : "git there only as `git -C " + wt.worktreePath + " <status|diff|add|...>`"}. Then quick_pr commits, pushes and opens its PR.`,
   };
 }
 
+// The project's own worktree setup (dependencies, env files), so tests and
+// the build run in the quick change. One note when it ends.
+async function installDependencies(
+  workspaceId: string,
+  label: string,
+  worktreePath: string,
+  projectPath: string
+): Promise<void> {
+  try {
+    const r = await setupWorktree({ worktreePath, sourcePath: projectPath });
+    const failed = r.steps.find((s) => !s.success);
+    addNote(
+      workspaceId,
+      failed
+        ? `Quick change "${label}": setup failed at ${failed.name}: ${failed.error ?? "see its worktree"}.`
+        : `Quick change "${label}": dependencies installed, ready to build and test.`
+    );
+  } catch (e) {
+    addNote(
+      workspaceId,
+      `Quick change "${label}": setup failed: ${(e as Error).message}.`
+    );
+  }
+}
+
 // A quick change of this workspace's orchestrator, by name, id or PR.
 export function workspaceQuick(workspaceId: string, ref: string): Session {
   const owner = ownerOf(workspaceId);

package/lib/orchestrator/review.ts

@@ -55,6 +55,7 @@ import {
 import { noteQuickReview } from "./quick";
 import { workspaceTask } from "./targets";
 import { untrusted } from "./untrusted";
+import { isFast } from "../project-tier/getProjectTier";
 
 const short = (sha: string) => sha.slice(0, 7);
 // The most diff one reviewer is given, and the most parts a change too big
@@ -267,6 +268,8 @@ export async function reviewAt(
   sha: string,
   opts: ReviewOpts = {}
 ): Promise<string> {
+  if (target.task && isFast(target.task))
+    return `${target.task.name} is in a fast project: no independent review; it merges through the fast gates.`;
   const known = getCheck(target.id, sha, "review");
   // A card task's scope check runs after its review; one never stored (a
   // restart between the two) means running the job again.

package/lib/orchestrator/serve.ts

@@ -26,11 +26,13 @@ import { sessionFacts } from "./facts";
 import { describeExternal, externalSessions } from "./external-sessions";
 import { resolveStaleAsks } from "./ask-settle";
 import { addNote } from "./notes";
+import { projectTierTool } from "./project-tier-tool";
 import { addProject } from "./add-project";
 import { addRule, removeRule } from "./rules";
 import { askSaad } from "./ask-tool";
 import { askQuestion, resolveQuestion } from "./questions";
 import { listOrchestratorPeers, messageOrchestrator } from "./cross";
+import { sweepArm, sweepDryRun } from "./sweep-arm";
 import { PAUSED_REFUSAL } from "./pause";
 import { readSession } from "./read";
 import { reviewTarget, signOffTarget } from "./external-gates";
@@ -216,6 +218,12 @@ export async function runTool(
       const a = p(tool, raw);
       return moveTaskTo(w, a.task, a.machine);
     }
+    case "sweep_dry_run":
+      return sweepDryRun(p(tool, raw).machine);
+    case "sweep_arm": {
+      const a = p(tool, raw);
+      return sweepArm(w, a.machine, a.on, a.reason);
+    }
     case "stop":
       return stop(w, p(tool, raw).session);
     case "done":
@@ -230,6 +238,10 @@ export async function runTool(
       const a = p(tool, raw);
       return addProject(w, a.path, a.name);
     }
+    case "project_tier": {
+      const a = p(tool, raw);
+      return projectTierTool(w, a.project, a.tier);
+    }
     case "note":
       addNote(w, p(tool, raw).text);
       return "Noted.";
@@ -265,10 +277,12 @@ export async function runTool(
       const a = p(tool, raw);
       return reviewTarget(w, a.target, { fresh: a.fresh });
     }
-    case "sign_off":
-      return signOffTarget(w, p(tool, raw).task);
+    case "sign_off": {
+      const a = p(tool, raw);
+      return signOffTarget(w, a.task, { direct: a.direct, reason: a.reason });
+    }
     case "arm":
-      return arm(w, p(tool, raw).task);
+      return await arm(w, p(tool, raw).task);
     case "disarm":
       return disarm(w, p(tool, raw).task);
     case "ask_saad":

package/lib/orchestrator/shell-guard.ts

@@ -230,7 +230,7 @@ function aosRefusal(args: string[]): string | null {
     stop: T.stop,
   };
   if (sub === "sweep" && args.includes("--arm"))
-    return "Refused: `aos sweep --arm` turns on removing files and databases, which a person decides: Health, Clean-up, Turn on. `--dry-run` and `--disarm` are fine.";
+    return `Refused: \`aos sweep --arm\` turns on removing files and databases, which is Saad's call: Health, Clean-up, Turn on. When he has said to, use ${T.sweep_arm} (after ${T.sweep_dry_run}). \`--dry-run\` and \`--disarm\` are fine.`;
   if (sub && tool[sub])
     return `Refused: \`aos ${sub}\` isn't for you; use ${tool[sub]}, which is scoped to this workspace and held by Pause.`;
   return null;
@@ -617,3 +617,25 @@ export async function shellRefusal(
   }
   return null;
 }
+
+// The one thing full access still flags: a command that looks like it stops
+// or restarts AgentOS or its tmux, which ends every session it runs, this one
+// included. A warning, never a refusal; null for anything else.
+export async function shellWarning(
+  command: unknown,
+  ctx: ShellContext
+): Promise<string | null> {
+  if (typeof command !== "string") return null;
+  const parsed = parseShell(command);
+  if (typeof parsed === "string") return null;
+  for (const cmd of parsed) {
+    const invs = invocations(cmd);
+    if (typeof invs === "string") continue;
+    for (const inv of invs) {
+      const why = await stopRefusal(inv, ctx).catch(() => null);
+      if (why)
+        return `Warning: ${why.replace(/^Refused: /, "")} It will run anyway.`;
+    }
+  }
+  return null;
+}

package/lib/orchestrator/signoff.test-helpers.ts

@@ -6,6 +6,7 @@ import { beforeAll, beforeEach, expect, vi } from "vitest";
 import type { TaskPR } from "@/lib/tasks/state";
 import type { ClaudeRun } from "./claude-cli";
 import type { SessionFacts } from "./facts";
+import { tempDir } from "@/lib/test-temp";
 
 // Shared fixtures for the signoff*.test.ts files: a real repository with a
 // local bare remote, gh faked around it. Import this before anything it mocks.
@@ -162,7 +163,7 @@ export const askUp = async (
 export const POLL = { timeout: 20000, interval: 20 };
 
 beforeAll(() => {
-  const home = fs.mkdtempSync(path.join(os.tmpdir(), "aos-orch-signoff-"));
+  const home = tempDir("aos-orch-signoff-");
   vi.spyOn(os, "homedir").mockReturnValue(home);
 });
 beforeEach(() => {
@@ -212,7 +213,7 @@ export function setup(
   } = {}
 ) {
   setMergeApprovals(opts.approvals ?? false);
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), "aos-orch-repo-"));
+  const root = tempDir("aos-orch-repo-");
   const remote = path.join(root, "remote.git");
   const repo = path.join(root, "repo");
   git(root, "init", "-q", "--bare", "-b", "main", remote);
@@ -230,6 +231,9 @@ export function setup(
     workingDirectory: repo,
   });
   setProjectWorkspace(project.id, workspace.id);
+  db.prepare(`UPDATE projects SET tier = 'production' WHERE id = ?`).run(
+    project.id
+  );
   ensureOrchestrator(workspace.id);
   const task = seedSession({
     projectId: project.id,

package/lib/orchestrator/signoff.ts

@@ -41,6 +41,8 @@ import {
   reviewSignature,
 } from "./loop-guard";
 import { addNote } from "./notes";
+import { isFast } from "../project-tier/getProjectTier";
+import { recordFastMerge } from "./fast-lane-state";
 import { latestApproval, refundApproval, spendApproval } from "./ask-approvals";
 import { workSubject } from "./asks";
 import { carryApproval } from "./approval-carry";
@@ -71,7 +73,7 @@ export function restackedOf(task: Session) {
 
 // `approval`: Saad approved this merge on his asks list, for this commit.
 export type Verdict =
-  | { ok: true; sha: string; pr: number; approval?: number }
+  | { ok: true; sha: string; pr: number; approval?: number; fast?: true }
   | { ok: false; wait: boolean; text: string };
 
 // Whether the task may merge now, and at which commit. Landing merges a
@@ -107,13 +109,15 @@ export async function judge(
   // A PR quick_pr opened (by the row AgentOS wrote, never the body): its
   // code review is the independent review of this head, and until that
   // passes it waits, before any gate is judged or counted.
-  const quick = isQuick(task)
-    ? quickCodeReview(
-        sha,
-        getCheck(task.id, sha, "review"),
-        restackedOf(task)?.to === sha
-      )
-    : null;
+  const fast = isFast(task);
+  const quick =
+    isQuick(task) && !fast
+      ? quickCodeReview(
+          sha,
+          getCheck(task.id, sha, "review"),
+          restackedOf(task)?.to === sha
+        )
+      : null;
   // Saad's approval of this head stands in for that review (gateVerdict).
   if (
     quick?.wait &&
@@ -157,7 +161,7 @@ export async function judge(
         return quick ? { refusal: gate.refusal, wait: null } : gate;
       })(),
     }),
-    opts
+    { ...opts, fast }
   );
 }
 
@@ -178,8 +182,9 @@ export async function gateVerdict(
   workspaceId: string,
   work: GateWork,
   inputs: () => Promise<Omit<GateInput, "sha" | "ruleBreaks">>,
-  opts: { count?: boolean } = {}
+  opts: { count?: boolean; fast?: boolean } = {}
 ): Promise<Verdict> {
+  const fast = !!opts.fast;
   const no = (text: string, wait = false): Verdict => ({
     ok: false,
     wait,
@@ -216,7 +221,9 @@ export async function gateVerdict(
         : null;
     const refusal = i.codeReview.refusal ?? stack;
     if (refusal) return no(`${approved} ${refusal}`);
-    const ci = ciGate({ sha, ...i, repoCI: await repoCIFor(repo, work, i) });
+    const ci = fast
+      ? { state: "pass" as const }
+      : ciGate({ sha, ...i, repoCI: await repoCIFor(repo, work, i) });
     if (ci.state === "fail") return no(`${approved} ${ci.reason}`);
     if (ci.state === "wait") return no(`${approved} ${ci.reason}`, true);
     // "escalate" is a repository with no CI: Saad is who that goes to.
@@ -245,7 +252,7 @@ export async function gateVerdict(
   }
   // Here too, not only in the review: one reviewed in parts while approvals
   // were off goes to Saad once they're on.
-  if (mergeApprovalsOn()) {
+  if (mergeApprovalsOn() && !fast) {
     const size = (await fullDiff(repo, base, sha)).length;
     if (size > DIFF_CAP) {
       const why = `PR #${pr.number}'s diff at ${short(sha)} is ${size} characters, too big to review whole`;
@@ -255,8 +262,11 @@ export async function gateVerdict(
 
   const ruled = ruleBreaks(files, await addedLines(repo, base, sha));
   const live = await inputs();
-  const repoCI = await repoCIFor(repo, base, live);
-  const outcomes = evaluateGates({ sha, ruleBreaks: ruled, ...live, repoCI });
+  const repoCI = fast ? undefined : await repoCIFor(repo, base, live);
+  const outcomes = evaluateGates(
+    { sha, ruleBreaks: ruled, ...live, repoCI },
+    { fast }
+  );
   const head = `${work.name} (PR #${pr.number} at ${short(sha)}) can't merge:`;
   const toSaad = outcomes.find((o) => o.state === "escalate");
   if (toSaad)
@@ -266,9 +276,12 @@ export async function gateVerdict(
   const failed = outcomes.filter((o) => o.state === "fail");
   const waiting = outcomes.filter((o) => o.state === "wait");
   if (!failed.length && !waiting.length)
-    return { ok: true, sha, pr: pr.number };
+    return fast
+      ? { ok: true, sha, pr: pr.number, fast: true }
+      : { ok: true, sha, pr: pr.number };
   const lines: string[] = [];
-  if (opts.count === false)
+  // The fast lane has no loop guard: a failure is told, never counted.
+  if (opts.count === false || fast)
     lines.push(...failed.map((o) => `- ${o.gate} failed: ${o.reason}`));
   else {
     for (const o of outcomes)
@@ -346,11 +359,15 @@ export async function mergeJudged(
   await refundIfRefused(task.id, verdict.approval, async () => {
     method = await signOffTask(task.id, { head: verdict.sha, wait: opts.wait });
   });
+  if (verdict.fast)
+    recordFastMerge(task.id, workspaceId, verdict.pr, verdict.sha);
   addNote(
     workspaceId,
-    verdict.approval
-      ? `Merged ${task.name} (PR #${verdict.pr}, ${short(verdict.sha)}) on Saad's approval of that commit.`
-      : `Merged ${task.name} (PR #${verdict.pr}, ${short(verdict.sha)}): CI green, review passed, in scope.`
+    verdict.fast
+      ? `Merged ${task.name} (PR #${verdict.pr}, ${short(verdict.sha)}) on the fast lane: no CI wait or review.`
+      : verdict.approval
+        ? `Merged ${task.name} (PR #${verdict.pr}, ${short(verdict.sha)}) on Saad's approval of that commit.`
+        : `Merged ${task.name} (PR #${verdict.pr}, ${short(verdict.sha)}): CI green, review passed, in scope.`
   );
   return `Merged ${task.name}: PR #${verdict.pr} ${method ? MERGED_AS[method] : "merged"} at ${short(verdict.sha)}.`;
 }

package/lib/orchestrator/sweep-arm.ts

@@ -0,0 +1,180 @@
+/**
+ * The orchestrator's way to turn the full disk clean-up on or off, for this
+ * machine or a linked one. Turning it on is Saad's call, so the tool says it's
+ * for when he has said to, wants the latest dry run of that machine from the
+ * last hour (what it would remove is what he agreed to), and logs who and
+ * the dry run's totals. A linked machine is armed over ssh to its own
+ * loopback, where its AgentOS trusts the caller: its arm endpoint refuses a
+ * device token on purpose.
+ */
+
+import { getHost, hostExec, hostIdNamed, isRemoteHost } from "../hosts";
+import { remotePort } from "../hosts/link";
+import {
+  cleanRemoteText,
+  hostApi,
+  requireHostLink,
+  type HostLink,
+} from "../hosts/remote-api";
+import { fromSqliteTime } from "../session-meta";
+import { setReaperArmed } from "../worktree-sweep/settings";
+import { sweepNow } from "../worktree-sweep/start";
+import { sweepState, type SweepState } from "../worktree-sweep/state";
+import type { SweepRun } from "../worktree-sweep/types";
+import { addNote } from "./notes";
+import { PAUSED_REFUSAL } from "./pause";
+import { getWorkspace } from "../workspaces";
+
+export const DRY_RUN_FRESH_MS = 60 * 60 * 1000;
+
+const TOOL_DRY = "sweep_dry_run";
+const GB = (b: number) => (b / 1024 ** 3).toFixed(2) + " GB";
+
+type Verdict = { ok: true; run: SweepRun } | { ok: false; why: string };
+
+// The newest dry run decides: an older fresh one doesn't stand in for it.
+export function dryRunVerdict(
+  runs: SweepRun[],
+  where: string,
+  now = Date.now()
+): Verdict {
+  const next = `Run ${TOOL_DRY} for ${where} first (it takes a few minutes), then call sweep_arm again.`;
+  const run = runs.find((r) => r.dryRun);
+  if (!run) return { ok: false, why: `${where} has no dry run. ${next}` };
+  if (!run.finishedAt)
+    return {
+      ok: false,
+      why: `The dry run on ${where} is still going. Wait for it, then call sweep_arm again.`,
+    };
+  if (run.error)
+    return {
+      ok: false,
+      why: `The latest dry run on ${where} failed (${run.error}). ${next}`,
+    };
+  const age = now - fromSqliteTime(run.finishedAt).getTime();
+  if (age > DRY_RUN_FRESH_MS)
+    return {
+      ok: false,
+      why: `The latest dry run on ${where} is ${Math.round(age / 60000)} minutes old; it must be from the last hour. ${next}`,
+    };
+  return { ok: true, run };
+}
+
+export function totalsLine(run: SweepRun, now = Date.now()): string {
+  const d = run.details;
+  const mins = run.finishedAt
+    ? Math.max(
+        0,
+        Math.round((now - fromSqliteTime(run.finishedAt).getTime()) / 60000)
+      )
+    : 0;
+  return (
+    `dry run #${run.id} (${mins} min ago): would remove ${run.removed} (${GB(run.freedBytes)}), ` +
+    `${d?.pendingTotal?.count ?? 0} (${GB(d?.pendingTotal?.bytes ?? 0)}) waiting for the full clean-up, ${run.skipped} kept` +
+    (d?.report ? `; list: ${cleanRemoteText(d.report)}` : "")
+  );
+}
+
+interface Machine {
+  hostId: string;
+  name: string;
+  link: HostLink | null;
+}
+
+function machineOf(ref: string): Machine {
+  const hostId = hostIdNamed(ref);
+  if (!isRemoteHost(hostId))
+    return { hostId, name: "this machine", link: null };
+  return {
+    hostId,
+    name: getHost(hostId)?.name ?? ref,
+    link: requireHostLink(hostId),
+  };
+}
+
+// Another machine's numbers, read defensively.
+function clean(state: SweepState): SweepState {
+  const num = (n: unknown) => (Number.isFinite(Number(n)) ? Number(n) : 0);
+  return {
+    ...state,
+    armed: state.armed === true,
+    runs: (Array.isArray(state.runs) ? state.runs : []).map((r) => ({
+      ...r,
+      id: num(r.id),
+      dryRun: r.dryRun === true,
+      removed: num(r.removed),
+      freedBytes: num(r.freedBytes),
+      skipped: num(r.skipped),
+      error: r.error ? cleanRemoteText(r.error) : null,
+    })),
+  };
+}
+
+const readState = async (m: Machine): Promise<SweepState> =>
+  m.link
+    ? clean(await hostApi<SweepState>(m.link, "/api/worktree-sweep"))
+    : sweepState();
+
+async function setArmed(m: Machine, armed: boolean): Promise<void> {
+  if (!m.link) return setReaperArmed(armed);
+  if (!armed) {
+    await hostApi(m.link, "/api/worktree-sweep", {
+      method: "PUT",
+      body: { armed: false },
+    });
+    return;
+  }
+  const port = remotePort(m.link.url);
+  await hostExec(
+    m.hostId,
+    `curl -fsS -m 10 -X PUT -H 'Content-Type: application/json' -d '{"armed":true}' http://127.0.0.1:${port}/api/worktree-sweep`,
+    20000
+  ).catch((err) => {
+    throw new Error(
+      `Couldn't turn it on for ${m.name}: ${cleanRemoteText(err instanceof Error ? err.message : err)}`
+    );
+  });
+  if (!(await readState(m)).armed)
+    throw new Error(`${m.name} did not turn the full clean-up on`);
+}
+
+export async function sweepArm(
+  workspaceId: string,
+  machine: string,
+  on: boolean,
+  reason: string
+): Promise<string> {
+  const m = machineOf(machine);
+  const state = await readState(m);
+  const latest = state.runs.find((r) => r.dryRun && r.finishedAt && !r.error);
+  if (state.armed === on)
+    return `The full clean-up is already ${on ? "on" : "off"} for ${m.name}.`;
+  if (on) {
+    // Turning it off only makes things safer, so Pause doesn't hold it.
+    if (getWorkspace(workspaceId)?.orch_paused_at)
+      throw new Error(PAUSED_REFUSAL);
+    const verdict = dryRunVerdict(state.runs, m.name);
+    if (!verdict.ok) throw new Error(verdict.why);
+  }
+  await setArmed(m, on);
+  const totals = latest ? ` Latest ${totalsLine(latest)}.` : "";
+  const line = `Orchestrator turned the full disk clean-up ${on ? "on" : "off"} for ${m.name}: ${reason}.${totals}`;
+  addNote(workspaceId, line);
+  return line;
+}
+
+export async function sweepDryRun(machine: string): Promise<string> {
+  const m = machineOf(machine);
+  const started = `Dry run started on ${m.name}; it takes a few minutes and removes nothing. When Saad has said to turn the full clean-up on, call sweep_arm: it reads this run.`;
+  if (m.link) {
+    await hostApi(m.link, "/api/worktree-sweep/run", {
+      body: { dryRun: true },
+    });
+    return started;
+  }
+  await new Promise<void>((resolve, reject) => {
+    sweepNow(true).then(() => resolve(), reject);
+    setTimeout(resolve, 250);
+  });
+  return started;
+}

package/lib/orchestrator/tool-names.ts

@@ -29,6 +29,8 @@ export const TOOL_NAMES = {
   plan_pieces: name("plan_pieces"),
   drop: name("drop"),
   move: name("move"),
+  sweep_dry_run: name("sweep_dry_run"),
+  sweep_arm: name("sweep_arm"),
   set_priority: name("set_priority"),
   start_now: name("start_now"),
   pause_task: name("pause_task"),
@@ -38,6 +40,7 @@ export const TOOL_NAMES = {
   archive: name("archive"),
   resurrect: name("resurrect"),
   add_project: name("add_project"),
+  project_tier: name("project_tier"),
   note: name("note"),
   question: name("question"),
   resolve_question: name("resolve_question"),
@@ -67,7 +70,8 @@ export const TOOL_NAMES = {
 // task worktree other than its own quick changes, writing AgentOS's state,
 // stopping AgentOS or its tmux, and reading secrets. That catches honest
 // mistakes, not a determined bypass. Its file writes are checked the same
-// way, against a longer list (write-guard.ts).
+// way, against a longer list (write-guard.ts). All of that applies only with
+// the workspace's Orchestrator full access off (full-access.ts).
 export const ORCHESTRATOR_PERMISSIONS: {
   permissionMode: PermissionMode;
   allowedTools: string[];

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_TIERS } from "../project-tier/types";
 import { PROJECT_NAME } from "../project-add/name";
 import { TASK_ROLES, type ModelRole } from "../models/roles";
 import { PRIORITIES } from "../tasks/schedule-types";
@@ -21,6 +22,13 @@ 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 sweepMachine = z
+  .string()
+  .trim()
+  .min(1)
+  .max(200)
+  .describe('A linked machine\'s name (see Machines), or "here" for this one');
+
 const modelRef = z
   .string()
   .trim()
@@ -153,8 +161,9 @@ export const TOOL_SHAPES = {
     model: modelOverride,
     plan: z
       .boolean()
+      .optional()
       .describe(
-        "Your decision for this job: true to plan first on the planning model, then implement on the implementation model; false to skip the plan and put the steps in the prompt yourself"
+        "Your decision for this job: true to plan first on the planning model, then implement on the implementation model; false to skip the plan and put the steps in the prompt yourself. Default: false in a fast project, the workspace's setting in a production one"
       ),
     plan_only: z
       .boolean()
@@ -167,6 +176,7 @@ export const TOOL_SHAPES = {
       .trim()
       .min(3)
       .max(200)
+      .optional()
       .describe(
         'Why, in a few words Saad reads on the task card: "touches 6 files across gates and UI", "one-line default change"'
       ),
@@ -268,6 +278,17 @@ export const TOOL_SHAPES = {
         'A linked machine\'s name (see Machines), or "here" to bring the task back'
       ),
   },
+  sweep_dry_run: { machine: sweepMachine },
+  sweep_arm: {
+    machine: sweepMachine,
+    on: z.boolean().describe("true turns the full clean-up on, false off"),
+    reason: z
+      .string()
+      .trim()
+      .min(1)
+      .max(500)
+      .describe("What Saad said, and when; it goes in the decision log"),
+  },
   set_priority: {
     task: ref("A queued or running task: name, project/name or id"),
     priority: z.enum(PRIORITIES),
@@ -320,6 +341,10 @@ export const TOOL_SHAPES = {
       .optional()
       .describe("A new project's name (default: the folder's)"),
   },
+  project_tier: {
+    project: z.string().trim().min(1).max(200).optional(),
+    tier: z.enum(PROJECT_TIERS).optional(),
+  },
   note: { text: z.string().trim().min(1).max(2000) },
   question: {
     text: z
@@ -409,7 +434,21 @@ export const TOOL_SHAPES = {
       .optional()
       .describe("Run it again even if this commit has a verdict"),
   },
-  sign_off: { task },
+  sign_off: {
+    task,
+    direct: z
+      .boolean()
+      .optional()
+      .describe(
+        "Merge now at the PR's head without the gates; needs Orchestrator full access and a reason"
+      ),
+    reason: z
+      .string()
+      .trim()
+      .max(300)
+      .optional()
+      .describe("Why the gates are skipped (required with direct)"),
+  },
   arm: { task },
   disarm: { task },
   ask_saad: {