@dv.nghiem/flowdeck 0.4.7 → 0.4.9

package/dist/index.js

@@ -1,9 +1,6 @@
-import { createRequire } from "node:module";
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
-
 // src/index.ts
-import { readFileSync as readFileSync28, readdirSync as readdirSync4, existsSync as existsSync29 } from "fs";
-import { join as join27, basename as basename2 } from "path";
+import { readFileSync as readFileSync24, readdirSync as readdirSync3, existsSync as existsSync25 } from "fs";
+import { join as join24, basename as basename2 } from "path";
 import { dirname as dirname3 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
@@ -281,6 +278,14 @@ function parseState(content) {
         result[key] = value === "true";
       } else if (key === "requires_design_first" || key === "design_approved" || key === "design_override") {
         result[key] = value === "true";
+      } else if (key === "skippedStages") {
+        result[key] = value.replace(/[\[\]]/g, "").split(",").map((s) => s.trim()).filter(Boolean);
+      } else if (key === "escalationHistory" || key === "routingScores") {
+        try {
+          result[key] = JSON.parse(value);
+        } catch {
+          result[key] = undefined;
+        }
       } else if (value !== "" && !isNaN(Number(value)) && key !== "plan_file" && key !== "confirmed_at") {
         result[key] = Number(value);
       } else {
@@ -352,7 +357,12 @@ function readPlanningState(dir) {
     lastUpdatedBy: parsed.lastUpdatedBy || "",
     lastUpdatedPhase: parsed.lastUpdatedPhase || 1,
     summaryVersion: parsed.summaryVersion || 0,
-    freshnessStatus: parsed.freshnessStatus || "unknown"
+    freshnessStatus: parsed.freshnessStatus || "unknown",
+    workflowClass: parsed.workflowClass || undefined,
+    skippedStages: parsed.skippedStages || undefined,
+    escalationHistory: parsed.escalationHistory || undefined,
+    routingScores: parsed.routingScores || undefined,
+    routingReason: parsed.routingReason || undefined
   };
 }
 function parseTDDState(parsed) {
@@ -569,986 +579,54 @@ ${entry}`, "utf-8");
   }
 });
 
-// src/tools/run-pipeline.ts
+// src/tools/repo-memory.ts
 import { tool as tool3 } from "@opencode-ai/plugin";
-
-// src/services/agent-performance.ts
-import { existsSync as existsSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync4, mkdirSync as mkdirSync2 } from "fs";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync4, existsSync as existsSync5, mkdirSync as mkdirSync2 } from "fs";
 import { join as join5 } from "path";
-function perfPath(dir) {
-  return join5(codebaseDir(dir), "AGENT_PERF.json");
-}
-function loadStore(dir) {
-  const p = perfPath(dir);
-  if (!existsSync5(p))
-    return { entries: [], updated_at: new Date().toISOString() };
-  try {
-    return JSON.parse(readFileSync5(p, "utf-8"));
-  } catch {
-    return { entries: [], updated_at: new Date().toISOString() };
-  }
-}
-function saveStore(dir, store) {
-  const cd = codebaseDir(dir);
-  if (!existsSync5(cd))
-    mkdirSync2(cd, { recursive: true });
-  writeFileSync4(perfPath(dir), JSON.stringify(store, null, 2), "utf-8");
-}
-function makeKey(agent, model, task_type) {
-  return `${agent}::${model}::${task_type}`;
-}
-function recordRun(dir, agent, model, task_type, success, duration_ms, cost = 0) {
-  const store = loadStore(dir);
-  const key = makeKey(agent, model, task_type);
-  const existing = store.entries.find((e) => makeKey(e.agent, e.model, e.task_type) === key);
-  if (existing) {
-    existing.runs++;
-    if (success)
-      existing.successes++;
-    else
-      existing.failures++;
-    existing.total_duration_ms += duration_ms;
-    existing.total_cost += cost;
-    existing.last_run = new Date().toISOString();
-    existing.last_status = success ? "success" : "failure";
-  } else {
-    store.entries.push({
-      agent,
-      model,
-      task_type,
-      runs: 1,
-      successes: success ? 1 : 0,
-      failures: success ? 0 : 1,
-      total_duration_ms: duration_ms,
-      total_cost: cost,
-      last_run: new Date().toISOString(),
-      last_status: success ? "success" : "failure"
-    });
-  }
-  store.updated_at = new Date().toISOString();
-  saveStore(dir, store);
-}
-
-// src/tools/dispatch-routing.ts
-function shouldRetry(promptRes) {
-  if (!promptRes)
-    return false;
-  const detail = promptRes.error?.detail;
-  if (isTransientError(detail))
-    return true;
-  const infoError = promptRes.data?.info?.error;
-  const text = typeof infoError === "string" ? infoError : JSON.stringify(infoError ?? "");
-  return isTransientError(text);
-}
-function isTransientError(text) {
-  if (!text)
-    return false;
-  const haystack = text.toLowerCase();
-  return haystack.includes("overload") || haystack.includes("rate limit") || haystack.includes("timeout") || haystack.includes("temporar") || haystack.includes("econnreset");
-}
-function normalizeTaskType(taskType, agent) {
-  const normalized = (taskType ?? "").trim().toLowerCase();
-  if (isTaskType(normalized))
-    return normalized;
-  const a = agent.toLowerCase();
-  if (a.includes("design") || a.includes("ui-ux"))
-    return "design";
-  if (a.includes("review"))
-    return "review";
-  if (a.includes("test"))
-    return "testing";
-  if (a.includes("debug"))
-    return "debugging";
-  if (a.includes("security"))
-    return "security";
-  if (a.includes("doc"))
-    return "documentation";
-  if (a.includes("architect") || a.includes("planner"))
-    return "planning";
-  if (a.includes("orchestrator") || a.includes("coordinator"))
-    return "orchestration";
-  if (a.includes("analyst") || a.includes("research"))
-    return "analysis";
-  return "implementation";
-}
-function isTaskType(value) {
-  return value === "planning" || value === "design" || value === "implementation" || value === "debugging" || value === "review" || value === "testing" || value === "documentation" || value === "analysis" || value === "security" || value === "orchestration";
-}
-var UI_HEAVY_KEYWORDS = [
-  "landing page",
-  "marketing site",
-  "website",
-  "web app",
-  "mobile app",
-  "app screen",
-  "dashboard",
-  "admin panel",
-  "settings page",
-  "onboarding ux",
-  "kanban",
-  "design system",
-  "responsive",
-  "ui",
-  "ux",
-  "cta",
-  "conversion flow",
-  "saas interface",
-  "user-facing"
-];
-var NON_UI_KEYWORDS = [
-  "backend",
-  "infrastructure",
-  "migration",
-  "pipeline",
-  "api only",
-  "database only",
-  "cli",
-  "worker"
-];
-function isUiHeavyTask(input) {
-  const normalized = input.trim().toLowerCase();
-  if (!normalized)
-    return false;
-  const hasUiSignal = UI_HEAVY_KEYWORDS.some((keyword) => normalized.includes(keyword));
-  if (!hasUiSignal)
-    return false;
-  const hasOnlyNonUiSignals = NON_UI_KEYWORDS.some((keyword) => normalized.includes(keyword)) && !normalized.includes("frontend");
-  return !hasOnlyNonUiSignals;
-}
-
-// src/tools/run-pipeline.ts
-function extractText(parts) {
-  return parts.filter((p) => p.type === "text" && typeof p.text === "string").map((p) => p.text).join(`
-`);
-}
-function createRunPipelineTool(client) {
-  return tool3({
-    description: "Run agents in sequential pipeline. Each step's output is appended to the next step's context. One fresh child session per step. Returns full trace with session ID, input/output/duration per step.",
-    args: {
-      steps: tool3.schema.array(tool3.schema.object({
-        agent: tool3.schema.string(),
-        prompt: tool3.schema.string(),
-        task_type: tool3.schema.string().optional()
-      })),
-      initial_context: tool3.schema.string().optional(),
-      abort_on_failure: tool3.schema.boolean().optional().default(true),
-      retry_attempts: tool3.schema.number().optional().default(1),
-      max_carry_chars: tool3.schema.number().optional()
-    },
-    async execute(args, context) {
-      const startTime = Date.now();
-      const trace = [];
-      let carryContext = args.initial_context ?? "";
-      let aborted = false;
-      const retryAttempts = typeof args.retry_attempts === "number" ? args.retry_attempts : 1;
-      const maxRetries = Math.max(0, Math.floor(retryAttempts));
-      const totalSteps = args.steps.length;
-      let inflightChildId = null;
-      const abortHandler = () => {
-        if (inflightChildId) {
-          client.session.abort({
-            path: { id: inflightChildId },
-            query: { directory: context.directory }
-          }).catch(() => {});
-        }
-      };
-      context.abort.addEventListener("abort", abortHandler);
-      try {
-        for (let stepIdx = 0;stepIdx < args.steps.length; stepIdx++) {
-          const step = args.steps[stepIdx];
-          if (context.abort.aborted) {
-            aborted = true;
-            break;
-          }
-          const stepStart = Date.now();
-          const taskType = normalizeTaskType(step.task_type, step.agent);
-          const stepInput = carryContext ? `${carryContext}
-
----
-
-${step.prompt}` : step.prompt;
-          const createRes = await client.session.create({
-            body: { parentID: context.sessionID, title: `${step.agent}-pipeline` },
-            query: { directory: context.directory }
-          });
-          if (createRes.error || !createRes.data?.id) {
-            const errMsg = `Failed to create session: ${createRes.error?.detail ?? "unknown"}`;
-            trace.push({ agent: step.agent, task_type: taskType, model: "", input: stepInput, output: errMsg, duration_ms: Date.now() - stepStart, success: false });
-            aborted = true;
-            break;
-          }
-          inflightChildId = createRes.data.id;
-          let promptRes = null;
-          let retriesUsed = 0;
-          for (let attempt = 0;attempt <= maxRetries; attempt++) {
-            promptRes = await client.session.prompt({
-              path: { id: inflightChildId },
-              body: {
-                agent: step.agent,
-                parts: [{ type: "text", text: stepInput }],
-                tools: { question: false }
-              },
-              query: { directory: context.directory }
-            });
-            if (!shouldRetry(promptRes) || attempt === maxRetries)
-              break;
-            retriesUsed++;
-          }
-          inflightChildId = null;
-          if (context.abort.aborted) {
-            aborted = true;
-            break;
-          }
-          if (!promptRes || promptRes.error) {
-            const errMsg = `Prompt failed: ${promptRes?.error?.detail ?? "unknown"}`;
-            trace.push({ agent: step.agent, session_id: createRes.data.id, task_type: taskType, model: "", input: stepInput, output: `${errMsg}${retriesUsed > 0 ? ` (retries: ${retriesUsed})` : ""}`, duration_ms: Date.now() - stepStart, success: false });
-            recordRun(context.directory, step.agent, "", taskType, false, Date.now() - stepStart);
-            if (args.abort_on_failure) {
-              aborted = true;
-              break;
-            }
-            continue;
-          }
-          const info = promptRes.data?.info;
-          if (info?.error) {
-            const errMsg = `Agent error: ${JSON.stringify(info.error)}`;
-            trace.push({ agent: step.agent, session_id: createRes.data.id, task_type: taskType, model: "", input: stepInput, output: `${errMsg}${retriesUsed > 0 ? ` (retries: ${retriesUsed})` : ""}`, duration_ms: Date.now() - stepStart, success: false });
-            recordRun(context.directory, step.agent, "", taskType, false, Date.now() - stepStart);
-            if (args.abort_on_failure) {
-              aborted = true;
-              break;
-            }
-            continue;
-          }
-          const output = extractText(promptRes.data?.parts ?? []);
-          trace.push({ agent: step.agent, session_id: createRes.data.id, task_type: taskType, model: "", input: stepInput, output: output || "(no text output)", duration_ms: Date.now() - stepStart, success: true, context_chars: carryContext.length });
-          recordRun(context.directory, step.agent, "", taskType, true, Date.now() - stepStart);
-          const rawOutput = output || "";
-          carryContext = typeof args.max_carry_chars === "number" && rawOutput.length > args.max_carry_chars ? rawOutput.slice(rawOutput.length - args.max_carry_chars) : rawOutput;
-        }
-      } finally {
-        context.abort.removeEventListener("abort", abortHandler);
-      }
-      const totalDuration = Date.now() - startTime;
-      return JSON.stringify({
-        steps: trace,
-        total_duration_ms: totalDuration,
-        aborted
-      });
-    }
-  });
-}
-
-// src/tools/delegate.ts
-import { tool as tool4 } from "@opencode-ai/plugin";
-import { existsSync as existsSync10, readFileSync as readFileSync10 } from "fs";
-
-// src/services/prompt-cache.ts
-import { createHash } from "crypto";
-import { existsSync as existsSync6, readFileSync as readFileSync6, writeFileSync as writeFileSync5, readdirSync as readdirSync3, statSync, mkdirSync as mkdirSync3 } from "fs";
-import { join as join6 } from "path";
-var CACHEABLE_AGENTS = new Set([
-  "researcher",
-  "code-explorer",
-  "reviewer",
-  "plan-checker",
-  "security-auditor",
-  "question-guard",
-  "quick-router"
-]);
-var CACHE_DIR_NAME = "prompt-cache";
-var MAX_CACHE_ENTRIES = 200;
-var DEFAULT_TTL_MS = 30 * 60 * 1000;
-function cacheDir(dir) {
-  return join6(codebaseDir(dir), CACHE_DIR_NAME);
-}
-function entryPath(dir, key) {
-  return join6(cacheDir(dir), `${key}.json`);
-}
-function readEntry(dir, key, stateVersion, indexVersion) {
-  const path = entryPath(dir, key);
-  if (!existsSync6(path))
-    return null;
-  try {
-    const entry = JSON.parse(readFileSync6(path, "utf-8"));
-    const age = Date.now() - new Date(entry.created_at).getTime();
-    if (age > entry.ttl_ms)
-      return null;
-    if (entry.state_version !== stateVersion || entry.index_version !== indexVersion)
-      return null;
-    return entry.response;
-  } catch {
-    return null;
-  }
-}
-function hashKey(agent, prompt, context, stateVersion, indexVersion) {
-  const raw = JSON.stringify({ agent, prompt: prompt.trim(), context: context.trim(), stateVersion, indexVersion });
-  return createHash("sha256").update(raw).digest("hex").slice(0, 32);
-}
-function normalizeForCache(text) {
-  return text.replace(/\s+/g, " ").trim();
-}
-function hashKeyNormalized(agent, prompt, context, stateVersion, indexVersion) {
-  const normalized = JSON.stringify({
-    agent,
-    prompt: normalizeForCache(prompt),
-    context: normalizeForCache(context),
-    stateVersion,
-    indexVersion
-  });
-  return createHash("sha256").update(normalized).digest("hex").slice(0, 32);
-}
-function getCached(dir, agent, prompt, context, stateVersion, indexVersion, safe_to_cache = false) {
-  if (!safe_to_cache)
-    return null;
-  if (!CACHEABLE_AGENTS.has(agent))
-    return null;
-  const exactKey = hashKey(agent, prompt, context, stateVersion, indexVersion);
-  const exactResult = readEntry(dir, exactKey, stateVersion, indexVersion);
-  if (exactResult !== null)
-    return exactResult;
-  const normKey = hashKeyNormalized(agent, prompt, context, stateVersion, indexVersion);
-  if (normKey === exactKey)
-    return null;
-  return readEntry(dir, normKey, stateVersion, indexVersion);
-}
-function setCached(dir, agent, prompt, context, stateVersion, indexVersion, response, safe_to_cache = false, ttl_ms = DEFAULT_TTL_MS) {
-  if (!safe_to_cache)
-    return;
-  if (!CACHEABLE_AGENTS.has(agent))
-    return;
-  const cd = cacheDir(dir);
-  if (!existsSync6(cd))
-    mkdirSync3(cd, { recursive: true });
-  const key = hashKey(agent, prompt, context, stateVersion, indexVersion);
-  const entry = {
-    key,
-    agent,
-    state_version: stateVersion,
-    index_version: indexVersion,
-    created_at: new Date().toISOString(),
-    ttl_ms,
-    response
-  };
-  writeFileSync5(entryPath(dir, key), JSON.stringify(entry, null, 2), "utf-8");
-  pruneExpired(dir);
-}
-function pruneExpired(dir) {
-  const cd = cacheDir(dir);
-  if (!existsSync6(cd))
-    return;
-  try {
-    const files = readdirSync3(cd).filter((f) => f.endsWith(".json"));
-    const now = Date.now();
-    const entries = [];
-    for (const f of files) {
-      const p = join6(cd, f);
-      try {
-        const entry = JSON.parse(readFileSync6(p, "utf-8"));
-        const age = now - new Date(entry.created_at).getTime();
-        entries.push({ path: p, created_at: new Date(entry.created_at).getTime(), expired: age > entry.ttl_ms });
-      } catch {
-        entries.push({ path: p, created_at: 0, expired: true });
-      }
-    }
-    let deleted = 0;
-    for (const e of entries) {
-      if (e.expired) {
-        try {
-          __require("fs").unlinkSync(e.path);
-        } catch {}
-        deleted++;
-      }
-    }
-    const valid = entries.filter((e) => !e.expired).sort((a, b) => a.created_at - b.created_at);
-    const excess = valid.length - MAX_CACHE_ENTRIES;
-    for (let i = 0;i < excess; i++) {
-      try {
-        __require("fs").unlinkSync(valid[i].path);
-      } catch {}
-    }
-  } catch {}
-}
-
-// src/tools/codebase-index.ts
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync6, existsSync as existsSync7, mkdirSync as mkdirSync4 } from "fs";
-import { join as join7 } from "path";
-var CODEBASE_INDEX_FILE = "CODEBASE_INDEX.md";
-function indexPath(dir) {
-  return join7(planningDir(dir), CODEBASE_INDEX_FILE);
-}
-function readCodebaseIndex(dir) {
-  const path = indexPath(dir);
-  if (!existsSync7(path)) {
-    return {
-      exists: false,
-      lastUpdatedAt: "",
-      lastUpdatedBy: "",
-      sourceStage: "",
-      changedFiles: [],
-      fileSnapshots: {},
-      explorationHistory: [],
-      summaryVersion: 0,
-      freshnessStatus: "unknown"
-    };
-  }
-  try {
-    const content = readFileSync7(path, "utf-8");
-    return parseCodebaseIndexContent(content);
-  } catch {
-    return {
-      exists: false,
-      lastUpdatedAt: "",
-      lastUpdatedBy: "",
-      sourceStage: "",
-      changedFiles: [],
-      fileSnapshots: {},
-      explorationHistory: [],
-      summaryVersion: 0,
-      freshnessStatus: "unknown"
-    };
-  }
-}
-function parseCodebaseIndexContent(content) {
-  const result = { exists: true };
-  for (const line of content.split(`
-`)) {
-    if (line.startsWith("#") || line.trim() === "")
-      continue;
-    const strippedLine = line.replace(/\*\*/g, "").replace(/^([a-zA-Z_][a-zA-Z0-9_]*):\s*(.*)/, "$1: $2");
-    const kvMatch = strippedLine.match(/^([a-zA-Z_][a-zA-Z0-9_]*):\s*(.*)/);
-    if (!kvMatch)
-      continue;
-    const key = kvMatch[1].trim();
-    const value = kvMatch[2].trim();
-    if (key === "changedFiles") {
-      result.changedFiles = value.replace(/[\[\]]/g, "").split(",").map((s) => s.trim()).filter(Boolean);
-    } else if (key === "summaryVersion") {
-      result.summaryVersion = parseInt(value, 10) || 0;
-    } else if (key === "freshnessStatus") {
-      result.freshnessStatus = value;
-    } else if (key === "lastUpdatedAt" || key === "lastUpdatedBy" || key === "sourceStage") {
-      result[key] = value.replace(/^["']|["']$/g, "");
-    }
-  }
-  let blockCount = 0;
-  for (const jsonMatch of content.matchAll(/```json\n([\s\S]*?)\n```/g)) {
-    if (blockCount >= 2)
-      break;
-    blockCount++;
-    try {
-      const parsed = JSON.parse(jsonMatch[1]);
-      if (parsed.fileSnapshots)
-        result.fileSnapshots = parsed.fileSnapshots;
-      if (parsed.explorationHistory)
-        result.explorationHistory = parsed.explorationHistory;
-      if (!parsed.fileSnapshots && !parsed.explorationHistory) {
-        if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
-          if (!result.fileSnapshots)
-            result.fileSnapshots = {};
-          Object.assign(result.fileSnapshots, parsed);
-        } else if (Array.isArray(parsed)) {
-          result.explorationHistory = parsed;
-        }
-      }
-    } catch {
-      result.freshnessStatus = "unknown";
-    }
-  }
-  return {
-    exists: true,
-    lastUpdatedAt: result.lastUpdatedAt || "",
-    lastUpdatedBy: result.lastUpdatedBy || "",
-    sourceStage: result.sourceStage || "",
-    changedFiles: result.changedFiles || [],
-    fileSnapshots: result.fileSnapshots || {},
-    explorationHistory: result.explorationHistory || [],
-    summaryVersion: result.summaryVersion || 0,
-    freshnessStatus: result.freshnessStatus || "unknown"
-  };
-}
-
-// src/services/token-metrics.ts
-import { existsSync as existsSync8, readFileSync as readFileSync8, appendFileSync, mkdirSync as mkdirSync5 } from "fs";
-import { join as join8 } from "path";
-function estimateTokens(text) {
-  return Math.ceil(text.length / 4);
-}
-function metricsPath(dir) {
-  return join8(codebaseDir(dir), "TOKEN_METRICS.jsonl");
-}
-function appendEvent(dir, event) {
-  const cd = codebaseDir(dir);
-  if (!existsSync8(cd))
-    mkdirSync5(cd, { recursive: true });
-  appendFileSync(metricsPath(dir), JSON.stringify(event) + `
-`, "utf-8");
-}
-function recordModelCall(dir, workflow_id, stage, inputText, outputText, agent, duration_ms, model, est_cost_usd) {
-  const est_input_tokens = estimateTokens(inputText);
-  const est_output_tokens = estimateTokens(outputText);
-  appendEvent(dir, {
-    ts: new Date().toISOString(),
-    workflow_id,
-    stage,
-    event: "model_call",
-    agent,
-    model,
-    est_input_tokens,
-    est_output_tokens,
-    input_chars: inputText.length,
-    output_chars: outputText.length,
-    duration_ms,
-    est_cost_usd
-  });
-}
-function recordCacheHit(dir, workflow_id, stage, inputText, agent, model) {
-  appendEvent(dir, {
-    ts: new Date().toISOString(),
-    workflow_id,
-    stage,
-    event: "cache_hit",
-    agent,
-    model,
-    est_input_tokens: estimateTokens(inputText),
-    est_output_tokens: 0,
-    input_chars: inputText.length,
-    output_chars: 0
-  });
-}
-function recordRetryCall(dir, workflow_id, stage, inputText, outputText, agent, duration_ms, model, est_cost_usd) {
-  const est_input_tokens = estimateTokens(inputText);
-  const est_output_tokens = estimateTokens(outputText);
-  appendEvent(dir, {
-    ts: new Date().toISOString(),
-    workflow_id,
-    stage,
-    event: "retry",
-    agent,
-    model,
-    est_input_tokens,
-    est_output_tokens,
-    input_chars: inputText.length,
-    output_chars: outputText.length,
-    duration_ms,
-    est_cost_usd
-  });
-}
-var _workflowTimers = new Map;
-
-// src/config/loader.ts
-import { existsSync as existsSync9, readFileSync as readFileSync9 } from "fs";
-import { join as join9 } from "path";
-import { homedir } from "os";
-var CONFIG_FILENAME = "flowdeck.json";
-function getGlobalConfigDir() {
-  return process.env.OPENCODE_CONFIG_DIR || (process.env.XDG_CONFIG_HOME ? join9(process.env.XDG_CONFIG_HOME, "opencode") : join9(homedir(), ".config", "opencode"));
-}
-function loadFlowDeckConfig(directory) {
-  const candidates = [];
-  if (directory) {
-    candidates.push(join9(directory, ".opencode", CONFIG_FILENAME));
-  }
-  candidates.push(join9(getGlobalConfigDir(), CONFIG_FILENAME));
-  for (const configPath of candidates) {
-    if (existsSync9(configPath)) {
-      try {
-        const content = readFileSync9(configPath, "utf-8");
-        return JSON.parse(content);
-      } catch {}
-    }
-  }
-  return {};
-}
-function resolveDesignFirstConfig(config) {
-  return {
-    enabled: config.designFirst?.enabled ?? true,
-    enforcement: config.designFirst?.enforcement ?? "strict",
-    requireApprovalBeforeImplementation: config.designFirst?.requireApprovalBeforeImplementation ?? true,
-    modelOverrides: config.designFirst?.modelOverrides ?? {},
-    defaultSkillsByTaskType: config.designFirst?.defaultSkillsByTaskType ?? {
-      "landing-page": ["landing-page-design", "wireframe-planning", "design-system-definition", "frontend-handoff"],
-      dashboard: ["dashboard-design", "ui-ux-planning", "wireframe-planning", "responsive-review"],
-      "admin-panel": ["ui-ux-planning", "wireframe-planning", "design-system-definition", "frontend-handoff"],
-      "app-screen": ["app-shell-design", "ui-ux-planning", "wireframe-planning", "responsive-review"],
-      "general-ui": ["ui-ux-planning", "wireframe-planning", "design-system-definition", "frontend-handoff"]
-    }
-  };
-}
-// src/services/cost-estimator.ts
-var PRICING_TABLE = [
-  { prefix: "claude-opus-4", pricing: { input: 15, output: 75 } },
-  { prefix: "claude-opus", pricing: { input: 15, output: 75 } },
-  { prefix: "claude-sonnet-4", pricing: { input: 3, output: 15 } },
-  { prefix: "claude-sonnet-3-5", pricing: { input: 3, output: 15 } },
-  { prefix: "claude-sonnet-3", pricing: { input: 3, output: 15 } },
-  { prefix: "claude-sonnet", pricing: { input: 3, output: 15 } },
-  { prefix: "claude-haiku-4", pricing: { input: 0.8, output: 4 } },
-  { prefix: "claude-haiku-3-5", pricing: { input: 0.8, output: 4 } },
-  { prefix: "claude-haiku", pricing: { input: 0.25, output: 1.25 } },
-  { prefix: "claude-3-opus", pricing: { input: 15, output: 75 } },
-  { prefix: "claude-3-5-sonnet", pricing: { input: 3, output: 15 } },
-  { prefix: "claude-3-sonnet", pricing: { input: 3, output: 15 } },
-  { prefix: "claude-3-haiku", pricing: { input: 0.25, output: 1.25 } },
-  { prefix: "claude", pricing: { input: 3, output: 15 } },
-  { prefix: "gpt-5.4-mini", pricing: { input: 0.15, output: 0.6 } },
-  { prefix: "gpt-5-mini", pricing: { input: 0.15, output: 0.6 } },
-  { prefix: "gpt-4.1", pricing: { input: 2, output: 8 } },
-  { prefix: "gpt-4o-mini", pricing: { input: 0.15, output: 0.6 } },
-  { prefix: "gpt-4o", pricing: { input: 2.5, output: 10 } },
-  { prefix: "gpt-4-turbo", pricing: { input: 10, output: 30 } },
-  { prefix: "gpt-4", pricing: { input: 30, output: 60 } },
-  { prefix: "gpt-3.5", pricing: { input: 0.5, output: 1.5 } },
-  { prefix: "gpt-5", pricing: { input: 10, output: 30 } },
-  { prefix: "o3-mini", pricing: { input: 1.1, output: 4.4 } },
-  { prefix: "o3", pricing: { input: 10, output: 40 } },
-  { prefix: "o1-mini", pricing: { input: 1.1, output: 4.4 } },
-  { prefix: "o1", pricing: { input: 15, output: 60 } },
-  { prefix: "gemini-2.0-flash", pricing: { input: 0.1, output: 0.4 } },
-  { prefix: "gemini-2.5-flash", pricing: { input: 0.15, output: 0.6 } },
-  { prefix: "gemini-2.5-pro", pricing: { input: 1.25, output: 5 } },
-  { prefix: "gemini-1.5-flash", pricing: { input: 0.075, output: 0.3 } },
-  { prefix: "gemini-1.5-pro", pricing: { input: 1.25, output: 5 } },
-  { prefix: "gemini", pricing: { input: 0.1, output: 0.4 } },
-  { prefix: "github-copilot/sonnet", pricing: { input: 3, output: 15 } },
-  { prefix: "github-copilot/haiku", pricing: { input: 0.25, output: 1.25 } },
-  { prefix: "github-copilot/gpt-4", pricing: { input: 2.5, output: 10 } },
-  { prefix: "github-copilot", pricing: { input: 3, output: 15 } }
-];
-var FALLBACK_PRICING = { input: 3, output: 15 };
-function getModelPricing(model) {
-  if (!model)
-    return FALLBACK_PRICING;
-  const lower = model.toLowerCase();
-  for (const entry of PRICING_TABLE) {
-    if (lower.startsWith(entry.prefix.toLowerCase()))
-      return entry.pricing;
-  }
-  return FALLBACK_PRICING;
-}
-function estimateCostUSD(model, inputTokens, outputTokens) {
-  const pricing = getModelPricing(model);
-  return inputTokens / 1e6 * pricing.input + outputTokens / 1e6 * pricing.output;
-}
-
-// src/tools/delegate.ts
-function extractText2(parts) {
-  return parts.filter((p) => p.type === "text" && typeof p.text === "string").map((p) => p.text).join(`
-`);
-}
-async function runWithStreaming(client, childId, agentName, fullPrompt, toolsConfig, directory, abort, onTitle) {
-  const sseResult = await client.event.subscribe({ query: { directory } });
-  const stream = sseResult.stream;
-  const asyncRes = await client.session.promptAsync({
-    path: { id: childId },
-    query: { directory },
-    body: {
-      agent: agentName,
-      tools: toolsConfig,
-      parts: [{ type: "text", text: fullPrompt }]
-    }
-  });
-  if (asyncRes.error) {
-    return {
-      output: "",
-      error: `promptAsync failed: ${JSON.stringify(asyncRes.error)}`
-    };
-  }
-  let streamedText = "";
-  let currentTool = "";
-  onTitle(`⏳ ${agentName} — starting…`);
-  try {
-    for await (const raw of stream) {
-      if (abort.aborted)
-        break;
-      const event = typeof raw === "object" && raw !== null ? Object.values(raw)[0] ?? raw : raw;
-      if (!event || typeof event !== "object")
-        continue;
-      const sid = event.properties?.sessionID;
-      if (sid && sid !== childId)
-        continue;
-      switch (event.type) {
-        case "session.next.step.started": {
-          const model = event.properties?.model?.id ?? "";
-          onTitle(`\uD83E\uDD14 ${agentName} — thinking${model ? ` (${model})` : ""}…`);
-          break;
-        }
-        case "session.next.text.delta": {
-          const delta = event.properties?.delta ?? "";
-          streamedText += delta;
-          const preview = streamedText.slice(-80).replace(/\n/g, " ").trim();
-          onTitle(`✍️  ${agentName} — ${preview}`);
-          break;
-        }
-        case "session.next.text.ended": {
-          const text = event.properties?.text ?? streamedText;
-          streamedText = text;
-          break;
-        }
-        case "session.next.reasoning.delta": {
-          const delta = event.properties?.delta ?? "";
-          const preview = delta.slice(0, 60).replace(/\n/g, " ").trim();
-          onTitle(`\uD83D\uDCAD ${agentName} — ${preview}`);
-          break;
-        }
-        case "session.next.tool.called": {
-          currentTool = event.properties?.tool ?? "tool";
-          onTitle(`\uD83D\uDD27 ${agentName} → ${currentTool}…`);
-          break;
-        }
-        case "session.next.tool.progress": {
-          const content = event.properties?.content ?? [];
-          const progressText = content.filter((c) => c.type === "text").map((c) => c.text).join(" ").slice(0, 80).replace(/\n/g, " ").trim();
-          if (progressText) {
-            onTitle(`\uD83D\uDD27 ${agentName} → ${currentTool}: ${progressText}`);
-          }
-          break;
-        }
-        case "session.next.tool.success": {
-          onTitle(`✅ ${agentName} → ${currentTool} done`);
-          currentTool = "";
-          break;
-        }
-        case "session.next.tool.failed": {
-          onTitle(`❌ ${agentName} → ${currentTool} failed`);
-          currentTool = "";
-          break;
-        }
-        case "session.next.retried": {
-          onTitle(`↻ ${agentName} — retrying…`);
-          break;
-        }
-        case "session.next.step.ended": {
-          const cost = event.properties?.cost ?? 0;
-          const finish = event.properties?.finish ?? "";
-          if (cost > 0) {
-            onTitle(`\uD83D\uDCCA ${agentName} — step done ($${cost.toFixed(4)}) [${finish}]`);
-          } else {
-            onTitle(`\uD83D\uDCCA ${agentName} — step done [${finish}]`);
-          }
-          break;
-        }
-        case "session.error": {
-          const msg = event.properties?.error?.message ?? JSON.stringify(event.properties?.error);
-          return { output: streamedText, error: `Session error: ${msg}` };
-        }
-        case "session.idle": {
-          onTitle(`✓ ${agentName} — complete`);
-          goto_done:
-            break goto_done;
-        }
-      }
-      if (event.type === "session.idle")
-        break;
-    }
-  } catch (err) {
-    if (!abort.aborted) {
-      onTitle(`⚠️  ${agentName} — stream closed (${err?.message ?? err})`);
-    }
-  }
-  if (streamedText) {
-    return { output: streamedText };
-  }
-  try {
-    const msgsRes = await client.session.messages({
-      path: { id: childId },
-      query: { directory }
-    });
-    const messages = msgsRes.data ?? [];
-    for (let i = messages.length - 1;i >= 0; i--) {
-      const msg = messages[i];
-      if (msg.role === "assistant") {
-        const text = extractText2(msg.parts ?? []);
-        if (text)
-          return { output: text };
-      }
-    }
-  } catch {}
-  return { output: "" };
-}
-function createDelegateTool(client) {
-  return tool4({
-    description: "Delegate a task to a single agent via a child session. Returns the agent's output.",
-    args: {
-      agent: tool4.schema.string(),
-      prompt: tool4.schema.string(),
-      context: tool4.schema.string().optional(),
-      task_type: tool4.schema.string().optional(),
-      retry_attempts: tool4.schema.number().optional().default(1),
-      safe_to_cache: tool4.schema.boolean().optional().default(false),
-      cache_ttl_ms: tool4.schema.number().optional(),
-      workflow_id: tool4.schema.string().optional(),
-      stage: tool4.schema.string().optional()
-    },
-    async execute(args, execContext) {
-      const startTime = Date.now();
-      const taskType = normalizeTaskType(args.task_type, args.agent);
-      const retryAttempts = typeof args.retry_attempts === "number" ? args.retry_attempts : 1;
-      const maxRetries = Math.max(0, Math.floor(retryAttempts));
-      let agentModel = "";
-      try {
-        const cfg = loadFlowDeckConfig(execContext.directory);
-        agentModel = cfg.agents?.[args.agent]?.model ?? "";
-      } catch {}
-      const metricsWorkflowId = args.workflow_id ?? "";
-      const metricsStage = args.stage ?? "delegate";
-      const fullPrompt = args.context ? `${args.context}
-
----
-
-${args.prompt}` : args.prompt;
-      const safe_to_cache = args.safe_to_cache === true && CACHEABLE_AGENTS.has(args.agent);
-      let stateVersion = 0;
-      let indexVersion = 0;
-      if (safe_to_cache) {
-        const index = readCodebaseIndex(execContext.directory);
-        const sp = statePath(execContext.directory);
-        const rawState = existsSync10(sp) ? readFileSync10(sp, "utf-8") : "";
-        const state = rawState ? parseState(rawState) : {};
-        stateVersion = typeof state.summaryVersion === "number" ? state.summaryVersion : 0;
-        indexVersion = typeof index.summaryVersion === "number" ? index.summaryVersion : 0;
-        const cached = getCached(execContext.directory, args.agent, fullPrompt, args.context ?? "", stateVersion, indexVersion, true);
-        if (cached !== null) {
-          if (metricsWorkflowId) {
-            recordCacheHit(execContext.directory, metricsWorkflowId, metricsStage, fullPrompt, args.agent, agentModel);
-          }
-          return JSON.stringify({
-            agent: args.agent,
-            success: true,
-            output: cached,
-            task_type: taskType,
-            model: "",
-            retries_used: 0,
-            duration_ms: Date.now() - startTime,
-            cached: true
-          });
-        }
-      }
-      const createRes = await client.session.create({
-        body: { parentID: execContext.sessionID, title: `${args.agent}-delegate` },
-        query: { directory: execContext.directory }
-      });
-      if (createRes.error || !createRes.data?.id) {
-        return JSON.stringify({
-          agent: args.agent,
-          success: false,
-          error: `Failed to create session: ${createRes.error?.detail ?? "unknown"}`,
-          duration_ms: Date.now() - startTime
-        });
-      }
-      const childId = createRes.data.id;
-      execContext.abort.addEventListener("abort", () => {
-        client.session.abort({
-          path: { id: childId },
-          query: { directory: execContext.directory }
-        }).catch(() => {});
-      });
-      let lastOutput = "";
-      let lastError;
-      let retriesUsed = 0;
-      for (let attempt = 0;attempt <= maxRetries; attempt++) {
-        const attemptStart = Date.now();
-        if (attempt > 0) {
-          execContext.metadata({ title: `↻ ${args.agent} — retry ${attempt}/${maxRetries}…` });
-        }
-        const result = await runWithStreaming(client, childId, args.agent, fullPrompt, { question: false }, execContext.directory, execContext.abort, (title) => execContext.metadata({ title }));
-        lastOutput = result.output;
-        lastError = result.error;
-        const shouldRetryAttempt = !!(lastError || !lastOutput.trim());
-        if (!shouldRetryAttempt || attempt === maxRetries)
-          break;
-        if (metricsWorkflowId) {
-          const retryInputTokens = estimateTokens(fullPrompt);
-          const retryCostUsd = agentModel ? estimateCostUSD(agentModel, retryInputTokens, 0) : undefined;
-          recordRetryCall(execContext.directory, metricsWorkflowId, metricsStage, fullPrompt, "", args.agent, Date.now() - attemptStart, agentModel, retryCostUsd);
-        }
-        retriesUsed++;
-      }
-      if (lastError && !lastOutput.trim()) {
-        recordRun(execContext.directory, args.agent, "", taskType, false, Date.now() - startTime);
-        return JSON.stringify({
-          agent: args.agent,
-          session_id: childId,
-          success: false,
-          error: lastError,
-          task_type: taskType,
-          model: "",
-          retries_used: retriesUsed,
-          duration_ms: Date.now() - startTime
-        });
-      }
-      recordRun(execContext.directory, args.agent, "", taskType, true, Date.now() - startTime);
-      if (metricsWorkflowId) {
-        const inputTokens = estimateTokens(fullPrompt);
-        const outputTokens = estimateTokens(lastOutput);
-        const costUsd = agentModel ? estimateCostUSD(agentModel, inputTokens, outputTokens) : undefined;
-        recordModelCall(execContext.directory, metricsWorkflowId, metricsStage, fullPrompt, lastOutput, args.agent, Date.now() - startTime, agentModel, costUsd);
-      }
-      if (safe_to_cache && lastOutput) {
-        setCached(execContext.directory, args.agent, fullPrompt, args.context ?? "", stateVersion, indexVersion, lastOutput, true, args.cache_ttl_ms);
-      }
-      return JSON.stringify({
-        agent: args.agent,
-        session_id: childId,
-        success: true,
-        output: lastOutput || "(no text output)",
-        task_type: taskType,
-        model: "",
-        retries_used: retriesUsed,
-        duration_ms: Date.now() - startTime
-      });
-    }
-  });
-}
-
-// src/tools/repo-memory.ts
-import { tool as tool5 } from "@opencode-ai/plugin";
-import { readFileSync as readFileSync11, writeFileSync as writeFileSync7, existsSync as existsSync11, mkdirSync as mkdirSync6 } from "fs";
-import { join as join10 } from "path";
 var MEMORY_FILE = "MEMORY.json";
 function memoryPath(directory) {
-  return join10(codebaseDir(directory), MEMORY_FILE);
+  return join5(codebaseDir(directory), MEMORY_FILE);
 }
 function emptyMemory() {
   return { version: "1.0", last_updated: new Date().toISOString(), nodes: {} };
 }
 function readMemory(directory) {
   const p = memoryPath(directory);
-  if (!existsSync11(p))
+  if (!existsSync5(p))
     return emptyMemory();
   try {
-    return JSON.parse(readFileSync11(p, "utf-8"));
+    return JSON.parse(readFileSync5(p, "utf-8"));
   } catch {
     return emptyMemory();
   }
 }
 function writeMemory(directory, memory) {
   const base = codebaseDir(directory);
-  if (!existsSync11(base))
-    mkdirSync6(base, { recursive: true });
+  if (!existsSync5(base))
+    mkdirSync2(base, { recursive: true });
   memory.last_updated = new Date().toISOString();
-  writeFileSync7(memoryPath(directory), JSON.stringify(memory, null, 2), "utf-8");
+  writeFileSync4(memoryPath(directory), JSON.stringify(memory, null, 2), "utf-8");
 }
-var repoMemoryTool = tool5({
+var repoMemoryTool = tool3({
   description: "Repo Memory Graph: read/write/query persistent architecture graph in .codebase/MEMORY.json (modules, dependencies, ownership, bug history, conventions)",
   args: {
-    action: tool5.schema.enum(["read", "write_node", "query", "delete_node"]),
-    node_id: tool5.schema.string().optional(),
-    node: tool5.schema.object({
-      type: tool5.schema.enum(["module", "service", "api", "schema", "config"]),
-      path: tool5.schema.string(),
-      owner: tool5.schema.string().optional(),
-      tags: tool5.schema.array(tool5.schema.string()),
-      dependencies: tool5.schema.array(tool5.schema.string()),
-      dependents: tool5.schema.array(tool5.schema.string()),
-      bug_history: tool5.schema.array(tool5.schema.string()),
-      conventions: tool5.schema.array(tool5.schema.string())
+    action: tool3.schema.enum(["read", "write_node", "query", "delete_node"]),
+    node_id: tool3.schema.string().optional(),
+    node: tool3.schema.object({
+      type: tool3.schema.enum(["module", "service", "api", "schema", "config"]),
+      path: tool3.schema.string(),
+      owner: tool3.schema.string().optional(),
+      tags: tool3.schema.array(tool3.schema.string()),
+      dependencies: tool3.schema.array(tool3.schema.string()),
+      dependents: tool3.schema.array(tool3.schema.string()),
+      bug_history: tool3.schema.array(tool3.schema.string()),
+      conventions: tool3.schema.array(tool3.schema.string())
     }).optional(),
-    query: tool5.schema.object({
-      type: tool5.schema.enum(["module", "service", "api", "schema", "config"]).optional(),
-      owner: tool5.schema.string().optional(),
-      tag: tool5.schema.string().optional(),
-      path_prefix: tool5.schema.string().optional()
+    query: tool3.schema.object({
+      type: tool3.schema.enum(["module", "service", "api", "schema", "config"]).optional(),
+      owner: tool3.schema.string().optional(),
+      tag: tool3.schema.string().optional(),
+      path_prefix: tool3.schema.string().optional()
     }).optional()
   },
   async execute(args, context) {
@@ -1603,50 +681,50 @@ var repoMemoryTool = tool5({
 });
 
 // src/tools/failure-replay.ts
-import { tool as tool6 } from "@opencode-ai/plugin";
-import { readFileSync as readFileSync12, writeFileSync as writeFileSync8, existsSync as existsSync12, mkdirSync as mkdirSync7 } from "fs";
-import { join as join11 } from "path";
+import { tool as tool4 } from "@opencode-ai/plugin";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync5, existsSync as existsSync6, mkdirSync as mkdirSync3 } from "fs";
+import { join as join6 } from "path";
 var FAILURES_FILE = "FAILURES.json";
 function failuresPath(directory) {
-  return join11(codebaseDir(directory), FAILURES_FILE);
+  return join6(codebaseDir(directory), FAILURES_FILE);
 }
 function readStore(directory) {
   const p = failuresPath(directory);
-  if (!existsSync12(p))
+  if (!existsSync6(p))
     return { version: "1.0", last_updated: new Date().toISOString(), entries: [] };
   try {
-    return JSON.parse(readFileSync12(p, "utf-8"));
+    return JSON.parse(readFileSync6(p, "utf-8"));
   } catch {
     return { version: "1.0", last_updated: new Date().toISOString(), entries: [] };
   }
 }
 function writeStore(directory, store) {
   const base = codebaseDir(directory);
-  if (!existsSync12(base))
-    mkdirSync7(base, { recursive: true });
+  if (!existsSync6(base))
+    mkdirSync3(base, { recursive: true });
   store.last_updated = new Date().toISOString();
-  writeFileSync8(failuresPath(directory), JSON.stringify(store, null, 2), "utf-8");
+  writeFileSync5(failuresPath(directory), JSON.stringify(store, null, 2), "utf-8");
 }
-var failureReplayTool = tool6({
+var failureReplayTool = tool4({
   description: "Failure Replay Engine: record and query past failures (reverted commits, failed deployments, flaky tests, bug fixes) in .codebase/FAILURES.json so the agent avoids repeating mistakes",
   args: {
-    action: tool6.schema.enum(["record", "query", "list", "mark_resolved"]),
-    entry: tool6.schema.object({
-      id: tool6.schema.string(),
-      type: tool6.schema.enum(["reverted_commit", "failed_deployment", "flaky_test", "bug_fix", "build_failure"]),
-      description: tool6.schema.string(),
-      affected_paths: tool6.schema.array(tool6.schema.string()),
-      root_cause: tool6.schema.string().optional(),
-      fix_applied: tool6.schema.string().optional(),
-      tags: tool6.schema.array(tool6.schema.string())
+    action: tool4.schema.enum(["record", "query", "list", "mark_resolved"]),
+    entry: tool4.schema.object({
+      id: tool4.schema.string(),
+      type: tool4.schema.enum(["reverted_commit", "failed_deployment", "flaky_test", "bug_fix", "build_failure"]),
+      description: tool4.schema.string(),
+      affected_paths: tool4.schema.array(tool4.schema.string()),
+      root_cause: tool4.schema.string().optional(),
+      fix_applied: tool4.schema.string().optional(),
+      tags: tool4.schema.array(tool4.schema.string())
     }).optional(),
-    query: tool6.schema.object({
-      type: tool6.schema.enum(["reverted_commit", "failed_deployment", "flaky_test", "bug_fix", "build_failure"]).optional(),
-      path_prefix: tool6.schema.string().optional(),
-      tag: tool6.schema.string().optional(),
-      limit: tool6.schema.number().optional()
+    query: tool4.schema.object({
+      type: tool4.schema.enum(["reverted_commit", "failed_deployment", "flaky_test", "bug_fix", "build_failure"]).optional(),
+      path_prefix: tool4.schema.string().optional(),
+      tag: tool4.schema.string().optional(),
+      limit: tool4.schema.number().optional()
     }).optional(),
-    entry_id: tool6.schema.string().optional()
+    entry_id: tool4.schema.string().optional()
   },
   async execute(args, context) {
     const dir = context.directory ?? process.cwd();
@@ -1708,18 +786,18 @@ var failureReplayTool = tool6({
 });
 
 // src/tools/decision-trace.ts
-import { tool as tool7 } from "@opencode-ai/plugin";
-import { readFileSync as readFileSync13, existsSync as existsSync13, mkdirSync as mkdirSync8, appendFileSync as appendFileSync2 } from "fs";
-import { join as join12 } from "path";
+import { tool as tool5 } from "@opencode-ai/plugin";
+import { readFileSync as readFileSync7, existsSync as existsSync7, mkdirSync as mkdirSync4, appendFileSync } from "fs";
+import { join as join7 } from "path";
 var DECISIONS_FILE = "DECISIONS.jsonl";
 function decisionsPath(directory) {
-  return join12(codebaseDir(directory), DECISIONS_FILE);
+  return join7(codebaseDir(directory), DECISIONS_FILE);
 }
 function readDecisions(directory) {
   const p = decisionsPath(directory);
-  if (!existsSync13(p))
+  if (!existsSync7(p))
     return [];
-  return readFileSync13(p, "utf-8").split(`
+  return readFileSync7(p, "utf-8").split(`
 `).filter((l) => l.trim()).map((l) => {
     try {
       return JSON.parse(l);
@@ -1728,29 +806,29 @@ function readDecisions(directory) {
     }
   }).filter(Boolean);
 }
-var decisionTraceTool = tool7({
+var decisionTraceTool = tool5({
   description: "Decision Trace: record why the agent changed something, what evidence was used, and assumptions made. Stored in .codebase/DECISIONS.jsonl for fast review.",
   args: {
-    action: tool7.schema.enum(["record", "query", "get_for_file"]),
-    entry: tool7.schema.object({
-      id: tool7.schema.string(),
-      file_path: tool7.schema.string(),
-      change_type: tool7.schema.enum(["create", "edit", "delete", "refactor"]),
-      rationale: tool7.schema.string(),
-      evidence: tool7.schema.array(tool7.schema.string()),
-      assumptions: tool7.schema.array(tool7.schema.string()),
-      alternatives_considered: tool7.schema.array(tool7.schema.string()),
-      risk_level: tool7.schema.enum(["low", "medium", "high"]),
-      agent: tool7.schema.string().optional(),
-      session_id: tool7.schema.string().optional()
+    action: tool5.schema.enum(["record", "query", "get_for_file"]),
+    entry: tool5.schema.object({
+      id: tool5.schema.string(),
+      file_path: tool5.schema.string(),
+      change_type: tool5.schema.enum(["create", "edit", "delete", "refactor"]),
+      rationale: tool5.schema.string(),
+      evidence: tool5.schema.array(tool5.schema.string()),
+      assumptions: tool5.schema.array(tool5.schema.string()),
+      alternatives_considered: tool5.schema.array(tool5.schema.string()),
+      risk_level: tool5.schema.enum(["low", "medium", "high"]),
+      agent: tool5.schema.string().optional(),
+      session_id: tool5.schema.string().optional()
     }).optional(),
-    query: tool7.schema.object({
-      file_path: tool7.schema.string().optional(),
-      change_type: tool7.schema.enum(["create", "edit", "delete", "refactor"]).optional(),
-      risk_level: tool7.schema.enum(["low", "medium", "high"]).optional(),
-      limit: tool7.schema.number().optional()
+    query: tool5.schema.object({
+      file_path: tool5.schema.string().optional(),
+      change_type: tool5.schema.enum(["create", "edit", "delete", "refactor"]).optional(),
+      risk_level: tool5.schema.enum(["low", "medium", "high"]).optional(),
+      limit: tool5.schema.number().optional()
     }).optional(),
-    file_path: tool7.schema.string().optional()
+    file_path: tool5.schema.string().optional()
   },
   async execute(args, context) {
     const dir = context.directory ?? process.cwd();
@@ -1759,10 +837,10 @@ var decisionTraceTool = tool7({
       case "record": {
         if (!args.entry)
           return JSON.stringify({ error: "entry required" });
-        if (!existsSync13(base))
-          mkdirSync8(base, { recursive: true });
+        if (!existsSync7(base))
+          mkdirSync4(base, { recursive: true });
         const entry = { ...args.entry, timestamp: new Date().toISOString() };
-        appendFileSync2(decisionsPath(dir), JSON.stringify(entry) + `
+        appendFileSync(decisionsPath(dir), JSON.stringify(entry) + `
 `, "utf-8");
         return JSON.stringify({ success: true, id: args.entry.id });
       }
@@ -1793,48 +871,48 @@ var decisionTraceTool = tool7({
 });
 
 // src/tools/policy-engine.ts
-import { tool as tool8 } from "@opencode-ai/plugin";
-import { readFileSync as readFileSync14, writeFileSync as writeFileSync10, existsSync as existsSync14, mkdirSync as mkdirSync9 } from "fs";
-import { join as join13 } from "path";
+import { tool as tool6 } from "@opencode-ai/plugin";
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync7, existsSync as existsSync8, mkdirSync as mkdirSync5 } from "fs";
+import { join as join8 } from "path";
 var POLICIES_FILE = "POLICIES.json";
 function policiesPath(directory) {
-  return join13(codebaseDir(directory), POLICIES_FILE);
+  return join8(codebaseDir(directory), POLICIES_FILE);
 }
 function readStore2(directory) {
   const p = policiesPath(directory);
-  if (!existsSync14(p))
+  if (!existsSync8(p))
     return { version: "1.0", last_updated: new Date().toISOString(), policies: [] };
   try {
-    return JSON.parse(readFileSync14(p, "utf-8"));
+    return JSON.parse(readFileSync8(p, "utf-8"));
   } catch {
     return { version: "1.0", last_updated: new Date().toISOString(), policies: [] };
   }
 }
 function writeStore2(directory, store) {
   const base = codebaseDir(directory);
-  if (!existsSync14(base))
-    mkdirSync9(base, { recursive: true });
+  if (!existsSync8(base))
+    mkdirSync5(base, { recursive: true });
   store.last_updated = new Date().toISOString();
-  writeFileSync10(policiesPath(directory), JSON.stringify(store, null, 2), "utf-8");
+  writeFileSync7(policiesPath(directory), JSON.stringify(store, null, 2), "utf-8");
 }
-var policyEngineTool = tool8({
+var policyEngineTool = tool6({
   description: "Self-Healing Policy Engine: manage .codebase/POLICIES.json — add, list, query, toggle, and record violations of editing policies learned from past failures",
   args: {
-    action: tool8.schema.enum(["list", "add", "record_violation", "toggle", "query"]),
-    policy: tool8.schema.object({
-      id: tool8.schema.string(),
-      name: tool8.schema.string(),
-      trigger: tool8.schema.string(),
-      rule: tool8.schema.string(),
-      source: tool8.schema.enum(["manual", "learned"]),
-      failure_count: tool8.schema.number()
+    action: tool6.schema.enum(["list", "add", "record_violation", "toggle", "query"]),
+    policy: tool6.schema.object({
+      id: tool6.schema.string(),
+      name: tool6.schema.string(),
+      trigger: tool6.schema.string(),
+      rule: tool6.schema.string(),
+      source: tool6.schema.enum(["manual", "learned"]),
+      failure_count: tool6.schema.number()
     }).optional(),
-    policy_id: tool8.schema.string().optional(),
-    active: tool8.schema.boolean().optional(),
-    query: tool8.schema.object({
-      source: tool8.schema.enum(["manual", "learned"]).optional(),
-      active_only: tool8.schema.boolean().optional(),
-      trigger_contains: tool8.schema.string().optional()
+    policy_id: tool6.schema.string().optional(),
+    active: tool6.schema.boolean().optional(),
+    query: tool6.schema.object({
+      source: tool6.schema.enum(["manual", "learned"]).optional(),
+      active_only: tool6.schema.boolean().optional(),
+      trigger_contains: tool6.schema.string().optional()
     }).optional()
   },
   async execute(args, context) {
@@ -1896,22 +974,22 @@ var policyEngineTool = tool8({
 });
 
 // src/tools/hash-edit.ts
-import { tool as tool9 } from "@opencode-ai/plugin";
-import { readFileSync as readFileSync15, writeFileSync as writeFileSync11 } from "fs";
-import { createHash as createHash2 } from "crypto";
-var hashEditTool = tool9({
+import { tool as tool7 } from "@opencode-ai/plugin";
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync8 } from "fs";
+import { createHash } from "crypto";
+var hashEditTool = tool7({
   description: "Reliable file editing with content verification. Takes a target content, its expected MD5 hash, and replacement content. Only applies if the hash matches, preventing edits on stale file versions.",
   args: {
-    filePath: tool9.schema.string(),
-    targetContent: tool9.schema.string(),
-    expectedHash: tool9.schema.string().optional(),
-    replacementContent: tool9.schema.string()
+    filePath: tool7.schema.string(),
+    targetContent: tool7.schema.string(),
+    expectedHash: tool7.schema.string().optional(),
+    replacementContent: tool7.schema.string()
   },
   async execute(args, context) {
     const fullPath = args.filePath.startsWith("/") ? args.filePath : `${context.directory}/${args.filePath}`;
     let content;
     try {
-      content = readFileSync15(fullPath, "utf-8");
+      content = readFileSync9(fullPath, "utf-8");
     } catch (e) {
       return `Error: Could not read file ${args.filePath}`;
     }
@@ -1919,28 +997,128 @@ var hashEditTool = tool9({
       return `Error: Target content not found in ${args.filePath}. It may have been modified by another agent.`;
     }
     if (args.expectedHash) {
-      const actualHash = createHash2("md5").update(args.targetContent).digest("hex");
+      const actualHash = createHash("md5").update(args.targetContent).digest("hex");
       if (actualHash !== args.expectedHash) {
         return `Error: Hash mismatch for target content. Expected ${args.expectedHash}, got ${actualHash}. Refusing to edit stale content.`;
       }
     }
-    const newContent = content.replace(args.targetContent, args.replacementContent);
-    writeFileSync11(fullPath, newContent, "utf-8");
-    return `Successfully updated ${args.filePath} using hash-anchored edit.`;
+    const newContent = content.replace(args.targetContent, args.replacementContent);
+    writeFileSync8(fullPath, newContent, "utf-8");
+    return `Successfully updated ${args.filePath} using hash-anchored edit.`;
+  }
+});
+
+// src/tools/council.ts
+import { tool as tool8 } from "@opencode-ai/plugin";
+import { appendFileSync as appendFileSync2, existsSync as existsSync10, mkdirSync as mkdirSync7 } from "fs";
+import { join as join10 } from "path";
+import { createHash as createHash2 } from "crypto";
+
+// src/tools/codebase-index.ts
+import { readFileSync as readFileSync10, writeFileSync as writeFileSync9, existsSync as existsSync9, mkdirSync as mkdirSync6 } from "fs";
+import { join as join9 } from "path";
+var CODEBASE_INDEX_FILE = "CODEBASE_INDEX.md";
+function indexPath(dir) {
+  return join9(planningDir(dir), CODEBASE_INDEX_FILE);
+}
+function readCodebaseIndex(dir) {
+  const path = indexPath(dir);
+  if (!existsSync9(path)) {
+    return {
+      exists: false,
+      lastUpdatedAt: "",
+      lastUpdatedBy: "",
+      sourceStage: "",
+      changedFiles: [],
+      fileSnapshots: {},
+      explorationHistory: [],
+      summaryVersion: 0,
+      freshnessStatus: "unknown"
+    };
+  }
+  try {
+    const content = readFileSync10(path, "utf-8");
+    return parseCodebaseIndexContent(content);
+  } catch {
+    return {
+      exists: false,
+      lastUpdatedAt: "",
+      lastUpdatedBy: "",
+      sourceStage: "",
+      changedFiles: [],
+      fileSnapshots: {},
+      explorationHistory: [],
+      summaryVersion: 0,
+      freshnessStatus: "unknown"
+    };
+  }
+}
+function parseCodebaseIndexContent(content) {
+  const result = { exists: true };
+  for (const line of content.split(`
+`)) {
+    if (line.startsWith("#") || line.trim() === "")
+      continue;
+    const strippedLine = line.replace(/\*\*/g, "").replace(/^([a-zA-Z_][a-zA-Z0-9_]*):\s*(.*)/, "$1: $2");
+    const kvMatch = strippedLine.match(/^([a-zA-Z_][a-zA-Z0-9_]*):\s*(.*)/);
+    if (!kvMatch)
+      continue;
+    const key = kvMatch[1].trim();
+    const value = kvMatch[2].trim();
+    if (key === "changedFiles") {
+      result.changedFiles = value.replace(/[\[\]]/g, "").split(",").map((s) => s.trim()).filter(Boolean);
+    } else if (key === "summaryVersion") {
+      result.summaryVersion = parseInt(value, 10) || 0;
+    } else if (key === "freshnessStatus") {
+      result.freshnessStatus = value;
+    } else if (key === "lastUpdatedAt" || key === "lastUpdatedBy" || key === "sourceStage") {
+      result[key] = value.replace(/^["']|["']$/g, "");
+    }
+  }
+  let blockCount = 0;
+  for (const jsonMatch of content.matchAll(/```json\n([\s\S]*?)\n```/g)) {
+    if (blockCount >= 2)
+      break;
+    blockCount++;
+    try {
+      const parsed = JSON.parse(jsonMatch[1]);
+      if (parsed.fileSnapshots)
+        result.fileSnapshots = parsed.fileSnapshots;
+      if (parsed.explorationHistory)
+        result.explorationHistory = parsed.explorationHistory;
+      if (!parsed.fileSnapshots && !parsed.explorationHistory) {
+        if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+          if (!result.fileSnapshots)
+            result.fileSnapshots = {};
+          Object.assign(result.fileSnapshots, parsed);
+        } else if (Array.isArray(parsed)) {
+          result.explorationHistory = parsed;
+        }
+      }
+    } catch {
+      result.freshnessStatus = "unknown";
+    }
   }
-});
+  return {
+    exists: true,
+    lastUpdatedAt: result.lastUpdatedAt || "",
+    lastUpdatedBy: result.lastUpdatedBy || "",
+    sourceStage: result.sourceStage || "",
+    changedFiles: result.changedFiles || [],
+    fileSnapshots: result.fileSnapshots || {},
+    explorationHistory: result.explorationHistory || [],
+    summaryVersion: result.summaryVersion || 0,
+    freshnessStatus: result.freshnessStatus || "unknown"
+  };
+}
 
 // src/tools/council.ts
-import { tool as tool10 } from "@opencode-ai/plugin";
-import { appendFileSync as appendFileSync3, existsSync as existsSync15, mkdirSync as mkdirSync10 } from "fs";
-import { join as join14 } from "path";
-import { createHash as createHash3 } from "crypto";
-import { readFileSync as readFileSync16 } from "fs";
+import { readFileSync as readFileSync11 } from "fs";
 var _councilCache = new Map;
 var COUNCIL_CACHE_TTL_MS = 20 * 60 * 1000;
 function councilCacheKey(task, agents, stateVersion, indexVersion) {
   const sorted = [...agents].sort();
-  return createHash3("sha256").update(JSON.stringify({ task: task.trim(), agents: sorted, sv: stateVersion, iv: indexVersion })).digest("hex").slice(0, 32);
+  return createHash2("sha256").update(JSON.stringify({ task: task.trim(), agents: sorted, sv: stateVersion, iv: indexVersion })).digest("hex").slice(0, 32);
 }
 async function runWithConcurrencyLimit(tasks, limit) {
   const results = new Array(tasks.length);
@@ -1956,20 +1134,20 @@ async function runWithConcurrencyLimit(tasks, limit) {
   return results;
 }
 function createCouncilTool(client) {
-  return tool10({
+  return tool8({
     description: "Run an ensemble of agents (Council) on the same task to reach consensus or compare approaches. Runs specialized agents in parallel (bounded concurrency) and returns their synthesized outputs.",
     args: {
-      task: tool10.schema.string(),
-      agents: tool10.schema.array(tool10.schema.string()).optional(),
-      force_fresh: tool10.schema.boolean().optional().default(false),
-      max_concurrency: tool10.schema.number().optional().default(3)
+      task: tool8.schema.string(),
+      agents: tool8.schema.array(tool8.schema.string()).optional(),
+      force_fresh: tool8.schema.boolean().optional().default(false),
+      max_concurrency: tool8.schema.number().optional().default(3)
     },
     async execute(args, context) {
       const agents = args.agents || ["architect", "reviewer", "backend-coder"];
       const concurrencyLimit = Math.max(1, Math.min(5, typeof args.max_concurrency === "number" ? args.max_concurrency : 3));
       const index = readCodebaseIndex(context.directory);
       const sp = statePath(context.directory);
-      const rawState = existsSync15(sp) ? readFileSync16(sp, "utf-8") : "";
+      const rawState = existsSync10(sp) ? readFileSync11(sp, "utf-8") : "";
       const state = rawState ? parseState(rawState) : {};
       const stateVersion = typeof state.summaryVersion === "number" ? state.summaryVersion : 0;
       const indexVersion = typeof index.summaryVersion === "number" ? index.summaryVersion : 0;
@@ -2045,18 +1223,18 @@ Please synthesize these results. Identify areas of agreement, resolve conflicts,
 function persistCouncilResult(directory, payload) {
   try {
     const base = codebaseDir(directory);
-    if (!existsSync15(base))
-      mkdirSync10(base, { recursive: true });
-    const path = join14(base, "COUNCILS.jsonl");
-    appendFileSync3(path, JSON.stringify(payload) + `
+    if (!existsSync10(base))
+      mkdirSync7(base, { recursive: true });
+    const path = join10(base, "COUNCILS.jsonl");
+    appendFileSync2(path, JSON.stringify(payload) + `
 `, "utf-8");
   } catch {}
 }
 
 // src/tools/reflect.ts
-import { tool as tool11 } from "@opencode-ai/plugin";
-import { existsSync as existsSync16, readFileSync as readFileSync17 } from "fs";
-import { join as join15 } from "path";
+import { tool as tool9 } from "@opencode-ai/plugin";
+import { existsSync as existsSync11, readFileSync as readFileSync12 } from "fs";
+import { join as join11 } from "path";
 var MAX_ARTIFACT_BYTES = 4000;
 function tail(text, maxBytes) {
   if (text.length <= maxBytes)
@@ -2064,10 +1242,10 @@ function tail(text, maxBytes) {
   return `... (truncated) ...
 ` + text.slice(-maxBytes);
 }
-var reflectTool = tool11({
+var reflectTool = tool9({
   description: "Gather session artifacts (decisions, telemetry, failures, policies) and return a structured " + "reflection context that the agent can reason over to produce self-improvement proposals.",
   args: {
-    scope: tool11.schema.enum(["session", "project"]).optional().describe("'session' (default) uses only recent artifacts; 'project' includes all historical data")
+    scope: tool9.schema.enum(["session", "project"]).optional().describe("'session' (default) uses only recent artifacts; 'project' includes all historical data")
   },
   async execute(args, context) {
     const root = context.directory;
@@ -2085,11 +1263,11 @@ var reflectTool = tool11({
     ];
     let found = 0;
     for (const [rel, label] of ARTIFACT_PATHS) {
-      const full = join15(root, rel);
-      if (!existsSync16(full))
+      const full = join11(root, rel);
+      if (!existsSync11(full))
         continue;
       try {
-        const raw = readFileSync17(full, "utf-8").trim();
+        const raw = readFileSync12(full, "utf-8").trim();
         if (!raw)
           continue;
         const count = raw.split(`
@@ -2109,16 +1287,16 @@ var reflectTool = tool11({
 });
 
 // src/tools/codegraph-tool.ts
-import { tool as tool12 } from "@opencode-ai/plugin";
+import { tool as tool10 } from "@opencode-ai/plugin";
 
 // src/services/codegraph.ts
 import { spawnSync } from "child_process";
-import { existsSync as existsSync17, readFileSync as readFileSync18, writeFileSync as writeFileSync12, mkdirSync as mkdirSync11 } from "fs";
-import { join as join16 } from "path";
+import { existsSync as existsSync12, readFileSync as readFileSync13, writeFileSync as writeFileSync10, mkdirSync as mkdirSync8 } from "fs";
+import { join as join12 } from "path";
 var CODEGRAPH_META_FILE = "CODEGRAPH.md";
 var MAX_FRESHNESS_MS = 30 * 60 * 1000;
 function metaPath(dir) {
-  return join16(codebaseDir(dir), CODEGRAPH_META_FILE);
+  return join12(codebaseDir(dir), CODEGRAPH_META_FILE);
 }
 function isCodegraphInstalled() {
   try {
@@ -2133,11 +1311,11 @@ function isCodegraphInstalled() {
   }
 }
 function isCodegraphIndexed(dir) {
-  return existsSync17(join16(dir, ".codegraph", "codegraph.db"));
+  return existsSync12(join12(dir, ".codegraph", "codegraph.db"));
 }
 function readCodegraphMeta(dir) {
   const path = metaPath(dir);
-  if (!existsSync17(path)) {
+  if (!existsSync12(path)) {
     return {
       installed: false,
       indexed: false,
@@ -2150,7 +1328,7 @@ function readCodegraphMeta(dir) {
     };
   }
   try {
-    const content = readFileSync18(path, "utf-8");
+    const content = readFileSync13(path, "utf-8");
     return parseCodegraphMeta(content);
   } catch {
     return {
@@ -2217,8 +1395,8 @@ function parseCodegraphMeta(content) {
 }
 function writeCodegraphMeta(dir, meta) {
   const base = codebaseDir(dir);
-  if (!existsSync17(base))
-    mkdirSync11(base, { recursive: true });
+  if (!existsSync12(base))
+    mkdirSync8(base, { recursive: true });
   const lines = [
     "# Codegraph Metadata",
     "",
@@ -2231,7 +1409,7 @@ function writeCodegraphMeta(dir, meta) {
     `**installLog:** ${meta.installLog}`,
     `**indexLog:** ${meta.indexLog}`
   ];
-  writeFileSync12(metaPath(dir), lines.join(`
+  writeFileSync10(metaPath(dir), lines.join(`
 `), "utf-8");
 }
 function isCodegraphFresh(dir, maxAgeMs = MAX_FRESHNESS_MS) {
@@ -2442,11 +1620,11 @@ function markCodegraphStale(dir) {
 }
 
 // src/tools/codegraph-tool.ts
-var codegraphTool = tool12({
+var codegraphTool = tool10({
   description: "Manage codegraph lifecycle only: check installation, install, init/rebuild the index, refresh (incremental sync), " + "query status, or mark-stale. Valid actions: check | install | init | refresh | status | mark-stale. " + "Do NOT use this tool for code intelligence queries (files, search, callers, callees, etc.) — " + "those are available as codegraph MCP tools (codegraph_files, codegraph_search, codegraph_context, " + "codegraph_explore, codegraph_callers, codegraph_callees, codegraph_impact, codegraph_trace) " + "when the index is ready.",
   args: {
-    action: tool12.schema.enum(["check", "install", "init", "refresh", "status", "mark-stale"]),
-    agent: tool12.schema.string().optional()
+    action: tool10.schema.enum(["check", "install", "init", "refresh", "status", "mark-stale"]),
+    agent: tool10.schema.string().optional()
   },
   async execute(args, context) {
     const dir = context.directory ?? process.cwd();
@@ -2535,21 +1713,21 @@ var codegraphTool = tool12({
 });
 
 // src/tools/load-rules.ts
-import { tool as tool13 } from "@opencode-ai/plugin";
-import { existsSync as existsSync18, readFileSync as readFileSync19 } from "fs";
-import { join as join17, dirname as dirname2 } from "path";
+import { tool as tool11 } from "@opencode-ai/plugin";
+import { existsSync as existsSync13, readFileSync as readFileSync14 } from "fs";
+import { join as join13, dirname as dirname2 } from "path";
 import { fileURLToPath } from "url";
-var RULES_DIR = join17(dirname2(fileURLToPath(import.meta.url)), "..", "rules");
+var RULES_DIR = join13(dirname2(fileURLToPath(import.meta.url)), "..", "rules");
 var _loadedPaths = new Set;
-var loadRulesTool = tool13({
+var loadRulesTool = tool11({
   description: "Load additional rule modules on demand for the current workflow stage. " + "Use this at the start of a new stage (execute, verify, fix-bug) to load " + "coding-style, security, testing, and language-specific rules that were not " + "injected at startup. Returns the full text of selected rules. " + "Already-loaded rules are not returned again (suppressed to avoid duplication).",
   args: {
-    stage: tool13.schema.string().optional().describe("Current workflow stage: discuss | plan | execute | verify | fix-bug | write-docs"),
-    languages: tool13.schema.array(tool13.schema.string()).optional().describe("Project languages to load rules for, e.g. ['typescript']. " + "Omit to use all languages (returns all matching stage rules)."),
-    force_reload: tool13.schema.boolean().optional().default(false).describe("When true, return rules even if they were already loaded in this session. " + "Use only when stage context has changed and you need a fresh load.")
+    stage: tool11.schema.string().optional().describe("Current workflow stage: discuss | plan | execute | verify | fix-bug | write-docs"),
+    languages: tool11.schema.array(tool11.schema.string()).optional().describe("Project languages to load rules for, e.g. ['typescript']. " + "Omit to use all languages (returns all matching stage rules)."),
+    force_reload: tool11.schema.boolean().optional().default(false).describe("When true, return rules even if they were already loaded in this session. " + "Use only when stage context has changed and you need a fresh load.")
   },
   async execute(args) {
-    const rulesDir = existsSync18(RULES_DIR) ? RULES_DIR : null;
+    const rulesDir = existsSync13(RULES_DIR) ? RULES_DIR : null;
     if (!rulesDir) {
       return JSON.stringify({
         loaded: [],
@@ -2575,7 +1753,7 @@ var loadRulesTool = tool13({
         continue;
       }
       try {
-        const text = readFileSync19(rule.path, "utf-8");
+        const text = readFileSync14(rule.path, "utf-8");
         contents.push(`## ${name}
 
 ${text}`);
@@ -2606,11 +1784,11 @@ ${text}`);
 function ruleShortName(rule) {
   return rule.path.replace(RULES_DIR + "/", "").replace(/\.md$/, "");
 }
-var listRulesTool = tool13({
+var listRulesTool = tool11({
   description: "List all available FlowDeck rule modules with their metadata (description, always_on, " + "stages, languages). Use this before calling load-rules to see what is available. " + "Does NOT load rule content — only returns metadata for discovery.",
   args: {},
   async execute() {
-    const rulesDir = existsSync18(RULES_DIR) ? RULES_DIR : null;
+    const rulesDir = existsSync13(RULES_DIR) ? RULES_DIR : null;
     if (!rulesDir) {
       return JSON.stringify({ rules: [], error: `Rules directory not found at ${RULES_DIR}` });
     }
@@ -2630,13 +1808,13 @@ var listRulesTool = tool13({
 });
 
 // src/tools/rtk-setup.ts
-import { tool as tool14 } from "@opencode-ai/plugin";
+import { tool as tool12 } from "@opencode-ai/plugin";
 
 // src/services/rtk-manager.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import { existsSync as existsSync19 } from "fs";
-import { homedir as homedir2 } from "os";
-import { join as join18 } from "path";
+import { existsSync as existsSync14 } from "fs";
+import { homedir } from "os";
+import { join as join14 } from "path";
 
 // src/services/rtk-policy.ts
 var SUPPORTED_COMMANDS = new Set([
@@ -2682,7 +1860,7 @@ var INSTALL_INSTRUCTIONS = [
   "After installation, call rtk-setup again to verify detection."
 ].join(`
 `);
-var CANDIDATE_PATHS = [join18(homedir2(), ".local", "bin", "rtk"), "/usr/local/bin/rtk", "/usr/bin/rtk"];
+var CANDIDATE_PATHS = [join14(homedir(), ".local", "bin", "rtk"), "/usr/local/bin/rtk", "/usr/bin/rtk"];
 function detectRtk() {
   const fromPath = spawnSync2("rtk", ["--version"], { encoding: "utf-8", timeout: 5000 });
   if (fromPath.status === 0) {
@@ -2691,7 +1869,7 @@ function detectRtk() {
     return { installed: true, binPath: "rtk", version };
   }
   for (const candidate of CANDIDATE_PATHS) {
-    if (!existsSync19(candidate))
+    if (!existsSync14(candidate))
       continue;
     const result = spawnSync2(candidate, ["--version"], { encoding: "utf-8", timeout: 5000 });
     if (result.status === 0) {
@@ -2769,7 +1947,7 @@ function getRtkStatus(opts) {
 }
 
 // src/tools/rtk-setup.ts
-var rtkSetupTool = tool14({
+var rtkSetupTool = tool12({
   description: [
     "Detect, initialize, and report status of rtk (output compression proxy for CLI commands).",
     "rtk reduces noisy CLI output (git, npm, test runners, linters, docker) by 60-90%.",
@@ -2777,7 +1955,7 @@ var rtkSetupTool = tool14({
     "When RTK_INSTALLED=true in the environment, use `$RTK_BIN git status` for compressed output."
   ].join(" "),
   args: {
-    action: tool14.schema.enum(["status", "init"]).optional().describe("'status' — detect and report rtk state (default). " + "'init' — detect, then run `rtk init -g` to install the bash hook. " + "Use 'init' only once per environment setup.")
+    action: tool12.schema.enum(["status", "init"]).optional().describe("'status' — detect and report rtk state (default). " + "'init' — detect, then run `rtk init -g` to install the bash hook. " + "Use 'init' only once per environment setup.")
   },
   async execute(args) {
     const action = args.action ?? "status";
@@ -2817,15 +1995,99 @@ var rtkSetupTool = tool14({
 });
 
 // src/hooks/guard-rails.ts
-import { existsSync as existsSync20, readFileSync as readFileSync20 } from "fs";
-import { join as join19 } from "path";
+import { existsSync as existsSync16, readFileSync as readFileSync16 } from "fs";
+import { join as join16 } from "path";
+
+// src/lib/task-routing.ts
+var UI_HEAVY_KEYWORDS = [
+  "landing page",
+  "marketing site",
+  "website",
+  "web app",
+  "mobile app",
+  "app screen",
+  "dashboard",
+  "admin panel",
+  "settings page",
+  "onboarding ux",
+  "kanban",
+  "design system",
+  "responsive",
+  "ui",
+  "ux",
+  "cta",
+  "conversion flow",
+  "saas interface",
+  "user-facing"
+];
+var NON_UI_KEYWORDS = [
+  "backend",
+  "infrastructure",
+  "migration",
+  "pipeline",
+  "api only",
+  "database only",
+  "cli",
+  "worker"
+];
+function isUiHeavyTask(input) {
+  const normalized = input.trim().toLowerCase();
+  if (!normalized)
+    return false;
+  const hasUiSignal = UI_HEAVY_KEYWORDS.some((keyword) => normalized.includes(keyword));
+  if (!hasUiSignal)
+    return false;
+  const hasOnlyNonUiSignals = NON_UI_KEYWORDS.some((keyword) => normalized.includes(keyword)) && !normalized.includes("frontend");
+  return !hasOnlyNonUiSignals;
+}
+
+// src/config/loader.ts
+import { existsSync as existsSync15, readFileSync as readFileSync15 } from "fs";
+import { join as join15 } from "path";
+import { homedir as homedir2 } from "os";
+var CONFIG_FILENAME = "flowdeck.json";
+function getGlobalConfigDir() {
+  return process.env.OPENCODE_CONFIG_DIR || (process.env.XDG_CONFIG_HOME ? join15(process.env.XDG_CONFIG_HOME, "opencode") : join15(homedir2(), ".config", "opencode"));
+}
+function loadFlowDeckConfig(directory) {
+  const candidates = [];
+  if (directory) {
+    candidates.push(join15(directory, ".opencode", CONFIG_FILENAME));
+  }
+  candidates.push(join15(getGlobalConfigDir(), CONFIG_FILENAME));
+  for (const configPath of candidates) {
+    if (existsSync15(configPath)) {
+      try {
+        const content = readFileSync15(configPath, "utf-8");
+        return JSON.parse(content);
+      } catch {}
+    }
+  }
+  return {};
+}
+function resolveDesignFirstConfig(config) {
+  return {
+    enabled: config.designFirst?.enabled ?? true,
+    enforcement: config.designFirst?.enforcement ?? "strict",
+    requireApprovalBeforeImplementation: config.designFirst?.requireApprovalBeforeImplementation ?? true,
+    modelOverrides: config.designFirst?.modelOverrides ?? {},
+    defaultSkillsByTaskType: config.designFirst?.defaultSkillsByTaskType ?? {
+      "landing-page": ["landing-page-design", "wireframe-planning", "design-system-definition", "frontend-handoff"],
+      dashboard: ["dashboard-design", "ui-ux-planning", "wireframe-planning", "responsive-review"],
+      "admin-panel": ["ui-ux-planning", "wireframe-planning", "design-system-definition", "frontend-handoff"],
+      "app-screen": ["app-shell-design", "ui-ux-planning", "wireframe-planning", "responsive-review"],
+      "general-ui": ["ui-ux-planning", "wireframe-planning", "design-system-definition", "frontend-handoff"]
+    }
+  };
+}
+// src/hooks/guard-rails.ts
 var PLANNING_DIR2 = ".planning";
 var CONFIG_FILE = "config.json";
 var STATE_FILE2 = "STATE.md";
 function resolveExecutionMode(configPath, trustScore, volatility) {
-  if (existsSync20(configPath)) {
+  if (existsSync16(configPath)) {
     try {
-      const config = JSON.parse(readFileSync20(configPath, "utf-8"));
+      const config = JSON.parse(readFileSync16(configPath, "utf-8"));
       if (config.execution_mode === "review-only")
         return "review-only";
       if (config.execution_mode === "guarded")
@@ -2879,22 +2141,22 @@ async function guardRailsHook(ctx, input, _output) {
   if (!ENABLED)
     return;
   const dir = ctx.directory;
-  const planningDirPath = join19(dir, PLANNING_DIR2);
+  const planningDirPath = join16(dir, PLANNING_DIR2);
   const codebaseDirectory = codebaseDir(dir);
-  const configPath = join19(planningDirPath, CONFIG_FILE);
-  const statePath2 = join19(planningDirPath, STATE_FILE2);
+  const configPath = join16(planningDirPath, CONFIG_FILE);
+  const statePath2 = join16(planningDirPath, STATE_FILE2);
   const workspaceRoot = findWorkspaceRoot(dir);
   if (workspaceRoot && dir !== workspaceRoot) {
     const config = getWorkspaceConfig(dir);
-    if (config && config.workspace_mode === "shared" && !existsSync20(planningDirPath)) {
+    if (config && config.workspace_mode === "shared" && !existsSync16(planningDirPath)) {
       const msg = `No .planning/ in this sub-repo. Switch to workspace root: cd ${workspaceRoot}`;
       throw new Error(`[flowdeck] BLOCK: ${msg}`);
     }
   }
   if (input.tool === "write" || input.tool === "edit") {
-    if (!existsSync20(planningDirPath))
+    if (!existsSync16(planningDirPath))
       return;
-    if (!existsSync20(codebaseDirectory)) {
+    if (!existsSync16(codebaseDirectory)) {
       throw new Error(`[flowdeck] WARNING: .codebase/ not found. Run /fd-map-codebase to map the codebase.`);
     }
     const execMode = resolveExecutionMode(configPath, null);
@@ -2950,15 +2212,15 @@ function getDesignGateMessage(dir) {
 }
 function planSuggestsUiHeavy(dir, phase) {
   const planPath = phasePlanPath(dir, phase);
-  if (!existsSync20(planPath))
+  if (!existsSync16(planPath))
     return false;
-  const planContent = readFileSync20(planPath, "utf-8");
+  const planContent = readFileSync16(planPath, "utf-8");
   return isUiHeavyTask(planContent);
 }
 function effectiveSeverity(configPath, statePath2) {
-  if (existsSync20(configPath)) {
+  if (existsSync16(configPath)) {
     try {
-      const configContent = readFileSync20(configPath, "utf-8");
+      const configContent = readFileSync16(configPath, "utf-8");
       const config = JSON.parse(configContent);
       if (config.guard_enforcement === "warn")
         return "warn";
@@ -2974,10 +2236,10 @@ function getEffectiveSeverity(configPath, statePath2) {
   return effectiveSeverity(configPath, statePath2);
 }
 function getPlanConfirmed(statePath2) {
-  if (!existsSync20(statePath2))
+  if (!existsSync16(statePath2))
     return false;
   try {
-    const content = readFileSync20(statePath2, "utf-8");
+    const content = readFileSync16(statePath2, "utf-8");
     const match = content.match(/plan_confirmed:\s*(true|false)/i);
     return match ? match[1].toLowerCase() === "true" : false;
   } catch {
@@ -2985,32 +2247,32 @@ function getPlanConfirmed(statePath2) {
   }
 }
 function getWarningMessage(planningDir2) {
-  if (!existsSync20(join19(planningDir2, STATE_FILE2))) {
+  if (!existsSync16(join16(planningDir2, STATE_FILE2))) {
     return "No STATE.md found. Run /fd-map-codebase then /fd-new-feature to start a feature.";
   }
   return "Plan not confirmed. Run /fd-plan and confirm to enable execution.";
 }
 function getBlockMessage(planningDir2) {
-  if (!existsSync20(join19(planningDir2, STATE_FILE2))) {
+  if (!existsSync16(join16(planningDir2, STATE_FILE2))) {
     return "No STATE.md found. Run /fd-map-codebase then /fd-new-feature to start a feature.";
   }
   return "Plan not confirmed. Run /fd-plan and confirm to enable execution.";
 }
 
 // src/hooks/tool-guard.ts
-import { existsSync as existsSync21, readFileSync as readFileSync21 } from "fs";
-import { join as join20 } from "path";
+import { existsSync as existsSync17, readFileSync as readFileSync17 } from "fs";
+import { join as join17 } from "path";
 var IS_ENABLED = () => process.env.FLOWDECK_TOOL_GUARD_ENABLED === "on";
 var BLOCKED_PATTERNS = {
   read: [".env", ".pem", ".key", ".secret"],
   write: ["node_modules"],
   bash: ["rm -rf"]
 };
-function isBlocked(tool15, args) {
-  const patterns = BLOCKED_PATTERNS[tool15];
+function isBlocked(tool13, args) {
+  const patterns = BLOCKED_PATTERNS[tool13];
   if (!patterns)
     return null;
-  if (tool15 === "bash") {
+  if (tool13 === "bash") {
     const cmd = args.command;
     if (!cmd)
       return null;
@@ -3021,7 +2283,7 @@ function isBlocked(tool15, args) {
     }
     return null;
   }
-  if (tool15 === "read") {
+  if (tool13 === "read") {
     const filePath = args.filePath;
     if (!filePath)
       return null;
@@ -3032,7 +2294,7 @@ function isBlocked(tool15, args) {
     }
     return null;
   }
-  if (tool15 === "write") {
+  if (tool13 === "write") {
     const filePath = args.filePath;
     if (!filePath)
       return null;
@@ -3046,11 +2308,11 @@ function isBlocked(tool15, args) {
   return null;
 }
 function checkArchConstraint(directory, filePath) {
-  const constraintsPath = join20(codebaseDir(directory), "CONSTRAINTS.md");
-  if (!existsSync21(constraintsPath))
+  const constraintsPath = join17(codebaseDir(directory), "CONSTRAINTS.md");
+  if (!existsSync17(constraintsPath))
     return null;
   try {
-    const content = readFileSync21(constraintsPath, "utf-8");
+    const content = readFileSync17(constraintsPath, "utf-8");
     const match = content.match(/## Forbidden Paths\n([\s\S]*?)(?:\n##|$)/);
     if (!match)
       return null;
@@ -3091,9 +2353,9 @@ function isUiDesignApprovalRequired(directory) {
     return !(state.design_stage === "handoff_complete" && state.design_approved);
   }
   const planPath = phasePlanPath(directory, state.phase || 1);
-  if (!existsSync21(planPath))
+  if (!existsSync17(planPath))
     return false;
-  const planContent = readFileSync21(planPath, "utf-8");
+  const planContent = readFileSync17(planPath, "utf-8");
   if (!isUiHeavyTask(planContent))
     return false;
   return !(state.design_stage === "handoff_complete" && state.design_approved);
@@ -3122,18 +2384,18 @@ async function toolGuardHook(ctx, input, output) {
 }
 
 // src/hooks/session-start.ts
-import { existsSync as existsSync22, readFileSync as readFileSync22 } from "fs";
+import { existsSync as existsSync18, readFileSync as readFileSync18 } from "fs";
 async function sessionStartHook(ctx) {
   const planningDir2 = ctx.directory + "/.planning";
   const codebaseDirectory = codebaseDir(ctx.directory);
   const workspaceRoot = findWorkspaceRoot(ctx.directory);
   const config = workspaceRoot ? getWorkspaceConfig(ctx.directory) : null;
-  if (!existsSync22(planningDir2)) {
+  if (!existsSync18(planningDir2)) {
     return {
       flowdeck_phase: null,
       flowdeck_status: "no_plan",
       flowdeck_warning: "Run /fd-map-codebase to index the codebase, then /fd-new-feature to start a feature.",
-      flowdeck_has_codebase: existsSync22(codebaseDirectory),
+      flowdeck_has_codebase: existsSync18(codebaseDirectory),
       ...workspaceRoot && config?.sub_repos ? {
         flowdeck_workspace_root: workspaceRoot,
         flowdeck_sub_repos: config.sub_repos,
@@ -3144,7 +2406,7 @@ async function sessionStartHook(ctx) {
   }
   try {
     const stateFilePath = statePath(ctx.directory);
-    const content = readFileSync22(stateFilePath, "utf-8");
+    const content = readFileSync18(stateFilePath, "utf-8");
     const state = parseState(content);
     const currentPhase = state["current_phase"] || {};
     const result = {
@@ -3152,7 +2414,7 @@ async function sessionStartHook(ctx) {
       flowdeck_status: currentPhase["status"] ?? null,
       flowdeck_steps_pending: currentPhase["steps_pending"] ?? null,
       flowdeck_last_action: currentPhase["last_action"] ?? null,
-      flowdeck_has_codebase: existsSync22(codebaseDirectory)
+      flowdeck_has_codebase: existsSync18(codebaseDirectory)
     };
     if (workspaceRoot && config?.sub_repos && config.sub_repos.length > 0) {
       result.flowdeck_workspace_root = workspaceRoot;
@@ -3166,7 +2428,7 @@ async function sessionStartHook(ctx) {
       flowdeck_phase: null,
       flowdeck_status: "error",
       flowdeck_warning: "State file unreadable. Continuing without flowdeck context.",
-      flowdeck_has_codebase: existsSync22(codebaseDirectory)
+      flowdeck_has_codebase: existsSync18(codebaseDirectory)
     };
     if (workspaceRoot && config?.sub_repos && config.sub_repos.length > 0) {
       result.flowdeck_workspace_root = workspaceRoot;
@@ -3298,13 +2560,13 @@ class NotificationController {
     return this.lastNotifiedKey;
   }
 }
-function notifyPermissionNeeded(tool15) {
-  notify("FlowDeck Permission Required", `Agent needs approval to use tool: ${tool15}`, "critical");
+function notifyPermissionNeeded(tool13) {
+  notify("FlowDeck Permission Required", `Agent needs approval to use tool: ${tool13}`, "critical");
 }
 
 // src/hooks/patch-trust.ts
-import { existsSync as existsSync23, readFileSync as readFileSync23 } from "fs";
-import { join as join21 } from "path";
+import { existsSync as existsSync19, readFileSync as readFileSync19 } from "fs";
+import { join as join18 } from "path";
 var HIGH_RISK_KEYWORDS = [
   "password",
   "secret",
@@ -3326,11 +2588,11 @@ var HIGH_RISK_KEYWORDS = [
   "privilege"
 ];
 function loadFailedPaths(directory) {
-  const p = join21(codebaseDir(directory), "FAILURES.json");
-  if (!existsSync23(p))
+  const p = join18(codebaseDir(directory), "FAILURES.json");
+  if (!existsSync19(p))
     return [];
   try {
-    const data = JSON.parse(readFileSync23(p, "utf-8"));
+    const data = JSON.parse(readFileSync19(p, "utf-8"));
     return (data.entries ?? []).flatMap((e) => e.affected_paths ?? []);
   } catch {
     return [];
@@ -3383,8 +2645,8 @@ async function patchTrustHook(ctx, input, output) {
 }
 
 // src/hooks/decision-trace-hook.ts
-import { existsSync as existsSync24, mkdirSync as mkdirSync12, appendFileSync as appendFileSync4 } from "fs";
-import { join as join22 } from "path";
+import { existsSync as existsSync20, mkdirSync as mkdirSync9, appendFileSync as appendFileSync3 } from "fs";
+import { join as join19 } from "path";
 async function decisionTraceHook(ctx, input, output) {
   if (input.tool !== "write" && input.tool !== "edit")
     return;
@@ -3393,8 +2655,8 @@ async function decisionTraceHook(ctx, input, output) {
     return;
   const base = codebaseDir(ctx.directory);
   try {
-    if (!existsSync24(base))
-      mkdirSync12(base, { recursive: true });
+    if (!existsSync20(base))
+      mkdirSync9(base, { recursive: true });
     const entry = {
       timestamp: new Date().toISOString(),
       file_path: filePath,
@@ -3406,14 +2668,14 @@ async function decisionTraceHook(ctx, input, output) {
       risk_level: "unknown",
       auto_recorded: true
     };
-    appendFileSync4(join22(base, "DECISIONS.jsonl"), JSON.stringify(entry) + `
+    appendFileSync3(join19(base, "DECISIONS.jsonl"), JSON.stringify(entry) + `
 `, "utf-8");
   } catch {}
 }
 
 // src/services/approval-manager.ts
-import { existsSync as existsSync25, readFileSync as readFileSync24, writeFileSync as writeFileSync13, mkdirSync as mkdirSync13 } from "fs";
-import { join as join23 } from "path";
+import { existsSync as existsSync21, readFileSync as readFileSync20, writeFileSync as writeFileSync11, mkdirSync as mkdirSync10 } from "fs";
+import { join as join20 } from "path";
 var APPROVAL_TTL_MS = 30 * 60 * 1000;
 var SENSITIVE_PATTERNS = [
   /auth/i,
@@ -3450,20 +2712,20 @@ function isSensitivePath(filePath) {
   return SENSITIVE_PATTERNS.some((p) => p.test(filePath));
 }
 function approvalsPath(dir) {
-  return join23(codebaseDir(dir), "APPROVALS.json");
+  return join20(codebaseDir(dir), "APPROVALS.json");
 }
-function loadStore2(dir) {
+function loadStore(dir) {
   const p = approvalsPath(dir);
-  if (!existsSync25(p))
+  if (!existsSync21(p))
     return { requests: [] };
   try {
-    return JSON.parse(readFileSync24(p, "utf-8"));
+    return JSON.parse(readFileSync20(p, "utf-8"));
   } catch {
     return { requests: [] };
   }
 }
 function checkApproval(dir, file_path, command) {
-  const store = loadStore2(dir);
+  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;
 }
@@ -3475,8 +2737,8 @@ async function approvalHook(context, toolInput, output) {
   if (!ENABLED2)
     return;
   const dir = context.directory ?? process.cwd();
-  const tool15 = toolInput.name ?? toolInput.tool ?? "";
-  if (!WRITE_TOOLS.has(tool15))
+  const tool13 = toolInput.name ?? toolInput.tool ?? "";
+  if (!WRITE_TOOLS.has(tool13))
     return;
   const args = output.args ?? {};
   const filePath = String(args.path ?? args.file_path ?? args.filename ?? "");
@@ -3493,8 +2755,8 @@ async function approvalHook(context, toolInput, output) {
 }
 
 // src/services/event-logger.ts
-import { existsSync as existsSync26, mkdirSync as mkdirSync14, appendFileSync as appendFileSync5, readFileSync as readFileSync25, writeFileSync as writeFileSync14, renameSync, unlinkSync, statSync as statSync2 } from "fs";
-import { join as join24, resolve as resolve2, sep } from "path";
+import { existsSync as existsSync22, mkdirSync as mkdirSync11, appendFileSync as appendFileSync4, readFileSync as readFileSync21, writeFileSync as writeFileSync12, renameSync, unlinkSync, statSync } from "fs";
+import { join as join21, resolve as resolve2, sep } from "path";
 var SENSITIVE_KEYS = [
   "password",
   "token",
@@ -3548,7 +2810,7 @@ function isValidDirectory(directory) {
     return false;
   }
   try {
-    const stats = statSync2(directory);
+    const stats = statSync(directory);
     return stats.isDirectory();
   } catch {
     return false;
@@ -3559,13 +2821,13 @@ function logEvent(directory, event, log) {
     return;
   if (!isValidDirectory(directory))
     return;
-  const logDir = join24(directory, ".opencode");
-  const logPath = join24(logDir, "flowdeck-events.jsonl");
+  const logDir = join21(directory, ".opencode");
+  const logPath = join21(logDir, "flowdeck-events.jsonl");
   try {
-    if (!existsSync26(logDir)) {
-      mkdirSync14(logDir, { recursive: true });
+    if (!existsSync22(logDir)) {
+      mkdirSync11(logDir, { recursive: true });
     }
-    appendFileSync5(logPath, JSON.stringify(event) + `
+    appendFileSync4(logPath, JSON.stringify(event) + `
 `, "utf-8");
     rotateLogFile(logPath);
     if (log) {
@@ -3575,17 +2837,17 @@ function logEvent(directory, event, log) {
 }
 function rotateLogFile(logPath) {
   try {
-    const stats = statSync2(logPath);
+    const stats = statSync(logPath);
     if (stats.size < 5000)
       return;
-    const content = readFileSync25(logPath, "utf-8");
+    const content = readFileSync21(logPath, "utf-8");
     const lines = content.split(`
 `).filter((l) => l.trim());
     if (lines.length > 1000) {
       const backupPath = logPath + ".backup";
       renameSync(logPath, backupPath);
       const keep = lines.slice(-1000);
-      writeFileSync14(logPath, keep.join(`
+      writeFileSync12(logPath, keep.join(`
 `) + `
 `, "utf-8");
       try {
@@ -3609,8 +2871,6 @@ function formatEventForStderr(event) {
         icon = "\uD83D\uDD0D";
       else if (event.tool === "bash" || event.tool === "shell")
         icon = "\uD83C\uDFC3";
-      else if (event.tool === "delegate")
-        icon = "\uD83E\uDD16";
       else
         icon = "\uD83D\uDD27";
       const argStr = formatArgs(event.args);
@@ -3638,10 +2898,6 @@ function formatEventForStderr(event) {
       const error = event.error ? ` error: ${event.error}` : "";
       return `${dim}[${time}]${reset} ${icon} ${cyan}${agent}${reset}  → ${event.tool}(${argStr})${statusColor}${duration}${error}${reset}`;
     }
-    case "agent.delegated": {
-      const thinking = event.thinking ? ` "${event.thinking}"` : "";
-      return `${dim}[${time}]${reset} \uD83E\uDD16 ${cyan}${agent}${reset}  → delegate(${thinking})`;
-    }
     case "session.created":
       return `${dim}[${time}]${reset} \uD83D\uDCC2 session created${event.session_id ? ` (${event.session_id})` : ""}`;
     case "session.idle":
@@ -3780,10 +3036,6 @@ function extractAgentFromEvent(props) {
     return props.agent;
   if (typeof props.name === "string")
     return props.name;
-  const title = typeof props.title === "string" ? props.title : "";
-  const match = title.match(/^(.+)-delegate$/);
-  if (match)
-    return match[1];
   return "unknown";
 }
 
@@ -3838,15 +3090,15 @@ function createContextWindowMonitorHook() {
 }
 
 // src/hooks/shell-env-hook.ts
-import { existsSync as existsSync27, readFileSync as readFileSync26 } from "fs";
-import { join as join25 } from "path";
-import { createRequire as createRequire2 } from "module";
+import { existsSync as existsSync23, readFileSync as readFileSync22 } from "fs";
+import { join as join22 } from "path";
+import { createRequire } from "module";
 var _version;
 function getVersion() {
   if (_version)
     return _version;
   try {
-    const require2 = createRequire2(import.meta.url);
+    const require2 = createRequire(import.meta.url);
     const pkg = require2("../../package.json");
     _version = pkg.version ?? "0.0.0";
   } catch {
@@ -3875,7 +3127,7 @@ var MARKER_TO_LANG = {
 };
 function detectPackageManager(root) {
   for (const [lockfile, pm] of Object.entries(LOCKFILE_TO_PM)) {
-    if (existsSync27(join25(root, lockfile)))
+    if (existsSync23(join22(root, lockfile)))
       return pm;
   }
   return;
@@ -3884,7 +3136,7 @@ function detectLanguages(root) {
   const langs = [];
   const seen = new Set;
   for (const [marker, lang] of Object.entries(MARKER_TO_LANG)) {
-    if (!seen.has(lang) && existsSync27(join25(root, marker))) {
+    if (!seen.has(lang) && existsSync23(join22(root, marker))) {
       langs.push(lang);
       seen.add(lang);
     }
@@ -3892,11 +3144,11 @@ function detectLanguages(root) {
   return langs;
 }
 function readCurrentPhase(root) {
-  const statePath2 = join25(root, ".planning", "STATE.md");
-  if (!existsSync27(statePath2))
+  const statePath2 = join22(root, ".planning", "STATE.md");
+  if (!existsSync23(statePath2))
     return;
   try {
-    const content = readFileSync26(statePath2, "utf-8");
+    const content = readFileSync22(statePath2, "utf-8");
     const match = content.match(/phase:\s*(\S+)/i);
     return match?.[1];
   } catch {
@@ -4021,8 +3273,8 @@ function createSessionIdleHook(client, tracker) {
 }
 
 // src/hooks/compaction-hook.ts
-import { existsSync as existsSync28, readFileSync as readFileSync27 } from "fs";
-import { join as join26 } from "path";
+import { existsSync as existsSync24, readFileSync as readFileSync23 } from "fs";
+import { join as join23 } from "path";
 var STRUCTURED_SUMMARY_PROMPT = `
 When summarizing this session, you MUST include the following sections:
 
@@ -4063,10 +3315,10 @@ For each: agent name, status, description, session_id.
 var _lastInjected = new Map;
 function readPlanningState2(directory) {
   const sp = statePath(directory);
-  if (!existsSync28(sp))
+  if (!existsSync24(sp))
     return null;
   try {
-    const content = readFileSync27(sp, "utf-8");
+    const content = readFileSync23(sp, "utf-8");
     const parsed = parseState(content);
     const version = typeof parsed.summaryVersion === "number" ? parsed.summaryVersion : 0;
     return { content: content.slice(0, 1500), version };
@@ -4095,15 +3347,15 @@ function createCompactionHook(ctx, tracker) {
       sections.push(`_State unchanged since last compaction. summaryVersion=${currentStateVersion}_`);
       sections.push("");
     }
-    const indexPath2 = join26(ctx.directory, ".planning", "CODEBASE_INDEX.md");
-    if (indexChanged && existsSync28(indexPath2)) {
+    const indexPath2 = join23(ctx.directory, ".planning", "CODEBASE_INDEX.md");
+    if (indexChanged && existsSync24(indexPath2)) {
       try {
-        const indexContent = readFileSync27(indexPath2, "utf-8");
+        const indexContent = readFileSync23(indexPath2, "utf-8");
         const indexSummary = "\n## Codebase Index\n```\n" + indexContent.slice(0, 800) + "\n```\n";
         sections.push(indexSummary);
         sections.push("");
       } catch {}
-    } else if (existsSync28(indexPath2)) {
+    } else if (existsSync24(indexPath2)) {
       sections.push(`## Codebase Index (unchanged, v${currentIndexVersion})`);
       sections.push(`_Index unchanged since last compaction. summaryVersion=${currentIndexVersion}_`);
       sections.push("");
@@ -4129,7 +3381,7 @@ function createCompactionHook(ctx, tracker) {
 }
 
 // src/hooks/orchestrator-guard-hook.ts
-var DISABLED = process.env.FLOWDECK_ORCHESTRATOR_GUARD !== "on";
+var DISABLED = process.env.FLOWDECK_ORCHESTRATOR_GUARD === "off";
 var BLOCKED_TOOLS = new Set([
   "write_file",
   "write",
@@ -4146,26 +3398,63 @@ var BLOCKED_TOOLS = new Set([
   "execute",
   "run_command",
   "terminal",
-  "shell"
+  "shell",
+  "python",
+  "run_python",
+  "js",
+  "run_js",
+  "npm",
+  "pnpm",
+  "yarn",
+  "bun",
+  "cargo",
+  "go",
+  "make",
+  "cmake",
+  "docker",
+  "kubectl",
+  "terraform",
+  "pulumi"
 ]);
 var ALWAYS_ALLOWED = new Set([
-  "delegate",
-  "run-pipeline",
-  "council",
+  "read",
+  "read_file",
+  "view",
+  "search",
+  "grep",
+  "glob",
   "planning-state",
   "codebase-state",
   "repo-memory",
   "decision-trace",
   "policy-engine",
-  "reflect"
+  "reflect",
+  "codegraph",
+  "codegraph-search",
+  "codegraph-node",
+  "codegraph-explore",
+  "load-rules",
+  "list-rules",
+  "council",
+  "rtk-setup",
+  "hash-edit",
+  "failure-replay"
 ]);
-function isDelegationTool(name) {
-  return ALWAYS_ALLOWED.has(name);
+function normalizeToolName(name) {
+  return name.toLowerCase().replace(/[-_]/g, "");
 }
 function isBlocked2(name) {
-  const norm = name.toLowerCase().replace(/[-_]/g, "");
+  const norm = normalizeToolName(name);
   for (const b of BLOCKED_TOOLS) {
-    if (norm === b.replace(/[-_]/g, "") || norm === b.replace(/_/g, ""))
+    if (norm === normalizeToolName(b))
+      return true;
+  }
+  return false;
+}
+function isAlwaysAllowed(name) {
+  const norm = normalizeToolName(name);
+  for (const a of ALWAYS_ALLOWED) {
+    if (norm === normalizeToolName(a))
       return true;
   }
   return false;
@@ -4173,17 +3462,21 @@ function isBlocked2(name) {
 function blockMessage(toolName) {
   return `[Orchestrator Guard] The orchestrator cannot use \`${toolName}\` directly.
 
-` + `The orchestrator is a coordinator — it must delegate all implementation work.
+` + `The orchestrator is a coordinator, not an executor.
+
+` + `Routing options:
+` + `  @default-executor  — simple direct tasks (rename, typo fix, quick edit)
+` + `  @backend-coder     — backend code writing and editing
+` + `  @frontend-coder    — frontend code writing and editing
+` + `  @devops            — CI/CD, deploy, and infrastructure changes
+` + `  @mapper            — codebase mapping
+` + `  @researcher        — focused research and file analysis
+` + `  @tester            — tests, builds, and shell-heavy verification
+` + `  @writer            — documentation writing
 
-` + `Use the \`delegate\` tool to hand this off:
-` + `  delegate({ agent: "@backend-coder", prompt: "..." })      — backend code writing / editing
-` + `  delegate({ agent: "@frontend-coder", prompt: "..." })     — frontend code writing / editing
-` + `  delegate({ agent: "@devops", prompt: "..." })             — CI/CD, deploy, and infra changes
-` + `  delegate({ agent: "@mapper", prompt: "..." })     — codebase mapping
-` + `  delegate({ agent: "@researcher", prompt: "..." }) — research / file analysis
-` + `  delegate({ agent: "@tester", prompt: "..." })     — tests / commands
+` + `Allowed tools for orchestrator: read, search, planning-state, codebase-state, repo-memory, decision-trace, policy-engine, reflect, codegraph, load-rules, council, rtk-setup, hash-edit, failure-replay.
 
-` + `To enable this guard: set FLOWDECK_ORCHESTRATOR_GUARD=on`;
+` + `To disable this guard: set FLOWDECK_ORCHESTRATOR_GUARD=off`;
 }
 
 class OrchestratorGuard {
@@ -4215,12 +3508,21 @@ class OrchestratorGuard {
       return;
     if (sessionId !== this.primarySessionId)
       return;
-    if (isDelegationTool(toolName))
+    if (isAlwaysAllowed(toolName))
       return;
     if (isBlocked2(toolName)) {
       throw new Error(blockMessage(toolName));
     }
   }
+  _isBlockedForTest(name) {
+    return isBlocked2(name);
+  }
+  _isAllowedForTest(name) {
+    return isAlwaysAllowed(name);
+  }
+  _setPrimarySessionIdForTest(id) {
+    this.primarySessionId = id;
+  }
 }
 function extractSessionId(event) {
   const props = event.properties;
@@ -4351,274 +3653,331 @@ ${customAppendPrompt}`;
   return base;
 }
 // src/agents/orchestrator.ts
-var ORCHESTRATOR_PROMPT = `You coordinate multi-agent execution. You read STATE.md and PLAN.md at startup, delegate work to specialists, and track progress.
+var ORCHESTRATOR_PROMPT = `You are the FlowDeck Orchestrator. You coordinate multi-agent execution. You do NOT execute tasks yourself.
+
+## Core Rule: You Are a Router, Not a Worker
+
+**NEVER** perform the following directly:
+- Write or edit files
+- Run shell commands, bash scripts, or terminal operations
+- Run tests or builds
+- Implement code
+- Do full investigations
+- Run the entire coding workflow yourself
+
+Your ONLY job is to:
+1. **Analyze** the request
+2. **Classify** the task type and estimate complexity/risk/ambiguity
+3. **Choose** the appropriate workflow and execution path
+4. **Route** work to the correct agent or execution path
+5. **Supervise** progress
+6. **Collect** results
+7. **Return** the final coordinated outcome
+
+## Routing-First Protocol
+
+For EVERY user request, you MUST follow this exact sequence BEFORE any execution begins:
+
+### Step 1: Analyze
+- Read STATE.md if it exists
+- Identify current phase and workflow class
+- Understand what the user is asking for
+
+### Step 2: Classify
+Estimate:
+- Simplicity: Is this a rename, typo fix, config update, or simple question?
+- Confidence: How well does the request match known patterns?
+- Risk: Blast radius (files touched) and sensitivity (auth, security, data)
+- Codebase familiarity: Is the codebase mapping fresh?
+- Complexity: Cheap (classify, validate, summarize) vs expensive (architect, refactor)
+
+### Step 3: Choose Workflow
+Select ONE of these workflow classes:
+
+| Workflow Class | Execution Path | When to Select |
+|----------------|---------------|----------------|
+| \`quick\` | Route to @default-executor with \`direct-stock-tools\` mode | Simple, low-risk tasks (< 5 files, no ambiguity) |
+| \`standard\` | Plan with @planner → Execute with specialists → Verify with @reviewer | Normal implementation tasks |
+| \`explore\` | Discuss with @discusser → Plan with @planner → Execute with specialists | Ambiguous or unfamiliar tasks |
+| \`ui-heavy\` | Discuss with @discusser → Design with @design → Plan with @planner → Execute with specialists | UI/UX-heavy tasks |
+| \`bugfix\` | Discuss with @discusser → Fix with @debug-specialist / @backend-coder → Verify with @tester | Bug fixes |
+| \`docs-only\` | Route to @default-executor with \`inspect-only\` or \`simple-edit\` mode, or @writer for large docs | Documentation-only changes |
+| \`verify-heavy\` | Plan with @planner (enhanced checks) → Execute with specialists → Verify with @reviewer + @security-auditor | High blast radius or sensitive paths |
+
+### Step 4: Log the Decision
+Before routing, you MUST emit a routing decision in this exact format:
 
-## HARD RULES — Non-Negotiable
-
-**You are a coordinator. You NEVER do implementation work yourself.**
-
-1. **Never read source files directly.** You may read STATE.md, PLAN.md, and .codebase/ summary files — nothing else. For all other file reading, delegate to @code-explorer or @researcher.
-2. **Never write or edit any file.** All file creation, editing, and patching is done by specialist agents. Use \`delegate\` to hand it off.
-3. **Never run shell commands, tests, or builds.** Delegate to @tester or @build-error-resolver.
-4. **Every step in PLAN.md is executed by a delegated agent**, never by you directly.
-
-If you feel the urge to read a source file, write code, or run a command — stop. Identify the right specialist and delegate instead.
+\`\`\`
+## Routing Decision
+
+**Request:** <brief summary of user request>
+**Classification:** <task type> | Confidence: <0.0-1.0>
+**Workflow Selected:** <workflow class>
+**Reason:** <why this workflow was chosen>
+**Execution Path:** <which agent(s) will execute>
+**Estimated Blast Radius:** <number of files or "unknown">
+\`\`\`
 
-**Delegation is not optional. It is your only mode of operation.**
+### Step 5: Route and Supervise
+- Invoke the selected agent(s) using OpenCode's native @agent invocation
+- Provide clear, focused context
+- Wait for completion
+- Collect results
+- If escalation is needed, log the escalation and re-route
+
+## What You MAY Do Directly
+
+You may ONLY use these tools directly:
+- **read** — Read files for lightweight inspection
+- **search/grep** — Search codebase for patterns
+- **planning-state** — Read/update planning state
+- **codebase-state** — Read codebase documentation
+- **repo-memory** — Query architecture graph
+- **decision-trace** — Record decisions
+- **policy-engine** — Check policies
+- **reflect** — Gather session artifacts
+
+You may NEVER use:
+- write, write_file, create, create_file
+- edit, edit_file, patch, apply_patch, str_replace_editor, str_replace
+- bash, run_bash, execute, run_command, terminal, shell
+- Any tool that modifies the filesystem or executes commands
+
+## Execution Paths After Routing
+
+### Direct Execution Path (via @default-executor)
+When workflow class is \`quick\` or \`docs-only\` (simple):
+- Route to @default-executor with an explicit mode:
+  - \`direct-stock-tools\` — for simple file changes
+  - \`quick-answer\` — for questions
+  - \`inspect-only\` — for analysis/reporting
+  - \`simple-edit\` — for surgical changes
+- The @default-executor is the worker; you are the coordinator
+
+### Specialist Execution Path
+When workflow class is \`standard\`, \`explore\`, \`ui-heavy\`, \`bugfix\`, or \`verify-heavy\`:
+- Route implementation to role-specific specialists:
+  - @backend-coder — server, API, business logic, database
+  - @frontend-coder — UI components, client state, styling
+  - @devops — CI/CD, deployment, infrastructure
+  - @tester — tests, builds, verification
+  - @researcher — API docs, library research
+  - @reviewer — code quality review
+  - @security-auditor — security review
+  - @debug-specialist — root cause analysis
+
+### Parallel Execution Patterns
+
+Wave 1 (parallel):
+  @researcher       — research the library API
+  @backend-coder    — implement the model and types
+  @tester           — write test cases
+
+Wave 2 (after Wave 1):
+  @backend-coder    — implement service using Wave 1 research
+  @reviewer         — review Wave 1 implementation
+
+## Adaptive Routing and Escalation
+
+If you discover during supervision that the initial workflow class is insufficient:
+1. Log the escalation with reason
+2. Select the richer workflow class
+3. Re-route the remaining work to appropriate agents
+4. You STILL do not execute the work yourself
+
+Escalation paths:
+- quick → standard: when blast radius exceeds 3 files
+- standard → verify-heavy: when sensitive paths are touched
+- standard → ui-heavy: when design requirements emerge
+- explore → standard: when confidence improves after discussion
 
 ## Startup Behavior
 
-MUST execute at session start:
-1. Read \`STATE.md\` — identify current phase and active plan
-2. Read the active \`PLAN.md\` — identify which steps are complete and which are next
-3. Check which steps are marked complete
-4. Begin execution from the first incomplete step
+At session start:
+1. Read STATE.md to identify the current phase and active plan.
+2. Read the active PLAN.md to identify complete and incomplete steps.
+3. Resume from the first incomplete step.
 
-If STATE.md does not exist, tell the user: "No STATE.md found. Run \`/fd-map-codebase\` then \`/fd-new-feature\` to start a feature."
+If STATE.md does not exist, tell the user: No STATE.md found. Run /fd-map-codebase then /fd-new-feature to start a feature.
 
 ## Phase Gating
 
-Only orchestrate in the **execute** phase.
+Read STATE.md to determine the current phase and workflow class.
 
-If the project is in another phase:
-- **discuss** phase: "Run \`/fd-discuss\` to complete requirements gathering first."
-- **plan** phase: "Run \`/fd-plan\` to create the implementation plan first."
-- **review** phase: "Run \`/fd-verify\` to complete the review phase."
+The orchestrator may run in any phase, but should respect the workflow class:
+- For \`quick\` workflows: route to @default-executor, skip discuss/plan.
+- For \`standard\` workflows: plan → execute → verify.
+- For \`explore\` workflows: discuss → plan → execute → verify.
+- For \`ui-heavy\` workflows: discuss → design → plan → execute → verify.
+- For \`bugfix\` workflows: discuss → fix-bug → verify.
+- For \`docs-only\` workflows: route to @default-executor or @writer.
+- For \`verify-heavy\` workflows: plan → execute → verify (with enhanced checks).
 
 ## State-First Read Strategy
 
-Before delegating any agent that needs codebase context:
-1. Read \`STATE.md\` — check \`freshnessStatus\` and \`lastUpdatedAt\`
-2. Read \`.planning/CODEBASE_INDEX.md\` — check \`freshnessStatus\`
-3. If \`freshnessStatus === "fresh"\` AND needed files exist in \`fileSnapshots\`:
-   → Use the existing state. Do NOT re-explore the codebase.
-   → Log: "[StateManager] Skipped codebase exploration — state is fresh"
-4. If state is missing, stale, or insufficient:
-   → Delegate to @code-explorer with specific question
-   → After exploration completes, file-tracker auto-publishes to CODEBASE_INDEX.md
-   → Log: "[StateManager] Triggered re-exploration — state was stale"
-
-State becomes **stale** when:
-- \`lastUpdatedAt\` > 5 minutes ago
-- Phase transitions
-- New plan confirmed
-- User runs /fd-checkpoint or /fd-resume
-
-State becomes **fresh** when:
-- Any agent writes to CODEBASE_INDEX.md
-- updatePlanningState() is called
-- file-tracker hook fires after a file edit
+Before invoking an agent that needs codebase context:
+1. Read STATE.md and check freshnessStatus and lastUpdatedAt.
+2. Read .planning/CODEBASE_INDEX.md when available.
+3. Reuse fresh state when it already answers the question.
+4. When state is stale or missing, inspect the relevant files directly or route focused exploration to @code-explorer or @researcher.
 
 ## Step Execution
 
 For each incomplete step in PLAN.md:
-
-1. Identify the step's requirements and agent type
-2. Delegate to the appropriate agent with full context
-3. Wait for the agent to complete
-4. Mark the step complete in STATE.md
-5. Re-read STATE.md to confirm state
-6. Move to the next incomplete step
-
-## Implementation Routing
-
-When a plan step requires implementation, route to a role-specific agent:
-- Use @backend-coder for server, API, business logic, database, and non-UI application code.
-- Use @frontend-coder for UI components, client state, styling, and interaction behavior.
-- Use @devops for CI/CD workflows, deployment, infrastructure, runtime config, and operations scripts.
-- If a step mixes multiple domains, split it into multiple delegated tasks by domain.
-
-## Agent Team
-
-| Agent | Invoke | Best For |
-|-------|--------|----------|
-| Design | @design | Discovery, UX planning, wireframes, visual system, implementation handoff, design fidelity review |
-| Backend Coder | @backend-coder | Backend code implementation |
-| Frontend Coder | @frontend-coder | Frontend code implementation |
-| DevOps | @devops | CI/CD and infrastructure implementation |
-| Researcher | @researcher | API docs, library usage |
-| Tester | @tester | Writing and running tests |
-| Reviewer | @reviewer | Code quality review |
-| Writer | @writer | Documentation |
-| Mapper | @mapper | Codebase mapping to .codebase/ |
-| Architect | @architect | System design, ADRs |
-| Security Auditor | @security-auditor | Security review |
-| Code Explorer | @code-explorer | Reading unfamiliar code |
-| Debug Specialist | @debug-specialist | Root cause analysis |
-| Build Resolver | @build-error-resolver | Build/compile failures |
-| Doc Updater | @doc-updater | Updating existing docs |
-| Task Splitter | @task-splitter | Decomposing complex tasks |
-| Discusser | @discusser | Requirements extraction |
-| Plan Checker | @plan-checker | Plan quality review |
-| Planner | @planner | Feature planning |
-| Build Error Resolver | @build-error-resolver | Build error diagnosis |
-| Performance Optimizer | @performance-optimizer | Performance analysis |
-| Refactor Guide | @refactor-guide | Safe refactoring |
-
-## Phase State Machine
-
-\`\`\`
-discuss → plan → design (for UI-heavy tasks) → execute → review
-\`\`\`
-
-- **discuss**: Requirements extraction with @discusser
-- **plan**: Plan creation with @planner, review with @plan-checker
-- **design**: UX structure, wireframe/layout planning, and visual system definition with @design
-- **execute**: Implementation with @backend-coder, @frontend-coder, @devops, @tester, and @researcher in parallel where possible, only after approved design handoff for UI-heavy tasks
-- **review**: Review with @reviewer, @security-auditor
+1. Identify the step requirements and the best agent for the work.
+2. Gather only the context needed to brief that agent.
+3. Invoke the specialist directly with native agent routing.
+4. Wait for completion, then update and re-read STATE.md.
+5. Move to the next incomplete step.
 
 ## Tracking
 
 After each step completes:
-- Call \`mark_step_complete\` with the step ID
+- Call mark_step_complete with the step ID
 - Re-read STATE.md to confirm the update
-- Update STATE.md \`current_step\` to the next step
+- Update STATE.md current_step to the next step
 
 On all steps complete:
-- Update STATE.md \`phase\` to \`review\`
+- Update STATE.md phase to review
 - Summarize what was delivered
 
 ## Error Recovery
 
-If a delegated agent fails:
-1. Log the failure with the error message
-2. Retry once with clarified instructions
-3. If still failing, escalate:
-
-\`\`\`
-BLOCKED: implementation agent failed on step 3 (add payment endpoint).
-Error: [exact error message]
-Retried once with clarification. Still failing.
-
-Options:
-1. Skip this step and continue
-2. Replan step 3 with smaller scope
-3. Stop and debug manually
-
-Please advise.
-\`\`\`
+If a specialist fails:
+1. Log the failure with the exact error message.
+2. Retry once with clearer context if the issue is recoverable.
+3. If it still fails, surface a blocked summary with next options.
 
 ## Self-Learning
 
 When a task required unusual human guidance, a novel solution strategy, or exposed a knowledge gap:
-1. After the task completes successfully, write a new skill markdown file under \`src/skills/<name>/SKILL.md\` to capture the pattern
-2. Use a descriptive kebab-case name for the directory, a one-sentence description in the frontmatter, and structured Markdown content
-3. Include: When to Activate, Steps, Examples, and Pitfalls sections
+1. After the task completes successfully, write a new skill markdown file under src/skills/<name>/SKILL.md to capture the pattern.
+2. Use a descriptive kebab-case name for the directory, a one-sentence description in the frontmatter, and structured Markdown content.
+3. Include: When to Activate, Steps, Examples, and Pitfalls sections.
 
 Do NOT create a skill for routine tasks. Only capture genuinely novel or reusable patterns.`;
 var AGENT_DESCRIPTIONS = {
+  "default-executor": `@default-executor
+- Role: Default execution worker for simple, direct tasks
+- Permissions: Read/write files, shell execution
+- Best for: Quick answers, simple edits, inspect-only analysis, direct stock-tool usage
+- Use when: Workflow class is \`quick\` or \`docs-only\`, or a single focused task needs direct execution`,
   design: `@design
 - Role: Runs design-first workflow for user-facing tasks
 - Permissions: Read/write files
 - Best for: UX structure, wireframes, visual direction, tokens, and frontend handoff
-- **Delegate when:** Task includes website/app/dashboard/admin/user-facing UI work`,
+- Use when: Task includes website/app/dashboard/admin/user-facing UI work`,
   "backend-coder": `@backend-coder
 - Role: Implements backend features and fixes based on confirmed plans
 - Permissions: Read/write files
 - Best for: API, services, data layer, and business logic
-- **Delegate when:** Backend or server-side implementation work`,
+- Use when: Backend or server-side implementation work`,
   "frontend-coder": `@frontend-coder
 - Role: Implements frontend features and fixes based on confirmed plans
 - Permissions: Read/write files
 - Best for: UI components, client state, rendering, and interaction behavior
-- **Delegate when:** Frontend implementation work`,
+- Use when: Frontend implementation work`,
   devops: `@devops
 - Role: Implements DevOps and infrastructure changes based on confirmed plans
 - Permissions: Read/write files
 - Best for: CI/CD, deployment config, infra scripts, and runtime operations
-- **Delegate when:** Infrastructure, pipeline, or operations implementation work`,
+- Use when: Infrastructure, pipeline, or operations implementation work`,
   researcher: `@researcher
 - Role: Researches documentation, APIs, and best practices
 - Permissions: Read files
 - Stats: 10x better finding up-to-date library docs
-- **Delegate when:** Need API docs, library usage, best practices
-- **Don't delegate when:** Standard usage you're confident about`,
+- Use when: Need API docs, library usage, or best practices
+- Skip when: Standard usage you're already confident about`,
   tester: `@tester
 - Role: Writes and runs tests following TDD principles
 - Permissions: Read/write files
 - Best for: Writing tests before code (TDD), running test suites
-- **Delegate when:** Implementing new features, fixing bugs, test coverage needed`,
+- Use when: Implementing new features, fixing bugs, or increasing coverage`,
   reviewer: `@reviewer
 - Role: Reviews code for quality, security, and adherence to conventions
 - Permissions: Read files
 - Best for: Code review before PRs
-- **Delegate when:** After writing or modifying code, before opening PRs`,
+- Use when: After writing or modifying code, before opening PRs`,
   architect: `@architect
 - Role: Designs system architecture, creates ADRs, defines API contracts
 - Permissions: Read files
 - Best for: New modules, API changes, database schema changes, cross-cutting concerns
-- **Delegate when:** Planning new features that need architectural decisions`,
+- Use when: Planning new features that need architectural decisions`,
   "security-auditor": `@security-auditor
 - Role: Deep security audit of code changes
 - Permissions: Read files
 - Best for: OWASP Top 10, injection vulnerabilities, auth issues
-- **Delegate when:** Before merging security-sensitive code`,
+- Use when: Before merging security-sensitive code`,
   "code-explorer": `@code-explorer
 - Role: Explores and maps unfamiliar codebases
 - Permissions: Read files
 - Best for: Tracing call paths, building structural models
-- **Delegate when:** Before making changes to unfamiliar code`,
+- Use when: Before making changes to unfamiliar code`,
   "debug-specialist": `@debug-specialist
 - Role: Diagnoses bugs through systematic root cause analysis
 - Permissions: Read files
 - Best for: Deep investigation before fixing
-- **Delegate when:** Bug needs investigation, not just a quick fix`,
+- Use when: A bug needs investigation, not just a quick fix`,
   "build-error-resolver": `@build-error-resolver
 - Role: Fixes build errors, compilation failures, dependency issues
 - Permissions: Read/write files
 - Best for: Build failures, type errors, broken dependencies
-- **Delegate when:** Build fails, types error out, dependencies broken`,
+- Use when: Build fails, types error out, or dependencies break`,
   "doc-updater": `@doc-updater
 - Role: Updates documentation after code changes
 - Permissions: Read/write files
 - Best for: API references, README, inline comments
-- **Delegate when:** Implementation completes and docs need updating`,
+- Use when: Implementation completes and docs need syncing`,
   writer: `@writer
 - Role: Drafts project documentation
 - Permissions: Read/write files
 - Best for: README, API docs, user guides
-- **Delegate when:** Creating new documentation from scratch`,
+- Use when: Creating new documentation from scratch`,
   mapper: `@mapper
 - Role: Maps codebase to structured documentation files
 - Permissions: Read/write files
 - Best for: .codebase/ directory documentation
-- **Delegate when:** Need to document existing codebase structure`,
+- Use when: Need to document existing codebase structure`,
   "plan-checker": `@plan-checker
 - Role: Reviews PLAN.md for quality before execution
 - Permissions: Read files
 - Best for: Plan verification before execution
-- **Delegate when:** PLAN.md needs review before execution`,
+- Use when: PLAN.md needs review before execution`,
   "task-splitter": `@task-splitter
 - Role: Decomposes complex tasks into parallel workstreams
 - Permissions: Read files
 - Best for: Multi-track work organization
-- **Delegate when:** Complex task needs parallelization`,
+- Use when: Complex work needs parallelization`,
   discusser: `@discusser
 - Role: Extracts requirements via structured Q&A
 - Permissions: Read/write files
 - Best for: Requirements extraction
-- **Delegate when:** Starting new feature or project phase`,
+- Use when: Starting a new feature or project phase`,
   planner: `@planner
 - Role: Creates detailed implementation plans
 - Permissions: Read files
 - Best for: Feature planning, step breakdown
-- **Delegate when:** Need implementation plan for feature`,
+- Use when: Need an implementation plan for a feature`,
   "performance-optimizer": `@performance-optimizer
 - Role: Analyzes and optimizes performance
 - Permissions: Read files
 - Best for: Performance analysis
-- **Delegate when:** Need to optimize slow code`,
+- Use when: Need to optimize slow code`,
   "refactor-guide": `@refactor-guide
 - Role: Guides safe refactoring
 - Permissions: Read files
 - Best for: Code restructuring
-- **Delegate when:** Need to refactor existing code safely`
+- Use when: Need to refactor existing code safely`
 };
-function buildOrchestratorPrompt(disabledAgents) {
+function buildOrchestratorPrompt(disabledAgents, workflowClass) {
   const enabledAgents = Object.entries(AGENT_DESCRIPTIONS).filter(([name]) => !disabledAgents?.has(name)).map(([, desc]) => desc).join(`
 
 `);
-  return `${ORCHESTRATOR_PROMPT}
+  const workflowSection = workflowClass ? `
+## Current Workflow
+
+Active workflow class: ${workflowClass}` : "";
+  return `${ORCHESTRATOR_PROMPT}${workflowSection}
 
 <Delegation>
 
@@ -4626,21 +3985,23 @@ function buildOrchestratorPrompt(disabledAgents) {
 
 ${enabledAgents}
 
-## Delegation Guidelines
+## Routing Guidelines
 
 - Review available agents before acting
-- Reference paths/lines, don't paste files (\`src/app.ts:42\`)
-- Provide context summaries, let specialists read what they need
-- Skip delegation if overhead ≥ doing it yourself
+- Reference paths and line numbers instead of pasting full files
+- Provide context summaries, then let specialists inspect what they need
+- Use direct built-in tools ONLY for lightweight reading and status tracking
+- NEVER use write/edit/bash tools yourself — always route execution to agents
+- Log every routing decision before handing off work
 
 </Delegation>`;
 }
-function createOrchestratorAgent(model, customPrompt, customAppendPrompt, disabledAgents) {
-  const basePrompt = buildOrchestratorPrompt(disabledAgents);
+function createOrchestratorAgent(model, customPrompt, customAppendPrompt, disabledAgents, workflowClass) {
+  const basePrompt = buildOrchestratorPrompt(disabledAgents, workflowClass);
   const prompt = resolvePrompt(basePrompt, customPrompt, customAppendPrompt);
   const definition = {
     name: "orchestrator",
-    description: "AI coding orchestrator that delegates tasks to specialist agents for optimal quality, speed, and cost",
+    description: "AI coding orchestrator that coordinates specialist agents. Routes all work to appropriate agents and workflows. Does not execute tasks directly.",
     config: {
       temperature: 0.1,
       prompt
@@ -7325,9 +6686,71 @@ function createSupervisorAgent(model, customPrompt, customAppendPrompt) {
   return definition;
 }
 
+// src/agents/default-executor.ts
+var DEFAULT_EXECUTOR_PROMPT = `You are the Default Execution Agent — the worker that handles simple, direct tasks when the orchestrator has explicitly routed work to you through a chosen direct workflow.
+
+## Your Role
+
+You execute. You do NOT route, plan, or orchestrate.
+You receive a specific task from the orchestrator with a chosen execution mode, and you carry it out using the full set of available tools.
+
+## Execution Modes
+
+The orchestrator selects one of these modes when routing to you:
+
+- **direct-stock-tools** — Use OpenCode's built-in read/search/write/edit/bash tools directly to complete a focused task that fits in < 5 files and has no ambiguity.
+- **quick-answer** — Answer a question or provide information using read/search tools only. No file modifications.
+- **inspect-only** — Read and analyze code to answer questions or produce reports. No modifications.
+- **simple-edit** — Make a small, surgical change (rename, typo fix, constant update, config change). Must be reversible and low-risk.
+
+## Rules
+
+1. **Execute exactly what was routed to you.** Do not expand scope.
+2. **Do not invent new workflows.** If the task is bigger than expected, report back to the orchestrator — do not silently absorb it.
+3. **Use the simplest tool for the job.** Prefer read/search for investigation, write/edit for changes, bash for verification.
+4. **Report completion clearly.** Summarize what was done and any issues encountered.
+5. **Escalate if complexity emerges.** If you discover the task touches > 5 files, requires architectural decisions, or involves security-sensitive paths, stop and report to the orchestrator for re-routing.
+
+## Anti-Patterns
+
+- Do NOT act as an orchestrator yourself.
+- Do NOT route work to other agents.
+- Do NOT silently expand a "simple edit" into a full refactor.
+- Do NOT bypass the orchestrator's routing decision.
+
+## Completion Format
+
+When done, respond with:
+
+\`\`\`
+## Execution Complete
+
+**Mode:** <the mode you were given>
+**Files touched:** <list or "none">
+**Summary:** <what was done>
+**Verification:** <how you confirmed it works>
+**Issues:** <any problems found, or "none">
+\`\`\``;
+function createDefaultExecutorAgent(model, customPrompt, customAppendPrompt) {
+  const prompt = resolvePrompt(DEFAULT_EXECUTOR_PROMPT, customPrompt, customAppendPrompt);
+  const definition = {
+    name: "default-executor",
+    description: "Default execution worker for direct, simple tasks routed by the orchestrator. Handles quick-answer, inspect-only, simple-edit, and direct-stock-tools workflows.",
+    config: {
+      temperature: 0.1,
+      prompt
+    }
+  };
+  if (typeof model === "string" && model) {
+    definition.config.model = model;
+  }
+  return definition;
+}
+
 // src/agents/index.ts
 var AGENT_NAMES = [
   "orchestrator",
+  "default-executor",
   "planner",
   "backend-coder",
   "frontend-coder",
@@ -7370,6 +6793,8 @@ function createAgent(name, model, customPrompt, customAppendPrompt) {
   switch (name) {
     case "orchestrator":
       return createOrchestratorAgent(model, customPrompt, customAppendPrompt);
+    case "default-executor":
+      return createDefaultExecutorAgent(model, customPrompt, customAppendPrompt);
     case "planner":
       return createPlannerAgent(model, customPrompt, customAppendPrompt);
     case "backend-coder":
@@ -7456,612 +6881,11 @@ function getAgentConfigs(agentModels) {
   return configs;
 }
 
-// src/services/agent-contract-registry.ts
-var CONTRACTS = [
-  {
-    agent: "orchestrator",
-    role: "Coordinate multi-agent execution. Delegates all work — never implements directly.",
-    allowedTaskTypes: ["orchestration", "coordination", "delegation", "phase-management"],
-    requiredInputs: ["STATE.md", "PLAN.md"],
-    expectedOutputFields: ["delegated_steps", "completed_steps", "current_phase"],
-    allowedTools: [
-      "delegate",
-      "run-pipeline",
-      "council",
-      "planning-state",
-      "codebase-state",
-      "repo-memory",
-      "decision-trace",
-      "policy-engine",
-      "reflect"
-    ],
-    forbiddenActions: [
-      "write_file",
-      "edit_file",
-      "create_file",
-      "bash",
-      "patch",
-      "apply_patch",
-      "read source files directly"
-    ],
-    escalationConditions: [
-      "delegated agent fails twice",
-      "delegation budget exhausted",
-      "deadlock detected",
-      "all agents blocked on the same step"
-    ],
-    stopConditions: [
-      "all PLAN.md steps completed",
-      "user requests stop",
-      "budget exceeded with no fallback"
-    ],
-    successCriteria: [
-      "all plan steps delegated and completed",
-      "STATE.md phase updated to review",
-      "no implementation performed directly by orchestrator"
-    ]
-  },
-  {
-    agent: "planner",
-    role: "Create detailed implementation plans. Output PLAN.md with numbered steps.",
-    allowedTaskTypes: ["planning", "task-breakdown", "step-decomposition"],
-    requiredInputs: ["task description or STATE.md"],
-    expectedOutputFields: ["steps", "phase"],
-    allowedTools: ["read", "glob", "grep", "planning-state"],
-    forbiddenActions: [
-      "write source files",
-      "run bash commands",
-      "edit application code",
-      "implement features"
-    ],
-    escalationConditions: [
-      "requirements are ambiguous",
-      "dependencies between steps unclear",
-      "conflicting constraints"
-    ],
-    stopConditions: ["PLAN.md written and reviewed by plan-checker", "user confirms plan"],
-    successCriteria: [
-      "PLAN.md contains numbered steps with assigned agents",
-      "each step has clear success criteria",
-      "no implementation performed"
-    ]
-  },
-  {
-    agent: "plan-checker",
-    role: "Review PLAN.md quality before execution. Read-only.",
-    allowedTaskTypes: ["plan-review", "quality-check"],
-    requiredInputs: ["PLAN.md"],
-    expectedOutputFields: ["verdict", "issues", "recommendations"],
-    allowedTools: ["read", "glob", "grep"],
-    forbiddenActions: ["write or edit any files", "modify PLAN.md"],
-    escalationConditions: ["plan is fundamentally flawed", "critical gaps found"],
-    stopConditions: ["review complete", "verdict issued"],
-    successCriteria: ["structured review output", "no file modifications"]
-  },
-  {
-    agent: "design",
-    role: "Design UX, wireframes, and visual systems for UI-heavy tasks.",
-    allowedTaskTypes: ["ux-design", "wireframe", "visual-system", "design-handoff", "frontend-handoff"],
-    requiredInputs: ["task description", "requirements"],
-    expectedOutputFields: ["design_stage", "wireframes", "component_structure", "design_tokens"],
-    allowedTools: ["read", "write", "glob", "grep", "planning-state"],
-    forbiddenActions: [
-      "run bash commands",
-      "write application logic",
-      "implement backend code",
-      "implement React components"
-    ],
-    escalationConditions: [
-      "design requirements unclear",
-      "conflicting UX requirements",
-      "brand guidelines missing"
-    ],
-    stopConditions: ["design_stage=handoff_complete", "design_approved=true"],
-    successCriteria: [
-      "design document written",
-      "design_stage set to handoff_complete",
-      "design_approved set to true",
-      "no application code written"
-    ]
-  },
-  {
-    agent: "backend-coder",
-    role: "Implement backend features: API, services, data layer, business logic.",
-    allowedTaskTypes: ["implementation", "backend", "api", "database", "service", "bugfix"],
-    requiredInputs: ["PLAN.md step description", "relevant context files"],
-    expectedOutputFields: ["files_modified", "summary"],
-    allowedTools: ["read", "write", "edit", "bash", "glob", "grep"],
-    forbiddenActions: [
-      "modify frontend UI component files",
-      "change CI/CD config without devops involvement"
-    ],
-    escalationConditions: [
-      "architecture decision needed",
-      "security-sensitive change without audit",
-      "database migration required"
-    ],
-    stopConditions: ["step implementation complete", "tests pass", "reviewer approves"],
-    successCriteria: [
-      "code written per plan step",
-      "no regressions introduced",
-      "tests exist or updated"
-    ]
-  },
-  {
-    agent: "frontend-coder",
-    role: "Implement frontend features: UI components, client state, rendering.",
-    allowedTaskTypes: ["implementation", "frontend", "ui", "component", "styling", "bugfix"],
-    requiredInputs: ["PLAN.md step description", "design handoff for UI-heavy tasks"],
-    expectedOutputFields: ["files_modified", "summary"],
-    allowedTools: ["read", "write", "edit", "bash", "glob", "grep"],
-    forbiddenActions: [
-      "modify backend API files",
-      "change server configuration",
-      "implement without approved design for UI-heavy tasks"
-    ],
-    escalationConditions: [
-      "design handoff missing for UI-heavy task",
-      "component library or design system unclear"
-    ],
-    stopConditions: ["step implementation complete", "tests pass", "reviewer approves"],
-    successCriteria: [
-      "components implemented per approved design",
-      "no regressions introduced",
-      "tests exist or updated"
-    ]
-  },
-  {
-    agent: "devops",
-    role: "Implement DevOps and infrastructure changes: CI/CD, deployment, infra scripts.",
-    allowedTaskTypes: ["implementation", "ci-cd", "deployment", "infrastructure", "operations"],
-    requiredInputs: ["PLAN.md step description"],
-    expectedOutputFields: ["files_modified", "summary"],
-    allowedTools: ["read", "write", "edit", "bash", "glob", "grep"],
-    forbiddenActions: [
-      "modify application source code",
-      "deploy to production without approval"
-    ],
-    escalationConditions: [
-      "production deployment requires approval",
-      "destructive infra change"
-    ],
-    stopConditions: ["pipeline or infra change complete", "reviewer approves"],
-    successCriteria: ["infrastructure code written per plan", "no prod deployment without approval"]
-  },
-  {
-    agent: "tester",
-    role: "Write and run tests following TDD principles. Tests before implementation.",
-    allowedTaskTypes: ["testing", "tdd", "regression", "integration-test", "unit-test"],
-    requiredInputs: ["feature or step description", "relevant source files"],
-    expectedOutputFields: ["test_files_written", "tests_passing", "coverage_summary"],
-    allowedTools: ["read", "write", "edit", "bash", "glob", "grep"],
-    forbiddenActions: [
-      "delete failing tests to make suite pass",
-      "implement application features",
-      "skip TDD cycle (red → green → refactor)"
-    ],
-    escalationConditions: [
-      "test infrastructure broken",
-      "flaky tests blocking all progress"
-    ],
-    stopConditions: ["all tests pass", "coverage meets threshold"],
-    successCriteria: [
-      "tests written before implementation",
-      "all new tests pass",
-      "no test deletions to fix failures"
-    ]
-  },
-  {
-    agent: "reviewer",
-    role: "Review code quality, security, and convention adherence. Read-only.",
-    allowedTaskTypes: ["review", "code-review", "quality-check"],
-    requiredInputs: ["files to review", "context of changes"],
-    expectedOutputFields: ["verdict", "issues", "recommendations"],
-    allowedTools: ["read", "glob", "grep"],
-    forbiddenActions: [
-      "write or edit any files",
-      "make code changes",
-      "approve security-sensitive changes without security audit"
-    ],
-    escalationConditions: [
-      "security issues found",
-      "critical bugs found",
-      "architectural violations"
-    ],
-    stopConditions: ["review complete", "verdict issued"],
-    successCriteria: [
-      "structured review output with severity levels",
-      "issues categorized",
-      "no file modifications"
-    ]
-  },
-  {
-    agent: "security-auditor",
-    role: "Security audit: OWASP Top 10, injection, auth vulnerabilities. Read-only.",
-    allowedTaskTypes: ["security-audit", "vulnerability-scan", "auth-review"],
-    requiredInputs: ["files to audit", "change context"],
-    expectedOutputFields: ["findings", "severity_breakdown", "recommendations"],
-    allowedTools: ["read", "glob", "grep"],
-    forbiddenActions: [
-      "write or edit files",
-      "make changes to fix vulnerabilities directly"
-    ],
-    escalationConditions: [
-      "CRITICAL vulnerability found",
-      "auth bypass detected",
-      "data exposure found"
-    ],
-    stopConditions: ["audit complete", "all findings documented"],
-    successCriteria: [
-      "OWASP checklist evaluated",
-      "findings documented with severity levels",
-      "no file modifications"
-    ]
-  },
-  {
-    agent: "researcher",
-    role: "Research documentation, APIs, best practices. Read-only analysis.",
-    allowedTaskTypes: ["research", "api-lookup", "documentation", "best-practices"],
-    requiredInputs: ["research topic or question"],
-    expectedOutputFields: ["findings", "references", "recommendations"],
-    allowedTools: ["read", "glob", "grep", "web-search"],
-    forbiddenActions: ["write or edit files", "implement solutions"],
-    escalationConditions: [
-      "critical information unavailable",
-      "conflicting official documentation"
-    ],
-    stopConditions: ["research question answered", "findings documented"],
-    successCriteria: [
-      "findings clearly summarized",
-      "sources cited",
-      "no file modifications"
-    ]
-  },
-  {
-    agent: "architect",
-    role: "Design system architecture, create ADRs, define API contracts.",
-    allowedTaskTypes: ["architecture", "adr", "api-design", "system-design"],
-    requiredInputs: ["feature or system description", "existing codebase context"],
-    expectedOutputFields: ["architecture_document", "adr", "api_contracts"],
-    allowedTools: ["read", "write", "glob", "grep", "planning-state"],
-    forbiddenActions: ["write application code", "run bash commands"],
-    escalationConditions: [
-      "major architectural conflict with existing system",
-      "breaking API change required"
-    ],
-    stopConditions: ["ADR written", "architecture reviewed"],
-    successCriteria: [
-      "architecture documented with tradeoffs",
-      "no application code written"
-    ]
-  },
-  {
-    agent: "writer",
-    role: "Draft project documentation: README, API docs, user guides.",
-    allowedTaskTypes: ["documentation", "readme", "api-docs", "user-guide"],
-    requiredInputs: ["feature description or codebase context"],
-    expectedOutputFields: ["documentation_files"],
-    allowedTools: ["read", "write", "edit", "glob", "grep"],
-    forbiddenActions: ["modify application code", "run bash commands"],
-    escalationConditions: ["documentation scope unclear"],
-    stopConditions: ["docs written", "user confirms completeness"],
-    successCriteria: [
-      "documentation written and accurate",
-      "no application code changed"
-    ]
-  },
-  {
-    agent: "doc-updater",
-    role: "Update existing documentation after code changes.",
-    allowedTaskTypes: ["documentation-update", "doc-sync"],
-    requiredInputs: ["changed files", "change summary"],
-    expectedOutputFields: ["updated_docs"],
-    allowedTools: ["read", "write", "edit", "glob", "grep"],
-    forbiddenActions: [
-      "modify application code",
-      "delete documentation without replacement"
-    ],
-    escalationConditions: ["documentation conflicts with implementation"],
-    stopConditions: ["docs updated and synced"],
-    successCriteria: ["docs reflect current code", "no application code changed"]
-  },
-  {
-    agent: "supervisor",
-    role: "Governance review layer. Inspects existing commands/agents, validates policy, returns structured approve/revise/block/escalate decision. Never creates new commands or workflows.",
-    allowedTaskTypes: ["governance-review", "policy-check", "pre-execution-review", "post-stage-review"],
-    requiredInputs: ["target name (command or agent)", "task context"],
-    expectedOutputFields: ["decision", "targetType", "targetName", "exists", "reasons", "missingRequirements", "riskFlags", "requiredChanges", "approvalStatus", "confidenceScore"],
-    allowedTools: ["read", "glob", "grep", "planning-state", "policy-engine"],
-    forbiddenActions: [
-      "create new commands",
-      "create new workflows",
-      "invent new agent names",
-      "modify command intent",
-      "replace orchestrator",
-      "become second dispatcher",
-      "execute implementation tasks",
-      "write or edit source files",
-      "run bash commands",
-      "modify PLAN.md or STATE.md"
-    ],
-    escalationConditions: [
-      "human approval required and not granted",
-      "confidence below threshold",
-      "critical policy violation with no safe path forward"
-    ],
-    stopConditions: ["structured decision issued", "review complete"],
-    successCriteria: [
-      "structured SupervisorDecision returned",
-      "no new commands or workflows created",
-      "existing registry not modified",
-      "decision is one of: approve, revise, block, escalate"
-    ]
-  }
-];
-var REGISTRY = new Map(CONTRACTS.map((c) => [c.agent, c]));
-function getContract(agent) {
-  return REGISTRY.get(agent) ?? null;
-}
-
-// src/services/supervisor-binding.ts
-var REGISTERED_COMMANDS = [
-  "fd-ask",
-  "fd-checkpoint",
-  "fd-deploy-check",
-  "fd-design",
-  "fd-discuss",
-  "fd-doctor",
-  "fd-execute",
-  "fd-fix-bug",
-  "fd-map-codebase",
-  "fd-multi-repo",
-  "fd-new-feature",
-  "fd-plan",
-  "fd-quick",
-  "fd-reflect",
-  "fd-resume",
-  "fd-status",
-  "fd-suggest",
-  "fd-translate-intent",
-  "fd-verify",
-  "fd-write-docs",
-  "fd-done"
-];
-function resolveSupervisorConfig(directory) {
-  try {
-    const config = loadFlowDeckConfig(directory);
-    const sup = config?.governance?.supervisor ?? {};
-    return {
-      enabled: sup.enabled ?? false,
-      mode: sup.mode ?? "advisory",
-      reviewedTargets: sup.reviewedTargets ?? [],
-      canBlock: sup.canBlock ?? true,
-      confidenceThreshold: sup.confidenceThreshold ?? 0.7,
-      postExecutionReview: sup.postExecutionReview ?? false
-    };
-  } catch {
-    return {
-      enabled: false,
-      mode: "advisory",
-      reviewedTargets: [],
-      canBlock: true,
-      confidenceThreshold: 0.7,
-      postExecutionReview: false
-    };
-  }
-}
-function isRegisteredCommand(name) {
-  return REGISTERED_COMMANDS.includes(name);
-}
-function isRegisteredAgent(name) {
-  return AGENT_NAMES.includes(name);
-}
-function isRegisteredTarget(name) {
-  if (isRegisteredCommand(name))
-    return { exists: true, type: "command" };
-  if (isRegisteredAgent(name))
-    return { exists: true, type: "agent" };
-  return { exists: false, type: "agent" };
-}
-function checkCommandPolicy(commandName, ctx) {
-  const reasons = [];
-  const riskFlags = [];
-  const missingRequirements = [];
-  const requiredChanges = [];
-  if (commandName === "fd-new-feature" || commandName === "fd-execute") {
-    const taskLower = (ctx.taskDescription ?? "").toLowerCase();
-    const isUiHeavy = /landing page|dashboard|admin panel|website|web app|ui|ux|interface|frontend|component/.test(taskLower);
-    if (isUiHeavy && ctx.currentPhase === "execute" && ctx.designApprovalPresent === false) {
-      missingRequirements.push("design approval (design stage must complete before execute for UI-heavy tasks)");
-      riskFlags.push("UI-heavy task entering execute phase without design approval");
-      requiredChanges.push("Run /fd-design first and obtain design approval before proceeding to execute");
-    }
-  }
-  if (commandName === "fd-fix-bug") {
-    if (ctx.regressionTestPresent === false) {
-      missingRequirements.push("regression test (required before bugfix implementation)");
-      riskFlags.push("Bugfix command invoked without a regression test");
-      requiredChanges.push("Write a failing regression test before implementing the fix");
-    }
-  }
-  if (commandName === "fd-deploy-check") {
-    if (ctx.prerequisitesMet === false && ctx.missingInputs && ctx.missingInputs.length > 0) {
-      missingRequirements.push(...ctx.missingInputs);
-      riskFlags.push("Deploy check attempted with unmet prerequisites");
-    }
-  }
-  if (commandName === "fd-execute" && ctx.currentPhase && ctx.currentPhase !== "execute") {
-    riskFlags.push(`fd-execute invoked in phase "${ctx.currentPhase}" instead of "execute"`);
-    requiredChanges.push(`Ensure project phase is "execute" before running fd-execute (currently: ${ctx.currentPhase})`);
-  }
-  if (ctx.approvalRequired && !ctx.approvalGranted) {
-    missingRequirements.push("human approval (required for this command)");
-    riskFlags.push("Approval gate not satisfied");
-    requiredChanges.push("Obtain explicit human approval before proceeding");
-  }
-  const passed = missingRequirements.length === 0 && riskFlags.length === 0 && requiredChanges.length === 0;
-  if (passed) {
-    reasons.push(`Command "${commandName}" passed all policy checks`);
-  }
-  return { passed, reasons, riskFlags, missingRequirements, requiredChanges };
-}
-function checkAgentPolicy(agentName, ctx) {
-  const reasons = [];
-  const riskFlags = [];
-  const missingRequirements = [];
-  const requiredChanges = [];
-  const contract = getContract(agentName);
-  if (!contract) {
-    riskFlags.push(`Agent "${agentName}" has no registered capability contract`);
-    return { passed: false, reasons, riskFlags, missingRequirements, requiredChanges };
-  }
-  if (ctx.missingInputs && ctx.missingInputs.length > 0) {
-    for (const missing of ctx.missingInputs) {
-      const isRequired = contract.requiredInputs.some((r) => r.toLowerCase().includes(missing.toLowerCase()) || missing.toLowerCase().includes(r.toLowerCase()));
-      if (isRequired) {
-        missingRequirements.push(missing);
-        requiredChanges.push(`Provide "${missing}" before delegating to ${agentName}`);
-      }
-    }
-  }
-  if (ctx.approvalRequired && !ctx.approvalGranted) {
-    const needsApproval = contract.escalationConditions.some((c) => c.toLowerCase().includes("approval") || c.toLowerCase().includes("approve"));
-    if (needsApproval) {
-      missingRequirements.push("human approval");
-      riskFlags.push(`Agent "${agentName}" requires approval via escalation condition`);
-      requiredChanges.push("Obtain explicit human approval before proceeding");
-    }
-  }
-  if (agentName === "design" || agentName === "frontend-coder") {
-    const taskLower = (ctx.taskDescription ?? "").toLowerCase();
-    const isUiHeavy = /landing page|dashboard|admin panel|website|web app|ui|ux|interface|frontend|component/.test(taskLower);
-    if (agentName === "frontend-coder" && isUiHeavy && ctx.designApprovalPresent === false) {
-      missingRequirements.push("design handoff approval");
-      riskFlags.push("frontend-coder invoked for UI-heavy task without approved design handoff");
-      requiredChanges.push("Complete design stage and obtain design approval before delegating to frontend-coder");
-    }
-  }
-  const passed = missingRequirements.length === 0 && riskFlags.length === 0;
-  if (passed) {
-    reasons.push(`Agent "${agentName}" passed all policy checks`);
-  }
-  return { passed, reasons, riskFlags, missingRequirements, requiredChanges };
-}
-function computeConfidence(exists, policyResult, ctx) {
-  if (!exists)
-    return 0;
-  if (policyResult.riskFlags.length >= 3)
-    return 0.2;
-  if (policyResult.riskFlags.length === 2)
-    return 0.4;
-  if (policyResult.riskFlags.length === 1)
-    return 0.6;
-  if (policyResult.missingRequirements.length > 0)
-    return 0.5;
-  if (ctx.prerequisitesMet === false)
-    return 0.45;
-  return 0.95;
-}
-function resolveDecision(exists, policyResult, confidenceScore, threshold, ctx, clarificationQuestion) {
-  if (!exists) {
-    return { decision: "block", approvalStatus: "denied" };
-  }
-  if (ctx.approvalRequired && !ctx.approvalGranted) {
-    return { decision: "escalate", approvalStatus: "escalated", clarificationQuestion };
-  }
-  if (!policyResult.passed) {
-    if (policyResult.requiredChanges.length > 0) {
-      return { decision: "revise", approvalStatus: "pending" };
-    }
-    return { decision: "block", approvalStatus: "denied" };
-  }
-  if (confidenceScore < threshold) {
-    return { decision: "escalate", approvalStatus: "escalated", clarificationQuestion };
-  }
-  return { decision: "approve", approvalStatus: "approved" };
-}
-function runSupervisorReview(directory, targetName, ctx = {}, clarificationQuestion) {
-  const config = resolveSupervisorConfig(directory);
-  const reviewPhase = ctx.reviewPhase ?? "preflight";
-  const timestamp2 = new Date().toISOString();
-  if (config.reviewedTargets.length > 0 && !config.reviewedTargets.includes(targetName)) {
-    return {
-      decision: "approve",
-      targetType: "agent",
-      targetName,
-      exists: true,
-      reasons: [`Target "${targetName}" is not in the reviewed targets list — auto-approved`],
-      missingRequirements: [],
-      riskFlags: [],
-      requiredChanges: [],
-      approvalStatus: "approved",
-      confidenceScore: 1,
-      reviewPhase,
-      timestamp: timestamp2
-    };
-  }
-  const { exists, type: targetType } = isRegisteredTarget(targetName);
-  if (!exists) {
-    const decision2 = {
-      decision: "block",
-      targetType,
-      targetName,
-      exists: false,
-      reasons: [
-        `Target "${targetName}" is not registered in the FlowDeck command or agent registry.`,
-        "The supervisor does not create new commands or workflows.",
-        "Only registered targets can be executed."
-      ],
-      missingRequirements: [],
-      riskFlags: [`Unregistered target: "${targetName}"`],
-      requiredChanges: [
-        `Use one of the registered commands: ${REGISTERED_COMMANDS.join(", ")}`,
-        `Or use one of the registered agents: ${AGENT_NAMES.join(", ")}`
-      ],
-      approvalStatus: "denied",
-      confidenceScore: 0,
-      reviewPhase,
-      timestamp: timestamp2
-    };
-    return decision2;
-  }
-  const policyResult = targetType === "command" ? checkCommandPolicy(targetName, ctx) : checkAgentPolicy(targetName, ctx);
-  const confidenceScore = computeConfidence(exists, policyResult, ctx);
-  const { decision, approvalStatus, clarificationQuestion: escalationQuestion } = resolveDecision(exists, policyResult, confidenceScore, config.confidenceThreshold, ctx, clarificationQuestion);
-  const reasons = policyResult.reasons.length > 0 ? policyResult.reasons : decision === "approve" ? [`Target "${targetName}" reviewed and approved for execution`] : [`Target "${targetName}" reviewed — decision: ${decision}`];
-  const supervisorDecision = {
-    decision,
-    targetType,
-    targetName,
-    exists,
-    reasons,
-    missingRequirements: policyResult.missingRequirements,
-    riskFlags: policyResult.riskFlags,
-    requiredChanges: policyResult.requiredChanges,
-    approvalStatus,
-    confidenceScore,
-    reviewPhase,
-    timestamp: timestamp2,
-    ...escalationQuestion ? { clarificationQuestion: escalationQuestion } : {}
-  };
-  return supervisorDecision;
-}
-function shouldProceed(decision, mode, canBlock) {
-  if (!decision.exists)
-    return false;
-  if (!canBlock)
-    return true;
-  if (mode === "strict") {
-    return decision.decision === "approve" || decision.decision === "revise";
-  }
-  return decision.decision !== "block" || decision.confidenceScore > 0.3;
-}
-
 // src/index.ts
 function lazyLoadRulePaths(projectRoot) {
   const __dir = dirname3(fileURLToPath2(import.meta.url));
-  const rulesDir = join27(__dir, "..", "src", "rules");
-  if (!existsSync29(rulesDir))
+  const rulesDir = join24(__dir, "..", "src", "rules");
+  if (!existsSync25(rulesDir))
     return { paths: [], diagnostics: "[LazyRuleLoader] rules directory not found" };
   const detectedLanguages = detectProjectLanguages(projectRoot);
   const paths = getStartupRulePaths(rulesDir, detectedLanguages);
@@ -8071,16 +6895,16 @@ function lazyLoadRulePaths(projectRoot) {
 }
 function loadCommands() {
   const __dir = dirname3(fileURLToPath2(import.meta.url));
-  const commandsDir = join27(__dir, "..", "src", "commands");
-  if (!existsSync29(commandsDir))
+  const commandsDir = join24(__dir, "..", "src", "commands");
+  if (!existsSync25(commandsDir))
     return {};
   const commands = {};
   try {
-    for (const file of readdirSync4(commandsDir)) {
+    for (const file of readdirSync3(commandsDir)) {
       if (!file.endsWith(".md"))
         continue;
       const name = basename2(file, ".md");
-      const raw = readFileSync28(join27(commandsDir, file), "utf-8");
+      const raw = readFileSync24(join24(commandsDir, file), "utf-8");
       let description;
       let template = raw;
       const fmMatch = raw.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/);
@@ -8098,8 +6922,6 @@ function loadCommands() {
 var plugin = async (input, _options) => {
   const { directory, client, worktree } = input;
   const appLog = (msg) => client.app.log({ body: { service: "flowdeck", level: "info", message: msg } }).catch(() => {});
-  const runPipelineTool = createRunPipelineTool(client);
-  const delegateTool = createDelegateTool(client);
   const councilTool = createCouncilTool(client);
   const fileTracker = new SessionFileTracker;
   const { fileEdited, fileWatcherUpdated } = createFileTrackerHooks(fileTracker);
@@ -8164,8 +6986,8 @@ var plugin = async (input, _options) => {
           }
         }
       }
-      const skillsDir = join27(dirname3(fileURLToPath2(import.meta.url)), "..", "src", "skills");
-      if (existsSync29(skillsDir)) {
+      const skillsDir = join24(dirname3(fileURLToPath2(import.meta.url)), "..", "src", "skills");
+      if (existsSync25(skillsDir)) {
         const cfgAny = cfg;
         if (!cfgAny.skills || typeof cfgAny.skills !== "object") {
           cfgAny.skills = { paths: [] };
@@ -8194,8 +7016,6 @@ var plugin = async (input, _options) => {
     tool: {
       "planning-state": planningStateTool,
       "codebase-state": codebaseStateTool,
-      "run-pipeline": runPipelineTool,
-      delegate: delegateTool,
       "repo-memory": repoMemoryTool,
       "failure-replay": failureReplayTool,
       "decision-trace": decisionTraceTool,
@@ -8269,33 +7089,6 @@ var plugin = async (input, _options) => {
         }
       }
       orchestratorGuard.check(toolInput.sessionID ?? "", toolInput.tool ?? toolInput.name ?? "");
-      const toolName = toolInput.tool ?? toolInput.name ?? "";
-      if (toolName === "delegate" || toolName === "run-pipeline") {
-        const supConfig = resolveSupervisorConfig(directory);
-        if (supConfig.enabled) {
-          const args = toolOutput?.args ?? toolInput?.args ?? {};
-          const agentTarget = typeof args.agent === "string" ? args.agent.replace(/^@/, "") : Array.isArray(args.steps) && args.steps[0]?.agent ? String(args.steps[0].agent).replace(/^@/, "") : "";
-          if (agentTarget) {
-            const decision = runSupervisorReview(directory, agentTarget, {
-              taskDescription: typeof args.prompt === "string" ? args.prompt : undefined,
-              reviewPhase: "preflight",
-              session_id: toolInput.sessionID ?? toolInput.sessionId ?? ""
-            });
-            const proceed = shouldProceed(decision, supConfig.mode, supConfig.canBlock);
-            appLog(`[Supervisor] ${decision.reviewPhase} review of "${decision.targetName}": ` + `decision=${decision.decision} exists=${decision.exists} confidence=${decision.confidenceScore.toFixed(2)} ` + `${decision.riskFlags.length > 0 ? `risks=[${decision.riskFlags.join("; ")}]` : ""}`);
-            if (!proceed) {
-              const summary = [
-                `[Supervisor] Execution blocked for target "${decision.targetName}".`,
-                ...decision.reasons,
-                ...decision.missingRequirements.length > 0 ? [`Missing: ${decision.missingRequirements.join(", ")}`] : [],
-                ...decision.requiredChanges.length > 0 ? [`Required changes: ${decision.requiredChanges.join("; ")}`] : []
-              ].join(`
-`);
-              throw new Error(summary);
-            }
-          }
-        }
-      }
       await approvalHook({ directory }, toolInput, toolOutput);
       await guardRailsHook({ directory }, toolInput, toolOutput);
       await toolGuardHook({ directory }, toolInput, toolOutput);
@@ -8305,30 +7098,6 @@ var plugin = async (input, _options) => {
     },
     "tool.execute.after": async (toolInput, toolOutput) => {
       await eventLog.after({ directory }, toolInput, toolOutput);
-      const afterToolName = toolInput.tool ?? toolInput.name ?? "";
-      if (afterToolName === "delegate" || afterToolName === "run-pipeline") {
-        try {
-          const supConfig = resolveSupervisorConfig(directory);
-          if (supConfig.enabled && supConfig.postExecutionReview) {
-            const args = toolOutput?.args ?? toolInput?.args ?? {};
-            const agentTarget = typeof args.agent === "string" ? args.agent.replace(/^@/, "") : Array.isArray(args.steps) && args.steps[0]?.agent ? String(args.steps[0].agent).replace(/^@/, "") : "";
-            if (agentTarget) {
-              const executionErrored = toolOutput?.error != null || toolOutput?.status === "error" || typeof toolOutput?.output === "string" && toolOutput.output.startsWith("Error:");
-              const decision = runSupervisorReview(directory, agentTarget, {
-                taskDescription: typeof args.prompt === "string" ? args.prompt : undefined,
-                reviewPhase: "post-stage",
-                session_id: toolInput.sessionID ?? toolInput.sessionId ?? "",
-                prerequisitesMet: !executionErrored
-              });
-              const logLevel = decision.decision === "block" || decision.decision === "escalate" ? "[Supervisor][WARN]" : "[Supervisor]";
-              appLog(`${logLevel} post-stage review of "${decision.targetName}": ` + `decision=${decision.decision} exists=${decision.exists} confidence=${decision.confidenceScore.toFixed(2)} ` + `executionErrored=${executionErrored} ` + `${decision.riskFlags.length > 0 ? `risks=[${decision.riskFlags.join("; ")}]` : ""}`);
-              if (supConfig.mode === "strict" && !shouldProceed(decision, "strict", supConfig.canBlock)) {
-                appLog(`[Supervisor][STRICT] Post-execution governance violation detected for "${decision.targetName}". ` + `Review the scorecard and telemetry for this run. ` + `Reasons: ${decision.reasons.join("; ")}`);
-              }
-            }
-          }
-        } catch {}
-      }
       await contextMonitor["tool.execute.after"](toolInput, toolOutput);
     }
   };