feat: add FSD (Full Speed Drive) execution mode — autopilot without safeguards

Adds "fsd" as a third ExecutionMode alongside "manual" and "autopilot".
FSD runs the autopilot loop with all safeguard checks disabled (no-progress,
resume-cap, same-action-repeat) for maximum throughput. Includes end-to-end
implementation: backend types, route validation, autopilot loop skip logic,
frontend UI toggle (3-way cycle), PauseBanner FSD labels, and comprehensive
tests for all changed components.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: ccchow

CLAUDE.md

@@ -94,6 +94,7 @@ Full lists: [`docs/CODING-GOTCHAS.md`](docs/CODING-GOTCHAS.md), [`docs/TESTING-G
 - **In-memory queue vs SQLite**: `workspaceQueues`/`workspacePendingTasks` are in-memory only.
 - **Autopilot runs inside workspace queue**: `runAutopilotLoop` is wrapped in `enqueueBlueprintTask` at call sites. Inside the loop, use `executeNodeDirect` (not `executeNode`) to avoid nested enqueue deadlock. `resumeNodeSession()` requires an `executionId` — look up latest execution with a session via `getExecutionsForNode()`.
 - **BlueprintStatus vs MacroNodeStatus naming**: `BlueprintStatus` uses `"draft"/"approved"`, `MacroNodeStatus` uses `"pending"/"queued"/"running"/"done"/"failed"/"blocked"/"skipped"` (notably `"running"` not `"in_progress"`).
+- **ExecutionMode values**: `"manual" | "autopilot" | "fsd"`. The `isAutopilotMode()` helper in `plan-routes.ts` groups `"autopilot"` and `"fsd"` together — switching between them does NOT trigger `switchingToAutopilot` (no re-enqueue). FSD skips all safeguard checks in the autopilot loop (`skipSafeguards = isFsd`).
 - **AI operations in plan-operations.ts**: `enrichNodeInternal`, `reevaluateNodeInternal`, `splitNodeInternal`, `smartDepsInternal`, `reevaluateAllInternal` are extracted from route handlers. Both `plan-routes.ts` and `autopilot.ts` call these directly. `runWithRelatedSessionDetection` helper also lives here.
 - **Autopilot pause/resume flow**: When resuming from a safeguard pause, `PauseBanner.handleResume` must clear `pauseReason` and set `status: "running"` (both via API and optimistically in local state). `runAutopilotLoop` also clears `pauseReason` on start. The PUT endpoint's `switchingToAutopilot` only fires when `executionMode` changes FROM non-autopilot, so re-entering autopilot from a paused-autopilot state uses `runAllNodes` instead.
 - **Circular dependency: autopilot ↔ plan-executor**: `autopilot.ts` imports from `plan-executor.ts`. If `plan-executor.ts` needs to call autopilot (e.g. recovery), use dynamic `import("./autopilot.js")` to avoid circular import.

backend/src/__tests__/plan-routes.test.ts

@@ -23,10 +23,13 @@ vi.mock("node:fs", async (importOriginal) => {
       // Allow /test and /test/CLAUDE.md to pass validation
       const np = p.replace(/\\/g, "/");
       if (np === "/test" || np === "/test/CLAUDE.md") return true;
+      // /no-claude-md exists as a directory but has no CLAUDE.md
+      if (np === "/no-claude-md") return true;
       return actual.existsSync(p);
     }),
     statSync: vi.fn((p: string) => {
-      if (p.replace(/\\/g, "/") === "/test") return { isDirectory: (): boolean => true };
+      const np = p.replace(/\\/g, "/");
+      if (np === "/test" || np === "/no-claude-md") return { isDirectory: (): boolean => true };
       return actual.statSync(p);
     }),
   };
@@ -482,6 +485,22 @@ describe("plan-routes", () => {
       expect(res.body.defaultRole).toBe("qa");
     });
 
+    it("returns 400 when claude agent and no CLAUDE.md", async () => {
+      const res = await request(app)
+        .post("/api/blueprints")
+        .send({ title: "No Claude MD", projectCwd: "/no-claude-md" });
+      expect(res.status).toBe(400);
+      expect(res.body.error).toContain("CLAUDE.md");
+    });
+
+    it("skips CLAUDE.md check for non-claude agent types", async () => {
+      const res = await request(app)
+        .post("/api/blueprints")
+        .send({ title: "OpenClaw BP", projectCwd: "/no-claude-md", agentType: "openclaw" });
+      expect(res.status).toBe(201);
+      expect(res.body.title).toBe("OpenClaw BP");
+    });
+
     it("defaults role fields when not provided", async () => {
       const res = await request(app)
         .post("/api/blueprints")
@@ -2516,6 +2535,80 @@ describe("plan-routes", () => {
       expect(enqueueBlueprintTask).not.toHaveBeenCalled();
     });
 
+    it("clears pauseReason and enqueues autopilot loop when switching to fsd on approved blueprint", async () => {
+      vi.mocked(getBlueprint).mockReturnValueOnce({
+        id: "bp-1",
+        title: "Test",
+        description: "desc",
+        status: "approved",
+        executionMode: undefined,
+        pauseReason: "Some pause reason",
+        projectCwd: "/test",
+        nodes: [],
+        createdAt: "2024-01-01",
+        updatedAt: "2024-01-01",
+      } as any);
+
+      const res = await request(app)
+        .put("/api/blueprints/bp-1")
+        .send({ executionMode: "fsd" });
+      expect(res.status).toBe(200);
+
+      expect(updateBlueprint).toHaveBeenCalledWith("bp-1", expect.objectContaining({
+        executionMode: "fsd",
+        pauseReason: "",
+      }));
+      expect(enqueueBlueprintTask).toHaveBeenCalledWith("bp-1", expect.any(Function));
+
+      const enqueueCall = vi.mocked(enqueueBlueprintTask).mock.calls[0];
+      await enqueueCall[1]();
+      expect(runAutopilotLoop).toHaveBeenCalledWith("bp-1");
+    });
+
+    it("does NOT re-enqueue when already in fsd mode and setting fsd again", async () => {
+      vi.mocked(getBlueprint).mockReturnValueOnce({
+        id: "bp-1",
+        title: "Test",
+        description: "desc",
+        status: "approved",
+        executionMode: "fsd",
+        projectCwd: "/test",
+        nodes: [],
+        createdAt: "2024-01-01",
+        updatedAt: "2024-01-01",
+      } as any);
+
+      const res = await request(app)
+        .put("/api/blueprints/bp-1")
+        .send({ executionMode: "fsd" });
+      expect(res.status).toBe(200);
+
+      // Already fsd → not switching → no enqueue
+      expect(enqueueBlueprintTask).not.toHaveBeenCalled();
+    });
+
+    it("enqueues autopilot loop when switching from autopilot to fsd", async () => {
+      vi.mocked(getBlueprint).mockReturnValueOnce({
+        id: "bp-1",
+        title: "Test",
+        description: "desc",
+        status: "approved",
+        executionMode: "autopilot",
+        projectCwd: "/test",
+        nodes: [],
+        createdAt: "2024-01-01",
+        updatedAt: "2024-01-01",
+      } as any);
+
+      const res = await request(app)
+        .put("/api/blueprints/bp-1")
+        .send({ executionMode: "fsd" });
+      expect(res.status).toBe(200);
+
+      // autopilot → fsd: both are autopilot-like, so NOT a switch (isAutopilotMode → isAutopilotMode)
+      expect(enqueueBlueprintTask).not.toHaveBeenCalled();
+    });
+
     it("returns 400 for invalid executionMode", async () => {
       const res = await request(app)
         .put("/api/blueprints/bp-1")
@@ -2574,6 +2667,31 @@ describe("plan-routes", () => {
       expect(runAutopilotLoop).toHaveBeenCalledWith("bp-1", undefined);
     });
 
+    it("routes to runAutopilotLoop when executionMode is fsd", async () => {
+      vi.mocked(getBlueprint).mockReturnValueOnce({
+        id: "bp-1",
+        title: "Test",
+        description: "desc",
+        status: "approved",
+        executionMode: "fsd",
+        projectCwd: "/test",
+        nodes: [],
+        createdAt: "2024-01-01",
+        updatedAt: "2024-01-01",
+      } as any);
+
+      const res = await request(app).post("/api/blueprints/bp-1/run-all");
+      expect(res.status).toBe(200);
+      expect(res.body.message).toBe("execution started");
+
+      expect(enqueueBlueprintTask).toHaveBeenCalledWith("bp-1", expect.any(Function));
+      expect(executeAllNodes).not.toHaveBeenCalled();
+
+      const enqueueCall = vi.mocked(enqueueBlueprintTask).mock.calls[0];
+      await enqueueCall[1]();
+      expect(runAutopilotLoop).toHaveBeenCalledWith("bp-1", undefined);
+    });
+
     it("routes to executeAllNodes when executionMode is manual/undefined", async () => {
       vi.mocked(getBlueprint).mockReturnValueOnce({
         id: "bp-1",

backend/src/autopilot.ts

@@ -670,6 +670,7 @@ export function buildAutopilotPrompt(
   iteration: number,
   maxIterations: number,
   memory: AutopilotMemory = { blueprint: null, global: null },
+  fsdMode: boolean = false,
 ): string {
   const remaining = maxIterations - iteration;
 
@@ -682,17 +683,12 @@ export function buildAutopilotPrompt(
     memorySections += `\n## Blueprint Memory (your notes from earlier iterations)\n${memory.blueprint}\n`;
   }
 
