@saadnvd1/agent-os 0.3.671 → 0.3.672

package/app/api/projects/[id]/route.ts

@@ -1,5 +1,7 @@
 import { NextRequest, NextResponse } from "next/server";
+import { z } from "zod";
 import { setProjectWorkspace } from "@/lib/workspaces";
+import { PROJECT_TIERS, setProjectTier } from "@/lib/project-tier";
 import {
   getProjectWithDevServers,
   updateProject,
@@ -7,6 +9,8 @@ import {
   toggleProjectExpanded,
 } from "@/lib/projects";
 
+const tierSchema = z.enum(PROJECT_TIERS);
+
 interface RouteParams {
   params: Promise<{ id: string }>;
 }
@@ -46,6 +50,17 @@ export async function PATCH(request: NextRequest, { params }: RouteParams) {
       workspaceId,
     } = body;
 
+    let tier: z.infer<typeof tierSchema> | undefined;
+    if (body.tier !== undefined) {
+      const parsed = tierSchema.safeParse(body.tier);
+      if (!parsed.success)
+        return NextResponse.json(
+          { error: "tier must be production or fast" },
+          { status: 400 }
+        );
+      tier = parsed.data;
+    }
+
     // Handle expanded toggle separately
     if (typeof expanded === "boolean") {
       toggleProjectExpanded(id, expanded);
@@ -56,6 +71,17 @@ export async function PATCH(request: NextRequest, { params }: RouteParams) {
       setProjectWorkspace(id, workspaceId);
     }
 
+    if (tier) {
+      try {
+        setProjectTier(id, tier);
+      } catch {
+        return NextResponse.json(
+          { error: "Project not found or cannot be modified" },
+          { status: 404 }
+        );
+      }
+    }
+
     // Update other fields if provided
     if (
       name ||

package/components/Projects/ProjectSettingsDialog.tsx

@@ -12,6 +12,8 @@ import {
 import { Button } from "@/components/ui/button";
 import { Input } from "@/components/ui/input";
 import { Textarea } from "@/components/ui/textarea";
+import { ProjectTierField } from "./ProjectTierField";
+import type { ProjectTier } from "@/lib/project-tier/types";
 import {
   Select,
   SelectContent,
@@ -95,6 +97,7 @@ export function ProjectSettingsDialog({
     getDefaultModelForAgent("claude")
   );
   const [initialPrompt, setInitialPrompt] = useState("");
+  const [tier, setTier] = useState<ProjectTier>("fast");
   const [devServers, setDevServers] = useState<DevServerConfig[]>([]);
   const [repositories, setRepositories] = useState<RepositoryConfig[]>([]);
   const [isLoading, setIsLoading] = useState(false);
@@ -118,6 +121,7 @@ export function ProjectSettingsDialog({
       setName(project.name);
       setWorkingDirectory(project.working_directory);
       setAgentType(project.agent_type);
+      setTier(project.tier);
       setDefaultModel(
         isSupportedModelForAgent(project.agent_type, project.default_model)
           ? project.default_model
@@ -336,6 +340,7 @@ export function ProjectSettingsDialog({
         agentType,
         defaultModel,
         initialPrompt: initialPrompt.trim() || null,
+        tier,
       });
 
       // Handle dev server changes
@@ -526,6 +531,8 @@ export function ProjectSettingsDialog({
               </Select>
             </div>
 
+            <ProjectTierField value={tier} onChange={setTier} />
+
             {/* Initial Prompt */}
             <div className="space-y-2">
               <label className="text-sm font-medium">Initial Prompt</label>

package/components/Projects/ProjectTierField.tsx

@@ -0,0 +1,39 @@
+"use client";
+
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from "@/components/ui/select";
+import type { ProjectTier } from "@/lib/project-tier/types";
+
+const DETAIL: Record<ProjectTier, string> = {
+  production: "CI, the independent review and scope must pass before a merge.",
+  fast: "A task's PR merges as soon as it opens: no CI wait, no review.",
+};
+
+export function ProjectTierField({
+  value,
+  onChange,
+}: {
+  value: ProjectTier;
+  onChange: (tier: ProjectTier) => void;
+}) {
+  return (
+    <div className="space-y-2">
+      <label className="text-sm font-medium">Tier</label>
+      <Select value={value} onValueChange={(v) => onChange(v as ProjectTier)}>
+        <SelectTrigger>
+          <SelectValue />
+        </SelectTrigger>
+        <SelectContent>
+          <SelectItem value="fast">Fast</SelectItem>
+          <SelectItem value="production">Production</SelectItem>
+        </SelectContent>
+      </Select>
+      <p className="text-muted-foreground text-xs">{DETAIL[value]}</p>
+    </div>
+  );
+}

package/components/Workspaces/ProjectTiersForm.tsx

@@ -0,0 +1,33 @@
+"use client";
+
+import { SettingToggle } from "@/components/Settings/SettingToggle";
+import { useProjectsQuery, useUpdateProject } from "@/data/projects";
+
+// A workspace's projects, each switched between production (every merge gate)
+// and fast (a task's PR merges as soon as it opens).
+export function ProjectTiersForm({ workspaceId }: { workspaceId: string }) {
+  const { data: projects } = useProjectsQuery();
+  const update = useUpdateProject();
+  const mine = (projects ?? []).filter(
+    (p) => p.workspace_id === workspaceId && !p.is_uncategorized
+  );
+  if (!mine.length) return null;
+  return (
+    <div className="space-y-2">
+      {mine.map((p) => (
+        <SettingToggle
+          key={p.id}
+          title={`${p.name}: production`}
+          detail="On: CI, the independent review and scope gate its merges. Off (fast): a task's PR merges as soon as it opens."
+          checked={p.tier === "production"}
+          onChange={(on) =>
+            update.mutate({
+              projectId: p.id,
+              tier: on ? "production" : "fast",
+            })
+          }
+        />
+      ))}
+    </div>
+  );
+}

package/components/Workspaces/WorkspaceSettings.tsx

@@ -7,6 +7,7 @@ import { RulesForm } from "./RulesForm";
 import { FreshStartForm } from "./FreshStartForm";
 import { McpServersForm } from "./McpServersForm";
 import { HqFolderForm } from "./HqFolderForm";
+import { ProjectTiersForm } from "./ProjectTiersForm";
 import { StallForm } from "./StallForm";
 import { WorkspaceModelsForm } from "./WorkspaceModelsForm";
 import { AwayWindowForm } from "@/components/Away/AwayWindowForm";
@@ -49,6 +50,7 @@ export function WorkspaceSettings() {
           <WorkspaceModelsForm workspaceId={w.id} />
           <McpServersForm workspace={w} />
           <HqFolderForm workspaceId={w.id} />
+          <ProjectTiersForm workspaceId={w.id} />
           <SettingToggle
             title="Wake tasks on CI failures and reviews"
             detail="A task's agent is messaged once when a check fails on its PR's head, with the log's tail, and when someone reviews or comments on it."

package/data/projects/queries.ts

@@ -3,6 +3,7 @@ import type {
   ProjectWithRepositories,
   DetectedDevServer,
 } from "@/lib/projects";
+import type { ProjectTier } from "@/lib/db/types";
 import { projectKeys } from "./keys";
 import { sessionKeys } from "../sessions/keys";
 
@@ -131,6 +132,7 @@ export function useUpdateProject() {
       agentType,
       defaultModel,
       initialPrompt,
+      tier,
     }: {
       projectId: string;
       name?: string;
@@ -138,6 +140,7 @@ export function useUpdateProject() {
       agentType?: string;
       defaultModel?: string;
       initialPrompt?: string | null;
+      tier?: ProjectTier;
     }) => {
       const res = await fetch(`/api/projects/${projectId}`, {
         method: "PATCH",
@@ -148,6 +151,7 @@ export function useUpdateProject() {
           agentType,
           defaultModel,
           initialPrompt,
+          tier,
         }),
       });
       if (!res.ok) throw new Error("Failed to update project");

package/lib/db/migrations/20261018T2130_project_tier.ts

@@ -0,0 +1,38 @@
+import type { Migration } from "../migration-types";
+
+export default {
+  key: "20261018T2130_project_tier",
+  up: (db) => {
+    // A project's tier: "production" tasks pass every merge gate, "fast"
+    // ones merge as soon as their PR opens (orchestrator/fast-lane.ts). The
+    // LumifyHub and Workstak projects start production, in the same step as
+    // the column, so running this again never overwrites a tier Saad changed.
+    const cols = db.prepare(`PRAGMA table_info(projects)`).all() as {
+      name: string;
+    }[];
+    if (!cols.some((c) => c.name === "tier")) {
+      db.exec(
+        `ALTER TABLE projects ADD COLUMN tier TEXT NOT NULL DEFAULT 'fast'`
+      );
+      db.exec(
+        `UPDATE projects SET tier = 'production'
+         WHERE lower(name) LIKE 'lumifyhub%' OR lower(name) LIKE 'workstak%'
+            OR workspace_id IN (
+              SELECT id FROM workspaces WHERE lower(name) IN ('lumifyhub', 'workstak')
+            )`
+      );
+    }
+    // What the fast lane has done to a task: the PR it armed (so a disarm
+    // sticks) and the merge whose CI it still watches.
+    db.exec(`CREATE TABLE IF NOT EXISTS fast_lane_tasks (
+      session_id TEXT PRIMARY KEY,
+      workspace_id TEXT NOT NULL,
+      auto_armed_pr INTEGER,
+      merged_sha TEXT,
+      merged_pr INTEGER,
+      merged_at TEXT,
+      ci_checked_at TEXT,
+      ci_done_at TEXT
+    )`);
+  },
+} satisfies Migration;

package/lib/db/types.ts

@@ -175,6 +175,9 @@ export interface Group {
   created_at: string;
 }
 
+// production: every merge gate applies. fast: a task's PR merges when it opens.
+export type ProjectTier = "production" | "fast";
+
 export interface Project {
   id: string;
   name: string;
@@ -190,6 +193,7 @@ export interface Project {
   lh_board_id: string | null;
   lh_board_name: string | null;
   lh_board_page_id: string | null;
+  tier: ProjectTier;
   // What its tasks need from a machine (JSON array), and where that came from.
   machine_needs?: string | null;
   machine_needs_source?: string | null;

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

@@ -125,6 +125,10 @@ export function setup() {
     workingDirectory: repo,
   });
   setProjectWorkspace(project.id, workspace.id);
+  // These tests judge today's gates; fast-lane.test.ts flips it.
+  db.prepare(`UPDATE projects SET tier = 'production' WHERE id = ?`).run(
+    project.id
+  );
   ensureOrchestrator(workspace.id);
   const task = seedSession({
     projectId: project.id,

package/lib/orchestrator/armed.ts

@@ -26,6 +26,7 @@ import { getOrchestrator } from "./home";
 import { isPaused } from "./pause";
 import { review } from "./review";
 import { judge, mergeJudged } from "./signoff";
+import { isFast } from "../project-tier/getProjectTier";
 import { workspaceTask } from "./targets";
 import { markStatusDirty } from "../status/dirty";
 import { setPr } from "../db/session-parts";
@@ -88,9 +89,10 @@ export const anyArmed = (workspaceId: string) =>
   armedTasks(workspaceId).length > 0;
 
 // The orchestrator's `arm` and `disarm`.
-export function arm(workspaceId: string, ref: string): string {
+export async function arm(workspaceId: string, ref: string): Promise<string> {
   const task = workspaceTask(workspaceId, ref);
   armTask(task);
+  if (isFast(task)) return armedNow(workspaceId, task);
   return `Armed ${task.name}: AgentOS merges its PR the moment every sign_off gate passes at its head, and tells you with one event. A gate failure also comes as one event; it stays armed for the fix, unless the failure goes to Saad. No need to call sign_off.`;
 }
 
@@ -124,6 +126,17 @@ export function armTask(task: Session): void {
   setArmed(task.id, true);
 }
 
+// A fast task merges the moment it's armed, if its PR is open.
+async function armedNow(workspaceId: string, task: Session): Promise<string> {
+  const verdict = await judge(workspaceId, task, false, { count: false });
+  if (!verdict.ok)
+    return `Armed ${task.name} (fast project); not merged yet.\n${verdict.text}\nIt stays armed and merges once that is fixed.`;
+  await merge(workspaceId, task, verdict, defaults);
+  return stillArmed(workspaceId, task.id)
+    ? `Armed ${task.name} (fast project); the merge was refused, see the event. It stays armed.`
+    : `Merged ${task.name} (fast project): PR #${verdict.pr} at ${short(verdict.sha)}, no CI wait or review.`;
+}
+
 export function disarm(workspaceId: string, ref: string): string {
   const task = workspaceTask(workspaceId, ref);
   setArmed(task.id, false);

package/lib/orchestrator/brief.ts

@@ -28,6 +28,7 @@ export interface BriefProject {
   path: string;
   board: string | null;
   defaultBranch: string;
+  tier?: "production" | "fast";
 }
 
 // Read when the brief is built, so a switch flipped in Settings reaches the
@@ -121,7 +122,7 @@ Reading:
 Acting:
 - \`${TOOL_NAMES.send}\` (session, message, scope_change?): message a session; it arrives as its next prompt. scope_change records it on the task's brief for its review.
 - \`${TOOL_NAMES.message_orchestrator}\` (workspace, message): message another workspace's orchestrator, the only thing you reach outside this workspace. Use it to hand over a bug or ask for something in its projects; it decides what to do there.
-- \`${TOOL_NAMES.start_task}\` (project, prompt, base?, name?, view?, after?, priority?, machine?, now?, now_reason?, model?, plan, plan_only?, plan_reason): a task in its own worktree that ends in a PR. priority (urgent, blocking, normal, background) sets where it stands in the queue; machine mac pins work that needs this Mac. A busy or loaded machine holds a queued start and says why; don't retry it. Write the prompt as a full brief; name it in 2-6 words, or it's named from the prompt. It runs as a chat; pass view terminal only when the job needs a TUI. Pass after (a task's id or name, or "any") to hold it until that task finishes, instead of remembering it in your notes. Over the workspace's running task limit it's queued too: the result says "Queued (position N)", it starts by itself, and you get an event when it does. now true (with now_reason, not with after) starts it at once past the limit instead; it's logged for Saad, so use it only when it can't wait. Its models follow the role settings (it plans on the planning model, then implements on the implementation one); State plan and plan_reason for every task (see "Triage every job"). Pass model ("provider/model", or a map of role to one) only when Saad asks for one, or to put implementation on Opus when the work needs deep reasoning (say why in plan_reason or a note); another provider than anthropic only when Saad asks.
+- \`${TOOL_NAMES.start_task}\` (project, prompt, base?, name?, view?, after?, priority?, machine?, now?, now_reason?, model?, plan, plan_only?, plan_reason): a task in its own worktree that ends in a PR. priority (urgent, blocking, normal, background) sets where it stands in the queue; machine mac pins work that needs this Mac. A busy or loaded machine holds a queued start and says why; don't retry it. Write the prompt as a full brief; name it in 2-6 words, or it's named from the prompt. It runs as a chat; pass view terminal only when the job needs a TUI. Pass after (a task's id or name, or "any") to hold it until that task finishes, instead of remembering it in your notes. Over the workspace's running task limit it's queued too: the result says "Queued (position N)", it starts by itself, and you get an event when it does. now true (with now_reason, not with after) starts it at once past the limit instead; it's logged for Saad, so use it only when it can't wait. Its models follow the role settings (it plans on the planning model, then implements on the implementation one); State plan and plan_reason for every task in a production project (see "Triage every job"); a fast project skips the plan unless you pass plan true. Pass model ("provider/model", or a map of role to one) only when Saad asks for one, or to put implementation on Opus when the work needs deep reasoning (say why in plan_reason or a note); another provider than anthropic only when Saad asks.
 - \`${TOOL_NAMES.plan_pieces}\` (task, merge?, drop?): when a plan split into pieces (the plan-done event names them), list them; merge or drop edits the ones still waiting. A piece starts by itself once what it waits on has merged (or deployed); you don't start it.
 - \`${TOOL_NAMES.approve_plan}\` (task, message?): continue a plan_only task whose plan is ready; it implements on the implementation model, once. message amends the plan and is recorded on the task's brief as a scope change. Reject a plan with drop.
 - \`${TOOL_NAMES.set_task_model}\` (task, model, message?): move a paused task to another model and carry on in the same conversation and worktree; it keeps that model from then on. Only when Saad asks.
@@ -145,6 +146,7 @@ Acting:
 - \`${TOOL_NAMES.done}\` (session): finish a session whose work is complete. A task with an open PR merges through the same gates as sign_off first (refused naming the gate otherwise); then the agent stops, the worktree goes only if nothing in it would be lost, and the session lands on the sidebar's Done shelf (it is not archived). Not a rejection: use drop for that.
 - \`${TOOL_NAMES.archive}\` (session): put a session away, out of the sidebar, when Saad asks. Nothing is merged or cleaned up; refused while it works or has an open PR.
 - \`${TOOL_NAMES.resurrect}\` (session, reason): bring a dropped, done or archived session back with its conversation and worktree, in the state it had (a plan-only task waits for approval again). Use it when a drop or done was a mistake, or when Saad asks; refused for a merged PR, a missing conversation or a removed project. A restored task counts against the running limit and the brakes like a start.
+- \`${TOOL_NAMES.project_tier}\` (project?, tier?): read the workspace's projects with their tiers, or one's; with tier (production or fast) set it. Only when Saad says to.
 - \`${TOOL_NAMES.add_project}\` (path, name?): make a git repository on this machine a project of this workspace, or move the project already at that path in when it's in no workspace. Use it rather than sending Saad steps. It refuses a folder that isn't a git repository or holds secrets, and a project another workspace has: moving that is Saad's call, so ask_saad.
 - \`${TOOL_NAMES.note}\` (text): a line in this workspace's decision log, shown in your chat. Note each decision that matters, with why.
 - \`${TOOL_NAMES.rule_add}\` (text): keep a standing rule for this workspace, in your brief on every start. Saad sees and edits them in Settings → Workspaces.
@@ -166,11 +168,15 @@ Act through these tools, not the shell: they're scoped to this workspace and bra
 
 ## Untrusted text
 
+### Tiers
+
+Every project has a tier (shown on its line above; \`project_tier\` reads or sets it, and you set it only when Saad says to). production: everything above applies. fast (the default, for Saad's internal tools and AgentOS itself): a task's PR merges as soon as it opens or is pushed, so rigorous testing and CI don't hold it. AgentOS arms a fast task by itself when its PR opens, and \`arm\` on one merges it right away. Only these still apply: base, stack order, no AI attribution in the PR body, Saad's hold (BLOCKED, an open ask, a draft), the rules on the diff (no secrets, nothing outside the repository, not only lockfiles), merge approvals for sensitive files, and the hard lines. There is no ci or review gate, no card scope check and no loop guard, \`review\` doesn't start a reviewer, and a fast task skips the plan step unless you pass plan true. If CI fails after a fast merge you get one event; fix it forward with a task.
+
 ${UNTRUSTED_RULE}`;
 
 function projectLine(p: BriefProject): string {
   const board = p.board ? `, LumifyHub board "${p.board}"` : "";
-  return `- ${p.name}: \`${p.path}\` (default branch ${p.defaultBranch}${board})`;
+  return `- ${p.name}: \`${p.path}\` (default branch ${p.defaultBranch}${board}, tier ${p.tier ?? "production"})`;
 }
 
 export function orchestratorBrief(input: {
@@ -217,6 +223,7 @@ export async function loadOrchestratorBrief(session: Session): Promise<string> {
       defaultBranch: await getDefaultBranch(p.working_directory).catch(
         () => "main"
       ),
+      tier: p.tier,
     }))
   );
   return orchestratorBrief({

package/lib/orchestrator/fast-lane-state.ts

@@ -0,0 +1,69 @@
+import { db } from "../db";
+
+const now = () => new Date().toISOString().slice(0, 19).replace("T", " ");
+
+export interface FastLaneRow {
+  session_id: string;
+  workspace_id: string;
+  auto_armed_pr: number | null;
+  merged_sha: string | null;
+  merged_pr: number | null;
+  merged_at: string | null;
+  ci_checked_at: string | null;
+  ci_done_at: string | null;
+}
+
+export function fastLaneRow(sessionId: string): FastLaneRow | undefined {
+  return db
+    .prepare(`SELECT * FROM fast_lane_tasks WHERE session_id = ?`)
+    .get(sessionId) as FastLaneRow | undefined;
+}
+
+export function noteAutoArmed(
+  sessionId: string,
+  workspaceId: string,
+  pr: number
+): void {
+  db.prepare(
+    `INSERT INTO fast_lane_tasks (session_id, workspace_id, auto_armed_pr)
+     VALUES (?, ?, ?)
+     ON CONFLICT(session_id) DO UPDATE SET auto_armed_pr = excluded.auto_armed_pr`
+  ).run(sessionId, workspaceId, pr);
+}
+
+// A fast merge: the PR whose CI is watched for a while afterwards.
+export function recordFastMerge(
+  sessionId: string,
+  workspaceId: string,
+  pr: number,
+  sha: string
+): void {
+  db.prepare(
+    `INSERT INTO fast_lane_tasks (session_id, workspace_id, merged_sha, merged_pr, merged_at)
+     VALUES (?, ?, ?, ?, ?)
+     ON CONFLICT(session_id) DO UPDATE SET
+       merged_sha = excluded.merged_sha, merged_pr = excluded.merged_pr,
+       merged_at = excluded.merged_at, ci_checked_at = NULL, ci_done_at = NULL`
+  ).run(sessionId, workspaceId, sha, pr, now());
+}
+
+export function markCiChecked(sessionId: string, done: boolean): void {
+  db.prepare(
+    `UPDATE fast_lane_tasks SET ci_checked_at = ?, ci_done_at = CASE WHEN ? THEN ? ELSE ci_done_at END
+     WHERE session_id = ?`
+  ).run(now(), done ? 1 : 0, now(), sessionId);
+}
+
+// Merges still inside their CI watch.
+export function watchedMerges(
+  workspaceId: string,
+  sinceHours: number
+): FastLaneRow[] {
+  return db
+    .prepare(
+      `SELECT * FROM fast_lane_tasks
+       WHERE workspace_id = ? AND merged_at IS NOT NULL AND ci_done_at IS NULL
+         AND merged_at > datetime('now', ?)`
+    )
+    .all(workspaceId, `-${sinceHours} hours`) as FastLaneRow[];
+}

package/lib/orchestrator/fast-lane.ts

@@ -0,0 +1,96 @@
+/**
+ * The fast lane: a project whose tier is "fast" (project-tier) has no CI
+ * wait, independent review or scope check on a task's PR. Its gates are
+ * trimmed in gates.ts and signoff.ts; this arms each fast task once when its
+ * PR opens, so armed.ts merges it on the same pass, and watches the CI of
+ * what it merged for a while, telling the orchestrator once if that fails.
+ */
+
+import { db, type Session } from "../db";
+import { run } from "../tasks/gh";
+import { checksVerdict, failingCheck, type RollupEntry } from "../tasks/state";
+import { armTask } from "./armed";
+import { queueEventOnce } from "./events";
+import type { SessionFacts } from "./facts";
+import { isPaused } from "./pause";
+import { repoOf } from "./repo";
+import { isFast } from "../project-tier/getProjectTier";
+import {
+  fastLaneRow,
+  markCiChecked,
+  noteAutoArmed,
+  watchedMerges,
+} from "./fast-lane-state";
+
+const CI_WATCH_HOURS = 3;
+const CI_RECHECK_MS = 2 * 60 * 1000;
+
+export async function autoArmFast(
+  workspaceId: string,
+  facts: SessionFacts[]
+): Promise<void> {
+  if (isPaused(workspaceId)) return;
+  for (const f of facts) {
+    const pr = f.task?.pr;
+    if (!pr || pr.state !== "OPEN") continue;
+    const task = db
+      .prepare(
+        `SELECT * FROM session_rows WHERE id = ? AND task_status = 'running'
+           AND merge_armed_at IS NULL`
+      )
+      .get(f.id) as Session | undefined;
+    if (!task || !isFast(task)) continue;
+    if (fastLaneRow(task.id)?.auto_armed_pr === pr.number) continue;
+    try {
+      armTask(task);
+      noteAutoArmed(task.id, workspaceId, pr.number);
+    } catch {
+      // With Saad, or no orchestrator to tell: retried next pass.
+    }
+  }
+}
+
+async function ghRollup(task: Session, pr: number): Promise<RollupEntry[]> {
+  const out = await run(
+    "gh",
+    ["pr", "view", String(pr), "--json", "statusCheckRollup"],
+    repoOf(task),
+    15000
+  );
+  return (JSON.parse(out).statusCheckRollup ?? []) as RollupEntry[];
+}
+
+export async function followFastMerges(
+  workspaceId: string,
+  rollupOf: typeof ghRollup = ghRollup
+): Promise<void> {
+  const now = Date.now();
+  for (const row of watchedMerges(workspaceId, CI_WATCH_HOURS)) {
+    const checked = row.ci_checked_at
+      ? Date.parse(row.ci_checked_at.replace(" ", "T") + "Z")
+      : 0;
+    if (now - checked < CI_RECHECK_MS) continue;
+    const task = db
+      .prepare(`SELECT * FROM session_rows WHERE id = ?`)
+      .get(row.session_id) as Session | undefined;
+    if (!task || !row.merged_pr) {
+      markCiChecked(row.session_id, true);
+      continue;
+    }
+    try {
+      const rollup = await rollupOf(task, row.merged_pr);
+      const verdict = checksVerdict(rollup);
+      if (verdict === "fail") {
+        queueEventOnce(
+          workspaceId,
+          `fast-ci:${row.session_id}:${row.merged_sha}`,
+          row.session_id,
+          `task ${task.name}: merged on the fast lane (PR #${row.merged_pr}), but CI failed after the merge${failingCheck(rollup) ? ` (${failingCheck(rollup)})` : ""}. Fix forward with a task.`
+        );
+      }
+      markCiChecked(row.session_id, verdict !== "pending");
+    } catch {
+      markCiChecked(row.session_id, false);
+    }
+  }
+}

package/lib/orchestrator/gates.ts

@@ -165,7 +165,12 @@ export function checkGate(
   return { gate, state: "pass" };
 }
 
-export function evaluateGates(i: GateInput): GateOutcome[] {
+// `fast`: the fast lane keeps Saad's hold, the rules on the diff, the stack
+// and the PR body's attribution; no CI, review or card scope check.
+export function evaluateGates(
+  i: GateInput,
+  opts: { fast?: boolean } = {}
+): GateOutcome[] {
   const blocked: GateOutcome = i.prBlocked
     ? { gate: "blocked", state: "fail", reason: i.prBlocked }
     : i.prDraft
@@ -185,7 +190,7 @@ export function evaluateGates(i: GateInput): GateOutcome[] {
           : { gate: "blocked", state: "pass" };
   const scope: GateOutcome = i.ruleBreaks.length
     ? { gate: "scope", state: "fail", reason: i.ruleBreaks.join("; ") }
-    : i.fromCard
+    : i.fromCard && !opts.fast
       ? checkGate("scope", i.scope, i.sha)
       : { gate: "scope", state: "pass" };
   const stack: GateOutcome = i.stackRefusal
@@ -197,6 +202,7 @@ export function evaluateGates(i: GateInput): GateOutcome[] {
   const codeReview: GateOutcome = i.codeReview.refusal
     ? { gate: "code-review", state: "fail", reason: i.codeReview.refusal }
     : { gate: "code-review", state: "pass" };
+  if (opts.fast) return [codeReview, blocked, scope, stack];
   return [
     ciGate(i),
     checkGate("review", i.review, i.sha),

package/lib/orchestrator/project-tier-tool.ts

@@ -0,0 +1,33 @@
+import {
+  PROJECT_TIERS,
+  setProjectTier,
+  type ProjectTier,
+} from "../project-tier";
+import { addNote } from "./notes";
+import { workspaceProjects } from "./brief";
+import { workspaceProject } from "./targets";
+
+const line = (name: string, tier: ProjectTier) =>
+  `- ${name}: ${tier}${tier === "fast" ? " (merges when its PR opens)" : " (CI, review and scope gate its merges)"}`;
+
+// project_tier: read one project's tier, or all of the workspace's; with a
+// tier, set it (Saad's call: only when he says so).
+export function projectTierTool(
+  workspaceId: string,
+  projectRef?: string,
+  tier?: (typeof PROJECT_TIERS)[number]
+): string {
+  if (!projectRef) {
+    if (tier) throw new Error("Say which project to set");
+    const all = workspaceProjects(workspaceId);
+    return all.length
+      ? all.map((p) => line(p.name, p.tier)).join("\n")
+      : "No projects in this workspace.";
+  }
+  const project = workspaceProject(workspaceId, projectRef);
+  if (!tier) return line(project.name, project.tier);
+  if (tier === project.tier) return line(project.name, project.tier);
+  setProjectTier(project.id, tier);
+  addNote(workspaceId, `Set ${project.name} to ${tier}.`);
+  return `Set ${project.name} to ${tier}.\n${line(project.name, tier)}`;
+}

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,6 +26,7 @@ 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";
@@ -237,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.";
@@ -277,7 +282,7 @@ export async function runTool(
       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/signoff.test-helpers.ts

@@ -231,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/tool-names.ts

@@ -40,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"),

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";
@@ -160,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()
@@ -174,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"'
       ),
@@ -338,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

package/lib/orchestrator/tools.ts

@@ -165,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.',

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/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/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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saadnvd1/agent-os",
-  "version": "0.3.671",
+  "version": "0.3.672",
   "description": "Self-hosted web UI for managing Claude Code sessions",
   "bin": {
     "agent-os": "scripts/agent-os"