@saadnvd1/agent-os 0.3.664 → 0.3.672

package/lib/orchestrator/tools.ts

@@ -132,7 +132,7 @@ const DESCRIPTIONS: Record<ToolName, string> = {
   start_session:
     'Start an agent session in a project with a prompt, for work that isn\'t a PR task. It runs on the implementation model unless you give model (one "provider/model"; Opus only when the work needs deep reasoning), as a chat unless view is terminal (only for a job that needs a TUI). Refused while a brake holds.',
   quick_change:
-    "Make a small, low-risk edit yourself (a typo, a config value, a one-file fix): cuts a worktree and branch from the project's default branch and returns its path. You may write there (Write, Edit) and run git there as `git -C <path> ...` (status, diff, add, rm, mv, restore, reset, log, show); nowhere else in a project. Anything needing real work, tests or an investigation is a task (start_task).",
+    "Make a change yourself (without full access, a small low-risk one: a typo, a config value, a one-file fix): cuts a worktree and branch from the project's default branch and returns its path. Its dependencies install in the background (a note says when). You may write there (Write, Edit) and, with Orchestrator full access, run any git there; without it, only `git -C <path> ...` status, diff, add, rm, mv, restore, reset, log, show, and nowhere else in a project. Without full access, anything needing real work, tests or an investigation is a task (start_task).",
   quick_pr:
     "Commit everything in a quick change's worktree, push its branch (never the default branch) and open its PR, or push to the PR it already has. The PR goes through the same gates as a task's; with no task agent to run /do-code-review, its code-review gate is the independent review of its exact head, which starts now.",
   stack:
@@ -145,6 +145,10 @@ const DESCRIPTIONS: Record<ToolName, string> = {
     "A task whose plan split into pieces: each piece, its repo, what it waits on and its state. With merge or drop (position numbers) it edits the pieces still waiting: a merged piece's slice goes to the piece before it, a dropped one is left out and anything waiting on it is held. It can't add pieces or change reasons.",
   drop: "Reject a task: close its PR and remove its worktree. A task still waiting in the queue is removed by its id. Logged with the reason.",
   move: 'Carry a running task to a linked machine, or back with "here": for heavy test or build work. It keeps its branch, conversation and plan; the gates, events, read, send, stop, done and drop work the same wherever it runs, and the machine it lands on can\'t merge it. Takes a few minutes and runs in the background; an event says when it lands. Refused while paused, for a task waiting on Saad (an escalation or open ask), and for card and stacked tasks.',
+  sweep_dry_run:
+    "Start a dry run of the disk clean-up on this machine or a linked one: it lists what the full clean-up would remove and removes nothing. Takes a few minutes; sweep_arm reads it.",
+  sweep_arm:
+    "Turn the full disk clean-up (test leftovers, stale task databases, spares, temp folders, build caches) on or off for this machine or a linked one. Only for when Saad has said to turn it on: put what he said in reason. Turning it on is refused unless that machine's latest dry run finished in the last hour (run sweep_dry_run first, and read its totals). Off is always allowed. Logged in the decision log with the dry run's totals.",
   set_priority:
     "Change the priority of a queued task (it re-ranks the line at once) or a running one (it only matters if it is paused and waits to resume). urgent starts first even on a busy machine; background starts last.",
   start_now:
@@ -161,6 +165,8 @@ const DESCRIPTIONS: Record<ToolName, string> = {
     "Bring a dropped, done or archived session back: the same session and conversation, its worktree (with its uncommitted files and plan) back from what was saved or from its branch, its status as it was (a plan-only task waits for approval again, one with a PR is idle), and a PR a drop closed reopened. Archived sessions just unarchive. Held by Pause and braked like a start. Refused when its conversation is gone, its PR was merged, its project was removed or its branch is in use. Give a reason; it goes in the decision log.",
   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.",
+  project_tier:
+    "Read or set a project's tier. production: every merge gate applies (CI, independent review, scope). fast: a task's PR merges as soon as it opens, with no CI wait or review. Without a project, lists this workspace's; with a project, reads it; with a tier too, sets it, only when Saad says to.",
   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.',
@@ -183,7 +189,7 @@ const DESCRIPTIONS: Record<ToolName, string> = {
   review:
     "Start an independent read-only review of a PR at its exact head commit, or read the stored verdict for that commit. Takes a task, or any open PR in a workspace repository by #N, owner/repo#N or URL, even one no task owns.",
   sign_off:
-    "Merge a PR, with its project's merge method, through the gates: CI green and settled, a passing review of that commit, nothing blocked, in scope, stack parent merged. Takes a task, or any open PR in a workspace repository by #N, owner/repo#N or URL (an external PR). Refuses with the failing gate, or a repository outside the workspace.",
+    "Merge a PR, with its project's merge method, through the gates: CI green and settled, a passing review of that commit, nothing blocked, in scope, stack parent merged. Takes a task, or any open PR in a workspace repository by #N, owner/repo#N or URL (an external PR). Refuses with the failing gate, or a repository outside the workspace. With direct true (and a reason) it merges now at the PR's head without the gates; only with Orchestrator full access, and not while paused or while the task waits on Saad.",
   arm: "Arm a task's PR to merge: AgentOS merges it, through the same gates as sign_off, the moment they all pass at its head, and tells you with one event. A gate failure comes as one event and it stays armed for the fix; one that goes to Saad disarms it. Survives restarts. Use it instead of calling sign_off until it passes.",
   disarm:
     "Disarm a task armed to merge: it merges only through sign_off again.",

package/lib/orchestrator/watcher.ts

@@ -5,6 +5,7 @@
  * every 15s while anything in the workspace is working, every 60s when not.
  */
 
+import { autoArmFast, followFastMerges } from "./fast-lane";
 import { chatState, chatStateNow, sendChat } from "../chat/runner";
 import type { ChatState } from "../chat/events";
 import { getWorkspace } from "../workspaces";
@@ -96,7 +97,11 @@ function mergePipeline(workspaceId: string, facts: SessionFacts[]): void {
       console.error(`Judging asked commits in ${workspaceId}:`, error)
     );
     await rebaseConflicting(workspaceId, facts);
+    await autoArmFast(workspaceId, facts);
     await mergeArmed(workspaceId, facts);
+    await followFastMerges(workspaceId).catch((error) =>
+      console.error(`Following fast merges in ${workspaceId}:`, error)
+    );
   })()
     .catch((error) =>
       console.error(`Merge pipeline for ${workspaceId}:`, error)

package/lib/orchestrator/write-guard.ts

@@ -1,5 +1,7 @@
 /**
- * Where an orchestrator may write. Anywhere on the machine except the
+ * Where an orchestrator may write (unless its workspace has Orchestrator full
+ * access on, the default: orchestratorToolRefusal then checks nothing but
+ * warns about stopping AgentOS; full-access.ts). Anywhere on the machine except the
  * workspace's project repositories and their task worktrees (code changes go
  * through tasks, so the merge gates keep meaning something), AgentOS's own
  * install and state (all of ~/.agent-os but its own folder), secret files,
@@ -18,13 +20,15 @@ import fs from "fs";
 import os from "os";
 import path from "path";
 import { db, type Session } from "../db";
+import type { ToolGuardResult } from "../chat/driver";
 import { git, GitError } from "../git-exec";
 import { isOrchestratorSecretPath as isSecretPath } from "../secret-paths";
 import { WORKTREES_DIR } from "../worktrees";
 import { orchestratorDir } from "./home";
 import { LIMITS_FILE } from "./usage";
 import { quickWorktrees } from "./quick-store";
-import { shellRefusal } from "./shell-guard";
+import { shellRefusal, shellWarning, type ShellContext } from "./shell-guard";
+import { orchestratorFullAccess } from "./full-access";
 import { liveCheckout } from "../dev-instance/liveServer";
 
 // The tools that write a file, and the argument naming it.
@@ -366,24 +370,47 @@ export async function orchestratorToolRefusal(
   session: Session,
   tool: string,
   input: Record<string, unknown>
-): Promise<string | null> {
-  if (tool === "Bash") return commandRefusal(session, input.command);
+): Promise<ToolGuardResult> {
+  const full = orchestratorFullAccess(session);
+  if (tool === "Bash")
+    return full
+      ? commandWarning(session, input.command)
+      : commandRefusal(session, input.command);
   const arg = WRITE_TOOLS[tool];
   if (!arg) return null;
   const filePath = input[arg];
+  if (full) return null;
   if (typeof filePath !== "string") return "No file path to check.";
   return writeRefusal(filePath, await orchestratorWriteBounds(session));
 }
 
+// With full access: only a warning for stopping AgentOS or its tmux.
+async function commandWarning(
+  session: Session,
+  command: unknown
+): Promise<ToolGuardResult> {
+  const warning = await shellWarning(
+    command,
+    shellContext(session, await orchestratorWriteBounds(session))
+  );
+  return warning ? { warning } : null;
+}
+
 // A shell command, against the deny list (shell-guard.ts), its writes held
 // to the shell's share of the write bounds.
 async function commandRefusal(
   session: Session,
   command: unknown
 ): Promise<string | null> {
-  const bounds = await orchestratorWriteBounds(session);
+  return shellRefusal(
+    command,
+    shellContext(session, await orchestratorWriteBounds(session))
+  );
+}
+
+function shellContext(session: Session, bounds: WriteBounds): ShellContext {
   const dbFile = agentOsDbPath();
-  return shellRefusal(command, {
+  return {
     cwd: bounds.cwd,
     writeRefusal: (p) => writeRefusal(p, bounds, { shell: true }),
     isAgentOsState: async (p) => {
@@ -402,7 +429,7 @@ async function commandRefusal(
     },
     checkoutKind: (dir) => checkoutKind(session, dir),
     protectedPids,
-  });
+  };
 }
 
 // Whether a folder is a project checkout of the session's own workspace

package/lib/project-config/brief.ts

@@ -18,9 +18,11 @@ import { simulatorBrief } from "../simulator/brief";
 export function runningBrief(
   config: ProjectConfig,
   ports: Record<string, number>,
-  database: SessionDatabase | null = null
+  database: SessionDatabase | null = null,
+  warning: string | null = null
 ): string {
   const lines: string[] = [];
+  if (warning) lines.push(`- ${warning}`);
   const names = Object.entries(ports);
   if (names.length)
     lines.push(

package/lib/project-config/database.ts

@@ -43,6 +43,12 @@ export type PgRun = (
 
 export const pgRun: PgRun = (cmd, args, env) =>
   new Promise((resolve) => {
+    // A test that reached the real server could list or drop the owner's
+    // databases: every test injects its own run.
+    if (process.env.VITEST)
+      throw new Error(
+        "Refusing to run the real Postgres tools under the test runner"
+      );
     execFile(
       cmd,
       args,

package/lib/project-config/index.ts

@@ -1,17 +1,28 @@
 /**
- * The one reader of a project's config: `agentos.json`, else `.dispatch.json`,
- * else the legacy `.agent-os/worktrees.json` / `.agent-os.json`. The first
- * file that exists is the config; a broken one is an error, never a reason
- * to read the next. Design: docs/decisions/2026-10-10-agentos-json.md.
+ * The one reader of a project's config: `agentos.json` and `.dispatch.json`
+ * together, else the legacy `.agent-os/worktrees.json` / `.agent-os.json`
+ * (the first of those that exists). A broken file is an error, never a
+ * reason to read the next or to ignore it.
+ *
+ * When both agentos.json and .dispatch.json exist they merge by top-level
+ * key: agentos.json wins any key it sets, and its value replaces
+ * .dispatch.json's whole (no deep merge, so a partial `browse` never mixes
+ * with the old one); keys only .dispatch.json has still apply, after its
+ * normalization (`workspace` becomes `cards.workspace`, dispatch-only keys
+ * are dropped). `inherited` names those keys and `warning` says to move them.
+ * Design: docs/decisions/2026-10-10-agentos-json.md.
  */
 
 import * as fs from "fs";
 import * as path from "path";
 import type { z } from "zod";
 import {
+  agentosFields,
   agentosJson,
+  dispatchFields,
   dispatchJson,
   legacyJson,
+  mergedJson,
   RESERVED_ENV,
   type ProjectConfig,
 } from "./schema";
@@ -34,9 +45,20 @@ export interface LoadedConfig {
   source: string | null;
   // Why the file was refused, naming it and every bad field.
   error: string | null;
+  // Top-level keys that came from .dispatch.json because agentos.json lacks
+  // them; empty unless both files exist.
+  inherited: string[];
+  // One line for the brief when both files exist; null otherwise.
+  warning: string | null;
 }
 
-const NONE: LoadedConfig = { config: {}, source: null, error: null };
+export const NONE: LoadedConfig = Object.freeze({
+  config: {},
+  source: null,
+  error: null,
+  inherited: Object.freeze([]) as unknown as string[],
+  warning: null,
+});
 
 function describe(file: string, error: z.ZodError): string {
   const fields = error.issues.map((i) => {
@@ -61,7 +83,9 @@ function fromLegacy(raw: z.infer<typeof legacyJson>): ProjectConfig {
   return config;
 }
 
-function parse(file: string, text: string): LoadedConfig {
+// `checked: false` leaves the port-name check to the merge, which can see
+// the ports the other file declares.
+function parse(file: string, text: string, checked = true): LoadedConfig {
   let raw: unknown;
   try {
     raw = JSON.parse(text);
@@ -73,31 +97,102 @@ function parse(file: string, text: string): LoadedConfig {
     };
   }
   if (file === "agentos.json") {
-    const got = agentosJson.safeParse(raw);
+    const got = (checked ? agentosJson : agentosFields).safeParse(raw);
     return got.success
-      ? { config: got.data, source: file, error: null }
+      ? { ...NONE, config: got.data, source: file }
       : { ...NONE, source: file, error: describe(file, got.error) };
   }
   if (file === ".dispatch.json") {
-    const got = dispatchJson.safeParse(raw);
+    const got = (checked ? dispatchJson : dispatchFields).safeParse(raw);
     if (!got.success)
       return { ...NONE, source: file, error: describe(file, got.error) };
     const { workspace, ...config } = got.data;
     if (workspace && !config.cards?.workspace)
       config.cards = { ...config.cards, workspace };
-    return { config, source: file, error: null };
+    return { ...NONE, config, source: file };
   }
   const got = legacyJson.safeParse(raw);
   return got.success
-    ? { config: fromLegacy(got.data), source: file, error: null }
+    ? { ...NONE, config: fromLegacy(got.data), source: file }
     : { ...NONE, source: file, error: describe(file, got.error) };
 }
 
+export const bothFilesWarning = (inherited: string[]): string =>
+  `This repo has both agentos.json and .dispatch.json; keys ${inherited.join(", ")} come from .dispatch.json. Move them into agentos.json and delete .dispatch.json.`;
+
+function merge(agentos: ProjectConfig, dispatch: ProjectConfig): LoadedConfig {
+  const inherited = Object.keys(dispatch).filter((k) => !(k in agentos));
+  const config = {
+    ...Object.fromEntries(
+      inherited.map((k) => [k, dispatch[k as keyof ProjectConfig]])
+    ),
+    ...agentos,
+  } as ProjectConfig;
+  const got = mergedJson.safeParse(config);
+  if (!got.success)
+    return {
+      ...NONE,
+      source: "agentos.json",
+      error: describe("agentos.json with .dispatch.json", got.error),
+    };
+  return {
+    ...NONE,
+    config,
+    source: "agentos.json",
+    inherited,
+    warning: inherited.length ? bothFilesWarning(inherited) : null,
+  };
+}
+
+function statOf(projectPath: string, file: string): fs.Stats | null {
+  try {
+    const stat = fs.statSync(path.join(projectPath, file));
+    return stat.isFile() ? stat : null;
+  } catch {
+    return null;
+  }
+}
+
+function readFile(projectPath: string, file: string): string | LoadedConfig {
+  try {
+    return fs.readFileSync(path.join(projectPath, file), "utf-8");
+  } catch (e) {
+    return {
+      ...NONE,
+      source: file,
+      error: `${file} could not be read: ${(e as Error).message}`,
+    };
+  }
+}
+
+// Both files, merged. A broken one is the error, whichever it is.
+function loadBoth(projectPath: string): LoadedConfig {
+  const parsed: LoadedConfig[] = [];
+  for (const file of ["agentos.json", ".dispatch.json"]) {
+    const text = readFile(projectPath, file);
+    if (typeof text !== "string") return text;
+    const got = parse(file, text, false);
+    if (got.error) return got;
+    parsed.push(got);
+  }
+  return merge(parsed[0].config, parsed[1].config);
+}
+
 // Keyed on the project; reused while the file's mtime and size hold, since
 // agentEnv reads it for every terminal and chat start.
 const cache = new Map<string, { stamp: string; loaded: LoadedConfig }>();
 
 export function loadProjectConfig(projectPath: string): LoadedConfig {
+  const a = statOf(projectPath, "agentos.json");
+  const d = statOf(projectPath, ".dispatch.json");
+  if (a && d) {
+    const stamp = `both:${a.mtimeMs}:${a.size}:${d.mtimeMs}:${d.size}`;
+    const hit = cache.get(projectPath);
+    if (hit?.stamp === stamp) return hit.loaded;
+    const loaded = loadBoth(projectPath);
+    cache.set(projectPath, { stamp, loaded });
+    return loaded;
+  }
   for (const file of CONFIG_FILES) {
     const full = path.join(projectPath, file);
     let stat: fs.Stats;
@@ -110,16 +205,8 @@ export function loadProjectConfig(projectPath: string): LoadedConfig {
     const stamp = `${file}:${stat.mtimeMs}:${stat.size}`;
     const hit = cache.get(projectPath);
     if (hit?.stamp === stamp) return hit.loaded;
-    let text: string;
-    try {
-      text = fs.readFileSync(full, "utf-8");
-    } catch (e) {
-      return {
-        ...NONE,
-        source: file,
-        error: `${file} could not be read: ${(e as Error).message}`,
-      };
-    }
+    const text = readFile(projectPath, file);
+    if (typeof text !== "string") return text;
     const loaded = parse(file, text);
     cache.set(projectPath, { stamp, loaded });
     return loaded;

package/lib/project-config/schema.ts

@@ -228,13 +228,19 @@ function portRefs(
 
 // agentos.json: an unknown key is an error, because it is nearly always a
 // typo that would otherwise be silently ignored.
-export const agentosJson = z.strictObject(shape).superRefine(portRefs);
+export const agentosFields = z.strictObject(shape);
+export const agentosJson = agentosFields.superRefine(portRefs);
 
 // .dispatch.json: the same fields, but dispatch has keys of its own. Its
 // top-level `workspace` is `cards.workspace` here.
-export const dispatchJson = z
-  .object({ ...shape, workspace: z.string().optional() })
-  .superRefine(portRefs);
+export const dispatchFields = z.object({
+  ...shape,
+  workspace: z.string().optional(),
+});
+export const dispatchJson = dispatchFields.superRefine(portRefs);
+
+// The cross-key port check on its own, for a config merged from two files.
+export const mergedJson = z.looseObject(shape).superRefine(portRefs);
 
 export const legacyJson = z.object({
   setup: z.array(z.string()).optional(),

package/lib/project-config/session.ts

@@ -10,7 +10,12 @@ import { sessionTmpDir } from "../sessions/leftovers";
 import { db } from "../db";
 import { getProject } from "../projects";
 import { sessionPorts } from "../ports";
-import { loadProjectConfig, projectEnv, type LoadedConfig } from "./index";
+import {
+  loadProjectConfig,
+  NONE,
+  projectEnv,
+  type LoadedConfig,
+} from "./index";
 import { runningBrief } from "./brief";
 import { databaseEnv, sessionDatabase } from "./database";
 
@@ -31,9 +36,7 @@ export function sessionConfig(
   sessionId: string
 ): LoadedConfig & { ports: Record<string, number> | null } {
   const projectPath = projectPathOf(sessionId);
-  const loaded = projectPath
-    ? loadProjectConfig(projectPath)
-    : { config: {}, source: null, error: null };
+  const loaded = projectPath ? loadProjectConfig(projectPath) : NONE;
   return { ...loaded, ports: sessionPorts(sessionId) };
 }
 
@@ -70,9 +73,9 @@ export function sessionProjectEnv(sessionId: string): Record<string, string> {
 
 export function sessionRunningBrief(sessionId: string): string {
   try {
-    const { config, source, ports } = sessionConfig(sessionId);
+    const { config, source, warning, ports } = sessionConfig(sessionId);
     return source
-      ? runningBrief(config, ports ?? {}, sessionDatabase(sessionId))
+      ? runningBrief(config, ports ?? {}, sessionDatabase(sessionId), warning)
       : "";
   } catch (error) {
     console.error(`[project-config] brief for ${sessionId}:`, error);

package/lib/project-tier/getProjectTier.ts

@@ -0,0 +1,18 @@
+import { db } from "@/lib/db";
+import type { ProjectTier } from "./types";
+
+// An unknown project counts as production: a missing row never opens the
+// fast lane.
+export function projectTier(projectId: string | null): ProjectTier {
+  if (!projectId) return "production";
+  const row = db
+    .prepare(`SELECT tier FROM projects WHERE id = ?`)
+    .get(projectId) as { tier: string } | undefined;
+  return row?.tier === "fast" ? "fast" : "production";
+}
+
+export const taskTier = (task: { project_id: string | null }): ProjectTier =>
+  projectTier(task.project_id);
+
+export const isFast = (task: { project_id: string | null }): boolean =>
+  taskTier(task) === "fast";

package/lib/project-tier/index.ts

@@ -0,0 +1,3 @@
+export { PROJECT_TIERS, type ProjectTier } from "./types";
+export { projectTier, taskTier, isFast } from "./getProjectTier";
+export { setProjectTier } from "./setProjectTier";

package/lib/project-tier/setProjectTier.ts

@@ -0,0 +1,14 @@
+import { getProject } from "@/lib/projects";
+import { db } from "@/lib/db";
+import type { Project } from "@/lib/db/types";
+import type { ProjectTier } from "./types";
+
+export function setProjectTier(projectId: string, tier: ProjectTier): Project {
+  const project = getProject(projectId);
+  if (!project || project.is_uncategorized)
+    throw new Error("Project not found or cannot be modified");
+  db.prepare(
+    `UPDATE projects SET tier = ?, updated_at = datetime('now') WHERE id = ?`
+  ).run(tier, projectId);
+  return getProject(projectId)!;
+}

package/lib/project-tier/types.ts

@@ -0,0 +1,3 @@
+export type { ProjectTier } from "@/lib/db/types";
+
+export const PROJECT_TIERS = ["production", "fast"] as const;

package/lib/security/net.ts

@@ -146,10 +146,13 @@ export function originAllowed(
 
 const SAFE_METHODS = new Set(["GET", "HEAD", "OPTIONS"]);
 
-// LumifyHub's approve page sends the browser back here, so this one URL is
-// reached by a cross-site top-level navigation. It acts only on a `state`
-// this instance issued, which a foreign page can't know.
-const CROSS_SITE_NAVIGATIONS = ["/api/lumifyhub/callback"];
+// LumifyHub's approve page and an MCP server's sign-in send the browser back
+// here, so these URLs are reached by a cross-site top-level navigation. Each
+// acts only on a `state` this instance issued, which a foreign page can't know.
+const CROSS_SITE_NAVIGATIONS = [
+  "/api/lumifyhub/callback",
+  "/api/mcp-auth/callback",
+];
 
 function crossSiteNavigationAllowed(req: {
   method?: string;

package/lib/start-options.ts

@@ -40,7 +40,14 @@ export async function startOptions(
     const opts = { workspaceId: project?.workspace_id ?? null };
     roles.plan = resolveRole("plan", opts, models).ref;
     roles.implement = resolveRole("implement", opts, models).ref;
-    planDefault = taskRouting(opts.workspaceId, "chat", undefined).plan;
+    planDefault = taskRouting(
+      opts.workspaceId,
+      "chat",
+      undefined,
+      undefined,
+      undefined,
+      project?.tier
+    ).plan;
   } catch (error) {
     planError = error instanceof Error ? error.message : String(error);
   }

package/lib/tasks/finish.ts

@@ -40,6 +40,7 @@ import { sessionEnded } from "../experiments/hooks";
 import { snapshotWorktree } from "../resurrect/snapshot";
 import { keepSessionFiles } from "../session-artifacts/collect";
 import { setPr, setTask } from "../db/session-parts";
+import { isFast } from "../project-tier/getProjectTier";
 
 export const sessionMergePolicy = (session: Session): MergePolicy =>
   mergePolicy(session.project_id ? getProject(session.project_id) : null);
@@ -167,7 +168,7 @@ export async function signOffTask(
     throw new Error(`${opts.base} isn't a base ${session.name} may merge into`);
   const judgedBase = opts.base ?? session.base_branch;
   const pr = await prFor(session, true);
-  const verdict = canSignOff(pr);
+  const verdict = canSignOff(pr, { ci: !isFast(session) });
   if (!verdict.ok) throw new Error(verdict.reason);
   if (pr!.base && pr!.base !== judgedBase)
     throw new Error(

package/lib/tasks/index.ts

@@ -15,7 +15,7 @@ import { effectiveModels } from "../models/config";
 import { ANTHROPIC } from "../models/roles";
 import { processTable, runsSomething } from "../process-table";
 import { randomUUID } from "crypto";
-import { db, queries, type Session } from "../db";
+import { db, queries, type ProjectTier, type Session } from "../db";
 import { getProject } from "../projects";
 import {
   createWorktree,
@@ -267,7 +267,8 @@ async function startTask(
         view,
         opts.model,
         opts.plan,
-        opts.planOnly
+        opts.planOnly,
+        project.tier
       ).plan;
     const session = await startRemoteTask(hostId, project, {
       id,
@@ -310,7 +311,8 @@ async function startTask(
           view,
           opts.model,
           opts.plan,
-          opts.planOnly
+          opts.planOnly,
+          project.tier
         )
       : otherAgentRouting(opts.model);
   const projectPath = expandHome(project.working_directory);
@@ -590,7 +592,9 @@ export function taskRouting(
   view: StartView,
   model: unknown,
   plan?: boolean,
-  planOnly?: boolean
+  planOnly?: boolean,
+  // A fast project skips the plan step unless the caller asks for it.
+  tier: ProjectTier = "production"
 ) {
   const override = parseOverride(model);
   const models = effectiveModels();
@@ -601,7 +605,8 @@ export function taskRouting(
   const planStep =
     view === "chat" &&
     (!!planOnly ||
-      ((plan ?? models.planStep) && planning.ref !== implement.ref));
+      ((plan ?? (tier === "fast" ? false : models.planStep)) &&
+        planning.ref !== implement.ref));
   return {
     override,
     plan: planStep,

package/lib/tasks/move-testing.ts

@@ -3,13 +3,13 @@
 // Tests mock ../worktrees (WORKTREES_DIR), ../env-setup and ../agents/launch.
 
 import fs from "fs";
-import os from "os";
 import path from "path";
 import { randomUUID } from "crypto";
 import { db, insertSessionRow, type Session } from "../db";
 import { createProject } from "../projects";
 import { writeTranscript } from "./transcript";
 import { gitSync } from "../git-exec";
+import { tempDir } from "@/lib/test-temp";
 
 export const CLAUDE_ID = "11111111-2222-3333-4444-555555555555";
 
@@ -30,7 +30,7 @@ export interface MoveFixture {
 /** HOME, Claude's folder and git identity all point into a temp dir. */
 export function setupMoveRepo(): MoveFixture {
   const saved = { HOME: process.env.HOME };
-  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "aos-move-"));
+  const tmp = tempDir("aos-move-");
   process.env.HOME = tmp;
   process.env.CLAUDE_CONFIG_DIR = path.join(tmp, ".claude");
   for (const who of ["AUTHOR", "COMMITTER"]) {

package/lib/tasks/state.ts

@@ -97,13 +97,19 @@ export function needsHuman(state: TaskState): boolean {
   ].includes(state);
 }
 
-export function canSignOff(pr: TaskPR | null): {
+// `ci: false` (a fast project): checks that are failing or running don't
+// refuse the merge.
+export function canSignOff(
+  pr: TaskPR | null,
+  opts: { ci?: boolean } = {}
+): {
   ok: boolean;
   reason?: string;
 } {
   if (!pr) return { ok: false, reason: "No pull request yet" };
   if (pr.state !== "OPEN")
     return { ok: false, reason: `PR is ${pr.state.toLowerCase()}` };
+  if (opts.ci === false) return { ok: true };
   if (pr.checks === "fail")
     return { ok: false, reason: "CI checks are failing" };
   if (pr.checks === "pending")

package/lib/test-temp.ts

@@ -0,0 +1,30 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+// Folders made by tempDir, removed when the test file ends (vitest.setup.ts
+// calls removeTempDirs). Kept on globalThis: vi.resetModules() would
+// otherwise lose the list.
+const KEY = Symbol.for("agentos.testTempDirs");
+const made = (): Set<string> => {
+  const g = globalThis as unknown as Record<symbol, Set<string> | undefined>;
+  return (g[KEY] ??= new Set<string>());
+};
+
+/** A fresh temp folder that is removed when the test file ends. */
+export function tempDir(prefix: string): string {
+  const dir = mkdtempSync(join(tmpdir(), prefix));
+  made().add(dir);
+  return dir;
+}
+
+export function removeTempDirs(): void {
+  for (const dir of made()) {
+    try {
+      rmSync(dir, { recursive: true, force: true, maxRetries: 5 });
+    } catch {
+      // the run root's removal is the backstop
+    }
+  }
+  made().clear();
+}