-  return `You are the Autopilot agent for a software blueprint. Your goal is to drive this blueprint to completion by choosing the best next action at each step.
-
-## Current Blueprint State
-${JSON.stringify(state, null, 2)}
-
-## Iteration ${iteration} of ${maxIterations}
-${memorySections}
-## Available Tools
-${TOOL_DESCRIPTIONS}
-
-## Recommended Workflow Rhythm
+  const workflowSection = fsdMode
+    ? `## FSD Mode (Full Speed Drive)
+You are running in FSD mode — no safeguards, no throttling. Execute as fast and efficiently as possible.
+Focus on running nodes to completion. Skip enrichment and coordination overhead unless absolutely necessary.
+Don't hesitate to run nodes back-to-back. Maximize throughput.`
+    : `## Recommended Workflow Rhythm
 Don't just run nodes back-to-back. Follow this quality-aware pattern:
 
 1. **Before running a node**: If its description is short or vague, use enrich_node first to improve the prompt.
@@ -701,9 +697,15 @@ Don't just run nodes back-to-back. Follow this quality-aware pattern:
 4. **When suggestions accumulate**: Review them — create_node for real issues, batch_mark_suggestions_used for minor/addressed ones.
 5. **When multiple roles are enabled and a design decision is ambiguous**: Use convene(topic, roleIds) to get multi-perspective input.
 
-A good rhythm: enrich → run → triage suggestions → repeat. Not every node needs all steps, but never do 5+ run_node calls in a row without a coordinate or suggestion triage in between.
+A good rhythm: enrich → run → triage suggestions → repeat. Not every node needs all steps, but never do 5+ run_node calls in a row without a coordinate or suggestion triage in between.`;
 
