@dv.nghiem/flowdeck 0.1.0 → 0.1.1

package/dist/index.js

@@ -185,90 +185,6 @@ function parseTDDState(parsed) {
     return;
   }
 }
-function serializeTDDState(tdd) {
-  return JSON.stringify({
-    stage: tdd.stage,
-    cycle: tdd.cycle,
-    behaviors: tdd.behaviors,
-    regression_test_links: tdd.regression_test_links,
-    override_log: tdd.override_log,
-    failing_tests: tdd.failing_tests,
-    passing_tests: tdd.passing_tests
-  });
-}
-function updateTDDState(dir, updates) {
-  const sp = statePath(dir);
-  if (!existsSync2(sp))
-    return;
-  const state = readPlanningState(dir);
-  const existingTdd = state["tdd"];
-  const current = existingTdd ?? {
-    stage: "behavior",
-    cycle: 1,
-    behaviors: [],
-    regression_test_links: [],
-    override_log: [],
-    failing_tests: 0,
-    passing_tests: 0
-  };
-  const updated = { ...current, ...updates };
-  const tddJson = serializeTDDState(updated);
-  let content = readFileSync2(sp, "utf-8");
-  if (content.includes("tdd:")) {
-    content = content.replace(/^tdd:.*$/m, `tdd: '${tddJson}'`);
-  } else if (content.startsWith("---")) {
-    const end = content.indexOf("---", 3);
-    if (end !== -1) {
-      content = content.slice(0, end) + `
-tdd: '` + tddJson.replace(/'/g, "''") + "'" + content.slice(end);
-    }
-  }
-  content = appendHistory(content, `TDD state updated: stage=${updated.stage}, cycle=${updated.cycle}`);
-  writeFileSync2(sp, content, "utf-8");
-}
-function updatePlanningState(dir, updates) {
-  const sp = statePath(dir);
-  if (!existsSync2(sp))
-    return;
-  let content = readFileSync2(sp, "utf-8");
-  if (updates.phase !== undefined) {
-    content = content.replace(/^phase:\s*.*/m, `phase: ${updates.phase}`);
-    content = appendHistory(content, `Phase changed to ${updates.phase}`);
-  }
-  if (updates.status !== undefined) {
-    content = content.replace(/^status:\s*.*/m, `status: ${updates.status}`);
-    content = appendHistory(content, `Status changed to ${updates.status}`);
-  }
-  if (updates.last_action !== undefined) {
-    content = content.replace(/^last_action:\s*.*/m, `last_action: "${updates.last_action}"`);
-    content = appendHistory(content, updates.last_action);
-  }
-  if (updates.next_action !== undefined) {
-    content = content.replace(/^next_action:\s*.*/m, `next_action: "${updates.next_action}"`);
-    content = appendHistory(content, `Next action: ${updates.next_action}`);
-  }
-  if (updates.blockers !== undefined) {
-    const blockersMd = updates.blockers.length > 0 ? updates.blockers.map((b) => `- ${b}`).join(`
-`) : "- none";
-    content = content.replace(/^## Blockers\n[\s\S]*?(?=\n##|\n#$)/m, `## Blockers
-${blockersMd}
-`);
-    content = appendHistory(content, `Blockers updated: ${updates.blockers.length} item(s)`);
-  }
-  if (updates.plan_confirmed !== undefined) {
-    content = content.replace(/^plan_confirmed:\s*.*/m, `plan_confirmed: ${updates.plan_confirmed}`);
-    content = appendHistory(content, `Plan confirmed: ${updates.plan_confirmed}`);
-  }
-  if (updates.steps_complete !== undefined) {
-    content = content.replace(/^steps_complete:\s*.*/m, `steps_complete: [${updates.steps_complete.join(", ")}]`);
-    content = appendHistory(content, `Steps complete: [${updates.steps_complete.join(", ")}]`);
-  }
-  if (updates.steps_pending !== undefined) {
-    content = content.replace(/^steps_pending:\s*.*/m, `steps_pending: [${updates.steps_pending.join(", ")}]`);
-    content = appendHistory(content, `Steps pending: [${updates.steps_pending.join(", ")}]`);
-  }
-  writeFileSync2(sp, content, "utf-8");
-}
 function findWorkspaceRoot(startDir) {
   let current = startDir;
   for (;; ) {
@@ -1887,14 +1803,6 @@ function tryTerminalBell() {
     process.stdout.write("\x07");
   } catch {}
 }
-function notifyCommandInteraction(command) {
-  const name = command.replace(/^\//, "");
-  if (INTERACTIVE_COMMANDS.has(name)) {
-    notify(`FlowDeck: /${name}`, "Your input is needed \u2014 please check OpenCode", "critical");
-  } else if (COMPLETION_COMMANDS.has(name)) {
-    notify(`FlowDeck: /${name} complete`, "Review the output and choose your next step", "info");
-  }
-}
 function notifySessionIdle() {
   notify("FlowDeck Task Completed", "Agent is idle and waiting for your next instruction", "info");
 }
@@ -2118,34 +2026,11 @@ function loadStore(dir) {
     return { requests: [] };
   }
 }
-function saveStore(dir, store) {
-  const cd = codebaseDir(dir);
-  if (!existsSync17(cd))
-    mkdirSync9(cd, { recursive: true });
-  writeFileSync12(approvalsPath(dir), JSON.stringify(store, null, 2), "utf-8");
-}
-function resolveApproval(dir, approval_id, decision) {
-  const store = loadStore(dir);
-  const req = store.requests.find((r) => r.id === approval_id);
-  if (!req)
-    return false;
-  req.status = decision;
-  req.resolved_at = new Date().toISOString();
-  saveStore(dir, store);
-  return true;
-}
 function checkApproval(dir, file_path, command) {
   const store = loadStore(dir);
   const now = Date.now();
   return store.requests.filter((r) => r.status === "approved" && r.resolved_at && (r.file_path === file_path || r.trigger === command) && now - new Date(r.resolved_at).getTime() < APPROVAL_TTL_MS).sort((a, b) => b.resolved_at.localeCompare(a.resolved_at)).at(0) ?? null;
 }
-function getPendingApprovals(dir) {
-  return loadStore(dir).requests.filter((r) => r.status === "pending");
-}
-function getRecentApprovals(dir, limit = 10) {
-  const store = loadStore(dir);
-  return store.requests.slice(-limit).reverse();
-}
 
 // src/hooks/approval-hook.ts
 var WRITE_TOOLS = new Set(["write_file", "edit_file", "create_file", "apply_patch", "str_replace_editor", "write"]);
@@ -2498,4073 +2383,20 @@ function createFlowDeckMcps() {
   return mcps;
 }
 
-// src/commands/setup/new-project.ts
-import { writeFileSync as writeFileSync13, existsSync as existsSync20, mkdirSync as mkdirSync10 } from "fs";
-import { join as join19 } from "path";
-var PLANNING_FILES = {
-  "PROJECT.md": `# Project
-
-**Name:** (set via /discuss)
-**Description:** (set via /discuss)
-**Tech stack:** (set via /discuss)
-
----
-
-## Goals
-
--
-
-## Non-negotiables
-
--
-
-## Out of Scope
-
--
-`,
-  "REQUIREMENTS.md": `# Requirements
-
-**Project:** (set via /discuss)
-**Version:** 1.0
-
----
-
-## v1 Requirements
-
-
-`,
-  "ROADMAP.md": `# Roadmap
-
-**Project:** (set via /discuss)
-**Version:** 1.0
-
----
-
-## Overview
-
-| Phase | Name | Purpose |
-|-------|------|---------|
-| 1 | Plugin Infrastructure & Core Tools | |
-| 2 | Hooks & Session Lifecycle | |
-| 3 | Agent Definitions | |
-| 4 | Setup & Planning Commands | |
-| 5 | Execution Commands | |
-| 6 | Installation & Documentation | |
-
----
-`,
-  "STATE.md": `---
-flowdeck_state_version: 1.0
-milestone: v1.0
-last_updated: "TEMPLATE_TIMESTAMP"
-progress:
-  total_phases: 6
-  completed_phases: 0
----
-
-# State
-
-**Project:** (set via /discuss)
-**Last updated:** TEMPLATE_TIMESTAMP
-
-## Current Phase
-
-phase: 1
-status: planned
-plan_file: none
-plan_confirmed: false
-confirmed_at: none
-
-## Progress
-
-last_action: ""
-next_action: "Run /discuss to start planning"
-steps_complete: []
-steps_pending: []
-
-## Blockers
-
-- none
-
-## Session History
-
-`,
-  "config.json": `{
-  "workflow": {
-    "parallelization": true,
-    "auto_advance": false,
-    "discuss_mode": "discuss"
-  },
-  "agents": {
-    "orchestrator": "anthropic/claude-sonnet-4-5",
-    "discusser": "anthropic/claude-sonnet-4-5",
-    "mapper": "google/gemini-2.5-flash",
-    "coder": "anthropic/claude-opus-4-5",
-    "reviewer": "google/gemini-2.5-flash",
-    "researcher": "openai/gpt-4o",
-    "tester": "anthropic/claude-haiku-4-5",
-    "writer": "anthropic/claude-haiku-4-5"
-  }
-}
-`
-};
-var newProjectCommand = {
-  name: "fd-new-project",
-  description: "Initialize .planning/ structure for greenfield projects",
-  async execute(context) {
-    const dir = context.directory ?? process.cwd();
-    const pd = planningDir(dir);
-    if (existsSync20(pd)) {
-      return {
-        error: `.planning/ already exists. Use /resume to continue or /progress to see state.`,
-        code: "ALREADY_EXISTS"
-      };
-    }
-    mkdirSync10(pd, { recursive: true });
-    mkdirSync10(join19(pd, "phases"), { recursive: true });
-    const timestamp2 = new Date().toISOString();
-    for (const [filename, content] of Object.entries(PLANNING_FILES)) {
-      const filePath = join19(pd, filename);
-      if (filename === "STATE.md") {
-        const stateContent = content.replace(/TEMPLATE_TIMESTAMP/g, timestamp2);
-        writeFileSync13(filePath, stateContent, "utf-8");
-      } else if (filename === "config.json") {
-        writeFileSync13(filePath, content, "utf-8");
-      } else {
-        writeFileSync13(filePath, content, "utf-8");
-      }
-    }
-    return {
-      success: true,
-      message: `.planning/ structure created. Run /discuss to capture project decisions.`,
-      files: Object.keys(PLANNING_FILES)
-    };
-  }
-};
-
-// src/commands/setup/map-codebase.ts
-import { existsSync as existsSync22, readdirSync as readdirSync3, readFileSync as readFileSync21 } from "fs";
-import { join as join21, relative, extname as extname2 } from "path";
-
-// src/lib/timestamps.ts
-import { readFileSync as readFileSync20, writeFileSync as writeFileSync14, existsSync as existsSync21, mkdirSync as mkdirSync11, statSync as statSync2 } from "fs";
-import { join as join20, extname } from "path";
-import { createHash as createHash2 } from "crypto";
-function loadTimestamps(dir) {
-  const path = join20(dir, ".codebase", ".meta", "timestamps.json");
-  if (!existsSync21(path))
-    return null;
-  try {
-    return JSON.parse(readFileSync20(path, "utf-8"));
-  } catch {
-    return null;
-  }
-}
-function saveTimestamps(dir, data) {
-  const metaDir = join20(dir, ".codebase", ".meta");
-  if (!existsSync21(metaDir))
-    mkdirSync11(metaDir, { recursive: true });
-  writeFileSync14(join20(metaDir, "timestamps.json"), JSON.stringify(data, null, 2), "utf-8");
-}
-function computeFileHash(filePath) {
-  const content = readFileSync20(filePath);
-  return createHash2("sha256").update(content).digest("hex");
-}
-function getFileMetadata(filePath, _baseDir) {
-  const stat = statSync2(filePath);
-  const type = extname(filePath);
-  const hash = computeFileHash(filePath);
-  return { mtime: stat.mtimeMs, size: stat.size, hash, type };
-}
-function checkFileChanged(filePath, storedMeta, _baseDir) {
-  if (!existsSync21(filePath)) {
-    return { changed: false };
-  }
-  const stat = statSync2(filePath);
-  const currentMtime = stat.mtimeMs;
-  if (!storedMeta) {
-    return { changed: true, reason: "new", currentMeta: getFileMetadata(filePath, _baseDir) };
-  }
-  if (Math.abs(currentMtime - storedMeta.mtime) > 1000) {
-    return { changed: true, reason: "mtime_changed", currentMeta: getFileMetadata(filePath, _baseDir) };
-  }
-  return { changed: false };
-}
-
-// src/lib/signatures.ts
-var SIGNATURE_PATTERNS = [
-  /import\s+(?:(?:type\s+)?(?:\{[^}]*\}|\*\s+as\s+\w+|\w+)\s+from\s+)?['"]([^'"]+)['"]/g,
-  /export\s+(?:\{[^}]*\}|\*)\s+from\s+['"]([^'"]+)['"]/g,
-  /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g
-];
-function extractSignatures(content) {
-  const signatures = [];
-  const lines = content.split(`
-`);
-  for (let lineIndex = 0;lineIndex < lines.length; lineIndex++) {
-    const line = lines[lineIndex];
-    for (const pattern of SIGNATURE_PATTERNS) {
-      pattern.lastIndex = 0;
-      let match;
-      while ((match = pattern.exec(line)) !== null) {
-        if (match[1]) {
-          signatures.push(`import:${match[1]}:${lineIndex + 1}`);
-        }
-      }
-    }
-  }
-  return signatures;
-}
-function detectConflicts(oldSigs, newSigs) {
-  const conflicts = [];
-  for (const [file, newFileSigs] of Object.entries(newSigs)) {
-    const oldFileSigs = oldSigs[file] || [];
-    if (JSON.stringify(oldFileSigs.sort()) !== JSON.stringify(newFileSigs.sort())) {
-      conflicts.push({
-        file,
-        oldCount: oldFileSigs.length,
-        newCount: newFileSigs.length,
-        affectedImports: newFileSigs.filter((s) => !oldFileSigs.includes(s))
-      });
-    }
-  }
-  return { conflicts };
-}
-
-// src/lib/confirmation.ts
-function confirmPrompt(operation, message) {
-  return {
-    success: true,
-    message,
-    status: "AWAITING_CONFIRM",
-    confirm_mode: "y/n",
-    operation
-  };
-}
-function skipResponse(operation) {
-  return {
-    success: true,
-    message: `${operation} skipped. No changes made.`,
-    skipped: true,
-    operation
-  };
-}
-
-// src/commands/setup/map-codebase.ts
-var SUPPORTED_EXTENSIONS = new Set([".ts", ".tsx", ".js", ".jsx", ".json"]);
-function discoverSourceFiles(dir) {
-  const files = [];
-  const walk = (d) => {
-    const entries = readdirSync3(d, { withFileTypes: true });
-    for (const entry of entries) {
-      const full = join21(d, entry.name);
-      if (entry.name === ".codebase" || entry.name === "node_modules" || entry.name === ".planning")
-        continue;
-      if (entry.isDirectory()) {
-        walk(full);
-      } else if (SUPPORTED_EXTENSIONS.has(extname2(entry.name))) {
-        files.push(relative(dir, full));
-      }
-    }
-  };
-  walk(dir);
-  return files;
-}
-function extractSignaturesFromFile(filePath) {
-  if (!existsSync22(filePath))
-    return [];
-  const content = readFileSync21(filePath, "utf-8");
-  return extractSignatures(content);
-}
-var mapCodebaseCommand = {
-  name: "fd-map-codebase",
-  description: "Parallel analysis agents \u2192 .codebase/ docs (STACK, ARCHITECTURE, STRUCTURE, CONVENTIONS, TESTING, CONCERNS). Use --incremental to process only changed files.",
-  async execute(context, args) {
-    const dir = context.directory ?? process.cwd();
-    const pd = planningDir(dir);
-    const incremental = args?.incremental === true;
-    const statePath2 = join21(pd, "STATE.md");
-    if (!existsSync22(statePath2)) {
-      return {
-        error: "STATE.md not found. Run /new-project first to initialize the project.",
-        code: "NOT_INITIALIZED"
-      };
-    }
-    if (incremental) {
-      const timestamps = loadTimestamps(dir);
-      if (!timestamps) {
-        return {
-          error: "Incremental mode requires prior run. Run `/map-codebase` without --incremental first.",
-          code: "NO_TIMESTAMPS"
-        };
-      }
-      return this.runIncremental(dir, timestamps);
-    }
-    return this.runFullRebuild(dir, args);
-  },
-  async runFullRebuild(dir, args) {
-    const codebasePath = join21(dir, ".codebase");
-    if (existsSync22(codebasePath)) {
-      if (!args?.yes) {
-        return {
-          ...confirmPrompt("map-codebase-overwrite", ".codebase/ already exists. Running /map-codebase will overwrite existing docs. Proceed? [y/n]"),
-          code: "EXISTS",
-          hint: "Use --yes to skip this confirmation"
-        };
-      }
-    }
-    const sourceFiles = discoverSourceFiles(dir);
-    const files = {};
-    const signatures = {};
-    const now = new Date().toISOString();
-    for (const relPath of sourceFiles) {
-      const fullPath = join21(dir, relPath);
-      const meta = getFileMetadata(fullPath, dir);
-      files[relPath] = meta;
-      signatures[relPath] = extractSignaturesFromFile(fullPath);
-    }
-    const timestampsData = {
-      version: "1.0",
-      last_run: now,
-      files,
-      signatures
-    };
-    saveTimestamps(dir, timestampsData);
-    return {
-      success: true,
-      message: `Starting parallel codebase mapping.`,
-      workflow: "map-codebase-flow.md",
-      output_dir: ".codebase/",
-      docs: ["STACK.md", "ARCHITECTURE.md", "STRUCTURE.md", "CONVENTIONS.md", "TESTING.md", "CONCERNS.md"],
-      next_step: "Workflow will spawn 6 mapper agents in parallel",
-      incremental_mode: false,
-      files_processed: sourceFiles.length
-    };
-  },
-  async runIncremental(dir, timestamps) {
-    const sourceFiles = discoverSourceFiles(dir);
-    const toProcess = [];
-    const unchanged = [];
-    for (const relPath of sourceFiles) {
-      const fullPath = join21(dir, relPath);
-      const storedMeta = timestamps.files[relPath];
-      const result = checkFileChanged(fullPath, storedMeta, dir);
-      if (result.changed) {
-        toProcess.push(relPath);
-      } else {
-        unchanged.push(relPath);
-      }
-    }
-    const newFiles = {};
-    const newSignatures = {};
-    const now = new Date().toISOString();
-    for (const relPath of toProcess) {
-      const fullPath = join21(dir, relPath);
-      const meta = getFileMetadata(fullPath, dir);
-      newFiles[relPath] = meta;
-      newSignatures[relPath] = extractSignaturesFromFile(fullPath);
-    }
-    const mergedFiles = { ...timestamps.files };
-    const mergedSignatures = { ...timestamps.signatures };
-    for (const relPath of toProcess) {
-      mergedFiles[relPath] = newFiles[relPath];
-      mergedSignatures[relPath] = newSignatures[relPath];
-    }
-    const conflictReport = detectConflicts(timestamps.signatures, mergedSignatures);
-    const timestampsData = {
-      version: "1.0",
-      last_run: now,
-      files: mergedFiles,
-      signatures: mergedSignatures
-    };
-    saveTimestamps(dir, timestampsData);
-    const response = {
-      success: true,
-      message: `Incremental mapping complete.`,
-      incremental_mode: true,
-      files_processed: toProcess.length,
-      files_unchanged: unchanged.length,
-      workflow: "map-codebase-flow.md",
-      output_dir: ".codebase/",
-      next_step: "Workflow will spawn mapper agents for changed files"
-    };
-    if (conflictReport.conflicts.length > 0) {
-      response.warning = `Cross-file reference conflicts detected in ${conflictReport.conflicts.length} file(s):
-` + conflictReport.conflicts.map((c) => `  - ${c.file}: ${c.oldCount} -> ${c.newCount} signatures (${c.affectedImports.length} changed)`).join(`
-`);
-      response.code = "SIGNATURE_CONFLICTS";
-    }
-    return response;
-  }
-};
-
-// src/commands/setup/settings.ts
-import { existsSync as existsSync23, readFileSync as readFileSync22, writeFileSync as writeFileSync15 } from "fs";
-import { join as join22 } from "path";
-var DEFAULT_MODELS = {
-  orchestrator: "anthropic/claude-sonnet-4-5",
-  discusser: "anthropic/claude-sonnet-4-5",
-  mapper: "google/gemini-2.5-flash",
-  coder: "anthropic/claude-opus-4-5",
-  reviewer: "google/gemini-2.5-flash",
-  researcher: "openai/gpt-4o",
-  tester: "anthropic/claude-haiku-4-5",
-  writer: "anthropic/claude-haiku-4-5"
-};
-var MODEL_PROFILES = {
-  quality: {
-    description: "Best quality (higher cost)",
-    agents: {
-      orchestrator: "anthropic/claude-opus-4-5",
-      discusser: "anthropic/claude-opus-4-5",
-      coder: "anthropic/claude-opus-4-5"
-    }
-  },
-  balanced: {
-    description: "Balanced quality/cost",
-    agents: {
-      orchestrator: "anthropic/claude-sonnet-4-5",
-      discusser: "anthropic/claude-sonnet-4-5",
-      coder: "anthropic/claude-sonnet-4-5"
-    }
-  },
-  budget: {
-    description: "Lowest cost",
-    agents: {
-      orchestrator: "anthropic/claude-haiku-4-5",
-      discusser: "anthropic/claude-haiku-4-5",
-      coder: "anthropic/claude-haiku-4-5"
-    }
-  }
-};
-var settingsCommand = {
-  name: "fd-settings",
-  description: "Interactive configurator for agent models, profiles, and workflow toggles",
-  async execute(context, args) {
-    const dir = context.directory ?? process.cwd();
-    const configPath = join22(dir, "opencode.json");
-    if (!args || !args.profile && !args.agent && !args.toggle) {
-      return showCurrentSettings(configPath);
-    }
-    if (args.profile && MODEL_PROFILES[args.profile]) {
-      return applyProfile(configPath, args.profile);
-    }
-    if (args.agent && args.model) {
-      return setAgentModel(configPath, args.agent, args.model);
-    }
-    if (args.toggle) {
-      return toggleWorkflowPhase(configPath, args.toggle, args.value === "true" || args.value === "on");
-    }
-    return {
-      error: "Invalid settings command. Use --profile, --agent, or --toggle",
-      code: "INVALID_ARGS"
-    };
-  }
-};
-function showCurrentSettings(configPath) {
-  const profileExists = existsSync23(configPath);
-  let config = {};
-  if (profileExists) {
-    try {
-      config = JSON.parse(readFileSync22(configPath, "utf-8"));
-    } catch {}
-  }
-  const agents = config.agents || DEFAULT_MODELS;
-  const output = [
-    "\u2550".repeat(55),
-    "FLOWDECK SETTINGS",
-    "\u2550".repeat(55),
-    "",
-    "Available profiles:",
-    "  --profile quality   | Best quality (higher cost)",
-    "  --profile balanced | Balanced quality/cost",
-    "  --profile budget   | Lowest cost",
-    "",
-    "Agent model overrides:",
-    "  --agent <name> --model <model>",
-    "  Valid agents: orchestrator, discusser, mapper, coder, reviewer, researcher, tester, writer",
-    "",
-    "Workflow toggles:",
-    "  --toggle <phase> --value <true|false>",
-    "  Example: --toggle research --value true",
-    "",
-    "Current agent models:"
-  ];
-  for (const [agent, model] of Object.entries(agents)) {
-    output.push(`  ${agent}: ${model}`);
-  }
-  output.push("\u2550".repeat(55));
-  return {
-    success: true,
-    message: output.join(`
-`),
-    meta: { formatted: "table", timestamp: timestamp() }
-  };
-}
-function applyProfile(configPath, profile) {
-  const profileData = MODEL_PROFILES[profile];
-  let config = {};
-  if (existsSync23(configPath)) {
-    try {
-      config = JSON.parse(readFileSync22(configPath, "utf-8"));
-    } catch {
-      config = {};
-    }
-  }
-  config.agents = config.agents || {};
-  for (const [agent, model] of Object.entries(profileData.agents)) {
-    config.agents[agent] = model;
-  }
-  config.model_profile = profile;
-  writeFileSync15(configPath, JSON.stringify(config, null, 2), "utf-8");
-  return {
-    success: true,
-    message: `Applied "${profile}" profile: ${profileData.description}`,
-    profile,
-    agents: profileData.agents
-  };
-}
-function setAgentModel(configPath, agent, model) {
-  const validAgents = Object.keys(DEFAULT_MODELS);
-  if (!validAgents.includes(agent)) {
-    return {
-      error: `Invalid agent "${agent}". Valid: ${validAgents.join(", ")}`,
-      code: "INVALID_AGENT"
-    };
-  }
-  let config = {};
-  if (existsSync23(configPath)) {
-    try {
-      config = JSON.parse(readFileSync22(configPath, "utf-8"));
-    } catch {
-      config = {};
-    }
-  }
-  config.agents = config.agents || {};
-  config.agents[agent] = model;
-  writeFileSync15(configPath, JSON.stringify(config, null, 2), "utf-8");
-  return {
-    success: true,
-    message: `Set ${agent} model to ${model}`,
-    agent,
-    model
-  };
-}
-function toggleWorkflowPhase(configPath, phase, enabled) {
-  let config = {};
-  if (existsSync23(configPath)) {
-    try {
-      config = JSON.parse(readFileSync22(configPath, "utf-8"));
-    } catch {
-      config = {};
-    }
-  }
-  config.workflow = config.workflow || {};
-  config.workflow[phase] = enabled;
-  writeFileSync15(configPath, JSON.stringify(config, null, 2), "utf-8");
-  return {
-    success: true,
-    message: `Workflow phase "${phase}" ${enabled ? "enabled" : "disabled"}`,
-    phase,
-    enabled
-  };
-}
-
-// src/commands/setup/doctor.ts
-import { execSync } from "child_process";
-import { existsSync as existsSync24, readFileSync as readFileSync23 } from "fs";
-import { join as join23 } from "path";
-var doctorCommand = {
-  name: "fd-doctor",
-  description: "Check FlowDeck installation and environment health",
-  async execute(context) {
-    const results = ["# FlowDeck Doctor Report", ""];
-    let healthy = true;
-    try {
-      const version = execSync("opencode --version", { encoding: "utf-8" }).trim();
-      results.push(`- [x] OpenCode detected: ${version}`);
-    } catch {
-      results.push("- [ ] OpenCode CLI not found on PATH");
-      healthy = false;
-    }
-    const configDir = process.env.OPENCODE_CONFIG_DIR || join23(process.env.HOME || "", ".config", "opencode");
-    const configFile = join23(configDir, "opencode.json");
-    if (existsSync24(configFile)) {
-      try {
-        const cfg = JSON.parse(readFileSync23(configFile, "utf-8"));
-        if (cfg.plugin && cfg.plugin.includes("@dv.nghiem/flowdeck")) {
-          results.push(`- [x] FlowDeck registered in ${configFile}`);
-        } else {
-          results.push(`- [ ] FlowDeck NOT registered in ${configFile}`);
-          healthy = false;
-        }
-      } catch {
-        results.push("- [ ] opencode.json is malformed");
-        healthy = false;
-      }
-    } else {
-      results.push(`- [ ] Configuration file ${configFile} not found`);
-      healthy = false;
-    }
-    const dir = context.directory ?? process.cwd();
-    const statePath2 = join23(dir, ".planning", "STATE.md");
-    if (existsSync24(statePath2)) {
-      results.push("- [x] .planning/STATE.md exists in current workspace");
-    } else {
-      results.push("- [!] No .planning/STATE.md found (run /new-project to initialize)");
-    }
-    results.push("", healthy ? "\u2705 Environment looks healthy!" : "\u274C Some issues were found. Please check the report above.");
-    return {
-      content: results.join(`
-`),
-      healthy
-    };
-  }
-};
-
-// src/commands/planning/discuss.ts
-import { readFileSync as readFileSync25, existsSync as existsSync26, mkdirSync as mkdirSync13 } from "fs";
-import { join as join25 } from "path";
-
-// src/lib/impact-radar.ts
-import { existsSync as existsSync25, readFileSync as readFileSync24 } from "fs";
-import { join as join24 } from "path";
-function matchWords(text, words) {
-  const lower = text.toLowerCase();
-  return words.some((w) => w.length > 3 && lower.includes(w));
-}
-function runImpactRadar(dir, changeText) {
-  const cd = codebaseDir(dir);
-  const words = changeText.toLowerCase().split(/\s+/);
-  const hotspots = [];
-  const known_failures = [];
-  const related_modules = [];
-  const volatilityPath2 = join24(cd, "VOLATILITY.json");
-  if (existsSync25(volatilityPath2)) {
-    try {
-      const v = JSON.parse(readFileSync24(volatilityPath2, "utf-8"));
-      for (const e of v.entries ?? []) {
-        if ((e.stability === "volatile" || e.stability === "critical") && matchWords(e.path, words)) {
-          hotspots.push({ path: e.path, stability: e.stability });
-        }
-      }
-    } catch {}
-  }
-  const failuresPath2 = join24(cd, "FAILURES.json");
-  if (existsSync25(failuresPath2)) {
-    try {
-      const f = JSON.parse(readFileSync24(failuresPath2, "utf-8"));
-      for (const e of f.entries ?? []) {
-        if (!e.tags?.includes("resolved") && matchWords(e.description ?? "", words)) {
-          known_failures.push({
-            id: e.id,
-            description: e.description,
-            affected_paths: e.affected_paths ?? [],
-            recurrence_count: e.recurrence_count ?? 1
-          });
-        }
-      }
-    } catch {}
-  }
-  const memoryPath2 = join24(cd, "MEMORY.json");
-  if (existsSync25(memoryPath2)) {
-    try {
-      const m = JSON.parse(readFileSync24(memoryPath2, "utf-8"));
-      for (const node of Object.values(m.nodes ?? {})) {
-        if (matchWords(node.path ?? "", words)) {
-          related_modules.push({ path: node.path, type: node.type, owner: node.owner });
-        }
-      }
-    } catch {}
-  }
-  const risk_flag = hotspots.length > 0 || known_failures.length > 0;
-  const advisory = risk_flag ? `\u26A0 Impact Radar: ${hotspots.length} volatile zone(s) and ${known_failures.length} known failure(s) match this change. Review before proceeding.` : null;
-  return { hotspots, known_failures, related_modules, risk_flag, advisory, score: risk_flag ? 0.7 : 0.3 };
-}
-function impactRadarSummaryLines(radar) {
-  if (!radar.risk_flag && radar.related_modules.length === 0)
-    return [];
-  const lines = ["\u2500".repeat(55), "  Impact Radar:"];
-  if (radar.hotspots.length > 0) {
-    lines.push(`  \u26A0 Volatile zones: ${radar.hotspots.map((h) => h.path).join(", ")}`);
-  }
-  if (radar.known_failures.length > 0) {
-    lines.push(`  \u26A0 Known failures: ${radar.known_failures.map((f) => f.id).join(", ")}`);
-  }
-  if (radar.related_modules.length > 0) {
-    lines.push(`  \u2139 Related modules: ${radar.related_modules.map((m) => m.path).join(", ")}`);
-  }
-  return lines;
-}
-function lookupPriorFailures(dir, scope, bugText, limit = 5) {
-  const cd = codebaseDir(dir);
-  const failuresPath2 = join24(cd, "FAILURES.json");
-  if (!existsSync25(failuresPath2))
-    return [];
-  try {
-    const store = JSON.parse(readFileSync24(failuresPath2, "utf-8"));
-    const entries = store.entries ?? [];
-    const words = bugText.toLowerCase().split(/\s+/).filter((w) => w.length > 3);
-    const scopePrefix = scope !== "all" ? scope.replace(/^\.\//, "") : "";
-    const matched = entries.filter((e) => !e.tags?.includes("resolved")).filter((e) => {
-      const pathMatch = scopePrefix ? e.affected_paths.some((p) => p.includes(scopePrefix)) : false;
-      const keywordMatch = words.some((w) => (e.description ?? "").toLowerCase().includes(w));
-      return pathMatch || keywordMatch;
-    }).sort((a, b) => (b.recurrence_count ?? 1) - (a.recurrence_count ?? 1));
-    return matched.slice(0, limit);
-  } catch {
-    return [];
-  }
-}
-
-// src/commands/planning/discuss.ts
-var discussCommand = {
-  name: "fd-discuss",
-  description: "Extract requirements via @discusser Q&A \u2014 saves decisions to .planning/phases/phase-N/DISCUSS.md with D-XX numbering",
-  async execute(context, args) {
-    const dir = context.directory ?? process.cwd();
-    const sp = statePath(dir);
-    const pd = planningDir(dir);
-    if (!existsSync26(sp)) {
-      return {
-        error: "STATE.md not found. Run /new-project first to initialize the project.",
-        code: "NOT_INITIALIZED"
-      };
-    }
-    const stateContent = readFileSync25(sp, "utf-8");
-    const phaseMatch = stateContent.match(/^phase:\s*(\d+)/m);
-    if (!phaseMatch) {
-      return { error: "No phase found in STATE.md. Project may be corrupted." };
-    }
-    const phase = parseInt(phaseMatch[1], 10);
-    const projectPath = join25(pd, "PROJECT.md");
-    if (!existsSync26(projectPath)) {
-      return { error: "PROJECT.md not found. Run /new-project first." };
-    }
-    const phaseDir = join25(pd, "phases", `phase-${phase}`);
-    if (!existsSync26(phaseDir)) {
-      mkdirSync13(phaseDir, { recursive: true });
-    }
-    const topic = args?.topic ?? "general";
-    const radar = runImpactRadar(dir, topic);
-    return {
-      success: true,
-      message: `Discuss phase started for phase ${phase}.`,
-      topic,
-      workflow: "discuss-flow.md",
-      phase_dir: phaseDir,
-      impact_radar: radar,
-      next_step: radar.risk_flag ? "Review impact_radar risks before finalizing decisions with @discusser" : "Review workflow output and respond to @discusser questions"
-    };
-  }
-};
-
-// src/commands/planning/plan.ts
-import { readFileSync as readFileSync26, existsSync as existsSync27, writeFileSync as writeFileSync16, mkdirSync as mkdirSync14 } from "fs";
-import { join as join26 } from "path";
-function buildImpactRadarSection(dir, changeText) {
-  const radar = runImpactRadar(dir, changeText);
-  const lines = ["## Change Impact Radar", ""];
-  if (!radar.risk_flag && radar.related_modules.length === 0) {
-    lines.push("_No volatility or failure signals found for this change. Proceed with standard review._");
-    lines.push("");
-    return lines.join(`
-`);
-  }
-  if (radar.hotspots.length > 0) {
-    lines.push("### Volatile Zones Touched");
-    for (const h of radar.hotspots)
-      lines.push(`- \`${h.path}\` \u2014 ${h.stability}`);
-    lines.push("");
-  }
-  if (radar.known_failures.length > 0) {
-    lines.push("### Known Failures (Unresolved)");
-    for (const e of radar.known_failures.slice(0, 5)) {
-      lines.push(`- **${e.id}** (\xD7${e.recurrence_count}): ${e.description.substring(0, 80)}`);
-    }
-    lines.push("");
-  }
-  if (radar.related_modules.length > 0) {
-    lines.push("### Related Architecture Nodes");
-    for (const n of radar.related_modules.slice(0, 8)) {
-      lines.push(`- \`${n.path}\` (${n.type})${n.owner ? ` \u2014 owner: ${n.owner}` : ""}`);
-    }
-    lines.push("");
-  }
-  return lines.join(`
-`);
-}
-var planCommand = {
-  name: "fd-plan",
-  description: "Create detailed implementation plan from DISCUSS.md decisions \u2014 save PLAN.md, update STATE.md, require CONFIRM before execution",
-  async execute(context, args) {
-    const dir = context.directory ?? process.cwd();
-    const sp = statePath(dir);
-    const pd = planningDir(dir);
-    if (!existsSync27(sp)) {
-      return {
-        error: "STATE.md not found. Run /new-project first.",
-        code: "NOT_INITIALIZED"
-      };
-    }
-    const stateContent = readFileSync26(sp, "utf-8");
-    const confirmedMatch = stateContent.match(/^plan_confirmed:\s*(true|false)/m);
-    const isConfirmed = confirmedMatch && confirmedMatch[1] === "true";
-    let phase;
-    if (args?.phase) {
-      phase = parseInt(args.phase, 10);
-    } else {
-      const phaseMatch = stateContent.match(/^phase:\s*(\d+)/m);
-      if (!phaseMatch) {
-        return { error: "No phase found in STATE.md." };
-      }
-      phase = parseInt(phaseMatch[1], 10);
-    }
-    const discussPath = join26(pd, "phases", `phase-${phase}`, "DISCUSS.md");
-    if (!existsSync27(discussPath)) {
-      return {
-        error: "DISCUSS.md not found. Run /discuss [topic] first to capture decisions.",
-        code: "NO_DISCUSS",
-        hint: `No DISCUSS.md found for phase ${phase}`
-      };
-    }
-    if (args?.yes && !isConfirmed) {
-      args = { ...args, confirm: true };
-    }
-    if (!isConfirmed && !args?.confirm) {
-      const discussContent2 = readFileSync26(discussPath, "utf-8");
-      const decisions = (discussContent2.match(/^D-\d+/gm) || []).length;
-      const lines = discussContent2.split(`
-`).slice(0, 50);
-      const preview = [
-        "\u2550".repeat(55),
-        `PLAN PHASE ${phase} \u2014 AWAITING CONFIRMATION`,
-        "\u2550".repeat(55),
-        "",
-        `DISCUSS.md: ${discussPath}`,
-        `Decisions found: ${decisions}`,
-        "",
-        "Preview:",
-        ...lines.map((l) => `  ${l}`),
-        "",
-        "\u2500".repeat(55),
-        "Type CONFIRM to save PLAN.md and enable execution",
-        "\u2550".repeat(55)
-      ];
-      return {
-        ...confirmPrompt("plan-confirm", preview.join(`
-`)),
-        phase,
-        decisions_found: decisions,
-        workflow: "plan-flow.md",
-        next_step: "Type CONFIRM to save, or run /discuss to modify decisions first"
-      };
-    }
-    const discussContent = readFileSync26(discussPath, "utf-8");
-    const planFile = phasePlanPath(dir, phase);
-    const decisionLines = [];
-    const inDecisions = false;
-    let currentDecision = "";
-    for (const line of discussContent.split(`
-`)) {
-      const dm = line.match(/^(D-\d+):\s+(.+)/);
-      if (dm) {
-        currentDecision = `${dm[1]}: ${dm[2]}`;
-        decisionLines.push(currentDecision);
-      }
-    }
-    const changeDescription = decisionLines.join("; ").substring(0, 200);
-    const impactRadarSection = buildImpactRadarSection(dir, changeDescription);
-    const planContent = [
-      "# Implementation Plan",
-      "",
-      `**Phase:** ${phase}`,
-      `**Created:** ${timestamp()}`,
-      `**Source:** DISCUSS.md (${decisionLines.length} decisions)`,
-      "",
-      "## Decisions",
-      "",
-      ...decisionLines.map((d) => `- ${d}`),
-      "",
-      impactRadarSection,
-      "## Steps",
-      "",
-      "- [ ] Step 1: [Implementation step]",
-      "- [ ] Step 2: [Implementation step]",
-      "- [ ] Step 3: [Implementation step]",
-      "",
-      "## Acceptance Criteria",
-      "",
-      "- [ ] Criterion 1",
-      "- [ ] Criterion 2",
-      "",
-      "## Status",
-      "",
-      "CONFIRMED"
-    ].join(`
-`);
-    const phaseDir = join26(pd, "phases", `phase-${phase}`);
-    if (!existsSync27(phaseDir)) {
-      mkdirSync14(phaseDir, { recursive: true });
-    }
-    writeFileSync16(planFile, planContent, "utf-8");
-    let state = readFileSync26(sp, "utf-8");
-    state = state.replace(/^plan_confirmed:\s*.*/m, "plan_confirmed: true");
-    state = state.replace(/^confirmed_at:\s*.*/m, `confirmed_at: ${timestamp()}`);
-    state = state.replace(/^status:\s*.*/m, "status: in_progress");
-    writeFileSync16(sp, state, "utf-8");
-    return {
-      success: true,
-      message: `PLAN.md saved for phase ${phase}. Execution enabled.`,
-      phase,
-      decisions_count: decisionLines.length,
-      plan_file: planFile,
-      status: "CONFIRMED"
-    };
-  }
-};
-
-// src/commands/planning/roadmap.ts
-import { readFileSync as readFileSync27, existsSync as existsSync28, writeFileSync as writeFileSync17 } from "fs";
-import { join as join27 } from "path";
-var roadmapCommand = {
-  name: "fd-roadmap",
-  description: "View or update project roadmap \u2014 displays ROADMAP.md, shows phase statuses, add new phase, or mark phase complete",
-  async execute(context, args) {
-    const dir = context.directory ?? process.cwd();
-    const pd = planningDir(dir);
-    const roadmapPath = join27(pd, "ROADMAP.md");
-    if (!existsSync28(pd)) {
-      return {
-        error: ".planning/ not found. Run /new-project first.",
-        code: "NOT_INITIALIZED"
-      };
-    }
-    if (!existsSync28(roadmapPath)) {
-      return {
-        error: "ROADMAP.md not found.",
-        code: "NO_ROADMAP"
-      };
-    }
-    const content = readFileSync27(roadmapPath, "utf-8");
-    if (args?.complete) {
-      const phaseNum = parseInt(args.complete, 10);
-      if (isNaN(phaseNum)) {
-        return { error: "Phase number must be a numeric value", code: "INVALID_PHASE" };
-      }
-      const phaseExists = content.match(new RegExp(`\\[ \\] Phase ${phaseNum}:`));
-      if (!phaseExists) {
-        return { error: `Phase ${phaseNum} not found in roadmap. Check /roadmap for valid phase numbers.`, code: "PHASE_NOT_FOUND" };
-      }
-      if (!args?.yes) {
-        return {
-          ...confirmPrompt("roadmap-complete", `Mark Phase ${args.complete} complete? This will update ROADMAP.md and STATE.md. [y/n]`),
-          phase: parseInt(args.complete, 10)
-        };
-      }
-      const phasePattern = new RegExp(`(\\-\\[ \\] Phase ${phaseNum}:)`, "i");
-      const completedPattern = new RegExp(`Phase ${phaseNum}: ([^\\(]+)`);
-      const dateStr = new Date().toISOString().split("T")[0];
-      let updated = content.replace(phasePattern, `[x] Phase ${phaseNum}:`);
-      const milestoneMatch = content.match(/### \uD83D\uDCCB (\S+) \(([^)]+)\)/);
-      if (milestoneMatch) {
-        const currentStatus = milestoneMatch[2];
-        updated = updated.replace(new RegExp(`### \uD83D\uDCCB ${milestoneMatch[1]} \\(${currentStatus}\\)(?!.*Shipped)`), `### \u2705 ${milestoneMatch[1]} (Shipped: ${dateStr})`);
-      }
-      if (args?.dryRun) {
-        const nextPhase2 = phaseNum + 1;
-        const proposedState = `phase: ${nextPhase2}
-status: in_progress`;
-        return {
-          success: true,
-          message: `[DRY-RUN] Would update ROADMAP.md:
-${updated}
-
-[DRY-RUN] Would update STATE.md:
-${proposedState}`,
-          meta: { dryRun: true, phase: phaseNum }
-        };
-      }
-      writeFileSync17(roadmapPath, updated, "utf-8");
-      const nextPhase = phaseNum + 1;
-      updatePlanningState(dir, {
-        phase: nextPhase,
-        status: "in_progress"
-      });
-      return {
-        success: true,
-        message: `Phase ${phaseNum} marked complete in ROADMAP.md and STATE.md updated (now Phase ${nextPhase})`,
-        phase: phaseNum
-      };
-    }
-    if (args?.add) {
-      const newPhase = args.add;
-      const sanitized = newPhase.replace(/[^\w\s\-]/g, "");
-      const newPhaseMd = `
-- [ ] Phase ${sanitized}: ${sanitized}
-`;
-      if (args?.dryRun) {
-        return {
-          success: true,
-          message: `[DRY-RUN] Would add to ROADMAP.md:
-${newPhaseMd}`,
-          meta: { dryRun: true, phase: sanitized }
-        };
-      }
-      const insertPoint = content.lastIndexOf("### \uD83D\uDCCB");
-      if (insertPoint === -1) {
-        return { error: "Could not find insertion point for new phase", code: "INSERT_FAILED" };
-      }
-      const updated = content.slice(0, insertPoint) + newPhaseMd + content.slice(insertPoint);
-      writeFileSync17(roadmapPath, updated, "utf-8");
-      return {
-        success: true,
-        message: `Phase "${newPhase}" added to ROADMAP.md`,
-        phase: newPhase
-      };
-    }
-    if (args?.json) {
-      return {
-        success: true,
-        data: { roadmap: content },
-        meta: { formatted: "json", timestamp: timestamp() }
-      };
-    }
-    if (args?.filter && !["complete", "in-progress", "planned"].includes(args.filter)) {
-      return { error: "Filter must be one of: complete, in-progress, planned", code: "INVALID_FILTER" };
-    }
-    const lines = content.split(`
-`);
-    const state = readPlanningState(dir);
-    const stepsComplete = Array.isArray(state.steps_complete) ? state.steps_complete : [];
-    const stepsPending = Array.isArray(state.steps_pending) ? state.steps_pending : [];
-    const currentPhase = state.phase ?? 0;
-    const phaseEntries = [];
-    let currentSection = "";
-    for (const line of lines) {
-      if (line.startsWith("### ")) {
-        currentSection = line.replace("### ", "").replace("[x] ", "\u2705 ").replace("[ ] ", "\u25CB ");
-      } else if (line.startsWith("- [x] Phase")) {
-        const phaseMatch = line.match(/Phase (\d+)/);
-        const nameMatch = line.match(/Phase \d+: ([^\u2014]+)/);
-        phaseEntries.push({
-          raw: line,
-          type: "complete",
-          phaseNum: phaseMatch ? parseInt(phaseMatch[1]) : null,
-          name: nameMatch ? nameMatch[1].trim() : "",
-          section: currentSection,
-          line
-        });
-      } else if (line.startsWith("- [ ] Phase")) {
-        const phaseMatch = line.match(/Phase (\d+)/);
-        const nameMatch = line.match(/Phase \d+: ([^\u2014]+)/);
-        phaseEntries.push({
-          raw: line,
-          type: "planned",
-          phaseNum: phaseMatch ? parseInt(phaseMatch[1]) : null,
-          name: nameMatch ? nameMatch[1].trim() : "",
-          section: currentSection,
-          line
-        });
-      } else if (line.startsWith("- \u2705")) {
-        phaseEntries.push({
-          raw: line,
-          type: "shipped",
-          phaseNum: null,
-          name: "",
-          section: currentSection,
-          line
-        });
-      }
-    }
-    const filterSet = new Set;
-    if (args?.filter === "complete") {
-      phaseEntries.forEach((p) => {
-        if (p.type === "complete" && p.phaseNum !== null)
-          filterSet.add(p.phaseNum);
-      });
-    } else if (args?.filter === "planned") {
-      phaseEntries.forEach((p) => {
-        if (p.type === "planned" && p.phaseNum !== null)
-          filterSet.add(p.phaseNum);
-      });
-    } else if (args?.filter === "in-progress") {
-      if (currentPhase > 0)
-        filterSet.add(currentPhase);
-    }
-    if (args?.sort && args.sort !== "number") {
-      phaseEntries.sort((a, b) => {
-        if (args.sort === "name") {
-          const nameA = a.name.toLowerCase();
-          const nameB = b.name.toLowerCase();
-          return nameA.localeCompare(nameB);
-        } else if (args.sort === "status") {
-          const order = { complete: 0, "in-progress": 1, planned: 2 };
-          const statusA = a.phaseNum === currentPhase ? "in-progress" : a.type;
-          const statusB = b.phaseNum === currentPhase ? "in-progress" : b.type;
-          const ordA = statusA === "in-progress" ? 1 : order[statusA] ?? 2;
-          const ordB = statusB === "in-progress" ? 1 : order[statusB] ?? 2;
-          if (ordA !== ordB)
-            return ordA - ordB;
-          return (a.phaseNum ?? 0) - (b.phaseNum ?? 0);
-        }
-        return 0;
-      });
-    }
-    function boldMatch(text, query) {
-      if (!query)
-        return text;
-      const regex = new RegExp(`(${query.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")})`, "gi");
-      return text.replace(regex, "**$1**");
-    }
-    let output = ["\u2550".repeat(55), "ROADMAP", "\u2550".repeat(55)];
-    currentSection = "";
-    for (const entry of phaseEntries) {
-      if (filterSet.size > 0 && entry.phaseNum !== null && !filterSet.has(entry.phaseNum)) {
-        continue;
-      }
-      if (entry.section !== currentSection) {
-        currentSection = entry.section;
-        output.push("", currentSection);
-      }
-      if (entry.type === "shipped") {
-        output.push(`  ${entry.raw}`);
-      } else if (entry.type === "complete" || entry.type === "planned") {
-        const phaseInfo = entry.raw.replace(/- \[[x ]\] Phase \d+: /, "").replace(" \u2014 ", " | ");
-        let stepInfo = "";
-        if (entry.phaseNum !== null) {
-          if (entry.type === "complete") {
-            const pComplete = stepsComplete.filter((s) => s === entry.phaseNum).length;
-            const pPending = stepsPending.filter((s) => s === entry.phaseNum).length;
-            if (pComplete > 0 || pPending > 0) {
-              stepInfo = ` [${pComplete}/${pComplete + pPending} steps]`;
-            }
-          } else {
-            const pPending = stepsPending.filter((s) => s === entry.phaseNum).length;
-            if (pPending > 0) {
-              stepInfo = ` [${pPending} pending]`;
-            }
-          }
-        }
-        const isCurrent = entry.phaseNum === currentPhase;
-        const marker = isCurrent ? ">> " : "   ";
-        const icon = entry.type === "complete" ? "\u2713" : "\u25CB";
-        let displayInfo = phaseInfo;
-        if (args?.search) {
-          displayInfo = boldMatch(phaseInfo, args.search);
-        }
-        output.push(`${marker}${icon} ${displayInfo}${stepInfo}`);
-      } else if (entry.raw.trim().startsWith("|")) {
-        output.push(`  ${entry.raw.trim()}`);
-      }
-    }
-    output.push("", "\u2500".repeat(55));
-    output.push("  Use: /roadmap --complete <N>  to mark phase N complete");
-    output.push("  Use: /roadmap --add <name>     to add a new phase");
-    output.push("  Use: /roadmap --dry-run       to preview changes without writing");
-    output.push("  Use: /roadmap --filter <F>    to filter by status (complete|in-progress|planned)");
-    output.push("  Use: /roadmap --search <Q>    to highlight matching phases");
-    output.push("  Use: /roadmap --sort <F>      to sort by field (number|name|status)");
-    output.push("\u2550".repeat(55));
-    return {
-      success: true,
-      message: output.join(`
-`),
-      meta: { formatted: "table", timestamp: timestamp() }
-    };
-  }
-};
-
-// src/commands/planning/dashboard.ts
-import { spawn } from "child_process";
-import { existsSync as existsSync29, readFileSync as readFileSync28 } from "fs";
-import path from "path";
-import { fileURLToPath } from "url";
-
-// src/dashboard/lib/port-finder.ts
-import http from "http";
-async function findOpenPort(startPort = 3456, maxRetries = 100) {
-  let port = startPort;
-  let retries = 0;
-  while (retries < maxRetries) {
-    const result = await tryPort(port);
-    if (result.available) {
-      return { port, host: "localhost" };
-    }
-    port++;
-    retries++;
-  }
-  throw new Error(`Could not find open port after ${maxRetries} attempts starting from ${startPort}`);
-}
-function tryPort(port) {
-  return new Promise((resolve3) => {
-    const server = http.createServer();
-    server.once("error", () => {
-      resolve3({ available: false });
-    });
-    server.once("listening", () => {
-      server.close(() => {
-        resolve3({ available: true });
-      });
-    });
-    server.listen(port, "127.0.0.1");
-  });
-}
-
-// src/commands/planning/dashboard.ts
-var SERVER_PATH = path.join(path.dirname(fileURLToPath(import.meta.url)), "dashboard", "server.mjs");
-var dashboardCommand = {
-  name: "fd-dashboard",
-  description: "Open project dashboard in browser \u2014 displays phase progress, milestones, and blockers",
-  async execute(context, args) {
-    const dir = context.directory ?? process.cwd();
-    const dashboardDir = path.join(dir, ".dashboard");
-    if (args?.refresh) {
-      const portFile = path.join(dashboardDir, "port");
-      if (!existsSync29(portFile)) {
-        return { success: false, error: "No dashboard server running. Run /dashboard first.", code: "NO_SERVER" };
-      }
-      const port2 = readFileSync28(portFile, "utf-8").trim();
-      try {
-        const resp = await fetch(`http://localhost:${port2}/refresh`);
-        if (resp.ok) {
-          return { success: true, message: `Dashboard refreshed at http://localhost:${port2}` };
-        }
-      } catch {
-        return { success: false, error: `Could not reach dashboard at port ${port2}`, code: "REFRESH_FAILED" };
-      }
-    }
-    const { port } = await findOpenPort(3456, 100);
-    const child = spawn("bun", [SERVER_PATH, `--port=${port}`, `--dir=${dir}`], {
-      detached: true,
-      stdio: "ignore"
-    });
-    child.unref();
-    await new Promise((r) => setTimeout(r, 500));
-    const url = `http://localhost:${port}`;
-    return {
-      success: true,
-      message: `Dashboard running at ${url} \u2014 opening browser`,
-      meta: { port, url }
-    };
-  }
-};
-
-// src/commands/planning/ask.ts
-var ROUTES = [
-  {
-    keywords: ["system design", "design", "architecture", "diagram", "structure", "component", "microservice", "schema design"],
-    agent: "architect",
-    focus: "system design and architecture",
-    description: "Design systems, components, and architecture"
-  },
-  {
-    keywords: ["impact", "blast radius", "affected", "downstream", "dependency", "ripple", "change radar"],
-    agent: "researcher",
-    focus: "change impact and dependency analysis",
-    description: "Assess impact and downstream effects of a change",
-    useImpactRadar: true
-  },
-  {
-    keywords: ["security", "vulnerability", "cve", "exploit", "injection", "xss", "csrf", "auth bypass", "pentest", "audit", "owasp"],
-    agent: "security-auditor",
-    focus: "security analysis",
-    description: "Security audit, vulnerability assessment, threat analysis"
-  },
-  {
-    keywords: ["performance", "bottleneck", "slow", "latency", "optimize", "benchmark", "profil", "memory leak", "cpu", "throughput"],
-    agent: "performance-optimizer",
-    focus: "performance analysis and optimization",
-    description: "Profile, benchmark, and optimize performance"
-  },
-  {
-    keywords: ["debug", "error", "exception", "crash", "panic", "traceback", "stack trace", "not working", "broken", "bug"],
-    agent: "debug-specialist",
-    focus: "root cause investigation",
-    description: "Investigate errors, crashes, and unexpected behavior"
-  },
-  {
-    keywords: ["test", "coverage", "spec", "unit test", "integration test", "mock", "fixture", "tdd", "assert"],
-    agent: "tester",
-    focus: "test generation and coverage",
-    description: "Write tests, improve coverage, and validate behavior"
-  },
-  {
-    keywords: ["refactor", "cleanup", "simplify", "extract", "rename", "reorganize", "decouple", "dry", "dead code"],
-    agent: "coder",
-    focus: "refactoring and code quality",
-    description: "Refactor and improve code without changing behavior"
-  },
-  {
-    keywords: ["document", "docs", "readme", "wiki", "jsdoc", "docstring", "comment", "explain to", "write up"],
-    agent: "writer",
-    focus: "documentation generation",
-    description: "Write or update documentation"
-  },
-  {
-    keywords: ["explain", "how does", "what does", "what is", "understand", "query", "search", "find", "where", "explore", "trace"],
-    agent: "code-explorer",
-    focus: "code exploration and explanation",
-    description: "Explore and explain code, find patterns, trace flows"
-  },
-  {
-    keywords: ["deploy", "release", "production", "rollback", "migration", "upgrade", "version"],
-    agent: "reviewer",
-    focus: "deployment readiness",
-    description: "Review for deployment readiness and risk"
-  },
-  {
-    keywords: ["plan", "roadmap", "breakdown", "estimate", "milestone", "task", "phase", "sprint"],
-    agent: "planner",
-    focus: "planning and task breakdown",
-    description: "Create plans, roadmaps, and task breakdowns"
-  }
-];
-function scoreRoute(task, rule) {
-  const lower = task.toLowerCase();
-  let score = 0;
-  for (const kw of rule.keywords) {
-    if (lower.includes(kw.toLowerCase())) {
-      score += kw.split(" ").length;
-    }
-  }
-  return score;
-}
-function pickRoute(task) {
-  let best = null;
-  for (const rule of ROUTES) {
-    const score = scoreRoute(task, rule);
-    if (score > 0 && (!best || score > best.score)) {
-      best = { ...rule, score };
-    }
-  }
-  return best ?? { ...ROUTES[ROUTES.length - 1], agent: "orchestrator", focus: "general task", description: "General purpose task", score: 0 };
-}
-var askCommand = {
-  name: "fd-ask",
-  description: "Smart dispatch \u2014 routes a free-form task to the appropriate specialized agent without a workflow",
-  async execute(context, args) {
-    const dir = context.directory ?? process.cwd();
-    if (!args?.task && !args?.agent) {
-      return {
-        error: "Provide a task description: /fd-ask --task 'system design for notifications'",
-        code: "NO_TASK",
-        hint: "Examples: 'explain how auth works', 'security audit of payments', 'design a caching layer'",
-        examples: ROUTES.slice(0, 5).map((r) => ({ agent: `@${r.agent}`, example: r.keywords[0] }))
-      };
-    }
-    const task = args?.task ?? "";
-    const route = args?.agent ? { agent: args.agent, focus: "user-specified", description: "Manually specified agent", score: -1, keywords: [], useImpactRadar: false } : pickRoute(task);
-    const radar = route.useImpactRadar ? runImpactRadar(dir, task) : null;
-    const dispatch = {
-      agent: `@${route.agent}`,
-      task,
-      focus: route.focus,
-      routed_by: args?.agent ? "user-override" : "keyword-match",
-      impact_radar: radar ?? undefined
-    };
-    if (args?.json) {
-      return {
-        success: true,
-        data: dispatch,
-        meta: { formatted: "json", timestamp: timestamp() }
-      };
-    }
-    const lines = [
-      "\u2500".repeat(55),
-      `  /fd-ask \u2192 routing to ${dispatch.agent}`,
-      `  Task:  ${task}`,
-      `  Focus: ${route.focus}`
-    ];
-    if (radar?.risk_flag) {
-      lines.push("\u2500".repeat(55));
-      lines.push("  \u26A0 Impact Radar:");
-      if (radar.hotspots.length > 0) {
-        lines.push(`  Volatile zones: ${radar.hotspots.map((h) => h.path).join(", ")}`);
-      }
-      if (radar.known_failures.length > 0) {
-        lines.push(`  Known failures: ${radar.known_failures.map((f) => f.id).join(", ")}`);
-      }
-    }
-    lines.push("\u2550".repeat(55));
-    return {
-      success: true,
-      message: lines.join(`
-`),
-      dispatch,
-      meta: { formatted: "table", timestamp: timestamp() }
-    };
-  }
-};
-
-// src/commands/execution/new-feature.ts
-import { existsSync as existsSync32, readFileSync as readFileSync31 } from "fs";
-
-// src/services/model-router.ts
-import { existsSync as existsSync30, readFileSync as readFileSync29 } from "fs";
-import { join as join28 } from "path";
-var DEFAULT_ROUTING = {
-  planning: { primary: "claude-sonnet-4-5", temperature: 0.3, reasoning_effort: "medium" },
-  implementation: { primary: "claude-opus-4-5", fallback: "claude-sonnet-4-5", high_risk_override: "claude-opus-4-5", temperature: 0.2, reasoning_effort: "high" },
-  debugging: { primary: "claude-sonnet-4-5", high_risk_override: "claude-opus-4-5", temperature: 0.2, reasoning_effort: "high" },
-  review: { primary: "gemini-2.5-flash", fallback: "claude-haiku-4-5", temperature: 0.1, reasoning_effort: "medium" },
-  testing: { primary: "claude-haiku-4-5", fallback: "gemini-2.5-flash", temperature: 0.1, reasoning_effort: "low" },
-  documentation: { primary: "claude-sonnet-4-5", fallback: "gemini-2.5-flash", temperature: 0.3, reasoning_effort: "low" },
-  analysis: { primary: "claude-sonnet-4-5", temperature: 0.3, reasoning_effort: "medium" },
-  security: { primary: "claude-opus-4-5", high_risk_override: "claude-opus-4-5", temperature: 0.1, reasoning_effort: "high" },
-  orchestration: { primary: "claude-sonnet-4-5", temperature: 0.3, reasoning_effort: "medium" }
-};
-function getRouterConfig(dir) {
-  const p = join28(codebaseDir(dir), "MODEL_ROUTER.json");
-  if (!existsSync30(p))
-    return DEFAULT_ROUTING;
-  try {
-    const overrides = JSON.parse(readFileSync29(p, "utf-8"));
-    return { ...DEFAULT_ROUTING, ...overrides };
-  } catch {
-    return DEFAULT_ROUTING;
-  }
-}
-function routeModel(dir, task_type, risk_score = 100) {
-  const config = getRouterConfig(dir);
-  const route = config[task_type] ?? DEFAULT_ROUTING.implementation;
-  const is_high_risk = risk_score < 40;
-  let model = route.primary;
-  let is_override = false;
-  if (is_high_risk && route.high_risk_override) {
-    model = route.high_risk_override;
-    is_override = true;
-  }
-  return {
-    model,
-    temperature: route.temperature ?? 0.3,
-    reasoning_effort: route.reasoning_effort,
-    task_type,
-    is_high_risk,
-    is_override
-  };
-}
-function buildAgentConfig(dir, agents) {
-  return agents.map((a) => {
-    const routed = routeModel(dir, a.task_type, a.risk_score ?? 100);
-    return {
-      name: a.name,
-      model: routed.model,
-      temperature: routed.temperature,
-      ...routed.reasoning_effort ? { reasoningEffort: routed.reasoning_effort } : {}
-    };
-  });
-}
-
-// src/services/run-trace.ts
-import { existsSync as existsSync31, readFileSync as readFileSync30, appendFileSync as appendFileSync4, writeFileSync as writeFileSync18, mkdirSync as mkdirSync15 } from "fs";
-import { join as join29 } from "path";
-import { randomUUID as randomUUID2 } from "crypto";
-function runsPath(dir) {
-  return join29(codebaseDir(dir), "RUNS.jsonl");
-}
-function startTrace(dir, command, args, session_id = "session-0") {
-  const cd = codebaseDir(dir);
-  if (!existsSync31(cd))
-    mkdirSync15(cd, { recursive: true });
-  const trace = {
-    run_id: randomUUID2(),
-    session_id,
-    command,
-    args,
-    started_at: new Date().toISOString(),
-    status: "running",
-    files_touched: [],
-    event_ids: [],
-    risk_score: 0
-  };
-  appendFileSync4(runsPath(dir), JSON.stringify(trace) + `
-`, "utf-8");
-  return trace;
-}
-
-// src/commands/execution/new-feature.ts
-var newFeatureCommand = {
-  name: "fd-new-feature",
-  description: "Execute feature implementation \u2014 guard check, orchestrator coordination, parallel coder+researcher, reviewer, tester, STATE.md update",
-  async execute(context, args) {
-    const dir = context.directory ?? process.cwd();
-    const sp = statePath(dir);
-    const pd = planningDir(dir);
-    const cd = codebaseDir(dir);
-    const checks = {
-      ".planning/": existsSync32(pd),
-      ".codebase/": existsSync32(cd),
-      "PLAN.md confirmed": () => {
-        if (!existsSync32(sp))
-          return false;
-        const state2 = readPlanningState(dir);
-        return state2.plan_confirmed === true;
-      }
-    };
-    const missing = Object.entries(checks).filter(([, v]) => typeof v === "boolean" ? !v : !v()).map(([k]) => k);
-    if (missing.length > 0) {
-      return {
-        error: `Missing prerequisites: ${missing.join(", ")}`,
-        code: "GUARD_FAILED",
-        hint: "Run /new-project, /map-codebase, and /plan first"
-      };
-    }
-    const state = readPlanningState(dir);
-    const phase = state.phase;
-    const planPath = phasePlanPath(dir, phase);
-    if (!existsSync32(planPath)) {
-      return {
-        error: "PLAN.md not found. Run /plan first.",
-        code: "NO_PLAN"
-      };
-    }
-    const featureText = args?.feature ?? readFileSync31(planPath, "utf-8").split(`
-`).slice(0, 10).join(" ");
-    const radar = runImpactRadar(dir, featureText);
-    const priorFailures = lookupPriorFailures(dir, "all", featureText);
-    const trace = startTrace(dir, "fd-new-feature", { feature: args?.feature ?? "", phase }, process.env.OPENCODE_SESSION_ID);
-    appendEvent(dir, {
-      session_id: process.env.OPENCODE_SESSION_ID ?? "session-0",
-      run_id: trace.run_id,
-      event: "command.start",
-      command: "fd-new-feature",
-      risk_score: radar.score,
-      meta: { phase, plan_file: planPath }
-    });
-    let tddState = state["tdd"];
-    if (!tddState) {
-      updateTDDState(dir, {
-        stage: "behavior",
-        cycle: 1,
-        behaviors: [],
-        regression_test_links: [],
-        override_log: [],
-        failing_tests: 0,
-        passing_tests: 0
-      });
-      tddState = readPlanningState(dir)["tdd"];
-    }
-    const codebaseResult = codebaseStateTool.execute({ action: "read", files: ["STACK.md", "ARCHITECTURE.md"] }, context);
-    const riskScore = radar.score;
-    const agentConfigs = buildAgentConfig(dir, [
-      { name: "coder", task_type: "implementation", risk_score: riskScore },
-      { name: "researcher", task_type: "analysis", risk_score: riskScore },
-      { name: "reviewer", task_type: "review", risk_score: riskScore },
-      { name: "tester", task_type: "testing", risk_score: riskScore }
-    ]);
-    const workflow = "execute-flow.md";
-    const config = {
-      orchestrator: {
-        model: agentConfigs.find((a) => a.name === "coder")?.model ?? "claude-sonnet-4-5",
-        temperature: 0.3,
-        maxSteps: 60
-      },
-      agents: agentConfigs,
-      run_id: trace.run_id,
-      parallel: {
-        coder: true,
-        researcher: true
-      },
-      worktree: true,
-      impact_radar: radar,
-      prior_failures: priorFailures.map((f) => ({
-        id: f.id,
-        type: f.type,
-        description: f.description,
-        affected_paths: f.affected_paths,
-        root_cause: f.root_cause ?? null,
-        fix_applied: f.fix_applied ?? null,
-        recurrence_count: f.recurrence_count
-      })),
-      post_execution: {
-        step: "record",
-        agent: "orchestrator",
-        actions: [
-          { tool: "repo-memory", action: "record", note: "add new module to MEMORY.json" },
-          { tool: "failure-replay", action: "record", condition: "if any build, test, or deployment failure occurred during this feature", note: "log to FAILURES.json for future reference" }
-        ]
-      }
-    };
-    if (args?.json) {
-      return {
-        success: true,
-        data: { workflow, config, phase, plan_file: planPath },
-        meta: { formatted: "json", timestamp: timestamp() }
-      };
-    }
-    const radarLines = impactRadarSummaryLines(radar);
-    const priorFailureLines = priorFailures.length > 0 ? [
-      "\u2500".repeat(55),
-      `  Prior failures in this area (${priorFailures.length}):`,
-      ...priorFailures.map((f) => {
-        const rc = f.recurrence_count > 1 ? ` (\xD7${f.recurrence_count})` : "";
-        const cause = f.root_cause ? ` \u2014 ${f.root_cause.substring(0, 60)}` : "";
-        return `  \u26A0 [${f.id}]${rc}${cause}`;
-      })
-    ] : [];
-    const tddStage = tddState ? tddState.stage.toUpperCase() : "NONE";
-    const tddFailing = tddState ? tddState.failing_tests : 0;
-    const tddPassing = tddState ? tddState.passing_tests : 0;
-    const tddBehaviors = tddState ? tddState.behaviors.length : 0;
-    const tddCycles = tddState ? tddState.cycle : 0;
-    const tableLines = [
-      "\u2550".repeat(55),
-      `New Feature: phase ${phase}`,
-      "\u2500".repeat(55),
-      `  Guard: .planning/ \u2713  .codebase/ \u2713  plan_confirmed \u2713`,
-      "\u2500".repeat(55),
-      `  TDD Stage: ${tddStage} | Cycle: ${tddCycles}`,
-      `  Tests: ${tddFailing} failing | ${tddPassing} passing`,
-      `  Behaviors: ${tddBehaviors} defined`,
-      ...priorFailureLines,
-      ...radarLines,
-      "\u2500".repeat(55),
-      "  orchestrator \u2192 coordinates TDD execution",
-      "  TDD cycle:    \u2192 RED (write failing tests) \u2192 GREEN (minimum impl) \u2192 REFACTOR",
-      "  sequential:   \u2192 @reviewer, @tester",
-      "  post-exec:    \u2192 record module (repo-memory) + any failures (failure-replay)",
-      "\u2500".repeat(55),
-      `  plan: ${planPath.split("/").pop()}`,
-      "\u2550".repeat(55)
-    ];
-    return {
-      success: true,
-      message: tableLines.join(`
-`),
-      workflow,
-      config,
-      phase,
-      plan_file: planPath,
-      impact_radar: radar,
-      prior_failures: config.prior_failures,
-      meta: { formatted: "table", timestamp: timestamp() }
-    };
-  }
-};
-
-// src/commands/execution/fix-bug.ts
-import { existsSync as existsSync34, readFileSync as readFileSync33 } from "fs";
-
-// src/services/policy-compiler.ts
-import { existsSync as existsSync33, readFileSync as readFileSync32 } from "fs";
-import { join as join30 } from "path";
-function loadPolicies(dir) {
-  const p = join30(codebaseDir(dir), "POLICIES.json");
-  if (!existsSync33(p))
-    return [];
-  try {
-    const store = JSON.parse(readFileSync32(p, "utf-8"));
-    return store.policies.filter((p2) => p2.active);
-  } catch {
-    return [];
-  }
-}
-function matchesTrigger(trigger, ctx) {
-  const t = trigger.toLowerCase();
-  const fields = [
-    ctx.command ?? "",
-    ctx.file_path ?? "",
-    ctx.change_description ?? "",
-    ctx.tool ?? ""
-  ].map((s) => s.toLowerCase());
-  const words = t.split(/\s+/).filter(Boolean);
-  return words.some((word) => fields.some((f) => f.includes(word)));
-}
-function deriveSeverity(rule) {
-  const blocking = ["never", "always block", "must not", "forbidden", "require approval", "requires approval"];
-  const lower = rule.toLowerCase();
-  return blocking.some((kw) => lower.includes(kw)) ? "block" : "warn";
-}
-function evaluatePolicies(dir, ctx) {
-  const policies = loadPolicies(dir);
-  const violations = [];
-  for (const policy of policies) {
-    if (matchesTrigger(policy.trigger, ctx)) {
-      violations.push({
-        policy_id: policy.id,
-        policy_name: policy.name,
-        rule: policy.rule,
-        trigger: policy.trigger,
-        severity: deriveSeverity(policy.rule)
-      });
-    }
-  }
-  for (const tddPolicy of TDD_POLICIES) {
-    if (matchesTrigger(tddPolicy.trigger, ctx)) {
-      violations.push({
-        policy_id: `tdd-${tddPolicy.name.replace(/\s+/g, "-").toLowerCase()}`,
-        policy_name: tddPolicy.name,
-        rule: tddPolicy.rule,
-        trigger: tddPolicy.trigger,
-        severity: tddPolicy.severity
-      });
-    }
-  }
-  return violations;
-}
-var FAILURE_RULES = [
-  {
-    path_pattern: /auth|login|password|jwt|session|oauth/i,
-    name: "Require approval for auth changes",
-    trigger: "auth change",
-    rule: "Require human approval before editing authentication or session logic",
-    rationale: "Auth changes have high blast radius and are frequent sources of security regressions"
-  },
-  {
-    path_pattern: /payment|billing|stripe|credit/i,
-    name: "Require approval for payment changes",
-    trigger: "payment file",
-    rule: "Require human approval before editing payment or billing logic",
-    rationale: "Payment changes risk revenue loss and PCI compliance violations"
-  },
-  {
-    path_pattern: /migration|migrate|schema|alembic/i,
-    name: "Always add tests for schema changes",
-    trigger: "database migration",
-    rule: "Always add integration tests before applying a database migration",
-    rationale: "Schema migrations are irreversible and have caused data loss in past failures"
-  },
-  {
-    path_pattern: /infra|terraform|k8s|kubernetes|ansible|helm/i,
-    name: "Never edit infra without review",
-    trigger: "infra change",
-    rule: "Never edit infrastructure configuration without a reviewer sign-off",
-    rationale: "Infrastructure changes caused downtime in past incidents"
-  },
-  {
-    path_pattern: /\.env|secrets\.|config\/prod/i,
-    name: "Block writes to secrets files",
-    trigger: "secrets file",
-    rule: "Never write directly to .env or secrets files \u2014 use vault/config management",
-    rationale: "Direct writes to secrets files risk credential leaks"
-  }
-];
-var TDD_POLICIES = [
-  {
-    name: "No implementation without failing test",
-    trigger: "fd-new-feature",
-    rule: "Never begin implementation until a failing test exists for the target behavior",
-    severity: "warn"
-  },
-  {
-    name: "No refactor without green tests",
-    trigger: "refactor implementation",
-    rule: "Never refactor while tests are not green \u2014 maintain passing test state",
-    severity: "block"
-  },
-  {
-    name: "Bugfix requires regression test",
-    trigger: "fd-fix-bug",
-    rule: "Every bugfix must include a regression test unless override is explicitly granted",
-    severity: "warn"
-  },
-  {
-    name: "Missing tests are major findings",
-    trigger: "code review",
-    rule: "Flag missing or weak tests as major findings in code review \u2014 not minor",
-    severity: "warn"
-  },
-  {
-    name: "Deploy blocked without test coverage",
-    trigger: "fd-deploy-check",
-    rule: "Fail deploy check when expected tests are missing for changed code",
-    severity: "block"
-  },
-  {
-    name: "TDD override must be logged",
-    trigger: "override TDD",
-    rule: "Every TDD stage override must be logged in override_log and surfaced in review",
-    severity: "warn"
-  }
-];
-function learnFromFailure(failure_type, affected_paths, root_cause) {
-  const allPaths = [failure_type, ...affected_paths ?? [], root_cause ?? ""].join(" ");
-  for (const rule of FAILURE_RULES) {
-    if (rule.path_pattern.test(allPaths)) {
-      const id = `learned-${rule.trigger.replace(/\s+/g, "-")}-${Date.now()}`;
-      return {
-        id,
-        name: rule.name,
-        trigger: rule.trigger,
-        rule: rule.rule,
-        source: "learned",
-        failure_count: 1,
-        rationale: rule.rationale
-      };
-    }
-  }
-  return null;
-}
-function formatViolations(violations) {
-  if (violations.length === 0)
-    return "";
-  const lines = [
-    `  Policy violations (${violations.length}):`,
-    ...violations.map((v) => {
-      const icon = v.severity === "block" ? "\u2717" : "\u26A0";
-      return `  ${icon} [${v.policy_id}] ${v.policy_name}: ${v.rule}`;
-    })
-  ];
-  return lines.join(`
-`);
-}
-
-// src/commands/execution/fix-bug.ts
-var fixBugCommand = {
-  name: "fd-fix-bug",
-  description: "Load STATE.md + ARCHITECTURE.md \u2014 explore scope \u2014 researcher \u2014 mini-plan \u2014 coder fix \u2014 regression test \u2014 reviewer confirmation",
-  async execute(context, args) {
-    const dir = context.directory ?? process.cwd();
-    const sp = statePath(dir);
-    if (!existsSync34(sp)) {
-      return {
-        error: "STATE.md not found. Run /new-project first.",
-        code: "NOT_INITIALIZED"
-      };
-    }
-    const scope = args?.scope || "all";
-    if (scope.includes("/") && !scope.startsWith("./") && scope !== "all") {
-      return {
-        error: "Invalid scope: absolute paths not allowed",
-        code: "INVALID_SCOPE",
-        hint: "Use relative path like ./src or 'all'"
-      };
-    }
-    const state = readPlanningState(dir);
-    let tddState = state["tdd"];
-    if (!tddState) {
-      updateTDDState(dir, {
-        stage: "behavior",
-        cycle: 1,
-        behaviors: [],
-        regression_test_links: [],
-        override_log: [],
-        failing_tests: 0,
-        passing_tests: 0
-      });
-      tddState = readPlanningState(dir).tdd;
-    }
-    const cd = codebaseDir(dir);
-    const archPath = `${cd}/ARCHITECTURE.md`;
-    let architectureContext = null;
-    if (existsSync34(archPath)) {
-      architectureContext = readFileSync33(archPath, "utf-8");
-    }
-    const bugText = [args?.bug ?? "", scope !== "all" ? scope : ""].filter(Boolean).join(" ");
-    const radar = runImpactRadar(dir, bugText);
-    const priorFailures = lookupPriorFailures(dir, scope, args?.bug ?? "");
-    const policyViolations = evaluatePolicies(dir, {
-      command: "fd-fix-bug",
-      change_description: bugText
-    });
-    const proposedPolicies = priorFailures.map((f) => learnFromFailure(f.type, f.affected_paths, f.root_cause ?? "")).filter(Boolean);
-    const trace = startTrace(dir, "fd-fix-bug", { bug: args?.bug ?? "", scope }, process.env.OPENCODE_SESSION_ID);
-    appendEvent(dir, {
-      session_id: process.env.OPENCODE_SESSION_ID ?? "session-0",
-      run_id: trace.run_id,
-      event: "command.start",
-      command: "fd-fix-bug",
-      risk_score: radar.score,
-      meta: { scope, prior_failure_count: priorFailures.length, policy_violations: policyViolations.length }
-    });
-    const workflow = "fix-bug-flow.md";
-    const config = {
-      phases: [
-        { step: 1, name: "explore", agent: "researcher", action: "investigate bug scope via ARCHITECTURE.md" },
-        { step: 2, name: "research", agent: "researcher", action: "identify root cause and affected components" },
-        { step: 3, name: "mini-plan", agent: "orchestrator", action: "create fix plan from research findings" },
-        { step: 4, name: "fix", agent: "coder", action: "implement bug fix" },
-        { step: 5, name: "regression", agent: "tester", action: "write and run regression test (MUST PASS)", mode: "regression" },
-        { step: 6, name: "verify", agent: "reviewer", action: "confirm fix after regression passes", require_regression_pass: true },
-        { step: 7, name: "record", agent: "orchestrator", action: "call failure-replay record to log resolved bug in .codebase/FAILURES.json", tool: "failure-replay", tool_action: "record" }
-      ],
-      run_id: trace.run_id,
-      scope,
-      architecture_context: architectureContext ? architectureContext.substring(0, 500) : null,
-      impact_radar: radar,
-      prior_failures: priorFailures.map((f) => ({
-        id: f.id,
-        type: f.type,
-        description: f.description,
-        affected_paths: f.affected_paths,
-        root_cause: f.root_cause ?? null,
-        fix_applied: f.fix_applied ?? null,
-        recurrence_count: f.recurrence_count
-      })),
-      policy_violations: policyViolations,
-      proposed_policies: proposedPolicies
-    };
-    if (args?.json) {
-      return {
-        success: true,
-        data: { workflow, config, phase: state.phase },
-        meta: { formatted: "json", timestamp: timestamp() }
-      };
-    }
-    const radarLines = impactRadarSummaryLines(radar);
-    const priorFailureLines = priorFailures.length > 0 ? [
-      "\u2500".repeat(55),
-      `  Prior failures in this area (${priorFailures.length}):`,
-      ...priorFailures.map((f) => {
-        const rc = f.recurrence_count > 1 ? ` (\xD7${f.recurrence_count})` : "";
-        const cause = f.root_cause ? ` \u2014 ${f.root_cause.substring(0, 60)}` : "";
-        return `  \u26A0 [${f.id}]${rc}${cause}`;
-      })
-    ] : [];
-    const tddStage = tddState ? tddState.stage.toUpperCase() : "NONE";
-    const tddFailing = tddState ? tddState.failing_tests : 0;
-    const tddPassing = tddState ? tddState.passing_tests : 0;
-    const tddOverrides = tddState ? tddState.override_log.length : 0;
-    const tableLines = [
-      "\u2500".repeat(55),
-      `Fix Bug: scope=${scope}`,
-      `Phase ${state.phase} | TDD-enforced 12-step workflow`,
-      "\u2500".repeat(55),
-      `  TDD Stage: ${tddStage} | Cycle: ${tddState?.cycle ?? 1}`,
-      `  Tests: ${tddFailing} failing | ${tddPassing} passing`,
-      `  Overrides used: ${tddOverrides}`,
-      "\u2500".repeat(55),
-      "  [1-2] explore + research \u2192 isolate root cause",
-      "  [3] define behaviors \u2192 acceptance cases for fix",
-      "  [4] RED      \u2192 @tester writes failing regression test",
-      "  [5] confirm  \u2192 test MUST fail before proceeding",
-      "  [6] GREEN    \u2192 @coder implements minimum fix",
-      "  [7] confirm  \u2192 test MUST pass before proceeding",
-      "  [8] REFACTOR \u2192 clean up (only if GREEN)",
-      "  [9-10] verify \u2192 full test suite passes",
-      "  [11] review  \u2192 @reviewer confirms + TDD discipline",
-      "  [12] record  \u2192 log fix + regression test in FAILURES.json",
-      ...priorFailureLines,
-      ...radarLines,
-      ...policyViolations.length > 0 ? ["\u2500".repeat(55), formatViolations(policyViolations)] : [],
-      "\u2500".repeat(55),
-      "\u26A0 GUARD: Regression test must fail RED \u2192 pass GREEN \u2192 refactor",
-      "\u2550".repeat(55)
-    ];
-    return {
-      success: true,
-      message: tableLines.join(`
-`),
-      workflow,
-      config,
-      phase: state.phase,
-      impact_radar: radar,
-      prior_failures: config.prior_failures,
-      meta: { formatted: "table", timestamp: timestamp() }
-    };
-  }
-};
-
-// src/commands/execution/review-code.ts
-import { existsSync as existsSync35 } from "fs";
-var reviewCodeCommand = {
-  name: "fd-review-code",
-  description: "Parallel reviewer + researcher + tester \u2014 aggregates into critical/major/minor report",
-  async execute(context, args) {
-    const dir = context.directory ?? process.cwd();
-    const sp = statePath(dir);
-    if (!existsSync35(sp)) {
-      return {
-        error: "STATE.md not found. Run /new-project first.",
-        code: "NOT_INITIALIZED"
-      };
-    }
-    const scope = args?.scope || "all";
-    const state = readPlanningState(dir);
-    if (scope.includes("/") && !scope.startsWith("./")) {
-      return {
-        error: "Invalid scope: absolute paths not allowed",
-        code: "INVALID_SCOPE",
-        hint: "Use relative paths like ./src or module name"
-      };
-    }
-    const radar = runImpactRadar(dir, scope !== "all" ? scope : "");
-    const policyViolations = evaluatePolicies(dir, {
-      command: "fd-review-code",
-      file_path: scope !== "all" ? scope : undefined
-    });
-    const workflow = "review-code-flow.md";
-    const config = {
-      agents: [
-        { name: "reviewer", focus: "quality,security,conventions,TDD_discipline", severity: "critical,high" },
-        { name: "researcher", focus: "api contracts,edge cases" },
-        { name: "tester", mode: "coverage" }
-      ],
-      scope,
-      aggregate: {
-        critical: "reviewer.critical + researcher.critical",
-        major: "reviewer.major + researcher.major + tester.missing_tests",
-        minor: "reviewer.minor + tester.minor"
-      },
-      tdd_checks: {
-        new_behavior_without_test: "flag as major",
-        bugfix_without_regression: "flag as critical",
-        implementation_larger_than_tests: "flag as major",
-        refactor_without_green: "flag as block"
-      },
-      impact_radar: radar,
-      policy_violations: policyViolations
-    };
-    if (args?.json) {
-      return {
-        success: true,
-        data: { workflow, config, phase: state.phase },
-        meta: { formatted: "json", timestamp: timestamp() }
-      };
-    }
-    const radarLines = impactRadarSummaryLines(radar);
-    const tableLines = [
-      "\u2500".repeat(50),
-      `Code Review: scope=${scope}`,
-      `Phase ${state.phase} | spawning 3 agents in parallel`,
-      "\u2500".repeat(50),
-      "  reviewer  \u2192 quality, security, conventions",
-      "  researcher \u2192 API contracts, edge cases",
-      "  tester    \u2192 test coverage",
-      ...radarLines,
-      ...policyViolations.length > 0 ? ["\u2500".repeat(50), formatViolations(policyViolations)] : [],
-      "\u2500".repeat(50),
-      "Aggregating results into critical/major/minor report...",
-      "\u2550".repeat(50)
-    ];
-    return {
-      success: true,
-      message: tableLines.join(`
-`),
-      workflow,
-      config,
-      phase: state.phase,
-      impact_radar: radar,
-      meta: { formatted: "table", timestamp: timestamp() }
-    };
-  }
-};
-
-// src/commands/execution/write-docs.ts
-import { existsSync as existsSync36 } from "fs";
-var writeDocsCommand = {
-  name: "fd-write-docs",
-  description: "Explore public APIs \u2014 writer drafts \u2014 reviewer accuracy check \u2014 writer final",
-  async execute(context, args) {
-    const dir = context.directory ?? process.cwd();
-    const sp = statePath(dir);
-    if (!existsSync36(sp)) {
-      return {
-        error: "STATE.md not found. Run /new-project first.",
-        code: "NOT_INITIALIZED"
-      };
-    }
-    const scope = args?.scope || "public";
-    const state = readPlanningState(dir);
-    if (scope.includes("/") && !scope.startsWith("./")) {
-      return {
-        error: "Invalid scope: absolute paths not allowed",
-        code: "INVALID_SCOPE"
-      };
-    }
-    const workflow = "write-docs-flow.md";
-    const config = {
-      agents: [
-        { name: "writer", model: "claude-haiku-4-5", temperature: 0.6, maxSteps: 20 },
-        { name: "reviewer", focus: "accuracy", check: "consistency with actual implementation" }
-      ],
-      phases: [
-        { step: "explore", agent: "writer", action: "discover public APIs and their signatures" },
-        { step: "draft", agent: "writer", action: "generate documentation draft" },
-        { step: "review", agent: "reviewer", action: "verify accuracy against source code" },
-        { step: "finalize", agent: "writer", action: "incorporate reviewer feedback and produce final docs" }
-      ],
-      scope
-    };
-    if (args?.json) {
-      return {
-        success: true,
-        data: { workflow, config, phase: state.phase },
-        meta: { formatted: "json", timestamp: timestamp() }
-      };
-    }
-    const tableLines = [
-      "\u2500".repeat(50),
-      `Write Docs: scope=${scope}`,
-      `Phase ${state.phase} | 4-step workflow`,
-      "\u2500".repeat(50),
-      "  [1] explore  \u2192 discover public APIs",
-      "  [2] draft    \u2192 writer generates draft",
-      "  [3] review   \u2192 reviewer verifies accuracy",
-      "  [4] finalize \u2192 writer produces final",
-      "\u2550".repeat(50)
-    ];
-    return {
-      success: true,
-      message: tableLines.join(`
-`),
-      workflow,
-      config,
-      phase: state.phase,
-      meta: { formatted: "table", timestamp: timestamp() }
-    };
-  }
-};
-
-// src/commands/execution/deploy-check.ts
-import { existsSync as existsSync37 } from "fs";
-var deployCheckCommand = {
-  name: "fd-deploy-check",
-  description: "Parallel tester + reviewer + researcher CVE check \u2014 orchestrator go/no-go decision",
-  async execute(context, args) {
-    const dir = context.directory ?? process.cwd();
-    const sp = statePath(dir);
-    if (!existsSync37(sp)) {
-      return {
-        error: "STATE.md not found. Run /new-project first.",
-        code: "NOT_INITIALIZED"
-      };
-    }
-    const state = readPlanningState(dir);
-    const workflow = "deploy-check-flow.md";
-    const config = {
-      agents: [
-        { name: "tester", budget: 10, action: "run test suite + TDD coverage check" },
-        { name: "reviewer", budget: 8, action: "quality and security review + TDD discipline" },
-        { name: "researcher", budget: 12, action: "CVE check (OSV.dev API, no critical false negatives)" }
-      ],
-      parallel: true,
-      aggregation: {
-        go_signals: ["testResult.passed", "reviewResult.approved", "cveResult.no_critical_cves", "tddResult.all_behaviors_tested"],
-        no_go_signals: ["testResult.failures", "reviewResult.critical_issues", "cveResult.critical_cves_found", "tddResult.missing_tests", "tddResult.bugfix_no_regression"]
-      },
-      decision: {
-        go: "All checks passed \u2014 safe to deploy",
-        no_go: "Deploy blocked by: {blocked_by}"
-      },
-      tdd_aware_checks: {
-        new_feature_changes_have_tests: "verify test delta matches code delta",
-        bugfix_has_regression_coverage: "ensure regression test exists and passes",
-        no_suspicious_test_omissions: "flag if code changed but no corresponding test change",
-        overrides_logged: "fail if TDD override used but not surfaced in review"
-      }
-    };
-    if (args?.json) {
-      return {
-        success: true,
-        data: { workflow, config, phase: state.phase },
-        meta: { formatted: "json", timestamp: timestamp() }
-      };
-    }
-    const tableLines = [
-      "\u2550".repeat(55),
-      `Deploy Check: phase ${state.phase}`,
-      "\u2500".repeat(55),
-      "  Parallel agents (step budget):",
-      "    tester    \u2192 10 steps (run test suite + TDD coverage)",
-      "    reviewer  \u2192  8 steps (quality + security + TDD discipline)",
-      "    researcher \u2192 12 steps (CVE check via OSV.dev)",
-      "\u2500".repeat(55),
-      "  TDD-aware checks:",
-      "    \u2022 new feature changes have corresponding tests",
-      "    \u2022 bugfixes have regression coverage",
-      "    \u2022 test deltas match code deltas",
-      "    \u2022 no suspicious test omissions",
-      "  Aggregating results for go/no-go...",
-      "\u2500".repeat(55),
-      "  GO    signals: test passed, review approved, no critical CVEs",
-      "  NO-GO signals: test failures, critical issues, critical CVEs found",
-      "\u2550".repeat(55)
-    ];
-    return {
-      success: true,
-      message: tableLines.join(`
-`),
-      workflow,
-      config,
-      phase: state.phase,
-      meta: { formatted: "table", timestamp: timestamp() }
-    };
-  }
-};
-
-// src/commands/state/progress.ts
-import { existsSync as existsSync38, readFileSync as readFileSync34 } from "fs";
-var progressCommand = {
-  name: "fd-progress",
-  description: "Display STATE.md, active PLAN.md, and recent RESULT.md files",
-  async execute(context, args) {
-    const dir = context.directory ?? process.cwd();
-    const sp = statePath(dir);
-    if (!existsSync38(sp)) {
-      return {
-        error: "STATE.md not found. Initialize project first with /new-project.",
-        code: "NOT_INITIALIZED",
-        hint: "Run /new-project to initialize the project"
-      };
-    }
-    const stateContent = readFileSync34(sp, "utf-8");
-    const state = parseState(stateContent);
-    const phaseMatch = stateContent.match(/^phase:\s*(\d+)/m);
-    const phase = phaseMatch ? parseInt(phaseMatch[1], 10) : 1;
-    let planContent = null;
-    const planPath = phasePlanPath(dir, phase);
-    if (existsSync38(planPath)) {
-      planContent = readFileSync34(planPath, "utf-8");
-    }
-    const recentResults = [];
-    for (let p = Math.max(1, phase - 2);p <= phase; p++) {
-      const rp = resultPath(dir, p);
-      if (existsSync38(rp)) {
-        recentResults.push({ phase: p, content: readFileSync34(rp, "utf-8") });
-      }
-    }
-    const output = {
-      state,
-      phase,
-      plan_preview: planContent ? planContent.substring(0, 500) : null,
-      recent_results: recentResults.map((r) => ({
-        phase: r.phase,
-        preview: r.content.substring(0, 200)
-      })),
-      last_updated: state.last_updated || timestamp()
-    };
-    if (args?.json) {
-      return {
-        success: true,
-        data: output,
-        meta: { formatted: "json", timestamp: timestamp() }
-      };
-    }
-    const tableLines = [
-      "\u2550".repeat(60),
-      `Phase: ${phase}  |  Status: ${state.status || "unknown"}  |  Updated: ${output.last_updated}`,
-      "\u2500".repeat(60)
-    ];
-    if (planContent) {
-      const stepsComplete = (stateContent.match(/steps_complete:\s*\[([^\]]*)\]/)?.[1] || "").split(",").filter((s) => s.trim()).length;
-      const totalSteps = (planContent.match(/Step\s+\d+/g) || []).length;
-      tableLines.push(`Plan: ${totalSteps} steps (${stepsComplete} complete)`);
-    } else {
-      tableLines.push("Plan: No active plan");
-    }
-    if (recentResults.length > 0) {
-      tableLines.push(`Recent results: ${recentResults.map((r) => `Phase ${r.phase}`).join(", ")}`);
-    }
-    tableLines.push("\u2550".repeat(60));
-    return {
-      success: true,
-      message: tableLines.join(`
-`),
-      data: output,
-      meta: { formatted: "table", timestamp: timestamp() }
-    };
-  }
-};
-
-// src/commands/state/resume.ts
-import { existsSync as existsSync39, readFileSync as readFileSync35 } from "fs";
-import { join as join31 } from "path";
-var resumeCommand = {
-  name: "fd-resume",
-  description: "Reload STATE.md + last PLAN.md + DISCUSS.md \u2014 brief user, PAUSE for confirmation, then continue from where stopped",
-  async execute(context, args) {
-    const dir = context.directory ?? process.cwd();
-    const sp = statePath(dir);
-    const pd = planningDir(dir);
-    if (!existsSync39(sp)) {
-      return {
-        error: "STATE.md not found. Run /new-project first to initialize the project.",
-        code: "NOT_INITIALIZED"
-      };
-    }
-    const stateContent = readFileSync35(sp, "utf-8");
-    const phaseMatch = stateContent.match(/^phase:\s*(\d+)/m);
-    if (!phaseMatch) {
-      return {
-        error: "No phase found in STATE.md. Project may be corrupted.",
-        code: "CORRUPTED"
-      };
-    }
-    const phase = parseInt(phaseMatch[1], 10);
-    const state = parseState(stateContent);
-    const planFile = state.plan_file || phasePlanPath(dir, phase);
-    const discussFile = join31(pd, "phases", `phase-${phase}`, "DISCUSS.md");
-    let planContent = null;
-    let discussContent = null;
-    if (existsSync39(planFile)) {
-      planContent = readFileSync35(planFile, "utf-8");
-    }
-    if (existsSync39(discussFile)) {
-      discussContent = readFileSync35(discussFile, "utf-8");
-    }
-    const stepsCompleteMatch = stateContent.match(/^steps_complete:\s*\[([^\]]*)\]/m);
-    const stepsComplete = stepsCompleteMatch ? stepsCompleteMatch[1].split(",").filter((s) => s.trim()) : [];
-    const stepsPendingMatch = stateContent.match(/^steps_pending:\s*\[([^\]]*)\]/m);
-    const stepsPending = stepsPendingMatch ? stepsPendingMatch[1].split(",").filter((s) => s.trim()) : [];
-    const lastActionMatch = stateContent.match(/^last_action:\s*"?([^"\n]+)"?/m);
-    const lastAction = lastActionMatch ? lastActionMatch[1] : "unknown";
-    const stepsDone = stepsComplete.length;
-    const stepsTotal = stepsDone + stepsPending.length;
-    if (args?.yes) {
-      args = { ...args, confirm: true };
-    }
-    if (args?.confirm === false) {
-      return skipResponse("session-resume");
-    }
-    if (!args?.confirm) {
-      const briefing = [
-        "\u2550".repeat(55),
-        `RESUME \u2014 Phase ${phase} Brief`,
-        "\u2550".repeat(55),
-        "",
-        `Last session ended at step ${stepsDone}/${stepsTotal}.`,
-        "",
-        `Completed (${stepsDone}):`,
-        ...stepsComplete.map((s) => `  \u2713 Step ${s}`),
-        "",
-        `Next (${stepsPending.length}):`,
-        ...stepsPending.slice(0, 5).map((s) => `  \u25CB Step ${s}`),
-        ...stepsPending.length > 5 ? [`  ... and ${stepsPending.length - 5} more`] : [],
-        "",
-        `Last action: ${lastAction}`,
-        "",
-        "\u2500".repeat(55),
-        "Type CONFIRM to resume from where you left off",
-        "\u2550".repeat(55)
-      ];
-      return {
-        success: true,
-        message: briefing.join(`
-`),
-        position: {
-          steps_done: stepsDone,
-          steps_remaining: stepsPending.length,
-          last_action: lastAction
-        },
-        status: "AWAITING_CONFIRM",
-        phase,
-        next_step: stepsPending[0] ? `Step ${stepsPending[0]}` : "All steps complete"
-      };
-    }
-    const restored = {
-      state: { phase, status: state.status, steps_complete: stepsComplete, steps_pending: stepsPending },
-      plan: planContent,
-      discuss: discussContent,
-      position: {
-        steps_done: stepsDone,
-        steps_remaining: stepsPending.length,
-        last_action: lastAction
-      }
-    };
-    const message = [
-      `\u2713 Resumed phase ${phase}: ${state.status}`,
-      `${stepsPending.length} steps remaining`,
-      `Last action: ${lastAction}`,
-      `Next: Step ${stepsPending[0] || "none"}`
-    ].join(" | ");
-    return {
-      success: true,
-      message,
-      restored,
-      meta: { formatted: "table", timestamp: timestamp() }
-    };
-  }
-};
-
-// src/commands/state/checkpoint.ts
-import { readFileSync as readFileSync36, writeFileSync as writeFileSync19, existsSync as existsSync40 } from "fs";
-var checkpointCommand = {
-  name: "fd-checkpoint",
-  description: "Force-save current state to STATE.md \u2014 safe to close session",
-  async execute(context, args) {
-    const dir = context.directory ?? process.cwd();
-    const sp = statePath(dir);
-    if (!existsSync40(sp)) {
-      return { error: "STATE.md not found. Initialize project first with /new-project." };
-    }
-    if (!args?.yes) {
-      return {
-        ...confirmPrompt("checkpoint-save", "Save checkpoint to STATE.md? [y/n]"),
-        saved_to: sp
-      };
-    }
-    let content = readFileSync36(sp, "utf-8");
-    const updated = timestamp();
-    if (content.includes("last_updated:")) {
-      content = content.replace(/^last_updated:.*/m, `last_updated: "${updated}"`);
-    }
-    if (content.includes("**Last updated:**")) {
-      content = content.replace(/\*\*Last updated:\*\*.*/, `**Last updated:** ${updated}`);
-    }
-    if (content.includes("## Session History")) {
-      const checkpointEntry = `- ${updated} \u2014 Checkpoint saved`;
-      content = content.replace(/(\n## Session History\n)/, `$1${checkpointEntry}
-`);
-    }
-    writeFileSync19(sp, content, "utf-8");
-    return {
-      success: true,
-      message: `Checkpoint saved at ${updated}`,
-      saved_to: sp
-    };
-  }
-};
-
-// src/commands/state/workspace-commands.ts
-import { readFileSync as readFileSync37, writeFileSync as writeFileSync20, existsSync as existsSync41 } from "fs";
-import { join as join32, resolve as resolve3 } from "path";
-function getRepoName2(repoPath) {
-  return repoPath.split(/[/\\]/).pop() || repoPath;
-}
-function parseWorkspaceState2(content) {
-  const result = {};
-  for (const line of content.split(`
-`)) {
-    const kvMatch = line.match(/^\*\*([^:]+):\*\*\s*(.+)/);
-    if (kvMatch) {
-      result[kvMatch[1].trim()] = kvMatch[2].trim();
-    }
-  }
-  return result;
-}
-function readRepoState(repoPath) {
-  const sp = statePath(repoPath);
-  if (!existsSync41(sp))
-    return null;
-  const content = readFileSync37(sp, "utf-8");
-  return parseWorkspaceState2(content);
-}
-async function listSubRepos(dir, subRepos, workspaceRoot) {
-  const configPath = join32(workspaceRoot, ".planning", "config.json");
-  const resolved = resolveSubRepos(configPath, subRepos);
-  const repos = [];
-  for (const repoPath of resolved) {
-    const repoName = getRepoName2(repoPath);
-    const planningPath = planningDir(repoPath);
-    const hasPlanning = existsSync41(planningPath);
-    repos.push({
-      name: repoName,
-      path: repoPath,
-      status: hasPlanning ? "active" : "not_initialized"
-    });
-  }
-  return repos;
-}
-function renderStatusTable(repos, repoStates) {
-  const lines = [];
-  lines.push("\u2550".repeat(60));
-  lines.push("Workspace Status");
-  lines.push("\u2500".repeat(60));
-  const header = "  Repo                  | Phase    | Status      | Progress";
-  lines.push(header);
-  lines.push("\u2500".repeat(60));
-  for (const repo of repos) {
-    const state = repoStates[repo.name];
-    const repoName = repo.name.padEnd(20);
-    let phase = "\u2014".padEnd(8);
-    let status = repo.status.padEnd(10);
-    let progress = "N/A".padEnd(15);
-    if (repo.status === "active" && state) {
-      if (state.phase)
-        phase = String(state.phase).padEnd(8);
-      if (state.status)
-        status = String(state.status).padEnd(10);
-      if (state.progress) {
-        const p = state.progress;
-        const percent = p.percent;
-        if (percent !== undefined) {
-          progress = `${percent}%`.padEnd(15);
-        }
-      }
-    }
-    lines.push(`  ${repoName} | ${phase} | ${status} | ${progress}`);
-  }
-  lines.push("\u2550".repeat(60));
-  const notInitialized = repos.filter((r) => r.status === "not_initialized");
-  if (notInitialized.length > 0) {
-    lines.push("");
-    lines.push(`\u26A0 ${notInitialized.length} repo(s) not initialized: ${notInitialized.map((r) => r.name).join(", ")}`);
-    lines.push("Run /workspace add to add repos, or /workspace sync to sync state.");
-  }
-  return lines;
-}
-var statusCommand = {
-  name: "fd-workspace status",
-  description: "Display workspace overview: all repos, their current phase, status, and progress",
-  async execute(context, args) {
-    const dir = context.directory ?? process.cwd();
-    const workspaceRoot = findWorkspaceRoot(dir);
-    if (!workspaceRoot) {
-      return { error: "Workspace root not found. No config.json with sub_repos found." };
-    }
-    const config = getWorkspaceConfig(dir);
-    if (!config) {
-      return { error: "Could not read workspace config." };
-    }
-    const subRepos = config.sub_repos || [];
-    if (subRepos.length === 0) {
-      return {
-        success: true,
-        message: "No sub-repos configured. Add repos with /workspace add <path> or configure sub_repos in config.json."
-      };
-    }
-    const repos = await listSubRepos(dir, subRepos, workspaceRoot);
-    const repoStates = {};
-    for (const repo of repos) {
-      if (repo.status === "active") {
-        repoStates[repo.name] = readRepoState(repo.path) || {};
-      }
-    }
-    const tableLines = renderStatusTable(repos, repoStates);
-    return {
-      success: true,
-      message: tableLines.join(`
-`),
-      data: {
-        workspace_root: workspaceRoot,
-        workspace_mode: config.workspace_mode,
-        repos: repos.map((r) => ({ name: r.name, status: r.status, state: repoStates[r.name] || null }))
-      }
-    };
-  }
-};
-var syncCommand = {
-  name: "fd-workspace sync",
-  description: "Sync workspace root STATE.md with all sub-repo states (shared mode)",
-  async execute(context) {
-    const dir = context.directory ?? process.cwd();
-    const workspaceRoot = findWorkspaceRoot(dir);
-    if (!workspaceRoot) {
-      return { error: "No workspace found. Ensure config.json has sub_repos configured." };
-    }
-    const config = getWorkspaceConfig(dir);
-    if (!config) {
-      return { error: "Could not read workspace config." };
-    }
-    if (config.workspace_mode === "per-repo") {
-      return {
-        success: true,
-        message: "Sync not needed in per-repo mode. Each repo manages its own .planning/."
-      };
-    }
-    const subRepos = config.sub_repos || [];
-    const repos = await listSubRepos(dir, subRepos, workspaceRoot);
-    const activeRepos = repos.filter((r) => r.status === "active");
-    if (activeRepos.length === 0) {
-      return {
-        success: true,
-        message: "No active repos to sync."
-      };
-    }
-    const tableLines = ["\u2550".repeat(60), "Workspace Sync Results", "\u2500".repeat(60)];
-    let syncCount = 0;
-    for (const repo of activeRepos) {
-      const state = readRepoState(repo.path);
-      if (state) {
-        syncCount++;
-        const phase = state.phase ? String(state.phase) : "\u2014";
-        const status = state.status ? String(state.status) : "unknown";
-        tableLines.push(`  ${repo.name.padEnd(22)} | Phase ${phase.padEnd(4)} | ${status}`);
-      }
-    }
-    let workspaceStateContent = "";
-    const workspaceStatePath = statePath(workspaceRoot);
-    if (existsSync41(workspaceStatePath)) {
-      workspaceStateContent = readFileSync37(workspaceStatePath, "utf-8");
-    } else {
-      workspaceStateContent = `---
-
-## Sub-Repo Status
-`;
-    }
-    const repoEntries = activeRepos.map((r) => {
-      const s = readRepoState(r.path);
-      return `**${r.name}:** Phase ${s?.phase ?? "?"} | ${s?.status ?? "?"} | Updated ${timestamp()}`;
-    }).join(`
-`);
-    if (workspaceStateContent.includes("## Sub-Repo Status")) {
-      workspaceStateContent = workspaceStateContent.replace(/## Sub-Repo Status\n[\s\S]*/, `## Sub-Repo Status
-${repoEntries}
-`);
-    } else {
-      workspaceStateContent += `
-## Sub-Repo Status
-${repoEntries}
-`;
-    }
-    writeFileSync20(workspaceStatePath, workspaceStateContent, "utf-8");
-    tableLines.push("\u2550".repeat(60));
-    tableLines.push(`Sync complete. ${syncCount}/${activeRepos.length} repos synchronized.`);
-    tableLines.push(`Workspace STATE.md updated at: ${workspaceRoot}`);
-    return {
-      success: true,
-      message: tableLines.join(`
-`)
-    };
-  }
-};
-var switchCommand = {
-  name: "fd-workspace switch",
-  description: "Switch current active repo in workspace context",
-  async execute(context, args) {
-    const dir = context.directory ?? process.cwd();
-    if (!args?.repo) {
-      return { error: "Repo name required. Usage: /workspace switch [repo]" };
-    }
-    const workspaceRoot = findWorkspaceRoot(dir);
-    if (!workspaceRoot) {
-      return { error: "No workspace found. Ensure config.json has sub_repos configured." };
-    }
-    const config = getWorkspaceConfig(dir);
-    if (!config) {
-      return { error: "Could not read workspace config." };
-    }
-    const subRepos = config.sub_repos || [];
-    const resolved = resolveSubRepos(join32(workspaceRoot, ".planning", "config.json"), subRepos);
-    const targetPath = resolved.find((p) => getRepoName2(p) === args.repo);
-    if (!targetPath) {
-      return { error: `Repo '${args.repo}' not found in workspace sub_repos.` };
-    }
-    const workspaceStatePath = statePath(workspaceRoot);
-    let content = existsSync41(workspaceStatePath) ? readFileSync37(workspaceStatePath, "utf-8") : `---
-
-`;
-    const currentRepoLine = `**current_repo:** ${args.repo}`;
-    if (content.includes("**current_repo:**")) {
-      content = content.replace(/\*\*current_repo:\*\*.*/m, currentRepoLine);
-    } else {
-      content = content.replace(/^---\n/, `---
-
-${currentRepoLine}
-`);
-    }
-    writeFileSync20(workspaceStatePath, content, "utf-8");
-    return {
-      success: true,
-      message: `Switched to repo '${args.repo}'. Subsequent commands will target this repo.`
-    };
-  }
-};
-var addCommand = {
-  name: "fd-workspace add",
-  description: "Add a repository path to workspace sub_repos",
-  async execute(context, args) {
-    const dir = context.directory ?? process.cwd();
-    if (!args?.path) {
-      return { error: "Path required. Usage: /workspace add [path]" };
-    }
-    const workspaceRoot = findWorkspaceRoot(dir);
-    if (!workspaceRoot) {
-      return { error: "No workspace found. Ensure config.json has sub_repos configured." };
-    }
-    const resolvedPath = resolve3(dir, args.path);
-    const planningPath = planningDir(resolvedPath);
-    if (!existsSync41(planningPath)) {
-      return { error: "Path does not have a .planning/ directory. Run /new-project in that repo first." };
-    }
-    const configPath = join32(workspaceRoot, ".planning", "config.json");
-    let configContent = readFileSync37(configPath, "utf-8");
-    let config = JSON.parse(configContent);
-    if (!config.sub_repos) {
-      config.sub_repos = [];
-    }
-    if (!config.sub_repos.includes(args.path)) {
-      config.sub_repos.push(args.path);
-      configContent = JSON.stringify(config, null, 2);
-      writeFileSync20(configPath, configContent, "utf-8");
-    }
-    return {
-      success: true,
-      message: `Added '${args.path}' to workspace. Run /workspace sync to include it in workspace state.`
-    };
-  }
-};
-var removeCommand = {
-  name: "fd-workspace remove",
-  description: "Remove a repository from workspace sub_repos (by repo name, not path)",
-  async execute(context, args) {
-    const dir = context.directory ?? process.cwd();
-    if (!args?.repo) {
-      return { error: "Repo name required. Usage: /workspace remove [repo]" };
-    }
-    const workspaceRoot = findWorkspaceRoot(dir);
-    if (!workspaceRoot) {
-      return { error: "No workspace found. Ensure config.json has sub_repos configured." };
-    }
-    const configPath = join32(workspaceRoot, ".planning", "config.json");
-    const configContent = readFileSync37(configPath, "utf-8");
-    const config = JSON.parse(configContent);
-    if (!config.sub_repos || !Array.isArray(config.sub_repos)) {
-      return { error: `Repo '${args.repo}' not found in workspace sub_repos.` };
-    }
-    const resolved = resolveSubRepos(configPath, config.sub_repos);
-    const targetPath = resolved.find((p) => getRepoName2(p) === args.repo);
-    if (!targetPath) {
-      return { error: `Repo '${args.repo}' not found in workspace sub_repos.` };
-    }
-    const originalPath = config.sub_repos.find((p) => {
-      const resolvedP = resolve3(workspaceRoot, p);
-      return resolvedP === targetPath || getRepoName2(resolvedP) === args.repo;
-    });
-    if (originalPath) {
-      config.sub_repos = config.sub_repos.filter((p) => p !== originalPath);
-      writeFileSync20(configPath, JSON.stringify(config, null, 2), "utf-8");
-    }
-    return {
-      success: true,
-      message: `Removed '${args.repo}' from workspace. Files unchanged.`
-    };
-  }
-};
-var defaultCommand = {
-  name: "fd-workspace",
-  description: "Workspace management commands (status, sync, switch, add, remove)",
-  async execute(context, args) {
-    return statusCommand.execute(context, args);
-  }
-};
-var workspaceCommands = [
-  statusCommand,
-  syncCommand,
-  switchCommand,
-  addCommand,
-  removeCommand,
-  defaultCommand
-];
-
-// src/commands/state/multi-repo.ts
-import { readFileSync as readFileSync38, writeFileSync as writeFileSync21, existsSync as existsSync42, mkdirSync as mkdirSync16 } from "fs";
-import { join as join33, resolve as resolve4, basename } from "path";
-import { execSync as execSync2 } from "child_process";
-var VALID_ROLES = ["upstream-api", "downstream-consumer", "shared-lib", "gateway", "worker"];
-function configPath(dir) {
-  return join33(planningDir(dir), "config.json");
-}
-function readConfig(dir) {
-  const cfg = configPath(dir);
-  if (!existsSync42(cfg)) {
-    return { multi_repos: [] };
-  }
-  try {
-    const parsed = JSON.parse(readFileSync38(cfg, "utf-8"));
-    if (!Array.isArray(parsed.multi_repos))
-      parsed.multi_repos = [];
-    return parsed;
-  } catch {
-    return { multi_repos: [] };
-  }
-}
-function writeConfig(dir, config) {
-  const pd = planningDir(dir);
-  if (!existsSync42(pd))
-    mkdirSync16(pd, { recursive: true });
-  writeFileSync21(configPath(dir), JSON.stringify(config, null, 2), "utf-8");
-}
-function getGitBranch(repoPath) {
-  try {
-    return execSync2(`git -C "${repoPath}" branch --show-current`, {
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "ignore"]
-    }).trim() || "\u2014";
-  } catch {
-    return "\u2014";
-  }
-}
-function renderListTable(repos) {
-  if (repos.length === 0) {
-    return "No repos registered. Use /fd-multi-repo --add <path> <role> to add one.";
-  }
-  const sep = "\u2500".repeat(90);
-  const header = `  ${"Name".padEnd(20)}  ${"Path".padEnd(25)}  ${"Role".padEnd(20)}  ${"Stack".padEnd(16)}  Team`;
-  const rows = repos.map((r) => `  ${r.name.padEnd(20)}  ${r.path.padEnd(25)}  ${r.role.padEnd(20)}  ${r.tech_stack.padEnd(16)}  ${r.owner_team}`);
-  const lines = [
-    "\u2550".repeat(90),
-    `Multi-Repo Registry (.planning/config.json) \u2014 ${repos.length} repo(s)`,
-    sep,
-    header,
-    sep,
-    ...rows,
-    "\u2550".repeat(90),
-    `
-Run /fd-multi-repo --status to check path health.`
-  ];
-  return lines.join(`
-`);
-}
-function renderStatusTable2(repos, dir) {
-  if (repos.length === 0) {
-    return "No repos registered. Use /fd-multi-repo --add <path> <role> to add one.";
-  }
-  const sep = "\u2500".repeat(80);
-  const header = `  ${"Name".padEnd(18)}  ${"Path".padEnd(22)}  ${"Exists".padEnd(7)}  ${"Branch".padEnd(18)}  .planning/`;
-  const rows = repos.map((r) => {
-    const absPath = resolve4(dir, r.path);
-    const exists = existsSync42(absPath);
-    const branch = exists ? getGitBranch(absPath) : "\u2014";
-    const hasPlanning = exists && existsSync42(planningDir(absPath));
-    return `  ${r.name.padEnd(18)}  ${r.path.padEnd(22)}  ${exists ? "\u2705" : "\u274C".padEnd(6)}  ${branch.padEnd(18)}  ${hasPlanning ? "\u2705" : "\u274C"}`;
-  });
-  const warnings = [];
-  for (const r of repos) {
-    const absPath = resolve4(dir, r.path);
-    if (!existsSync42(absPath))
-      warnings.push(`Warning: ${r.name} path does not exist on disk.`);
-    else if (!existsSync42(planningDir(absPath)))
-      warnings.push(`Warning: ${r.name} has no .planning/ \u2014 cross-repo planning context unavailable.`);
-  }
-  const lines = [
-    "\u2550".repeat(80),
-    "Multi-Repo Status",
-    sep,
-    header,
-    sep,
-    ...rows,
-    "\u2550".repeat(80),
-    ...warnings.length > 0 ? ["", ...warnings] : []
-  ];
-  return lines.join(`
-`);
-}
-var multiRepoCommand = {
-  name: "fd-multi-repo",
-  description: "Manage multi-repo registry in .planning/config.json \u2014 add, list, status, remove repos",
-  async execute(context, args) {
-    const dir = context.directory ?? process.cwd();
-    if (args?.add) {
-      const repoPath = args.add;
-      const role = args.role;
-      if (!role || !VALID_ROLES.includes(role)) {
-        return {
-          error: `Role is required and must be one of: ${VALID_ROLES.join(", ")}`,
-          code: "INVALID_ROLE",
-          hint: `Usage: /fd-multi-repo --add <path> --role <role>`
-        };
-      }
-      const name = args.name || basename(resolve4(dir, repoPath));
-      const config2 = readConfig(dir);
-      if (config2.multi_repos.some((r) => r.name === name || r.path === repoPath)) {
-        return {
-          error: `Repo '${name}' (or path '${repoPath}') is already registered.`,
-          code: "ALREADY_EXISTS"
-        };
-      }
-      const entry = {
-        name,
-        path: repoPath,
-        role,
-        tech_stack: args.tech_stack ?? "",
-        owner_team: args.owner_team ?? "",
-        added_at: timestamp()
-      };
-      config2.multi_repos.push(entry);
-      writeConfig(dir, config2);
-      return {
-        success: true,
-        message: `Registered '${name}' (${role}) at ${repoPath}.
-Run /fd-multi-repo --status to verify path health.`,
-        data: entry
-      };
-    }
-    if (args?.remove) {
-      const config2 = readConfig(dir);
-      const before = config2.multi_repos.length;
-      config2.multi_repos = config2.multi_repos.filter((r) => r.name !== args.remove);
-      if (config2.multi_repos.length === before) {
-        return {
-          error: `Repo '${args.remove}' not found in registry.`,
-          code: "NOT_FOUND",
-          hint: `Run /fd-multi-repo --list to see registered repos.`
-        };
-      }
-      writeConfig(dir, config2);
-      return {
-        success: true,
-        message: `Removed '${args.remove}' from registry. Files on disk are unchanged.`
-      };
-    }
-    if (args?.status) {
-      const config2 = readConfig(dir);
-      if (args.json)
-        return { success: true, data: config2.multi_repos };
-      return { success: true, message: renderStatusTable2(config2.multi_repos, dir) };
-    }
-    const config = readConfig(dir);
-    if (args?.json)
-      return { success: true, data: config.multi_repos };
-    return { success: true, message: renderListTable(config.multi_repos) };
-  }
-};
-
-// src/commands/intelligence/impact-radar.ts
-import { existsSync as existsSync43, readFileSync as readFileSync39 } from "fs";
-import { join as join34 } from "path";
-var impactRadarCommand = {
-  name: "fd-impact-radar",
-  description: "Change Impact Radar \u2014 predict which files, modules, APIs, tests, and DB paths are likely affected before the AI edits anything",
-  async execute(context, args) {
-    const dir = context.directory ?? process.cwd();
-    const sp = statePath(dir);
-    if (!existsSync43(sp)) {
-      return { error: "STATE.md not found. Run /new-project first.", code: "NOT_INITIALIZED" };
-    }
-    const change = args?.change || "";
-    const scope = args?.scope || "all";
-    const state = readPlanningState(dir);
-    const cd = codebaseDir(dir);
-    const archPath = join34(cd, "ARCHITECTURE.md");
-    const stackPath = join34(cd, "STACK.md");
-    const architectureContext = existsSync43(archPath) ? readFileSync39(archPath, "utf-8").substring(0, 800) : null;
-    const stackContext = existsSync43(stackPath) ? readFileSync39(stackPath, "utf-8").substring(0, 400) : null;
-    const volatilityPath2 = join34(cd, "VOLATILITY.json");
-    let hotspots = [];
-    if (existsSync43(volatilityPath2)) {
-      try {
-        const v = JSON.parse(readFileSync39(volatilityPath2, "utf-8"));
-        hotspots = (v.entries ?? []).filter((e) => e.stability === "volatile" || e.stability === "critical").map((e) => e.path).slice(0, 10);
-      } catch {}
-    }
-    const config = {
-      agents: [
-        { name: "researcher", role: "trace dependency graph from changed paths" },
-        { name: "architect", role: "identify API contracts and service boundaries at risk" },
-        { name: "tester", role: "find test files that cover the affected paths" }
-      ],
-      change_description: change,
-      scope,
-      architecture_context: architectureContext,
-      stack_context: stackContext,
-      known_hotspots: hotspots
-    };
-    const workflow = "impact-radar-flow.md";
-    if (args?.json) {
-      return { success: true, data: { workflow, config, phase: state.phase }, meta: { formatted: "json", timestamp: timestamp() } };
-    }
-    const lines = [
-      "\u2550".repeat(58),
-      "Change Impact Radar",
-      "\u2500".repeat(58),
-      `  Change: ${change || "(describe with --change)"}`,
-      `  Scope:  ${scope}`,
-      `  Hotspot files tracked: ${hotspots.length}`,
-      "\u2500".repeat(58),
-      "  researcher  \u2192 dependency graph scan",
-      "  architect   \u2192 API / service boundary risk",
-      "  tester      \u2192 affected test coverage",
-      "\u2500".repeat(58),
-      "  Outputs: affected files, APIs, tests, DB paths",
-      "\u2550".repeat(58)
-    ];
-    return { success: true, message: lines.join(`
-`), workflow, config, phase: state.phase, meta: { formatted: "table", timestamp: timestamp() } };
-  }
-};
-
-// src/commands/intelligence/blast-radius.ts
-import { existsSync as existsSync44, readFileSync as readFileSync40 } from "fs";
-import { join as join35 } from "path";
-var blastRadiusCommand = {
-  name: "fd-blast-radius",
-  description: "Blast Radius Preview \u2014 show likely downstream consequences of a proposed change including hidden dependencies and fragile integration points",
-  async execute(context, args) {
-    const dir = context.directory ?? process.cwd();
-    const sp = statePath(dir);
-    if (!existsSync44(sp)) {
-      return { error: "STATE.md not found. Run /new-project first.", code: "NOT_INITIALIZED" };
-    }
-    const change = args?.change || "";
-    const depth = parseInt(args?.depth ?? "2", 10);
-    const state = readPlanningState(dir);
-    const cd = codebaseDir(dir);
-    const memoryPath2 = join35(cd, "MEMORY.json");
-    let moduleCount = 0;
-    if (existsSync44(memoryPath2)) {
-      try {
-        const m = JSON.parse(readFileSync40(memoryPath2, "utf-8"));
-        moduleCount = Object.keys(m.nodes ?? {}).length;
-      } catch {}
-    }
-    const failuresPath2 = join35(cd, "FAILURES.json");
-    let knownFragileCount = 0;
-    if (existsSync44(failuresPath2)) {
-      try {
-        const f = JSON.parse(readFileSync40(failuresPath2, "utf-8"));
-        knownFragileCount = (f.entries ?? []).filter((e) => e.recurrence_count >= 2).length;
-      } catch {}
-    }
-    const config = {
-      agents: [
-        { name: "architect", role: "trace dependency graph to depth " + depth + ", flag integration points" },
-        { name: "researcher", role: "identify hidden couplings, shared state, event flows" },
-        { name: "tester", role: "predict test breakage categories (unit, integration, e2e)" }
-      ],
-      change_description: change,
-      traversal_depth: depth,
-      repo_memory_nodes: moduleCount,
-      known_fragile_patterns: knownFragileCount,
-      workflow: "blast-radius-flow.md"
-    };
-    if (args?.json) {
-      return { success: true, data: { config, phase: state.phase }, meta: { formatted: "json", timestamp: timestamp() } };
-    }
-    const lines = [
-      "\u2550".repeat(58),
-      "Blast Radius Preview",
-      "\u2500".repeat(58),
-      `  Change:    ${change || "(describe with --change)"}`,
-      `  Depth:     ${depth} hops`,
-      `  Graph:     ${moduleCount} nodes in Repo Memory`,
-      `  Fragile:   ${knownFragileCount} recurring failure patterns`,
-      "\u2500".repeat(58),
-      "  architect  \u2192 dependency traversal + integration risk",
-      "  researcher \u2192 hidden couplings, shared state",
-      "  tester     \u2192 predicted test breakage",
-      "\u2500".repeat(58),
-      "  Output: blast-radius report with downstream consequence map",
-      "\u2550".repeat(58)
-    ];
-    return { success: true, message: lines.join(`
-`), config, phase: state.phase, meta: { formatted: "table", timestamp: timestamp() } };
-  }
-};
-
-// src/commands/intelligence/translate-intent.ts
-import { existsSync as existsSync45 } from "fs";
-var translateIntentCommand = {
-  name: "fd-translate-intent",
-  description: "Intent-to-Change Translator \u2014 converts vague requests like 'make checkout faster' into 3\u20135 concrete, ranked implementation options with tradeoffs, assumptions, and clarifying questions",
-  async execute(context, args) {
-    const dir = context.directory ?? process.cwd();
-    const sp = statePath(dir);
-    if (!existsSync45(sp)) {
-      return { error: "STATE.md not found. Run /fd-new-project first.", code: "NOT_INITIALIZED" };
-    }
-    if (!args?.intent) {
-      return {
-        error: 'No intent provided. Use: /fd-translate-intent --intent "make checkout faster"',
-        code: "NO_INTENT",
-        hint: "Describe what you want in plain language"
-      };
-    }
-    const state = readPlanningState(dir);
-    const config = {
-      intent: args.intent,
-      agents: [
-        { name: "architect", role: "decompose intent into 3\u20135 concrete implementation options, each with name, description, files_affected, effort (S/M/L), risk (low/med/high), and tradeoffs" },
-        { name: "researcher", role: "fetch relevant codebase context, prior art, and constraints for each option" },
-        { name: "reviewer", role: "rank options by impact/effort/risk; select recommended option; list assumptions and clarifying questions" }
-      ],
-      output_format: {
-        options: "ranked list (1\u20135) with: name, description, files_affected, effort, risk, tradeoffs",
-        recommended_option: "index of recommended option with rationale (e.g. 'Option 2 \u2014 best risk/effort ratio')",
-        assumptions: "list of assumptions made about the codebase, user intent, or constraints",
-        clarifying_questions: "list any ambiguities that need user input before proceeding"
-      },
-      rank_options: args["rank-options"] !== false,
-      workflow: "translate-intent-flow.md"
-    };
-    if (args?.json) {
-      return { success: true, data: { config, phase: state.phase }, meta: { formatted: "json", timestamp: timestamp() } };
-    }
-    const lines = [
-      "\u2550".repeat(62),
-      "fd-translate-intent",
-      "\u2500".repeat(62),
-      `  Intent: "${args.intent}"`,
-      "\u2500".repeat(62),
-      "  architect  \u2192 decompose into 3\u20135 concrete options",
-      "  researcher \u2192 fetch codebase context + prior art",
-      "  reviewer   \u2192 rank by impact/effort/risk",
-      "\u2500".repeat(62),
-      "  Output:",
-      "    \u2022 ranked options table (name, effort, risk, tradeoffs)",
-      "    \u2022 recommended option with rationale",
-      "    \u2022 assumptions the agent made",
-      "    \u2022 clarifying questions if intent is ambiguous",
-      "\u2550".repeat(62)
-    ];
-    return { success: true, message: lines.join(`
-`), config, phase: state.phase, meta: { formatted: "table", timestamp: timestamp() } };
-  }
-};
-
-// src/commands/intelligence/volatility-map-cmd.ts
-import { existsSync as existsSync46 } from "fs";
-import { join as join36 } from "path";
-var volatilityMapCommand = {
-  name: "fd-volatility-map",
-  description: "Codebase Volatility Map \u2014 highlight unstable zones based on git churn, hotfix frequency, and unresolved TODO clusters. Updates .codebase/VOLATILITY.json.",
-  async execute(context, args) {
-    const dir = context.directory ?? process.cwd();
-    const sp = statePath(dir);
-    if (!existsSync46(sp)) {
-      return { error: "STATE.md not found. Run /new-project first.", code: "NOT_INITIALIZED" };
-    }
-    const threshold = args?.threshold ?? "volatile";
-    const state = readPlanningState(dir);
-    const cd = codebaseDir(dir);
-    const existingPath = join36(cd, "VOLATILITY.json");
-    const hasExisting = existsSync46(existingPath);
-    const config = {
-      threshold,
-      agents: [
-        { name: "researcher", role: "run git log --follow to count commits per file (last 90 days)" },
-        { name: "researcher", role: "scan TODO/FIXME/HACK/XXX comments per file" },
-        { name: "researcher", role: "find commits with 'hotfix', 'revert', 'urgent' in message" }
-      ],
-      output_tool: "volatility-map",
-      output_action: "write",
-      output_file: ".codebase/VOLATILITY.json",
-      has_existing_data: hasExisting,
-      workflow: "volatility-map-flow.md"
-    };
-    if (args?.json) {
-      return { success: true, data: { config, phase: state.phase }, meta: { formatted: "json", timestamp: timestamp() } };
-    }
-    const lines = [
-      "\u2550".repeat(60),
-      "Codebase Volatility Map",
-      "\u2500".repeat(60),
-      `  Threshold: ${threshold}+ zones`,
-      `  Existing data: ${hasExisting ? "yes (will update)" : "no (first run)"}`,
-      "\u2500".repeat(60),
-      "  researcher \u2192 git churn analysis (90 days)",
-      "  researcher \u2192 TODO/FIXME/HACK cluster scan",
-      "  researcher \u2192 hotfix/revert commit detection",
-      "\u2500".repeat(60),
-      "  Output: .codebase/VOLATILITY.json + summary of hotspots",
-      "\u2550".repeat(60)
-    ];
-    return { success: true, message: lines.join(`
-`), config, phase: state.phase, meta: { formatted: "table", timestamp: timestamp() } };
-  }
-};
-
-// src/commands/intelligence/regression-predict.ts
-import { existsSync as existsSync47, readFileSync as readFileSync41 } from "fs";
-import { join as join37 } from "path";
-var REGRESSION_CATEGORIES = [
-  "performance",
-  "auth",
-  "schema",
-  "ui-state",
-  "async-flow",
-  "api-contract",
-  "data-integrity",
-  "security",
-  "config",
-  "i18n"
-];
-var regressionPredictCommand = {
-  name: "fd-regression-predict",
-  description: "Regression Prediction \u2014 estimate the most likely regression categories (performance, auth, schema, UI states, async flows) for a proposed change",
-  async execute(context, args) {
-    const dir = context.directory ?? process.cwd();
-    const sp = statePath(dir);
-    if (!existsSync47(sp)) {
-      return { error: "STATE.md not found. Run /new-project first.", code: "NOT_INITIALIZED" };
-    }
-    const change = args?.change || "";
-    const files = args?.files || "";
-    const state = readPlanningState(dir);
-    const cd = codebaseDir(dir);
-    const failuresPath2 = join37(cd, "FAILURES.json");
-    let pastRegressions = [];
-    if (existsSync47(failuresPath2)) {
-      try {
-        const data = JSON.parse(readFileSync41(failuresPath2, "utf-8"));
-        pastRegressions = (data.entries ?? []).flatMap((e) => e.tags ?? []);
-      } catch {}
-    }
-    const config = {
-      change_description: change,
-      affected_files: files ? files.split(",").map((s) => s.trim()) : [],
-      regression_categories: REGRESSION_CATEGORIES,
-      past_regression_signals: pastRegressions.slice(0, 20),
-      agents: [
-        { name: "researcher", role: "map changed code to regression category keywords and patterns" },
-        { name: "tester", role: "estimate coverage gaps per predicted regression category" },
-        { name: "reviewer", role: "rank categories by probability and severity" }
-      ],
-      output_format: {
-        predictions: "ranked list: category, probability (high/med/low), reason, suggested test",
-        top_risk: "single highest-risk regression to watch"
-      },
-      workflow: "regression-predict-flow.md"
-    };
-    if (args?.json) {
-      return { success: true, data: { config, phase: state.phase }, meta: { formatted: "json", timestamp: timestamp() } };
-    }
-    const lines = [
-      "\u2550".repeat(60),
-      "Regression Prediction",
-      "\u2500".repeat(60),
-      `  Change:    ${change || "(describe with --change)"}`,
-      `  Files:     ${files || "(all affected)"}`,
-      `  Categories: ${REGRESSION_CATEGORIES.join(", ")}`,
-      "\u2500".repeat(60),
-      "  researcher \u2192 keyword/pattern mapping",
-      "  tester     \u2192 coverage gap per category",
-      "  reviewer   \u2192 ranked probability + severity",
-      "\u2500".repeat(60),
-      "  Output: regression risk table with suggested tests",
-      "\u2550".repeat(60)
-    ];
-    return { success: true, message: lines.join(`
-`), config, phase: state.phase, meta: { formatted: "table", timestamp: timestamp() } };
-  }
-};
-
-// src/commands/intelligence/test-gap.ts
-import { existsSync as existsSync48 } from "fs";
-var testGapCommand = {
-  name: "fd-test-gap",
-  description: "Test Gap Detector \u2014 identify areas of a proposed change weakly covered by tests and suggest the minimum high-value tests to add first",
-  async execute(context, args) {
-    const dir = context.directory ?? process.cwd();
-    const sp = statePath(dir);
-    if (!existsSync48(sp)) {
-      return { error: "STATE.md not found. Run /new-project first.", code: "NOT_INITIALIZED" };
-    }
-    const scope = args?.scope || "all";
-    const change = args?.change || "";
-    const state = readPlanningState(dir);
-    const cd = codebaseDir(dir);
-    const config = {
-      scope,
-      change_description: change,
-      agents: [
-        { name: "tester", role: "find source files changed with no corresponding test file" },
-        { name: "tester", role: "detect untested branches in changed functions (if/else, error paths)" },
-        { name: "researcher", role: "identify integration boundaries without contract tests" },
-        { name: "reviewer", role: "rank gaps by risk and suggest minimum viable test additions" }
-      ],
-      gap_types: [
-        "missing test file for changed module",
-        "untested error path",
-        "untested branch (if/else/switch)",
-        "no integration test for external call",
-        "no regression test for previously-failed path"
-      ],
-      output_format: {
-        gaps: "ranked list: file, gap_type, risk, suggested_test_name, test_skeleton",
-        minimum_viable_set: "top 3\u20135 tests that give the most coverage per effort"
-      },
-      workflow: "test-gap-flow.md"
-    };
-    if (args?.json) {
-      return { success: true, data: { config, phase: state.phase }, meta: { formatted: "json", timestamp: timestamp() } };
-    }
-    const lines = [
-      "\u2550".repeat(60),
-      "Test Gap Detector",
-      "\u2500".repeat(60),
-      `  Scope:  ${scope}`,
-      `  Change: ${change || "(describe with --change)"}`,
-      "\u2500".repeat(60),
-      "  tester     \u2192 missing test files + untested branches",
-      "  researcher \u2192 integration boundary gaps",
-      "  reviewer   \u2192 ranked gaps + minimum viable test set",
-      "\u2500".repeat(60),
-      "  Output: gap report + top 3\u20135 suggested tests with skeletons",
-      "\u2550".repeat(60)
-    ];
-    return { success: true, message: lines.join(`
-`), config, phase: state.phase, meta: { formatted: "table", timestamp: timestamp() } };
-  }
-};
-
-// src/commands/intelligence/review-route.ts
-import { existsSync as existsSync49 } from "fs";
-var ROUTING_KEYWORDS = {
-  security: ["auth", "token", "password", "crypto", "secret", "jwt", "permission", "rbac", "xss", "sql"],
-  backend: ["api", "route", "controller", "service", "database", "query", "migration"],
-  infra: ["docker", "kubernetes", "terraform", "ci", "cd", "deploy", "helm", "nginx", "aws", "gcp"],
-  "domain-owner": ["business", "billing", "payment", "checkout", "order", "subscription", "pricing"],
-  frontend: ["component", "css", "html", "react", "vue", "angular", "ui", "ux", "style"],
-  data: ["schema", "migration", "model", "index", "constraint", "foreign key", "partition"],
-  devops: ["pipeline", "workflow", ".yml", ".yaml", "action", "cron", "schedule", "artifact"]
-};
-function routeReview(filePaths, trustVerdict) {
-  const routes = new Set;
-  const combined = filePaths.join(" ").toLowerCase();
-  for (const [type, keywords] of Object.entries(ROUTING_KEYWORDS)) {
-    if (keywords.some((kw) => combined.includes(kw)))
-      routes.add(type);
-  }
-  if (trustVerdict === "high-risk")
-    routes.add("security");
-  return Array.from(routes);
-}
-var reviewRouteCommand = {
-  name: "fd-review-route",
-  description: "Human Review Routing \u2014 route risky patches to the right reviewer type (security, backend, infra, domain-owner) based on change nature and patch trust score",
-  async execute(context, args) {
-    const dir = context.directory ?? process.cwd();
-    const sp = statePath(dir);
-    if (!existsSync49(sp)) {
-      return { error: "STATE.md not found. Run /new-project first.", code: "NOT_INITIALIZED" };
-    }
-    const files = args?.files ? args.files.split(",").map((s) => s.trim()) : [];
-    const change = args?.change || "";
-    const state = readPlanningState(dir);
-    let trustVerdict = "safe";
-    if (files.length > 0) {
-      const ts = scorePatch(dir, files[0]);
-      trustVerdict = ts.verdict;
-    }
-    const routes = routeReview(files, trustVerdict);
-    const config = {
-      files,
-      change_description: change,
-      trust_verdict: trustVerdict,
-      routed_to: routes,
-      routing_rationale: routes.map((r) => `${r}: triggered by keywords in file paths/change description`),
-      workflow: "review-route-flow.md"
-    };
-    if (args?.json) {
-      return { success: true, data: { config, phase: state.phase }, meta: { formatted: "json", timestamp: timestamp() } };
-    }
-    const lines = [
-      "\u2550".repeat(60),
-      "Human Review Routing",
-      "\u2500".repeat(60),
-      `  Files:        ${files.length > 0 ? files.join(", ") : "(all changed files)"}`,
-      `  Trust verdict: ${trustVerdict}`,
-      `  Route to:     ${routes.length > 0 ? routes.join(", ") : "general reviewer"}`,
-      "\u2500".repeat(60),
-      "  Routing logic: keyword match + patch trust score",
-      "\u2550".repeat(60)
-    ];
-    return { success: true, message: lines.join(`
-`), config, phase: state.phase, routed_to: routes, meta: { formatted: "table", timestamp: timestamp() } };
-  }
-};
-
-// src/commands/analysis/analyze-change.ts
-import { existsSync as existsSync50, readFileSync as readFileSync43 } from "fs";
-import { join as join38 } from "path";
-var REGRESSION_CATEGORIES2 = [
-  "performance",
-  "auth",
-  "schema",
-  "ui-state",
-  "async-flow",
-  "api-contract",
-  "data-integrity",
-  "security",
-  "config",
-  "i18n"
-];
-var REVIEWER_KEYWORDS = {
-  security: ["auth", "token", "password", "crypto", "jwt", "permission", "xss"],
-  backend: ["api", "route", "controller", "service", "database", "query", "migration"],
-  infra: ["docker", "kubernetes", "terraform", "ci", "deploy", "helm", "aws", "gcp"],
-  "domain-owner": ["billing", "payment", "checkout", "order", "subscription"],
-  frontend: ["component", "css", "react", "vue", "angular", "ui"],
-  data: ["schema", "migration", "model", "index", "constraint"],
-  devops: ["pipeline", "workflow", ".yml", ".yaml", "action", "cron"]
-};
-function routeReviewers(change, files) {
-  const combined = [change, ...files].join(" ").toLowerCase();
-  return Object.entries(REVIEWER_KEYWORDS).filter(([, kws]) => kws.some((kw) => combined.includes(kw))).map(([type]) => type);
-}
-var analyzeChangeCommand = {
-  name: "fd-analyze-change",
-  description: "Pre-change analysis \u2014 runs impact radar, blast radius, regression prediction, test gaps, volatility, and reviewer routing in one report",
-  async execute(context, args) {
-    const dir = context.directory ?? process.cwd();
-    const sp = statePath(dir);
-    const cd = codebaseDir(dir);
-    if (!existsSync50(sp)) {
-      return { error: "STATE.md not found. Run /fd-new-project first.", code: "NOT_INITIALIZED" };
-    }
-    const change = args?.change || "";
-    const scope = args?.scope || "all";
-    const fileList = args?.files ? args.files.split(",").map((s) => s.trim()) : [];
-    const depth = parseInt(args?.depth ?? "2", 10);
-    const runAll = !args?.impact && !args?.["blast-radius"] && !args?.regression && !args?.["test-gap"] && !args?.volatility && !args?.["review-route"] || args?.all === true;
-    const runImpact = runAll || !!args?.impact;
-    const runBlast = runAll || !!args?.["blast-radius"];
-    const runRegression = runAll || !!args?.regression;
-    const runTestGap = runAll || !!args?.["test-gap"];
-    const runVolatility = runAll || !!args?.volatility;
-    const runReviewRoute = runAll || !!args?.["review-route"];
-    const modulesRun = [];
-    const state = readPlanningState(dir);
-    let hotspots = [];
-    let knownFailures = [];
-    let relatedModules = [];
-    let riskFlag = false;
-    if (runImpact && change) {
-      modulesRun.push("impact-radar");
-      const radar = runImpactRadar(dir, change);
-      hotspots = radar.hotspots.map((h) => h.path);
-      knownFailures = radar.known_failures.map((f) => f.id);
-      relatedModules = radar.related_modules.map((m) => m.path);
-      riskFlag = radar.risk_flag;
-    }
-    let moduleCount = 0;
-    let fragileCount = 0;
-    if (runBlast) {
-      modulesRun.push("blast-radius");
-      const memPath = join38(cd, "MEMORY.json");
-      if (existsSync50(memPath)) {
-        try {
-          moduleCount = Object.keys(JSON.parse(readFileSync43(memPath, "utf-8")).nodes ?? {}).length;
-        } catch {}
-      }
-      const failPath = join38(cd, "FAILURES.json");
-      if (existsSync50(failPath)) {
-        try {
-          const data = JSON.parse(readFileSync43(failPath, "utf-8"));
-          fragileCount = (data.entries ?? []).filter((e) => e.recurrence_count >= 2).length;
-        } catch {}
-      }
-    }
-    let pastRegressionSignals = [];
-    if (runRegression) {
-      modulesRun.push("regression-predict");
-      const failPath = join38(cd, "FAILURES.json");
-      if (existsSync50(failPath)) {
-        try {
-          const data = JSON.parse(readFileSync43(failPath, "utf-8"));
-          pastRegressionSignals = (data.entries ?? []).flatMap((e) => e.tags ?? []).slice(0, 20);
-        } catch {}
-      }
-    }
-    const gapTypes = runTestGap ? [
-      "missing test file for changed module",
-      "untested error path",
-      "untested branch (if/else/switch)",
-      "no integration test for external call",
-      "no regression test for previously-failed path"
-    ] : [];
-    if (runTestGap)
-      modulesRun.push("test-gap");
-    let volatileZones = [];
-    if (runVolatility) {
-      modulesRun.push("volatility-map");
-      const volPath = join38(cd, "VOLATILITY.json");
-      if (existsSync50(volPath)) {
-        try {
-          const v = JSON.parse(readFileSync43(volPath, "utf-8"));
-          volatileZones = (v.entries ?? []).filter((e) => e.stability === "volatile" || e.stability === "critical").slice(0, 15);
-        } catch {}
-      }
-    }
-    let reviewers = [];
-    let trustScore = null;
-    let trustVerdict = "safe";
-    if (runReviewRoute) {
-      modulesRun.push("review-route");
-      if (fileList.length > 0) {
-        const ts = scorePatch(dir, fileList[0]);
-        trustScore = ts.score;
-        trustVerdict = ts.verdict;
-      }
-      reviewers = routeReviewers(change, fileList);
-    }
-    const priorFailures = runImpact || runBlast ? lookupPriorFailures(dir, scope, change, 5) : [];
-    const affectedZones = [...new Set([...hotspots, ...volatileZones.map((v) => v.path)])];
-    const riskScore = trustScore ?? Math.max(0, 100 - hotspots.length * 15 - knownFailures.length * 10 - fragileCount * 8);
-    const riskSummary = riskFlag ? `\u26A0 HIGH RISK: ${hotspots.length} volatile zone(s), ${knownFailures.length} known failure(s), ${fragileCount} fragile pattern(s)` : affectedZones.length > 0 ? `\u26A1 MODERATE: ${affectedZones.length} affected zone(s) detected \u2014 review before proceeding` : "\u2713 LOW RISK: No volatile zones or known failures match this change";
-    const config = {
-      change_description: change,
-      scope,
-      files: fileList,
-      modules_run: modulesRun,
-      agents: [
-        runImpact && { name: "researcher", role: "trace dependency graph from changed paths" },
-        runBlast && { name: "architect", role: `trace blast radius to depth ${depth}, flag integration points` },
-        runRegression && { name: "tester", role: "estimate coverage gaps per predicted regression category" },
-        runTestGap && { name: "tester", role: "find source files changed with no test file" },
-        runReviewRoute && { name: "reviewer", role: "rank gaps by risk and confirm routing" }
-      ].filter(Boolean),
-      data: {
-        hotspots,
-        known_failures: knownFailures,
-        related_modules: relatedModules,
-        volatile_zones: volatileZones,
-        fragile_patterns: fragileCount,
-        repo_memory_nodes: moduleCount,
-        regression_categories: runRegression ? REGRESSION_CATEGORIES2 : [],
-        past_regression_signals: pastRegressionSignals,
-        test_gap_types: gapTypes,
-        recommended_reviewers: reviewers,
-        trust_score: trustScore,
-        trust_verdict: trustVerdict,
-        prior_failures: priorFailures.map((f) => f.id)
-      },
-      risk_score: riskScore,
-      risk_summary: riskSummary,
-      traversal_depth: depth
-    };
-    if (args?.json) {
-      return {
-        success: true,
-        data: {
-          modules_run: modulesRun,
-          affected_zones: affectedZones,
-          regression_categories: runRegression ? REGRESSION_CATEGORIES2 : [],
-          test_gap_types: gapTypes,
-          recommended_reviewers: reviewers,
-          risk_summary: riskSummary,
-          risk_score: riskScore,
-          config,
-          phase: state.phase
-        },
-        meta: { formatted: "json", timestamp: timestamp() }
-      };
-    }
-    const lines = [
-      "\u2550".repeat(62),
-      "fd-analyze-change",
-      "\u2500".repeat(62),
-      `  Change:   ${change || "(describe with --change)"}`,
-      `  Scope:    ${scope}`,
-      `  Modules:  ${modulesRun.join(", ") || "none selected"}`,
-      "\u2500".repeat(62)
-    ];
-    if (affectedZones.length > 0) {
-      lines.push(`  \u26A0 Affected zones:     ${affectedZones.slice(0, 5).join(", ")}${affectedZones.length > 5 ? ` +${affectedZones.length - 5} more` : ""}`);
-    }
-    if (knownFailures.length > 0) {
-      lines.push(`  \u26A0 Known failures:     ${knownFailures.join(", ")}`);
-    }
-    if (runRegression) {
-      lines.push(`  \u2248 Regression cats:   ${REGRESSION_CATEGORIES2.slice(0, 5).join(", ")}...`);
-    }
-    if (gapTypes.length > 0) {
-      lines.push(`  \u2717 Test gap types:     ${gapTypes.length} gap patterns checked`);
-    }
-    if (reviewers.length > 0) {
-      lines.push(`  \u2192 Route to:           ${reviewers.join(", ")}`);
-    }
-    lines.push("\u2500".repeat(62));
-    lines.push(`  ${riskSummary}`);
-    lines.push("\u2550".repeat(62));
-    return {
-      success: true,
-      message: lines.join(`
-`),
-      modules_run: modulesRun,
-      affected_zones: affectedZones,
-      recommended_reviewers: reviewers,
-      risk_summary: riskSummary,
-      risk_score: riskScore,
-      config,
-      phase: state.phase,
-      meta: { formatted: "table", timestamp: timestamp() }
-    };
-  }
-};
-
-// src/commands/analysis/guarded-edit.ts
-import { existsSync as existsSync51, readFileSync as readFileSync44 } from "fs";
-import { join as join39 } from "path";
-function loadActivePolicies(directory) {
-  const p = join39(codebaseDir(directory), "POLICIES.json");
-  if (!existsSync51(p))
-    return [];
-  try {
-    const store = JSON.parse(readFileSync44(p, "utf-8"));
-    return (store.policies ?? []).filter((pol) => pol.active);
-  } catch {
-    return [];
-  }
-}
-function loadVolatileFiles(directory) {
-  const p = join39(codebaseDir(directory), "VOLATILITY.json");
-  if (!existsSync51(p))
-    return new Set;
-  try {
-    const data = JSON.parse(readFileSync44(p, "utf-8"));
-    return new Set((data.entries ?? []).filter((e) => e.stability === "volatile" || e.stability === "critical").map((e) => e.path));
-  } catch {
-    return new Set;
-  }
-}
-function loadPriorFailurePaths(directory) {
-  const p = join39(codebaseDir(directory), "FAILURES.json");
-  if (!existsSync51(p))
-    return new Map;
-  try {
-    const data = JSON.parse(readFileSync44(p, "utf-8"));
-    const result = new Map;
-    for (const entry of data.entries ?? []) {
-      if (entry.tags?.includes("resolved"))
-        continue;
-      for (const path2 of entry.affected_paths ?? []) {
-        const existing = result.get(path2) ?? [];
-        result.set(path2, [...existing, entry.id]);
-      }
-    }
-    return result;
-  } catch {
-    return new Map;
-  }
-}
-function decideGate(trustScore, execMode, policyViolations, archConstrained, isVolatile, hasPriorFailures) {
-  if (archConstrained) {
-    return { decision: "block", reason: "Architectural constraint violation \u2014 path is forbidden by CONSTRAINTS.md" };
-  }
-  if (policyViolations.length > 0 && trustScore < 30) {
-    return { decision: "block", reason: `Policy violation + low trust score (${trustScore}): ${policyViolations[0]}` };
-  }
-  if (execMode === "review-only") {
-    return { decision: "require-review", reason: "Repository is in review-only execution mode" };
-  }
-  if (trustScore < 40 || policyViolations.length > 0) {
-    return { decision: "require-review", reason: `High risk: trust score ${trustScore}/100, ${policyViolations.length} policy violation(s)` };
-  }
-  if (execMode === "guarded" || isVolatile || hasPriorFailures) {
-    const signals = [];
-    if (execMode === "guarded")
-      signals.push("guarded execution mode");
-    if (isVolatile)
-      signals.push("volatile file");
-    if (hasPriorFailures)
-      signals.push("prior failures on this path");
-    return { decision: "require-confirmation", reason: `Moderate risk: ${signals.join(", ")}` };
-  }
-  return { decision: "auto-approve", reason: `Trust score ${trustScore}/100, no policy violations, stable file` };
-}
-var guardedEditCommand = {
-  name: "fd-guarded-edit",
-  description: "Edit gate \u2014 decides auto-approve / require-confirmation / require-review / block based on policy, trust score, volatility, and arch constraints",
-  async execute(context, args) {
-    const dir = context.directory ?? process.cwd();
-    if (!args?.file && !args?.change) {
-      return {
-        error: "Provide --file and/or --change to evaluate. Example: /fd-guarded-edit --file src/auth.ts --change 'update JWT expiry'",
-        code: "NO_INPUT",
-        hint: "Both --file and --change are optional, but at least one is needed for useful analysis"
-      };
-    }
-    const filePath = args?.file ?? "";
-    const change = args?.change ?? "";
-    const isDryRun = args?.["dry-run"] ?? false;
-    const trustScore = filePath ? scorePatch(dir, filePath, change || undefined) : { score: 70, verdict: "safe", signals: [] };
-    const archConstraint = filePath ? checkArchConstraint(dir, filePath) !== null : false;
-    const configPath2 = join39(planningDir(dir), "config.json");
-    const execMode = resolveExecutionMode(configPath2, trustScore.score);
-    const policies = loadActivePolicies(dir);
-    const policyViolations = policies.filter((p) => {
-      const combined = [filePath, change].join(" ").toLowerCase();
-      return combined.includes(p.trigger.toLowerCase());
-    }).map((p) => p.rule);
-    const volatileFiles = loadVolatileFiles(dir);
-    const priorFailureMap = loadPriorFailurePaths(dir);
-    const isVolatile = filePath ? Array.from(volatileFiles).some((vf) => filePath.includes(vf) || vf.includes(filePath)) : false;
-    const priorFailureIds = filePath ? Array.from(priorFailureMap.entries()).filter(([path2]) => filePath.includes(path2) || path2.includes(filePath)).flatMap(([, ids]) => ids) : [];
-    const { decision, reason } = decideGate(trustScore.score, execMode, policyViolations, archConstraint, isVolatile, priorFailureIds.length > 0);
-    const recommendedAction = {
-      "auto-approve": "Apply the change \u2014 no action needed",
-      "require-confirmation": "Review the diff carefully, then confirm to proceed",
-      "require-review": "Route to human reviewer before applying \u2014 do not auto-apply",
-      block: "Do NOT apply this change \u2014 resolve the violation first"
-    };
-    const result = {
-      decision,
-      reason,
-      risk_score: trustScore.score,
-      execution_mode: execMode,
-      policy_violations: policyViolations,
-      volatile_files: isVolatile ? [filePath] : [],
-      prior_failures: priorFailureIds,
-      arch_constraint: archConstraint,
-      recommended_action: recommendedAction[decision]
-    };
-    if (args?.json) {
-      return { success: true, data: result, meta: { formatted: "json", timestamp: timestamp() } };
-    }
-    const decisionIcon = {
-      "auto-approve": "\u2713",
-      "require-confirmation": "\u26A0",
-      "require-review": "\u2691",
-      block: "\u2717"
-    };
-    const lines = [
-      "\u2550".repeat(60),
-      `fd-guarded-edit${isDryRun ? " (dry-run)" : ""}`,
-      "\u2500".repeat(60),
-      `  File:   ${filePath || "(not specified)"}`,
-      `  Change: ${change || "(not specified)"}`,
-      "\u2500".repeat(60),
-      `  ${decisionIcon[decision]} Decision:    ${decision.toUpperCase()}`,
-      `  Reason:      ${reason}`,
-      `  Risk score:  ${trustScore.score}/100 (${trustScore.verdict})`,
-      `  Exec mode:   ${execMode}`
-    ];
-    if (policyViolations.length > 0) {
-      lines.push(`  Policies:    ${policyViolations.join("; ").substring(0, 60)}`);
-    }
-    if (priorFailureIds.length > 0) {
-      lines.push(`  Prior fails: ${priorFailureIds.join(", ")}`);
-    }
-    lines.push("\u2500".repeat(60));
-    lines.push(`  \u2192 ${recommendedAction[decision]}`);
-    lines.push("\u2550".repeat(60));
-    return {
-      success: true,
-      message: lines.join(`
-`),
-      ...result,
-      meta: { formatted: "table", timestamp: timestamp() }
-    };
-  }
-};
-
-// src/commands/analysis/evaluate-risk.ts
-import { existsSync as existsSync52, readFileSync as readFileSync45 } from "fs";
-import { join as join40 } from "path";
-var REGRESSION_CATEGORIES3 = [
-  "performance",
-  "auth",
-  "schema",
-  "ui-state",
-  "async-flow",
-  "api-contract",
-  "data-integrity",
-  "security",
-  "config",
-  "i18n"
-];
-var CATEGORY_KEYWORDS = {
-  performance: ["slow", "latency", "cache", "query", "index", "bulk", "batch", "load"],
-  auth: ["auth", "token", "session", "jwt", "oauth", "permission", "rbac", "login"],
-  schema: ["schema", "migration", "column", "table", "foreign key", "constraint", "index"],
-  "ui-state": ["state", "redux", "context", "store", "hook", "render", "component"],
-  "async-flow": ["async", "await", "promise", "callback", "event", "queue", "worker"],
-  "api-contract": ["api", "endpoint", "route", "request", "response", "payload", "version"],
-  "data-integrity": ["transaction", "rollback", "constraint", "unique", "required", "nullable"],
-  security: ["secret", "password", "encrypt", "decrypt", "hash", "sanitize", "inject"],
-  config: ["env", "config", "setting", "flag", "feature flag", "toggle", "env var"],
-  i18n: ["locale", "translation", "i18n", "l10n", "format", "timezone", "language"]
-};
-function predictRegressions(changeText) {
-  const lower = changeText.toLowerCase();
-  return REGRESSION_CATEGORIES3.filter((cat) => (CATEGORY_KEYWORDS[cat] ?? []).some((kw) => lower.includes(kw)));
-}
-function toRiskLevel(score) {
-  if (score >= 80)
-    return "low";
-  if (score >= 50)
-    return "medium";
-  if (score >= 25)
-    return "high";
-  return "critical";
-}
-function computeConfidence(directory) {
-  const cd = codebaseDir(directory);
-  let score = 20;
-  if (existsSync52(join40(cd, "ARCHITECTURE.md")))
-    score += 20;
-  if (existsSync52(join40(cd, "STACK.md")))
-    score += 10;
-  if (existsSync52(join40(cd, "MEMORY.json"))) {
-    try {
-      const nodes = Object.keys(JSON.parse(readFileSync45(join40(cd, "MEMORY.json"), "utf-8")).nodes ?? {}).length;
-      score += Math.min(25, nodes * 2);
-    } catch {}
-  }
-  if (existsSync52(join40(cd, "VOLATILITY.json"))) {
-    try {
-      const entries = JSON.parse(readFileSync45(join40(cd, "VOLATILITY.json"), "utf-8")).entries?.length ?? 0;
-      score += Math.min(15, entries);
-    } catch {}
-  }
-  if (existsSync52(join40(cd, "FAILURES.json"))) {
-    try {
-      const entries = JSON.parse(readFileSync45(join40(cd, "FAILURES.json"), "utf-8")).entries?.length ?? 0;
-      score += Math.min(10, entries);
-    } catch {}
-  }
-  return Math.min(100, score);
-}
-function saferAlternative(riskLevel, change) {
-  if (riskLevel === "low" || riskLevel === "medium")
-    return null;
-  const lower = change.toLowerCase();
-  if (lower.includes("auth") || lower.includes("jwt")) {
-    return "Consider a feature-flag rollout or shadow mode before swapping auth tokens";
-  }
-  if (lower.includes("schema") || lower.includes("migration")) {
-    return "Consider a backward-compatible migration (add column, backfill, then drop old) to avoid data loss";
-  }
-  if (lower.includes("api") || lower.includes("endpoint")) {
-    return "Consider versioning the endpoint (/v2) and deprecating the old one with a sunset header";
-  }
-  if (lower.includes("payment") || lower.includes("billing")) {
-    return "Consider a canary deployment limited to internal users before full rollout";
-  }
-  return "Consider breaking the change into smaller, independently testable steps";
-}
-var evaluateRiskCommand = {
-  name: "fd-evaluate-risk",
-  description: "Risk assessment \u2014 estimates change risk, confidence, likely regressions, and whether approval is needed before proceeding",
-  async execute(context, args) {
-    const dir = context.directory ?? process.cwd();
-    const sp = statePath(dir);
-    if (!existsSync52(sp)) {
-      return { error: "STATE.md not found. Run /fd-new-project first.", code: "NOT_INITIALIZED" };
-    }
-    if (!args?.change && !args?.file) {
-      return {
-        error: "Provide --change and/or --file. Example: /fd-evaluate-risk --change 'refactor auth middleware'",
-        code: "NO_INPUT"
-      };
-    }
-    const change = args?.change ?? "";
-    const filePath = args?.file ?? "";
-    const state = readPlanningState(dir);
-    let riskScore;
-    let trustSignals = [];
-    if (filePath) {
-      const ts = scorePatch(dir, filePath, change || undefined);
-      riskScore = ts.score;
-      trustSignals = ts.signals;
-    } else {
-      const radar = runImpactRadar(dir, change);
-      const baseDeduction = radar.hotspots.length * 12 + radar.known_failures.length * 10;
-      riskScore = Math.max(0, 100 - baseDeduction);
-      if (radar.hotspots.length > 0)
-        trustSignals.push(`${radar.hotspots.length} volatile zone(s)`);
-      if (radar.known_failures.length > 0)
-        trustSignals.push(`${radar.known_failures.length} known failure(s)`);
-    }
-    const riskLevel = toRiskLevel(riskScore);
-    const confidence = computeConfidence(dir);
-    const likelyRegressions = change ? predictRegressions(change) : [];
-    const approvalNeeded = riskScore < 60 || likelyRegressions.length >= 3;
-    let volatileZoneCount = 0;
-    let volatileZones = [];
-    if (args?.volatility !== false) {
-      const volPath = join40(codebaseDir(dir), "VOLATILITY.json");
-      if (existsSync52(volPath)) {
-        try {
-          const v = JSON.parse(readFileSync45(volPath, "utf-8"));
-          const zones = (v.entries ?? []).filter((e) => e.stability === "volatile" || e.stability === "critical");
-          volatileZoneCount = zones.length;
-          if (change) {
-            const words = change.toLowerCase().split(/\s+/).filter((w) => w.length > 3);
-            volatileZones = zones.filter((e) => words.some((w) => e.path.toLowerCase().includes(w))).map((e) => e.path).slice(0, 5);
-          }
-        } catch {}
-      }
-    }
-    const saferAlt = saferAlternative(riskLevel, change);
-    const agents = [
-      { name: "researcher", role: "map change description to affected paths and modules" },
-      { name: "reviewer", role: "validate risk level and regression predictions" },
-      riskLevel === "high" || riskLevel === "critical" ? { name: "security-auditor", role: "perform targeted security review of high-risk areas" } : null
-    ].filter(Boolean);
-    const result = {
-      risk_score: riskScore,
-      risk_level: riskLevel,
-      confidence,
-      approval_needed: approvalNeeded,
-      likely_regressions: likelyRegressions,
-      volatile_zones: volatileZoneCount,
-      volatile_matches: volatileZones,
-      safer_alternative: saferAlt,
-      trust_signals: trustSignals
-    };
-    if (args?.json) {
-      return {
-        success: true,
-        data: { ...result, agents, phase: state.phase },
-        meta: { formatted: "json", timestamp: timestamp() }
-      };
-    }
-    const riskIcon = { low: "\u2713", medium: "\u26A1", high: "\u26A0", critical: "\u2717" };
-    const lines = [
-      "\u2550".repeat(60),
-      "fd-evaluate-risk",
-      "\u2500".repeat(60),
-      `  Change:      ${change || "(not specified)"}`,
-      `  File:        ${filePath || "(not specified)"}`,
-      "\u2500".repeat(60),
-      `  ${riskIcon[riskLevel]} Risk level:  ${riskLevel.toUpperCase()} (score: ${riskScore}/100)`,
-      `  Confidence:  ${confidence}/100 (codebase context coverage)`,
-      `  Approval:    ${approvalNeeded ? "REQUIRED" : "not required"}`
-    ];
-    if (likelyRegressions.length > 0) {
-      lines.push(`  Regressions: ${likelyRegressions.join(", ")}`);
-    }
-    if (volatileZones.length > 0) {
-      lines.push(`  Hot zones:   ${volatileZones.join(", ")}`);
-    }
-    if (trustSignals.length > 0) {
-      lines.push(`  Signals:     ${trustSignals.join(", ")}`);
-    }
-    if (saferAlt) {
-      lines.push("\u2500".repeat(60));
-      lines.push(`  Safer alt:   ${saferAlt}`);
-    }
-    lines.push("\u2500".repeat(60));
-    lines.push(`  researcher \u2192 map to affected paths`);
-    lines.push(`  reviewer   \u2192 validate risk + regressions`);
-    if (riskLevel === "high" || riskLevel === "critical") {
-      lines.push(`  security   \u2192 targeted review of high-risk areas`);
-    }
-    lines.push("\u2550".repeat(60));
-    return {
-      success: true,
-      message: lines.join(`
-`),
-      ...result,
-      agents,
-      phase: state.phase,
-      meta: { formatted: "table", timestamp: timestamp() }
-    };
-  }
-};
-
-// src/commands/governance/approve.ts
-import { existsSync as existsSync53 } from "fs";
-var approveCommand = {
-  name: "fd-approve",
-  description: "Manage approval requests \u2014 list pending approvals, approve or reject a request by ID",
-  async execute(context, args) {
-    const dir = context.directory ?? process.cwd();
-    if (!existsSync53(statePath(dir))) {
-      return {
-        error: "STATE.md not found. Run /fd-new-project first.",
-        code: "NOT_INITIALIZED"
-      };
-    }
-    if (!args?.id || args?.list) {
-      const pending = getPendingApprovals(dir);
-      const recent = args?.recent ? getRecentApprovals(dir, 10) : [];
-      if (args?.json) {
-        return { success: true, data: { pending, recent }, meta: { formatted: "json", timestamp: timestamp() } };
-      }
-      if (pending.length === 0) {
-        return {
-          success: true,
-          message: ["\u2500".repeat(55), "  No pending approvals", "\u2550".repeat(55)].join(`
-`),
-          pending: [],
-          meta: { formatted: "table", timestamp: timestamp() }
-        };
-      }
-      const lines2 = [
-        "\u2500".repeat(55),
-        `  Pending Approvals (${pending.length})`,
-        "\u2500".repeat(55),
-        ...pending.map((a, i) => [
-          `  [${i + 1}] ID: ${a.id.slice(0, 8)}...`,
-          `      trigger: ${a.trigger}`,
-          `      reason:  ${a.reason}`,
-          ...a.file_path ? [`      file:    ${a.file_path}`] : [],
-          `      risk:    ${a.risk_score}  |  requested: ${a.requested_at.slice(0, 16).replace("T", " ")}`
-        ]).flat(),
-        "\u2500".repeat(55),
-        `  To approve: /fd-approve --id <full-id>`,
-        `  To reject:  /fd-approve --id <full-id> --reject`,
-        "\u2550".repeat(55)
-      ];
-      return {
-        success: true,
-        message: lines2.join(`
-`),
-        pending,
-        meta: { formatted: "table", timestamp: timestamp() }
-      };
-    }
-    const decision = args.reject ? "rejected" : "approved";
-    const ok = resolveApproval(dir, args.id, decision);
-    if (!ok) {
-      return {
-        success: false,
-        error: `Approval request not found: ${args.id}`,
-        hint: "Run /fd-approve to list pending approval IDs",
-        code: "NOT_FOUND"
-      };
-    }
-    appendEvent(dir, {
-      session_id: process.env.OPENCODE_SESSION_ID ?? "session-0",
-      run_id: process.env.OPENCODE_RUN_ID ?? "run-0",
-      event: "approval.resolve",
-      status: decision === "approved" ? "approved" : "rejected",
-      meta: { approval_id: args.id, decision }
-    });
-    const icon = decision === "approved" ? "\u2713" : "\u2717";
-    const lines = [
-      "\u2500".repeat(55),
-      `  ${icon} Approval ${decision}: ${args.id.slice(0, 8)}...`,
-      decision === "approved" ? "  Operation will proceed on next attempt." : "  Operation has been blocked.",
-      "\u2550".repeat(55)
-    ];
-    return {
-      success: true,
-      message: lines.join(`
-`),
-      approval_id: args.id,
-      decision,
-      meta: { formatted: "table", timestamp: timestamp() }
-    };
-  }
-};
-
-// src/index.ts
-function parseArgs(rawArgs) {
-  if (!rawArgs || rawArgs.trim() === "")
-    return {};
-  try {
-    return JSON.parse(rawArgs);
-  } catch (err) {
-    console.warn(`[flowdeck] Failed to parse command arguments as JSON: ${err instanceof Error ? err.message : String(err)}`);
-    return { input: rawArgs };
-  }
-}
-var server = async (input, _options) => {
-  const { directory, client, worktree } = input;
-  const runParallelTool = createRunParallelTool(client);
-  const runPipelineTool = createRunPipelineTool(client);
-  const delegateTool = createDelegateTool(client);
-  const councilTool = createCouncilTool(client);
-  const fileTracker = new SessionFileTracker;
-  const { fileEdited, fileWatcherUpdated } = createFileTrackerHooks(fileTracker);
-  const contextMonitor = createContextWindowMonitorHook();
-  const shellEnvHook = createShellEnvHook({ directory, worktree });
-  const todoHook = createTodoHook(client);
-  const sessionIdleHook = createSessionIdleHook(client, fileTracker);
-  const compactionHook = createCompactionHook({ directory }, fileTracker);
-  const allCommands = [
-    newProjectCommand,
-    mapCodebaseCommand,
-    settingsCommand,
-    doctorCommand,
-    discussCommand,
-    planCommand,
-    roadmapCommand,
-    dashboardCommand,
-    askCommand,
-    newFeatureCommand,
-    fixBugCommand,
-    reviewCodeCommand,
-    writeDocsCommand,
-    deployCheckCommand,
-    progressCommand,
-    resumeCommand,
-    checkpointCommand,
-    ...workspaceCommands,
-    multiRepoCommand,
-    impactRadarCommand,
-    blastRadiusCommand,
-    translateIntentCommand,
-    volatilityMapCommand,
-    regressionPredictCommand,
-    testGapCommand,
-    reviewRouteCommand,
-    analyzeChangeCommand,
-    guardedEditCommand,
-    evaluateRiskCommand,
-    approveCommand
-  ];
-  const commandMap = {};
-  for (const cmd of allCommands) {
-    commandMap[cmd.name] = cmd;
-  }
+// src/index.ts
+var server = async (input, _options) => {
+  const { directory, client, worktree } = input;
+  const runParallelTool = createRunParallelTool(client);
+  const runPipelineTool = createRunPipelineTool(client);
+  const delegateTool = createDelegateTool(client);
+  const councilTool = createCouncilTool(client);
+  const fileTracker = new SessionFileTracker;
+  const { fileEdited, fileWatcherUpdated } = createFileTrackerHooks(fileTracker);
+  const contextMonitor = createContextWindowMonitorHook();
+  const shellEnvHook = createShellEnvHook({ directory, worktree });
+  const todoHook = createTodoHook(client);
+  const sessionIdleHook = createSessionIdleHook(client, fileTracker);
+  const compactionHook = createCompactionHook({ directory }, fileTracker);
   return {
     mcp: createFlowDeckMcps(),
     tool: {
@@ -6601,21 +2433,6 @@ var server = async (input, _options) => {
         await sessionIdleHook();
       }
     },
-    "command.execute.before": async (cmdInput, output) => {
-      const handler = commandMap[cmdInput.command];
-      if (!handler)
-        return;
-      try {
-        const args = parseArgs(cmdInput.arguments);
-        const result = await handler.execute({ directory }, args);
-        const text = typeof result === "string" ? result : JSON.stringify(result, null, 2);
-        output.parts.push({ type: "text", text });
-        notifyCommandInteraction(cmdInput.command);
-      } catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        output.parts.push({ type: "text", text: `FlowDeck error: ${msg}` });
-      }
-    },
     "tool.execute.before": async (toolInput, toolOutput) => {
       await telemetryHook({ directory }, toolInput, toolOutput);
       await approvalHook({ directory }, toolInput, toolOutput);