-## Guidelines
+  const guidelinesSection = fsdMode
+    ? `## Guidelines
+- Execute nodes in dependency order. Don't run a node whose dependencies aren't done.
+- If a node failed, try resume with feedback or skip it — don't get stuck on any single node.
+- When all nodes are done, call complete().
+- You have ${remaining} iterations left.`
+    : `## Guidelines
 - Execute nodes in dependency order. Don't run a node whose dependencies aren't done.
 - If a node failed, analyze the error. Consider: resume with feedback, split it, modify its description/prompt, or skip it if non-critical.
 - If a node seems too complex (long description >500 chars, many dependencies), consider split_node first.
@@ -713,7 +715,21 @@ A good rhythm: enrich → run → triage suggestions → repeat. Not every node
 - If warning insights exist, consider addressing them when convenient but don't block progress.
 - If you're stuck or need a human decision (architectural choice, ambiguous requirement, external dependency), use pause(reason).
 - You have ${remaining} iterations left. Balance quality (coordinate, enrich, suggestion triage) with progress (run_node).
-- When all nodes are done: review any remaining unused suggestions. Use batch_mark_suggestions_used for ones not worth acting on. Use create_node for actionable ones. Then call complete().
+- When all nodes are done: review any remaining unused suggestions. Use batch_mark_suggestions_used for ones not worth acting on. Use create_node for actionable ones. Then call complete().`;
+
+  return `You are the Autopilot agent for a software blueprint. Your goal is to drive this blueprint to completion by choosing the best next action at each step.
+
+## Current Blueprint State
+${JSON.stringify(state, null, 2)}
+
+## Iteration ${iteration} of ${maxIterations}
+${memorySections}
+## Available Tools
+${TOOL_DESCRIPTIONS}
+
+${workflowSection}
+
+${guidelinesSection}
 
 ## Decision Format
 Respond with exactly one JSON object:
@@ -1234,7 +1250,8 @@ export async function runAutopilotLoop(blueprintId: string, options?: AutopilotL
   clearResumeCounts(blueprintId);
   clearSeenSuggestions(blueprintId);
 
-  const maxIterations = blueprint.maxIterations ?? 50;
+  const isFsdAtStart = blueprint.executionMode === "fsd";
+  const maxIterations = blueprint.maxIterations ?? (isFsdAtStart ? 200 : 50);
   let iteration = 0;
 
   // Memory: read existing per-blueprint and global memory at loop start
@@ -1249,7 +1266,7 @@ export async function runAutopilotLoop(blueprintId: string, options?: AutopilotL
     graceIterations: options?.safeguardGrace ?? 0,
   };
 
-  log.info(`Autopilot starting for blueprint ${blueprintId.slice(0, 8)} (max ${maxIterations} iterations)`);
+  log.info(`Autopilot starting for blueprint ${blueprintId.slice(0, 8)} (max ${maxIterations} iterations, mode: ${isFsdAtStart ? "fsd" : "autopilot"})`);
 
   try {
     while (iteration < maxIterations) {
@@ -1274,14 +1291,17 @@ export async function runAutopilotLoop(blueprintId: string, options?: AutopilotL
 
       // Check if user switched to manual mode
       const current = getBlueprint(blueprintId);
-      if (!current || current.executionMode !== "autopilot") {
+      const isFsd = current?.executionMode === "fsd";
+      if (!current || (current.executionMode !== "autopilot" && current.executionMode !== "fsd")) {
         logAutopilot(blueprintId, iteration, state.summary, "Mode switched to manual", "paused");
         log.info(`Autopilot stopped for ${blueprintId.slice(0, 8)}: mode switched to manual`);
         break;
       }
 
+      // FSD mode: skip all safeguard checks entirely
       // Safeguard grace period: skip checks when user explicitly resumed from a safeguard pause
       const inGracePeriod = safeguardState.graceIterations > 0;
+      const skipSafeguards = isFsd || inGracePeriod;
       if (inGracePeriod) {
         safeguardState.graceIterations--;
         // Still track state for when grace period ends
@@ -1290,7 +1310,7 @@ export async function runAutopilotLoop(blueprintId: string, options?: AutopilotL
         safeguardState.noProgressCount = 0;
       }
 
-      if (!inGracePeriod) {
+      if (!skipSafeguards) {
         // Check resume cap safeguard
         const resumeCapReason = checkResumeCapExceeded(blueprintId, state);
         if (resumeCapReason) {
@@ -1323,7 +1343,7 @@ export async function runAutopilotLoop(blueprintId: string, options?: AutopilotL
       const prompt = buildAutopilotPrompt(state, iteration, maxIterations, {
         blueprint: blueprintMemory,
         global: globalMemory,
-      });
+      }, isFsd);
       let decision: AutopilotDecision;
       try {
         decision = await callAgentForDecision(prompt, current.projectCwd);
@@ -1337,8 +1357,8 @@ export async function runAutopilotLoop(blueprintId: string, options?: AutopilotL
 
       log.info(`Autopilot iteration ${iteration}: ${decision.action} — ${decision.reasoning}`);
 
-      // Check same-action safeguard (also skipped during grace period)
-      if (!inGracePeriod) {
+      // Check same-action safeguard (skipped in FSD mode and during grace period)
+      if (!skipSafeguards) {
         const sameActionReason = checkSameActionRepeat(safeguardState, decision);
         if (sameActionReason) {
           updateBlueprint(blueprintId, {
@@ -1349,8 +1369,8 @@ export async function runAutopilotLoop(blueprintId: string, options?: AutopilotL
           log.warn(`Autopilot paused: ${sameActionReason}`);
           break;
         }
-      } else {
-        // Still track actions during grace period for post-grace checks
+      } else if (!isFsd) {
+        // Still track actions during grace period for post-grace checks (not needed for FSD)
         checkSameActionRepeat(safeguardState, decision);
       }
 

backend/src/plan-db.ts

@@ -13,7 +13,7 @@ export type ExecutionType = "primary" | "retry" | "continuation" | "subtask";
 export type ExecutionStatus = "running" | "done" | "failed" | "cancelled";
 export type FailureReason = "timeout" | "context_exhausted" | "output_token_limit" | "hung" | "error" | null;
 export type ReportedStatus = "done" | "failed" | "blocked" | null;
-export type ExecutionMode = "manual" | "autopilot";
+export type ExecutionMode = "manual" | "autopilot" | "fsd";
 export type RelatedSessionType = "enrich" | "reevaluate" | "split" | "evaluate" | "reevaluate_all" | "generate" | "smart_deps" | "coordinate";
 export type InsightSeverity = "info" | "warning" | "critical";
 export type ConveneSessionStatus = "active" | "synthesizing" | "completed" | "cancelled" | "failed";