@dv.nghiem/flowdeck 0.4.2 → 0.4.3

package/dist/index.js

@@ -1,50 +1,201 @@
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
 // src/index.ts
-import { readdirSync as readdirSync3, readFileSync as readFileSync24, existsSync as existsSync26 } from "fs";
-import { join as join25, basename } from "path";
-import { dirname as dirname4 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import { readFileSync as readFileSync31, readdirSync as readdirSync5, existsSync as existsSync33 } from "fs";
+import { join as join31, basename as basename2 } from "path";
+import { dirname as dirname5 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+
+// src/services/lazy-rule-loader.ts
+import { existsSync, readFileSync, readdirSync } from "fs";
+import { join, basename } from "path";
+var _discoveryCache = new Map;
+function parseFrontmatter(content) {
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n/);
+  if (!match)
+    return {};
+  const fm = {};
+  for (const line of match[1].split(`
+`)) {
+    const kv = line.match(/^(\w[\w_-]*):\s*(.+)$/);
+    if (!kv)
+      continue;
+    const [, key, raw] = kv;
+    const val = raw.trim();
+    if (val.startsWith("[") && val.endsWith("]")) {
+      fm[key] = val.slice(1, -1).split(",").map((s) => s.trim()).filter(Boolean);
+    } else if (val === "true") {
+      fm[key] = true;
+    } else if (val === "false") {
+      fm[key] = false;
+    } else {
+      fm[key] = val;
+    }
+  }
+  return fm;
+}
+function readRuleMetadata(filePath) {
+  try {
+    const fullContent = readFileSync(filePath, "utf-8");
+    const head = fullContent.slice(0, 1024);
+    const fm = parseFrontmatter(head);
+    const hasFrontmatter = Object.keys(fm).length > 0;
+    return {
+      path: filePath,
+      description: typeof fm.description === "string" ? fm.description : "",
+      always_on: hasFrontmatter ? fm.always_on === true : true,
+      stages: Array.isArray(fm.stages) ? fm.stages : [],
+      languages: Array.isArray(fm.languages) ? fm.languages : []
+    };
+  } catch {
+    return { path: filePath, description: "", always_on: true, stages: [], languages: [] };
+  }
+}
+function discoverRules(rulesDir) {
+  const cached = _discoveryCache.get(rulesDir);
+  if (cached)
+    return cached;
+  if (!existsSync(rulesDir))
+    return [];
+  const results = [];
+  function walk(dir) {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      const full = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        walk(full);
+      } else if (entry.isFile() && entry.name.endsWith(".md") && entry.name !== "README.md") {
+        results.push(readRuleMetadata(full));
+      }
+    }
+  }
+  walk(rulesDir);
+  _discoveryCache.set(rulesDir, results);
+  return results;
+}
+function selectRulePaths(rulesDir, context = {}) {
+  const all = discoverRules(rulesDir);
+  const selected = [];
+  const skipped = [];
+  const reasons = {};
+  const detectedLangs = context.languages ?? [];
+  for (const rule of all) {
+    const name = basename(rule.path);
+    if (rule.always_on) {
+      selected.push(rule);
+      reasons[rule.path] = "always_on=true";
+      continue;
+    }
+    if (rule.languages.length > 0) {
+      const matches = rule.languages.some((l) => detectedLangs.includes(l));
+      if (!matches) {
+        skipped.push(rule);
+        reasons[rule.path] = `language_mismatch: rule=${rule.languages.join("|")} detected=${detectedLangs.join("|") || "unknown"}`;
+        continue;
+      }
+    }
+    if (rule.stages.length > 0 && context.stage) {
+      if (!rule.stages.includes(context.stage)) {
+        skipped.push(rule);
+        reasons[rule.path] = `stage_mismatch: rule=${rule.stages.join("|")} current=${context.stage}`;
+        continue;
+      }
+    }
+    selected.push(rule);
+    reasons[rule.path] = rule.languages.length > 0 ? `language_match: ${rule.languages.join("|")}` : rule.stages.length > 0 ? `stage_match: ${rule.stages.join("|")} (no current stage filter)` : "default_include: no language/stage restriction";
+  }
+  return { selected, skipped, reasons, total_discovered: all.length };
+}
+function getStartupRulePaths(rulesDir, detectedLanguages) {
+  const selection = selectRulePaths(rulesDir, { languages: detectedLanguages });
+  return selection.selected.map((r) => r.path);
+}
+function detectProjectLanguages(projectRoot) {
+  const langs = [];
+  if (existsSync(join(projectRoot, "package.json"))) {
+    try {
+      const pkg = JSON.parse(readFileSync(join(projectRoot, "package.json"), "utf-8"));
+      const hasTsConfig = existsSync(join(projectRoot, "tsconfig.json"));
+      const deps = { ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} };
+      if (hasTsConfig || "typescript" in deps || "@types/node" in deps) {
+        langs.push("typescript");
+      } else {
+        langs.push("javascript");
+      }
+    } catch {
+      langs.push("javascript");
+    }
+  }
+  if (existsSync(join(projectRoot, "go.mod"))) {
+    langs.push("go");
+  }
+  if (existsSync(join(projectRoot, "Cargo.toml"))) {
+    langs.push("rust");
+  }
+  if (existsSync(join(projectRoot, "pom.xml")) || existsSync(join(projectRoot, "build.gradle")) || existsSync(join(projectRoot, "build.gradle.kts"))) {
+    langs.push("java");
+  }
+  if (existsSync(join(projectRoot, "requirements.txt")) || existsSync(join(projectRoot, "pyproject.toml")) || existsSync(join(projectRoot, "setup.py")) || existsSync(join(projectRoot, "setup.cfg"))) {
+    langs.push("python");
+  }
+  return [...new Set(langs)];
+}
+function buildSelectionDiagnostics(selection, context) {
+  const lines = [
+    `[LazyRuleLoader] discovered=${selection.total_discovered}` + ` selected=${selection.selected.length}` + ` skipped=${selection.skipped.length}`,
+    `[LazyRuleLoader] context:` + ` languages=[${(context.languages ?? []).join(",")}]` + ` stage=${context.stage ?? "none"}`
+  ];
+  for (const r of selection.selected) {
+    lines.push(`[LazyRuleLoader] LOAD  ${basename(r.path)}: ${selection.reasons[r.path]}`);
+  }
+  for (const r of selection.skipped) {
+    lines.push(`[LazyRuleLoader] SKIP  ${basename(r.path)}: ${selection.reasons[r.path]}`);
+  }
+  return lines.join(`
+`);
+}
 
 // src/tools/planning-state.ts
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 import { tool as tool2 } from "@opencode-ai/plugin";
-import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, existsSync as existsSync3 } from "fs";
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync3, existsSync as existsSync4 } from "fs";
 
 // src/tools/planning-state-lib.ts
-import { join as join2, dirname, resolve } from "path";
-import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync2 } from "fs";
+import { join as join3, dirname, resolve } from "path";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, existsSync as existsSync3 } from "fs";
 
 // src/tools/codebase-state.ts
 import { tool } from "@opencode-ai/plugin";
-import { readFileSync, writeFileSync, existsSync, readdirSync, mkdirSync } from "fs";
-import { join } from "path";
+import { readFileSync as readFileSync2, writeFileSync, existsSync as existsSync2, readdirSync as readdirSync2, mkdirSync } from "fs";
+import { join as join2 } from "path";
 var CODEBASE_DIR = ".codebase";
 function codebaseDir(directory) {
-  return join(directory, CODEBASE_DIR);
+  return join2(directory, CODEBASE_DIR);
 }
 function codebaseFilePath(directory, filename) {
-  return join(codebaseDir(directory), filename);
+  return join2(codebaseDir(directory), filename);
 }
 function listCodebaseFiles(directory) {
   const base = codebaseDir(directory);
-  if (!existsSync(base))
+  if (!existsSync2(base))
     return [];
-  return readdirSync(base).filter((f) => f.endsWith(".md") || f.endsWith(".json"));
+  return readdirSync2(base).filter((f) => f.endsWith(".md") || f.endsWith(".json"));
 }
 async function readCodebaseContext(dir, files) {
   const results = {};
   for (const file of files) {
     const filePath = codebaseFilePath(dir, file);
-    if (!existsSync(filePath)) {
+    if (!existsSync2(filePath)) {
       results[file] = { error: `File not found: ${file}` };
       continue;
     }
-    results[file] = readFileSync(filePath, "utf-8");
+    results[file] = readFileSync2(filePath, "utf-8");
   }
   return results;
 }
 async function updateCodebaseFile(dir, filename, content) {
   const base = codebaseDir(dir);
-  if (!existsSync(base)) {
+  if (!existsSync2(base)) {
     mkdirSync(base, { recursive: true });
   }
   const filePath = codebaseFilePath(dir, filename);
@@ -53,7 +204,7 @@ async function updateCodebaseFile(dir, filename, content) {
 }
 async function codebaseExists(dir) {
   const base = codebaseDir(dir);
-  if (!existsSync(base)) {
+  if (!existsSync2(base)) {
     return { exists: false, files: [] };
   }
   const files = listCodebaseFiles(dir);
@@ -91,16 +242,16 @@ var STATE_FILE = "STATE.md";
 var PLAN_FILE = "PLAN.md";
 var RESULT_FILE = "RESULT.md";
 function planningDir(directory) {
-  return join2(directory, PLANNING_DIR);
+  return join3(directory, PLANNING_DIR);
 }
 function statePath(directory) {
-  return join2(planningDir(directory), STATE_FILE);
+  return join3(planningDir(directory), STATE_FILE);
 }
 function phasePlanPath(directory, phase) {
-  return join2(planningDir(directory), "phases", `phase-${phase}`, PLAN_FILE);
+  return join3(planningDir(directory), "phases", `phase-${phase}`, PLAN_FILE);
 }
 function resultPath(directory, phase) {
-  return join2(planningDir(directory), "phases", `phase-${phase}`, RESULT_FILE);
+  return join3(planningDir(directory), "phases", `phase-${phase}`, RESULT_FILE);
 }
 function parseState(content) {
   const result = { exists: false };
@@ -156,7 +307,7 @@ ${entry}
 }
 function readPlanningState(dir) {
   const sp = statePath(dir);
-  if (!existsSync2(sp)) {
+  if (!existsSync3(sp)) {
     return {
       phase: 0,
       status: "",
@@ -178,7 +329,7 @@ function readPlanningState(dir) {
       freshnessStatus: "unknown"
     };
   }
-  const content = readFileSync2(sp, "utf-8");
+  const content = readFileSync3(sp, "utf-8");
   const parsed = parseState(content);
   return {
     phase: parsed.phase || 1,
@@ -226,10 +377,10 @@ function parseTDDState(parsed) {
 function findWorkspaceRoot(startDir) {
   let current = startDir;
   for (;; ) {
-    const configPath = join2(current, ".planning", "config.json");
-    if (existsSync2(configPath)) {
+    const configPath = join3(current, ".planning", "config.json");
+    if (existsSync3(configPath)) {
       try {
-        const config = JSON.parse(readFileSync2(configPath, "utf-8"));
+        const config = JSON.parse(readFileSync3(configPath, "utf-8"));
         if (config.sub_repos && Array.isArray(config.sub_repos) && config.sub_repos.length > 0) {
           return current;
         }
@@ -254,11 +405,11 @@ function getWorkspaceConfig(dir) {
   const root = findWorkspaceRoot(dir);
   if (!root)
     return null;
-  const configPath = join2(root, ".planning", "config.json");
-  if (!existsSync2(configPath))
+  const configPath = join3(root, ".planning", "config.json");
+  if (!existsSync3(configPath))
     return null;
   try {
-    const config = JSON.parse(readFileSync2(configPath, "utf-8"));
+    const config = JSON.parse(readFileSync3(configPath, "utf-8"));
     return {
       sub_repos: Array.isArray(config.sub_repos) ? config.sub_repos : null,
       workspace_mode: config.workspace_mode === "per-repo" ? "per-repo" : "shared",
@@ -300,19 +451,19 @@ var planningStateTool = tool2({
   async execute(args, context) {
     const dir = context.directory ?? process.cwd();
     const sp = statePath(dir);
-    if (!existsSync3(sp)) {
+    if (!existsSync4(sp)) {
       return JSON.stringify({ error: "STATE.md not found. Initialize project first." });
     }
     switch (args.action) {
       case "read": {
-        const content = readFileSync3(sp, "utf-8");
+        const content = readFileSync4(sp, "utf-8");
         return JSON.stringify({ exists: true, ...parseState(content) });
       }
       case "update": {
         const u = args.updates;
         if (!u)
           return JSON.stringify({ error: "No updates provided" });
-        let content = readFileSync3(sp, "utf-8");
+        let content = readFileSync4(sp, "utf-8");
         const upsertLine = (current, key, value) => {
           const pattern = new RegExp(`^${key}:\\s*.*$`, "m");
           if (pattern.test(current))
@@ -366,38 +517,38 @@ ${blockersMd}
         return JSON.stringify({ success: true, updated_at: timestamp() });
       }
       case "read_plan": {
-        const stateContent = readFileSync3(sp, "utf-8");
+        const stateContent = readFileSync4(sp, "utf-8");
         const phaseMatch = stateContent.match(/^phase:\s*(\d+)/m);
         if (!phaseMatch)
           return JSON.stringify({ error: "No phase found in STATE.md" });
         const phase = parseInt(phaseMatch[1], 10);
         const planFileMatch = stateContent.match(/^plan_file:\s*(.+)/m);
-        const planFile = planFileMatch ? planFileMatch[1].trim() : join3(planningDir(dir), "phases", `phase-${phase}`, PLAN_FILE2);
-        if (!existsSync3(planFile))
+        const planFile = planFileMatch ? planFileMatch[1].trim() : join4(planningDir(dir), "phases", `phase-${phase}`, PLAN_FILE2);
+        if (!existsSync4(planFile))
           return JSON.stringify({ error: `Plan file not found: ${planFile}` });
-        return JSON.stringify({ phase, plan_file: planFile, content: readFileSync3(planFile, "utf-8") });
+        return JSON.stringify({ phase, plan_file: planFile, content: readFileSync4(planFile, "utf-8") });
       }
       case "mark_complete": {
         const step = args.step;
         const summary = args.summary;
         if (step === undefined || !summary)
           return JSON.stringify({ error: "step and summary required" });
-        const stateContent = readFileSync3(sp, "utf-8");
+        const stateContent = readFileSync4(sp, "utf-8");
         const phaseMatch = stateContent.match(/^phase:\s*(\d+)/m);
         if (!phaseMatch)
           return JSON.stringify({ error: "No phase in STATE.md" });
         const phase = parseInt(phaseMatch[1], 10);
         const planFile = phasePlanPath(dir, phase);
         const resultFile = resultPath(dir, phase);
-        if (existsSync3(planFile)) {
-          let planContent = readFileSync3(planFile, "utf-8");
+        if (existsSync4(planFile)) {
+          let planContent = readFileSync4(planFile, "utf-8");
           planContent = planContent.replace(new RegExp(`(\\[ \\])\\s*Step\\s+${step}\\b`, "i"), `[x] Step ${step}`);
           writeFileSync3(planFile, planContent, "utf-8");
         }
         const entry = `- Step ${step} complete (${timestamp()}): ${summary}
 `;
-        if (existsSync3(resultFile)) {
-          writeFileSync3(resultFile, readFileSync3(resultFile, "utf-8") + entry, "utf-8");
+        if (existsSync4(resultFile)) {
+          writeFileSync3(resultFile, readFileSync4(resultFile, "utf-8") + entry, "utf-8");
         } else {
           writeFileSync3(resultFile, `# Phase ${phase} Results
 
@@ -428,19 +579,19 @@ ${entry}`, "utf-8");
 
 // src/tools/workspace-state.ts
 import { tool as tool3 } from "@opencode-ai/plugin";
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync4, existsSync as existsSync4 } from "fs";
-import { join as join4 } from "path";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync4, existsSync as existsSync5 } from "fs";
+import { join as join5 } from "path";
 function getRepoName(repoPath) {
   return repoPath.split(/[/\\]/).pop() || repoPath;
 }
 function readWorkspaceStateFile(workspaceRoot) {
-  const sp = join4(planningDir(workspaceRoot), "STATE.md");
-  if (!existsSync4(sp))
+  const sp = join5(planningDir(workspaceRoot), "STATE.md");
+  if (!existsSync5(sp))
     return null;
-  return readFileSync4(sp, "utf-8");
+  return readFileSync5(sp, "utf-8");
 }
 function writeWorkspaceStateFile(workspaceRoot, content) {
-  const sp = join4(planningDir(workspaceRoot), "STATE.md");
+  const sp = join5(planningDir(workspaceRoot), "STATE.md");
   writeFileSync4(sp, content, "utf-8");
 }
 function parseWorkspaceState(content) {
@@ -495,12 +646,12 @@ async function updateWorkspaceContextAction(dir, mode, workspaceRoot, updates) {
   return { success: true, updated_at: timestamp() };
 }
 async function listSubReposAction(dir, subRepos, workspaceRoot) {
-  const resolved = resolveSubRepos(join4(workspaceRoot, ".planning", "config.json"), subRepos);
+  const resolved = resolveSubRepos(join5(workspaceRoot, ".planning", "config.json"), subRepos);
   const repos = [];
   for (const repoPath of resolved) {
     const repoName = getRepoName(repoPath);
     const planningPath = planningDir(repoPath);
-    const hasPlanning = existsSync4(planningPath);
+    const hasPlanning = existsSync5(planningPath);
     repos.push({
       name: repoName,
       path: repoPath,
@@ -512,20 +663,20 @@ async function listSubReposAction(dir, subRepos, workspaceRoot) {
 async function getSubRepoStateAction(dir, repoName, subRepos, workspaceRoot, mode) {
   if (!repoName)
     return { error: "repo name is required" };
-  const resolved = resolveSubRepos(join4(workspaceRoot, ".planning", "config.json"), subRepos);
+  const resolved = resolveSubRepos(join5(workspaceRoot, ".planning", "config.json"), subRepos);
   const targetPath = resolved.find((p) => getRepoName(p) === repoName);
   if (!targetPath) {
     return { error: "not_found", path: repoName, message: `Repo '${repoName}' not found in sub_repos` };
   }
   const planningPath = planningDir(targetPath);
-  if (!existsSync4(planningPath)) {
+  if (!existsSync5(planningPath)) {
     return { error: "not_found", path: targetPath };
   }
   const sp = statePath(targetPath);
-  if (!existsSync4(sp)) {
+  if (!existsSync5(sp)) {
     return { error: "not_found", path: targetPath, message: `.planning/STATE.md not found in ${repoName}` };
   }
-  const stateContent = readFileSync4(sp, "utf-8");
+  const stateContent = readFileSync5(sp, "utf-8");
   const parsed = parseWorkspaceState(stateContent);
   return {
     repo_path: targetPath,
@@ -573,24 +724,24 @@ var workspaceStateTool = tool3({
 import { tool as tool4 } from "@opencode-ai/plugin";
 
 // src/services/agent-performance.ts
-import { existsSync as existsSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync5, mkdirSync as mkdirSync2 } from "fs";
-import { join as join5 } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync6, writeFileSync as writeFileSync5, mkdirSync as mkdirSync2 } from "fs";
+import { join as join6 } from "path";
 function perfPath(dir) {
-  return join5(codebaseDir(dir), "AGENT_PERF.json");
+  return join6(codebaseDir(dir), "AGENT_PERF.json");
 }
 function loadStore(dir) {
   const p = perfPath(dir);
-  if (!existsSync5(p))
+  if (!existsSync6(p))
     return { entries: [], updated_at: new Date().toISOString() };
   try {
-    return JSON.parse(readFileSync5(p, "utf-8"));
+    return JSON.parse(readFileSync6(p, "utf-8"));
   } catch {
     return { entries: [], updated_at: new Date().toISOString() };
   }
 }
 function saveStore(dir, store) {
   const cd = codebaseDir(dir);
-  if (!existsSync5(cd))
+  if (!existsSync6(cd))
     mkdirSync2(cd, { recursive: true });
   writeFileSync5(perfPath(dir), JSON.stringify(store, null, 2), "utf-8");
 }
@@ -732,7 +883,8 @@ function createRunPipelineTool(client) {
       })),
       initial_context: tool4.schema.string().optional(),
       abort_on_failure: tool4.schema.boolean().optional().default(true),
-      retry_attempts: tool4.schema.number().optional().default(1)
+      retry_attempts: tool4.schema.number().optional().default(1),
+      max_carry_chars: tool4.schema.number().optional()
     },
     async execute(args, context) {
       const startTime = Date.now();
@@ -818,9 +970,10 @@ ${step.prompt}` : step.prompt;
             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 });
+          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);
-          carryContext = output;
+          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);
@@ -836,6 +989,399 @@ ${step.prompt}` : step.prompt;
 
 // src/tools/delegate.ts
 import { tool as tool5 } from "@opencode-ai/plugin";
+import { existsSync as existsSync11, readFileSync as readFileSync11 } from "fs";
+
+// src/services/prompt-cache.ts
+import { createHash } from "crypto";
+import { existsSync as existsSync7, readFileSync as readFileSync7, writeFileSync as writeFileSync6, readdirSync as readdirSync3, statSync, mkdirSync as mkdirSync3 } from "fs";
+import { join as join7 } 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 join7(codebaseDir(dir), CACHE_DIR_NAME);
+}
+function entryPath(dir, key) {
+  return join7(cacheDir(dir), `${key}.json`);
+}
+function readEntry(dir, key, stateVersion, indexVersion) {
+  const path = entryPath(dir, key);
+  if (!existsSync7(path))
+    return null;
+  try {
+    const entry = JSON.parse(readFileSync7(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 (!existsSync7(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
+  };
+  writeFileSync6(entryPath(dir, key), JSON.stringify(entry, null, 2), "utf-8");
+  pruneExpired(dir);
+}
+function pruneExpired(dir) {
+  const cd = cacheDir(dir);
+  if (!existsSync7(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 = join7(cd, f);
+      try {
+        const entry = JSON.parse(readFileSync7(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 readFileSync8, writeFileSync as writeFileSync7, existsSync as existsSync8, mkdirSync as mkdirSync4 } from "fs";
+import { join as join8 } from "path";
+var CODEBASE_INDEX_FILE = "CODEBASE_INDEX.md";
+function indexPath(dir) {
+  return join8(planningDir(dir), CODEBASE_INDEX_FILE);
+}
+function readCodebaseIndex(dir) {
+  const path = indexPath(dir);
+  if (!existsSync8(path)) {
+    return {
+      exists: false,
+      lastUpdatedAt: "",
+      lastUpdatedBy: "",
+      sourceStage: "",
+      changedFiles: [],
+      fileSnapshots: {},
+      explorationHistory: [],
+      summaryVersion: 0,
+      freshnessStatus: "unknown"
+    };
+  }
+  try {
+    const content = readFileSync8(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 existsSync9, readFileSync as readFileSync9, appendFileSync, mkdirSync as mkdirSync5 } from "fs";
+import { join as join9 } from "path";
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+function metricsPath(dir) {
+  return join9(codebaseDir(dir), "TOKEN_METRICS.jsonl");
+}
+function appendEvent(dir, event) {
+  const cd = codebaseDir(dir);
+  if (!existsSync9(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 existsSync10, readFileSync as readFileSync10 } from "fs";
+import { join as join10 } from "path";
+import { homedir } from "os";
+var CONFIG_FILENAME = "flowdeck.json";
+function getGlobalConfigDir() {
+  return process.env.OPENCODE_CONFIG_DIR || (process.env.XDG_CONFIG_HOME ? join10(process.env.XDG_CONFIG_HOME, "opencode") : join10(homedir(), ".config", "opencode"));
+}
+function loadFlowDeckConfig(directory) {
+  const candidates = [];
+  if (directory) {
+    candidates.push(join10(directory, ".opencode", CONFIG_FILENAME));
+  }
+  candidates.push(join10(getGlobalConfigDir(), CONFIG_FILENAME));
+  for (const configPath of candidates) {
+    if (existsSync10(configPath)) {
+      try {
+        const content = readFileSync10(configPath, "utf-8");
+        return JSON.parse(content);
+      } catch {
+        console.warn(`[flowdeck] Failed to load config from ${configPath}`);
+      }
+    }
+  }
+  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(`
 `);
@@ -848,13 +1394,56 @@ function createDelegateTool(client) {
       prompt: tool5.schema.string(),
       context: tool5.schema.string().optional(),
       task_type: tool5.schema.string().optional(),
-      retry_attempts: tool5.schema.number().optional().default(1)
+      retry_attempts: tool5.schema.number().optional().default(1),
+      safe_to_cache: tool5.schema.boolean().optional().default(false),
+      cache_ttl_ms: tool5.schema.number().optional(),
+      workflow_id: tool5.schema.string().optional(),
+      stage: tool5.schema.string().optional()
     },
     async execute(args, context) {
       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(context.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(context.directory);
+        const sp = statePath(context.directory);
+        const rawState = existsSync11(sp) ? readFileSync11(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(context.directory, args.agent, fullPrompt, args.context ?? "", stateVersion, indexVersion, true);
+        if (cached !== null) {
+          if (metricsWorkflowId) {
+            recordCacheHit(context.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: context.sessionID, title: `${args.agent}-delegate` },
         query: { directory: context.directory }
@@ -874,7 +1463,7 @@ function createDelegateTool(client) {
           query: { directory: context.directory }
         }).catch(() => {});
       });
-      const fullPrompt = args.context ? `${args.context}
+      const fullPromptForSession = args.context ? `${args.context}
 
 ---
 
@@ -882,17 +1471,23 @@ ${args.prompt}` : args.prompt;
       let promptRes = null;
       let retriesUsed = 0;
       for (let attempt = 0;attempt <= maxRetries; attempt++) {
+        const attemptStart = Date.now();
         promptRes = await client.session.prompt({
           path: { id: childId },
           body: {
             agent: args.agent,
-            parts: [{ type: "text", text: fullPrompt }],
+            parts: [{ type: "text", text: fullPromptForSession }],
             tools: { question: false }
           },
           query: { directory: context.directory }
         });
         if (!shouldRetry(promptRes) || attempt === maxRetries)
           break;
+        if (metricsWorkflowId) {
+          const retryInputTokens = estimateTokens(fullPromptForSession);
+          const retryCostUsd = agentModel ? estimateCostUSD(agentModel, retryInputTokens, 0) : undefined;
+          recordRetryCall(context.directory, metricsWorkflowId, metricsStage, fullPromptForSession, "", args.agent, Date.now() - attemptStart, agentModel, retryCostUsd);
+        }
         retriesUsed++;
       }
       if (!promptRes || promptRes.error) {
@@ -924,6 +1519,15 @@ ${args.prompt}` : args.prompt;
       }
       const output = extractText2(promptRes.data?.parts ?? []);
       recordRun(context.directory, args.agent, "", taskType, true, Date.now() - startTime);
+      if (metricsWorkflowId) {
+        const inputTokens = estimateTokens(fullPromptForSession);
+        const outputTokens = estimateTokens(output);
+        const costUsd = agentModel ? estimateCostUSD(agentModel, inputTokens, outputTokens) : undefined;
+        recordModelCall(context.directory, metricsWorkflowId, metricsStage, fullPromptForSession, output, args.agent, Date.now() - startTime, agentModel, costUsd);
+      }
+      if (safe_to_cache && output) {
+        setCached(context.directory, args.agent, fullPromptForSession, args.context ?? "", stateVersion, indexVersion, output, true, args.cache_ttl_ms);
+      }
       return JSON.stringify({
         agent: args.agent,
         session_id: childId,
@@ -940,31 +1544,31 @@ ${args.prompt}` : args.prompt;
 
 // src/tools/repo-memory.ts
 import { tool as tool6 } from "@opencode-ai/plugin";
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync6, existsSync as existsSync6, mkdirSync as mkdirSync3 } from "fs";
-import { join as join6 } from "path";
+import { readFileSync as readFileSync12, writeFileSync as writeFileSync8, existsSync as existsSync12, mkdirSync as mkdirSync6 } from "fs";
+import { join as join11 } from "path";
 var MEMORY_FILE = "MEMORY.json";
 function memoryPath(directory) {
-  return join6(codebaseDir(directory), MEMORY_FILE);
+  return join11(codebaseDir(directory), MEMORY_FILE);
 }
 function emptyMemory() {
   return { version: "1.0", last_updated: new Date().toISOString(), nodes: {} };
 }
 function readMemory(directory) {
   const p = memoryPath(directory);
-  if (!existsSync6(p))
+  if (!existsSync12(p))
     return emptyMemory();
   try {
-    return JSON.parse(readFileSync6(p, "utf-8"));
+    return JSON.parse(readFileSync12(p, "utf-8"));
   } catch {
     return emptyMemory();
   }
 }
 function writeMemory(directory, memory) {
   const base = codebaseDir(directory);
-  if (!existsSync6(base))
-    mkdirSync3(base, { recursive: true });
+  if (!existsSync12(base))
+    mkdirSync6(base, { recursive: true });
   memory.last_updated = new Date().toISOString();
-  writeFileSync6(memoryPath(directory), JSON.stringify(memory, null, 2), "utf-8");
+  writeFileSync8(memoryPath(directory), JSON.stringify(memory, null, 2), "utf-8");
 }
 var repoMemoryTool = tool6({
   description: "Repo Memory Graph: read/write/query persistent architecture graph in .codebase/MEMORY.json (modules, dependencies, ownership, bug history, conventions)",
@@ -1041,28 +1645,28 @@ var repoMemoryTool = tool6({
 
 // src/tools/failure-replay.ts
 import { tool as tool7 } from "@opencode-ai/plugin";
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync7, existsSync as existsSync7, mkdirSync as mkdirSync4 } from "fs";
-import { join as join7 } from "path";
+import { readFileSync as readFileSync13, writeFileSync as writeFileSync9, existsSync as existsSync13, mkdirSync as mkdirSync7 } from "fs";
+import { join as join12 } from "path";
 var FAILURES_FILE = "FAILURES.json";
 function failuresPath(directory) {
-  return join7(codebaseDir(directory), FAILURES_FILE);
+  return join12(codebaseDir(directory), FAILURES_FILE);
 }
 function readStore(directory) {
   const p = failuresPath(directory);
-  if (!existsSync7(p))
+  if (!existsSync13(p))
     return { version: "1.0", last_updated: new Date().toISOString(), entries: [] };
   try {
-    return JSON.parse(readFileSync7(p, "utf-8"));
+    return JSON.parse(readFileSync13(p, "utf-8"));
   } catch {
     return { version: "1.0", last_updated: new Date().toISOString(), entries: [] };
   }
 }
 function writeStore(directory, store) {
   const base = codebaseDir(directory);
-  if (!existsSync7(base))
-    mkdirSync4(base, { recursive: true });
+  if (!existsSync13(base))
+    mkdirSync7(base, { recursive: true });
   store.last_updated = new Date().toISOString();
-  writeFileSync7(failuresPath(directory), JSON.stringify(store, null, 2), "utf-8");
+  writeFileSync9(failuresPath(directory), JSON.stringify(store, null, 2), "utf-8");
 }
 var failureReplayTool = tool7({
   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",
@@ -1146,17 +1750,17 @@ var failureReplayTool = tool7({
 
 // src/tools/decision-trace.ts
 import { tool as tool8 } from "@opencode-ai/plugin";
-import { readFileSync as readFileSync8, existsSync as existsSync8, mkdirSync as mkdirSync5, appendFileSync } from "fs";
-import { join as join8 } from "path";
+import { readFileSync as readFileSync14, existsSync as existsSync14, mkdirSync as mkdirSync8, appendFileSync as appendFileSync2 } from "fs";
+import { join as join13 } from "path";
 var DECISIONS_FILE = "DECISIONS.jsonl";
 function decisionsPath(directory) {
-  return join8(codebaseDir(directory), DECISIONS_FILE);
+  return join13(codebaseDir(directory), DECISIONS_FILE);
 }
 function readDecisions(directory) {
   const p = decisionsPath(directory);
-  if (!existsSync8(p))
+  if (!existsSync14(p))
     return [];
-  return readFileSync8(p, "utf-8").split(`
+  return readFileSync14(p, "utf-8").split(`
 `).filter((l) => l.trim()).map((l) => {
     try {
       return JSON.parse(l);
@@ -1196,10 +1800,10 @@ var decisionTraceTool = tool8({
       case "record": {
         if (!args.entry)
           return JSON.stringify({ error: "entry required" });
-        if (!existsSync8(base))
-          mkdirSync5(base, { recursive: true });
+        if (!existsSync14(base))
+          mkdirSync8(base, { recursive: true });
         const entry = { ...args.entry, timestamp: new Date().toISOString() };
-        appendFileSync(decisionsPath(dir), JSON.stringify(entry) + `
+        appendFileSync2(decisionsPath(dir), JSON.stringify(entry) + `
 `, "utf-8");
         return JSON.stringify({ success: true, id: args.entry.id });
       }
@@ -1231,28 +1835,28 @@ var decisionTraceTool = tool8({
 
 // src/tools/volatility-map.ts
 import { tool as tool9 } from "@opencode-ai/plugin";
-import { readFileSync as readFileSync9, writeFileSync as writeFileSync9, existsSync as existsSync9, mkdirSync as mkdirSync6 } from "fs";
-import { join as join9 } from "path";
+import { readFileSync as readFileSync15, writeFileSync as writeFileSync11, existsSync as existsSync15, mkdirSync as mkdirSync9 } from "fs";
+import { join as join14 } from "path";
 var VOLATILITY_FILE = "VOLATILITY.json";
 function volatilityPath(directory) {
-  return join9(codebaseDir(directory), VOLATILITY_FILE);
+  return join14(codebaseDir(directory), VOLATILITY_FILE);
 }
 function readStore2(directory) {
   const p = volatilityPath(directory);
-  if (!existsSync9(p))
+  if (!existsSync15(p))
     return { version: "1.0", last_updated: new Date().toISOString(), generated_at: new Date().toISOString(), entries: [] };
   try {
-    return JSON.parse(readFileSync9(p, "utf-8"));
+    return JSON.parse(readFileSync15(p, "utf-8"));
   } catch {
     return { version: "1.0", last_updated: new Date().toISOString(), generated_at: new Date().toISOString(), entries: [] };
   }
 }
 function writeStore2(directory, store) {
   const base = codebaseDir(directory);
-  if (!existsSync9(base))
-    mkdirSync6(base, { recursive: true });
+  if (!existsSync15(base))
+    mkdirSync9(base, { recursive: true });
   store.last_updated = new Date().toISOString();
-  writeFileSync9(volatilityPath(directory), JSON.stringify(store, null, 2), "utf-8");
+  writeFileSync11(volatilityPath(directory), JSON.stringify(store, null, 2), "utf-8");
 }
 function stabilityLabel(churn, hotfixes, todos) {
   const score = churn + hotfixes * 10 + todos * 2;
@@ -1339,28 +1943,28 @@ var volatilityMapTool = tool9({
 
 // src/tools/policy-engine.ts
 import { tool as tool10 } from "@opencode-ai/plugin";
-import { readFileSync as readFileSync10, writeFileSync as writeFileSync10, existsSync as existsSync10, mkdirSync as mkdirSync7 } from "fs";
-import { join as join10 } from "path";
+import { readFileSync as readFileSync16, writeFileSync as writeFileSync12, existsSync as existsSync16, mkdirSync as mkdirSync10 } from "fs";
+import { join as join15 } from "path";
 var POLICIES_FILE = "POLICIES.json";
 function policiesPath(directory) {
-  return join10(codebaseDir(directory), POLICIES_FILE);
+  return join15(codebaseDir(directory), POLICIES_FILE);
 }
 function readStore3(directory) {
   const p = policiesPath(directory);
-  if (!existsSync10(p))
+  if (!existsSync16(p))
     return { version: "1.0", last_updated: new Date().toISOString(), policies: [] };
   try {
-    return JSON.parse(readFileSync10(p, "utf-8"));
+    return JSON.parse(readFileSync16(p, "utf-8"));
   } catch {
     return { version: "1.0", last_updated: new Date().toISOString(), policies: [] };
   }
 }
 function writeStore3(directory, store) {
   const base = codebaseDir(directory);
-  if (!existsSync10(base))
-    mkdirSync7(base, { recursive: true });
+  if (!existsSync16(base))
+    mkdirSync10(base, { recursive: true });
   store.last_updated = new Date().toISOString();
-  writeFileSync10(policiesPath(directory), JSON.stringify(store, null, 2), "utf-8");
+  writeFileSync12(policiesPath(directory), JSON.stringify(store, null, 2), "utf-8");
 }
 var policyEngineTool = tool10({
   description: "Self-Healing Policy Engine: manage .codebase/POLICIES.json — add, list, query, toggle, and record violations of editing policies learned from past failures",
@@ -1442,8 +2046,8 @@ var policyEngineTool = tool10({
 
 // src/tools/hash-edit.ts
 import { tool as tool11 } from "@opencode-ai/plugin";
-import { readFileSync as readFileSync11, writeFileSync as writeFileSync11 } from "fs";
-import { createHash } from "crypto";
+import { readFileSync as readFileSync17, writeFileSync as writeFileSync13 } from "fs";
+import { createHash as createHash2 } from "crypto";
 var hashEditTool = tool11({
   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: {
@@ -1456,7 +2060,7 @@ var hashEditTool = tool11({
     const fullPath = args.filePath.startsWith("/") ? args.filePath : `${context.directory}/${args.filePath}`;
     let content;
     try {
-      content = readFileSync11(fullPath, "utf-8");
+      content = readFileSync17(fullPath, "utf-8");
     } catch (e) {
       return `Error: Could not read file ${args.filePath}`;
     }
@@ -1464,37 +2068,76 @@ var hashEditTool = tool11({
       return `Error: Target content not found in ${args.filePath}. It may have been modified by another agent.`;
     }
     if (args.expectedHash) {
-      const actualHash = createHash("md5").update(args.targetContent).digest("hex");
+      const actualHash = createHash2("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");
+    writeFileSync13(fullPath, newContent, "utf-8");
     return `Successfully updated ${args.filePath} using hash-anchored edit.`;
   }
 });
 
 // src/tools/council.ts
 import { tool as tool12 } from "@opencode-ai/plugin";
-import { appendFileSync as appendFileSync2, existsSync as existsSync11, mkdirSync as mkdirSync8 } from "fs";
-import { join as join11 } from "path";
+import { appendFileSync as appendFileSync3, existsSync as existsSync17, mkdirSync as mkdirSync11 } from "fs";
+import { join as join16 } from "path";
+import { createHash as createHash3 } from "crypto";
+import { readFileSync as readFileSync18 } 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);
+}
+async function runWithConcurrencyLimit(tasks, limit) {
+  const results = new Array(tasks.length);
+  let next = 0;
+  async function worker() {
+    while (next < tasks.length) {
+      const idx = next++;
+      results[idx] = await tasks[idx]();
+    }
+  }
+  const workers = Array.from({ length: Math.min(limit, tasks.length) }, () => worker());
+  await Promise.all(workers);
+  return results;
+}
 function createCouncilTool(client) {
   return tool12({
-    description: "Run an ensemble of agents (Council) on the same task to reach consensus or compare approaches. Runs 3 specialized agents in parallel and returns their synthesized outputs.",
+    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: tool12.schema.string(),
-      agents: tool12.schema.array(tool12.schema.string()).optional()
+      agents: tool12.schema.array(tool12.schema.string()).optional(),
+      force_fresh: tool12.schema.boolean().optional().default(false),
+      max_concurrency: tool12.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 = existsSync17(sp) ? readFileSync18(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;
+      if (!args.force_fresh) {
+        const cacheKey2 = councilCacheKey(args.task, agents, stateVersion, indexVersion);
+        const cached = _councilCache.get(cacheKey2);
+        if (cached && Date.now() - cached.cached_at < COUNCIL_CACHE_TTL_MS) {
+          return cached.synthesis + `
+
+<!-- council: cached result -->`;
+        }
+      }
       const tasks = agents.map((agent) => ({
         agent,
         prompt: `TASK: ${args.task}
 
 Please provide your best analysis/implementation for this task. Your output will be compared with other agents in a council.`
       }));
-      const results = await Promise.all(tasks.map(async (task) => {
+      const results = await runWithConcurrencyLimit(tasks.map((task) => async () => {
         const createRes = await client.session.create({
           body: { parentID: context.sessionID, title: `Council: ${task.agent}` },
           query: { directory: context.directory }
@@ -1514,7 +2157,7 @@ Please provide your best analysis/implementation for this task. Your output will
         const output = (promptRes.data?.parts ?? []).filter((p) => p.type === "text").map((p) => p.text).join(`
 `);
         return { agent: task.agent, output: output || "(no output)" };
-      }));
+      }), concurrencyLimit);
       const synthesisPrompt = `You are a Council Synthesizer. Below are the outputs from ${results.length} different agents on the same task.
       
 TASK: ${args.task}
@@ -1542,6 +2185,8 @@ Please synthesize these results. Identify areas of agreement, resolve conflicts,
         synthesis,
         created_at: new Date().toISOString()
       });
+      const cacheKey = councilCacheKey(args.task, agents, stateVersion, indexVersion);
+      _councilCache.set(cacheKey, { synthesis, cached_at: Date.now() });
       return synthesis;
     }
   });
@@ -1549,18 +2194,18 @@ Please synthesize these results. Identify areas of agreement, resolve conflicts,
 function persistCouncilResult(directory, payload) {
   try {
     const base = codebaseDir(directory);
-    if (!existsSync11(base))
-      mkdirSync8(base, { recursive: true });
-    const path = join11(base, "COUNCILS.jsonl");
-    appendFileSync2(path, JSON.stringify(payload) + `
+    if (!existsSync17(base))
+      mkdirSync11(base, { recursive: true });
+    const path = join16(base, "COUNCILS.jsonl");
+    appendFileSync3(path, JSON.stringify(payload) + `
 `, "utf-8");
   } catch {}
 }
 
 // src/tools/context-generator.ts
 import { tool as tool13 } from "@opencode-ai/plugin";
-import { writeFileSync as writeFileSync12, existsSync as existsSync12, readFileSync as readFileSync12, readdirSync as readdirSync2, statSync } from "fs";
-import { join as join12 } from "path";
+import { writeFileSync as writeFileSync14, existsSync as existsSync18, readFileSync as readFileSync19, readdirSync as readdirSync4, statSync as statSync2 } from "fs";
+import { join as join17 } from "path";
 var contextGeneratorTool = tool13({
   description: "Auto-generate or update hierarchical context files (AGENTS.md, CLAUDE.md) throughout the project. These files provide critical grounding for AI agents.",
   args: {
@@ -1569,20 +2214,20 @@ var contextGeneratorTool = tool13({
   },
   async execute(args, context) {
     const root = context.directory;
-    const target = args.targetDir ? join12(root, args.targetDir) : root;
-    if (!existsSync12(target)) {
+    const target = args.targetDir ? join17(root, args.targetDir) : root;
+    if (!existsSync18(target)) {
       return `Error: Directory ${target} does not exist.`;
     }
-    const agentsMdPath = join12(target, "AGENTS.md");
-    if (existsSync12(agentsMdPath) && !args.force) {
+    const agentsMdPath = join17(target, "AGENTS.md");
+    if (existsSync18(agentsMdPath) && !args.force) {
       return `AGENTS.md already exists in ${target}. Use force: true to overwrite.`;
     }
-    const pkgPath = join12(root, "package.json");
+    const pkgPath = join17(root, "package.json");
     let projectName = "Project";
     let techStack = "Unknown";
-    if (existsSync12(pkgPath)) {
+    if (existsSync18(pkgPath)) {
       try {
-        const pkg = JSON.parse(readFileSync12(pkgPath, "utf-8"));
+        const pkg = JSON.parse(readFileSync19(pkgPath, "utf-8"));
         projectName = pkg.name || projectName;
         techStack = Object.keys(pkg.dependencies || {}).slice(0, 5).join(", ");
       } catch {}
@@ -1599,8 +2244,8 @@ var contextGeneratorTool = tool13({
 3. **Planning**: Always check \`.planning/STATE.md\` before executing major changes.
 
 ## Directory Map
-${readdirSync2(target).slice(0, 10).map((f) => {
-      const s = statSync(join12(target, f));
+${readdirSync4(target).slice(0, 10).map((f) => {
+      const s = statSync2(join17(target, f));
       return `- \`${f}\`${s.isDirectory() ? "/" : ""} : [Description]`;
     }).join(`
 `)}
@@ -1608,17 +2253,17 @@ ${readdirSync2(target).slice(0, 10).map((f) => {
 ---
 Generated by FlowDeck Context Generator.
 `;
-    writeFileSync12(agentsMdPath, content, "utf-8");
+    writeFileSync14(agentsMdPath, content, "utf-8");
     return `Successfully generated AGENTS.md in ${target}.`;
   }
 });
 
 // src/tools/create-skill.ts
 import { tool as tool14 } from "@opencode-ai/plugin";
-import { mkdirSync as mkdirSync9, writeFileSync as writeFileSync13, existsSync as existsSync13 } from "fs";
-import { join as join13, dirname as dirname3 } from "path";
+import { mkdirSync as mkdirSync12, writeFileSync as writeFileSync15, existsSync as existsSync19 } from "fs";
+import { join as join18, dirname as dirname3 } from "path";
 import { fileURLToPath } from "url";
-var SKILLS_DIR = join13(dirname3(fileURLToPath(import.meta.url)), "..", "skills");
+var SKILLS_DIR = join18(dirname3(fileURLToPath(import.meta.url)), "..", "skills");
 var createSkillTool = tool14({
   description: "Create a new reusable skill in the FlowDeck skill library (src/skills/). " + "Use this when you discover a repeatable pattern, solve a novel problem with human guidance, " + "or want to capture domain knowledge for future sessions.",
   args: {
@@ -1628,9 +2273,9 @@ var createSkillTool = tool14({
     tags: tool14.schema.array(tool14.schema.string()).optional().describe("Optional tags for categorisation, e.g. ['performance', 'typescript']")
   },
   async execute(args) {
-    const skillDir = join13(SKILLS_DIR, args.name);
-    const skillFile = join13(skillDir, "SKILL.md");
-    if (existsSync13(skillFile)) {
+    const skillDir = join18(SKILLS_DIR, args.name);
+    const skillFile = join18(skillDir, "SKILL.md");
+    if (existsSync19(skillFile)) {
       return `Skill '${args.name}' already exists at ${skillFile}.
 ` + `Use a different name or delete the existing skill directory first.`;
     }
@@ -1645,8 +2290,8 @@ origin: FlowDeck (self-learned)${tagLine}
 `;
     const fullContent = frontmatter + args.content.trimStart();
     try {
-      mkdirSync9(skillDir, { recursive: true });
-      writeFileSync13(skillFile, fullContent, "utf-8");
+      mkdirSync12(skillDir, { recursive: true });
+      writeFileSync15(skillFile, fullContent, "utf-8");
       return `✓ Skill '${args.name}' created at ${skillFile}
 
 ` + `The skill is now part of the FlowDeck library. Restart OpenCode to load it into the active session.`;
@@ -1658,8 +2303,8 @@ origin: FlowDeck (self-learned)${tagLine}
 
 // src/tools/reflect.ts
 import { tool as tool15 } from "@opencode-ai/plugin";
-import { existsSync as existsSync14, readFileSync as readFileSync13 } from "fs";
-import { join as join14 } from "path";
+import { existsSync as existsSync20, readFileSync as readFileSync20 } from "fs";
+import { join as join19 } from "path";
 var MAX_ARTIFACT_BYTES = 4000;
 function tail(text, maxBytes) {
   if (text.length <= maxBytes)
@@ -1688,11 +2333,11 @@ var reflectTool = tool15({
     ];
     let found = 0;
     for (const [rel, label] of ARTIFACT_PATHS) {
-      const full = join14(root, rel);
-      if (!existsSync14(full))
+      const full = join19(root, rel);
+      if (!existsSync20(full))
         continue;
       try {
-        const raw = readFileSync13(full, "utf-8").trim();
+        const raw = readFileSync20(full, "utf-8").trim();
         if (!raw)
           continue;
         const count = raw.split(`
@@ -1716,12 +2361,12 @@ import { tool as tool16 } from "@opencode-ai/plugin";
 
 // src/services/codegraph.ts
 import { spawnSync } from "child_process";
-import { existsSync as existsSync15, readFileSync as readFileSync14, writeFileSync as writeFileSync14, mkdirSync as mkdirSync10 } from "fs";
-import { join as join15 } from "path";
+import { existsSync as existsSync21, readFileSync as readFileSync21, writeFileSync as writeFileSync16, mkdirSync as mkdirSync13 } from "fs";
+import { join as join20 } from "path";
 var CODEGRAPH_META_FILE = "CODEGRAPH.md";
 var MAX_FRESHNESS_MS = 30 * 60 * 1000;
 function metaPath(dir) {
-  return join15(codebaseDir(dir), CODEGRAPH_META_FILE);
+  return join20(codebaseDir(dir), CODEGRAPH_META_FILE);
 }
 function isCodegraphInstalled() {
   try {
@@ -1736,11 +2381,11 @@ function isCodegraphInstalled() {
   }
 }
 function isCodegraphIndexed(dir) {
-  return existsSync15(join15(dir, ".codegraph", "codegraph.db"));
+  return existsSync21(join20(dir, ".codegraph", "codegraph.db"));
 }
 function readCodegraphMeta(dir) {
   const path = metaPath(dir);
-  if (!existsSync15(path)) {
+  if (!existsSync21(path)) {
     return {
       installed: false,
       indexed: false,
@@ -1753,7 +2398,7 @@ function readCodegraphMeta(dir) {
     };
   }
   try {
-    const content = readFileSync14(path, "utf-8");
+    const content = readFileSync21(path, "utf-8");
     return parseCodegraphMeta(content);
   } catch {
     return {
@@ -1820,8 +2465,8 @@ function parseCodegraphMeta(content) {
 }
 function writeCodegraphMeta(dir, meta) {
   const base = codebaseDir(dir);
-  if (!existsSync15(base))
-    mkdirSync10(base, { recursive: true });
+  if (!existsSync21(base))
+    mkdirSync13(base, { recursive: true });
   const lines = [
     "# Codegraph Metadata",
     "",
@@ -1834,7 +2479,7 @@ function writeCodegraphMeta(dir, meta) {
     `**installLog:** ${meta.installLog}`,
     `**indexLog:** ${meta.indexLog}`
   ];
-  writeFileSync14(metaPath(dir), lines.join(`
+  writeFileSync16(metaPath(dir), lines.join(`
 `), "utf-8");
 }
 function isCodegraphFresh(dir, maxAgeMs = MAX_FRESHNESS_MS) {
@@ -2137,59 +2782,298 @@ var codegraphTool = tool16({
   }
 });
 
-// src/hooks/guard-rails.ts
-import { existsSync as existsSync17, readFileSync as readFileSync16 } from "fs";
-import { join as join17 } from "path";
-
-// src/config/loader.ts
-import { existsSync as existsSync16, readFileSync as readFileSync15 } from "fs";
-import { join as join16 } from "path";
-import { homedir } from "os";
-var CONFIG_FILENAME = "flowdeck.json";
-function getGlobalConfigDir() {
-  return process.env.OPENCODE_CONFIG_DIR || (process.env.XDG_CONFIG_HOME ? join16(process.env.XDG_CONFIG_HOME, "opencode") : join16(homedir(), ".config", "opencode"));
-}
-function loadFlowDeckConfig(directory) {
-  const candidates = [];
-  if (directory) {
-    candidates.push(join16(directory, ".opencode", CONFIG_FILENAME));
-  }
-  candidates.push(join16(getGlobalConfigDir(), CONFIG_FILENAME));
-  for (const configPath of candidates) {
-    if (existsSync16(configPath)) {
+// src/tools/load-rules.ts
+import { tool as tool17 } from "@opencode-ai/plugin";
+import { existsSync as existsSync22, readFileSync as readFileSync22 } from "fs";
+import { join as join21, dirname as dirname4 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var RULES_DIR = join21(dirname4(fileURLToPath2(import.meta.url)), "..", "rules");
+var _loadedPaths = new Set;
+var loadRulesTool = tool17({
+  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: tool17.schema.string().optional().describe("Current workflow stage: discuss | plan | execute | verify | fix-bug | write-docs"),
+    languages: tool17.schema.array(tool17.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: tool17.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 = existsSync22(RULES_DIR) ? RULES_DIR : null;
+    if (!rulesDir) {
+      return JSON.stringify({
+        loaded: [],
+        skipped_already_loaded: [],
+        skipped_no_match: [],
+        content: "",
+        error: `Rules directory not found at ${RULES_DIR}`
+      });
+    }
+    const context = {
+      stage: args.stage,
+      languages: args.languages
+    };
+    const selection = selectRulePaths(rulesDir, context);
+    const diagnostics = buildSelectionDiagnostics(selection, context);
+    const loaded = [];
+    const skippedAlreadyLoaded = [];
+    const contents = [];
+    for (const rule of selection.selected) {
+      const name = ruleShortName(rule);
+      if (!args.force_reload && _loadedPaths.has(rule.path)) {
+        skippedAlreadyLoaded.push(name);
+        continue;
+      }
       try {
-        const content = readFileSync15(configPath, "utf-8");
-        return JSON.parse(content);
+        const text = readFileSync22(rule.path, "utf-8");
+        contents.push(`## ${name}
+
+${text}`);
+        _loadedPaths.add(rule.path);
+        loaded.push(name);
       } catch {
-        console.warn(`[flowdeck] Failed to load config from ${configPath}`);
+        loaded.push(`${name} (read error)`);
       }
     }
+    const skippedNoMatch = selection.skipped.map((r) => ({
+      name: ruleShortName(r),
+      reason: selection.reasons[r.path]
+    }));
+    return JSON.stringify({
+      loaded,
+      skipped_already_loaded: skippedAlreadyLoaded,
+      skipped_no_match: skippedNoMatch,
+      total_available: selection.total_discovered,
+      diagnostics,
+      content: contents.join(`
+
+---
+
+`)
+    });
+  }
+});
+function ruleShortName(rule) {
+  return rule.path.replace(RULES_DIR + "/", "").replace(/\.md$/, "");
+}
+var listRulesTool = tool17({
+  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 = existsSync22(RULES_DIR) ? RULES_DIR : null;
+    if (!rulesDir) {
+      return JSON.stringify({ rules: [], error: `Rules directory not found at ${RULES_DIR}` });
+    }
+    const all = discoverRules(rulesDir);
+    return JSON.stringify({
+      total: all.length,
+      rules: all.map((r) => ({
+        name: r.path.replace(RULES_DIR + "/", "").replace(/\.md$/, ""),
+        description: r.description,
+        always_on: r.always_on,
+        stages: r.stages,
+        languages: r.languages,
+        loaded: _loadedPaths.has(r.path)
+      }))
+    });
+  }
+});
+
+// src/tools/rtk-setup.ts
+import { tool as tool18 } from "@opencode-ai/plugin";
+
+// src/services/rtk-manager.ts
+import { spawnSync as spawnSync2 } from "child_process";
+import { existsSync as existsSync23 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join22 } from "path";
+
+// src/services/rtk-policy.ts
+var SUPPORTED_COMMANDS = new Set([
+  "git",
+  "npm",
+  "npx",
+  "bun",
+  "pnpm",
+  "yarn",
+  "tsc",
+  "eslint",
+  "biome",
+  "oxlint",
+  "jest",
+  "vitest",
+  "pytest",
+  "cargo",
+  "docker",
+  "kubectl",
+  "gh"
+]);
+var COMPACT_GIT_SUBCOMMANDS = new Set([
+  "rev-parse",
+  "hash-object",
+  "cat-file",
+  "ls-files",
+  "ls-tree",
+  "show-ref",
+  "for-each-ref",
+  "symbolic-ref",
+  "config"
+]);
+var NEVER_WRAP = new Set(["codegraph", "curl", "sh", "bash", "zsh", "fish", "node", "python", "python3"]);
+function getSupportedCommands() {
+  return [...SUPPORTED_COMMANDS].sort();
+}
+
+// src/services/rtk-manager.ts
+var INSTALL_INSTRUCTIONS = [
+  "rtk is not installed. To install it manually:",
+  "  Linux/macOS: curl -fsSL https://raw.githubusercontent.com/rtk-ai/rtk/refs/heads/master/install.sh | sh",
+  "  Then add ~/.local/bin to your PATH if needed.",
+  "After installation, call rtk-setup again to verify detection."
+].join(`
+`);
+var CANDIDATE_PATHS = [join22(homedir2(), ".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) {
+    const version = (fromPath.stdout ?? "").trim().split(`
+`)[0] ?? "";
+    return { installed: true, binPath: "rtk", version };
+  }
+  for (const candidate of CANDIDATE_PATHS) {
+    if (!existsSync23(candidate))
+      continue;
+    const result = spawnSync2(candidate, ["--version"], { encoding: "utf-8", timeout: 5000 });
+    if (result.status === 0) {
+      const version = (result.stdout ?? "").trim().split(`
+`)[0] ?? "";
+      return { installed: true, binPath: candidate, version };
+    }
   }
-  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"]
+    installed: false,
+    error: "rtk binary not found in PATH or known install locations"
+  };
+}
+function initRtk(binPath) {
+  try {
+    const result = spawnSync2(binPath, ["init", "-g"], {
+      encoding: "utf-8",
+      timeout: 30000,
+      stdio: "pipe"
+    });
+    if (result.status !== 0) {
+      return {
+        success: false,
+        log: (result.stdout ?? "").trim(),
+        telemetryDisabled: false,
+        error: (result.stderr ?? "").trim() || `rtk init -g exited with code ${result.status}`
+      };
     }
+    const telResult = spawnSync2(binPath, ["telemetry", "disable"], {
+      encoding: "utf-8",
+      timeout: 1e4,
+      stdio: "pipe"
+    });
+    return {
+      success: true,
+      log: [
+        `[rtk] init -g succeeded: ${(result.stdout ?? "").trim()}`,
+        `[rtk] telemetry disable: ${telResult.status === 0 ? "ok" : `failed (code ${telResult.status}) — ${(telResult.stderr ?? "").trim()}`}`
+      ].filter(Boolean).join(`
+`),
+      telemetryDisabled: telResult.status === 0
+    };
+  } catch (err) {
+    return { success: false, log: "", telemetryDisabled: false, error: String(err) };
+  }
+}
+function getRtkStatus(opts) {
+  const detection = detectRtk();
+  if (!detection.installed) {
+    return {
+      installed: false,
+      initAttempted: false,
+      initSuccess: false,
+      telemetryDisabled: false,
+      installInstructions: INSTALL_INSTRUCTIONS
+    };
+  }
+  let initAttempted = false;
+  let initSuccess = false;
+  let telemetryDisabled = false;
+  if (opts?.runInit && detection.binPath) {
+    initAttempted = true;
+    const initResult = initRtk(detection.binPath);
+    initSuccess = initResult.success;
+    telemetryDisabled = initResult.telemetryDisabled;
+  }
+  return {
+    installed: true,
+    binPath: detection.binPath,
+    version: detection.version,
+    initAttempted,
+    initSuccess,
+    telemetryDisabled
   };
 }
+
+// src/tools/rtk-setup.ts
+var rtkSetupTool = tool18({
+  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%.",
+    "Call this to check if rtk is available, to run `rtk init -g`, or to get the binary path.",
+    "When RTK_INSTALLED=true in the environment, use `$RTK_BIN git status` for compressed output."
+  ].join(" "),
+  args: {
+    action: tool18.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";
+    const runInit = action === "init";
+    const status = getRtkStatus({ runInit });
+    const lines = ["## rtk Status"];
+    if (status.installed) {
+      lines.push(`- **Installed**: yes`);
+      lines.push(`- **Binary**: ${status.binPath ?? "rtk (in PATH)"}`);
+      if (status.version)
+        lines.push(`- **Version**: ${status.version}`);
+      if (runInit) {
+        if (status.initAttempted) {
+          lines.push(`- **Init**: ${status.initSuccess ? "✓ succeeded (bash hook installed)" : "✗ failed"}`);
+          lines.push(`- **Telemetry**: ${status.telemetryDisabled ? "✓ disabled (`rtk telemetry disable` ran)" : "⚠ disable step failed — run `rtk telemetry disable` manually"}`);
+          if (status.initSuccess) {
+            lines.push("", "  **Bash hook caveat**: `rtk init -g` writes to Claude Code / Copilot global config.", "  Whether it fires in non-interactive shell sessions depends on the runtime.", "  For reliable compression, use `$RTK_BIN <cmd>` explicitly.", "  `RTK_TELEMETRY_DISABLED=1` is always injected into bash sessions by FlowDeck.");
+          }
+        }
+      } else {
+        lines.push("- **Init**: not requested (pass `action: 'init'` to install bash hook)");
+        lines.push("- **Telemetry**: `RTK_TELEMETRY_DISABLED=1` is always set in bash sessions by FlowDeck");
+      }
+      lines.push("", "### Using rtk", "In bash commands, replace `git status` with `$RTK_BIN git status`.", "The `RTK_BIN` env var is injected by FlowDeck into every bash session when rtk is detected.", "", "### Supported commands", getSupportedCommands().map((c) => `- \`${c}\``).join(`
+`));
+    } else {
+      lines.push("- **Installed**: no", "");
+      lines.push("### Install rtk");
+      if (status.installInstructions) {
+        lines.push("```", status.installInstructions, "```");
+      }
+      lines.push("", "After installing, call `rtk-setup` again to verify detection.");
+    }
+    return lines.join(`
+`);
+  }
+});
+
 // src/hooks/guard-rails.ts
+import { existsSync as existsSync24, readFileSync as readFileSync23 } from "fs";
+import { join as join23 } from "path";
 var PLANNING_DIR2 = ".planning";
 var CONFIG_FILE = "config.json";
 var STATE_FILE2 = "STATE.md";
 function resolveExecutionMode(configPath, trustScore, volatility) {
-  if (existsSync17(configPath)) {
+  if (existsSync24(configPath)) {
     try {
-      const config = JSON.parse(readFileSync16(configPath, "utf-8"));
+      const config = JSON.parse(readFileSync23(configPath, "utf-8"));
       if (config.execution_mode === "review-only")
         return "review-only";
       if (config.execution_mode === "guarded")
@@ -2243,22 +3127,22 @@ async function guardRailsHook(ctx, input, _output) {
   if (!ENABLED)
     return;
   const dir = ctx.directory;
-  const planningDirPath = join17(dir, PLANNING_DIR2);
+  const planningDirPath = join23(dir, PLANNING_DIR2);
   const codebaseDirectory = codebaseDir(dir);
-  const configPath = join17(planningDirPath, CONFIG_FILE);
-  const statePath2 = join17(planningDirPath, STATE_FILE2);
+  const configPath = join23(planningDirPath, CONFIG_FILE);
+  const statePath2 = join23(planningDirPath, STATE_FILE2);
   const workspaceRoot = findWorkspaceRoot(dir);
   if (workspaceRoot && dir !== workspaceRoot) {
     const config = getWorkspaceConfig(dir);
-    if (config && config.workspace_mode === "shared" && !existsSync17(planningDirPath)) {
+    if (config && config.workspace_mode === "shared" && !existsSync24(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 (!existsSync17(planningDirPath))
+    if (!existsSync24(planningDirPath))
       return;
-    if (!existsSync17(codebaseDirectory)) {
+    if (!existsSync24(codebaseDirectory)) {
       throw new Error(`[flowdeck] WARNING: .codebase/ not found. Run /fd-map-codebase to map the codebase.`);
     }
     const execMode = resolveExecutionMode(configPath, null);
@@ -2314,15 +3198,15 @@ function getDesignGateMessage(dir) {
 }
 function planSuggestsUiHeavy(dir, phase) {
   const planPath = phasePlanPath(dir, phase);
-  if (!existsSync17(planPath))
+  if (!existsSync24(planPath))
     return false;
-  const planContent = readFileSync16(planPath, "utf-8");
+  const planContent = readFileSync23(planPath, "utf-8");
   return isUiHeavyTask(planContent);
 }
 function effectiveSeverity(configPath, statePath2) {
-  if (existsSync17(configPath)) {
+  if (existsSync24(configPath)) {
     try {
-      const configContent = readFileSync16(configPath, "utf-8");
+      const configContent = readFileSync23(configPath, "utf-8");
       const config = JSON.parse(configContent);
       if (config.guard_enforcement === "warn")
         return "warn";
@@ -2338,10 +3222,10 @@ function getEffectiveSeverity(configPath, statePath2) {
   return effectiveSeverity(configPath, statePath2);
 }
 function getPlanConfirmed(statePath2) {
-  if (!existsSync17(statePath2))
+  if (!existsSync24(statePath2))
     return false;
   try {
-    const content = readFileSync16(statePath2, "utf-8");
+    const content = readFileSync23(statePath2, "utf-8");
     const match = content.match(/plan_confirmed:\s*(true|false)/i);
     return match ? match[1].toLowerCase() === "true" : false;
   } catch {
@@ -2349,32 +3233,32 @@ function getPlanConfirmed(statePath2) {
   }
 }
 function getWarningMessage(planningDir2) {
-  if (!existsSync17(join17(planningDir2, STATE_FILE2))) {
+  if (!existsSync24(join23(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 (!existsSync17(join17(planningDir2, STATE_FILE2))) {
+  if (!existsSync24(join23(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 existsSync18, readFileSync as readFileSync17 } from "fs";
-import { join as join18 } from "path";
+import { existsSync as existsSync25, readFileSync as readFileSync24 } from "fs";
+import { join as join24 } 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(tool17, args) {
-  const patterns = BLOCKED_PATTERNS[tool17];
+function isBlocked(tool19, args) {
+  const patterns = BLOCKED_PATTERNS[tool19];
   if (!patterns)
     return null;
-  if (tool17 === "bash") {
+  if (tool19 === "bash") {
     const cmd = args.command;
     if (!cmd)
       return null;
@@ -2385,7 +3269,7 @@ function isBlocked(tool17, args) {
     }
     return null;
   }
-  if (tool17 === "read") {
+  if (tool19 === "read") {
     const filePath = args.filePath;
     if (!filePath)
       return null;
@@ -2396,7 +3280,7 @@ function isBlocked(tool17, args) {
     }
     return null;
   }
-  if (tool17 === "write") {
+  if (tool19 === "write") {
     const filePath = args.filePath;
     if (!filePath)
       return null;
@@ -2410,11 +3294,11 @@ function isBlocked(tool17, args) {
   return null;
 }
 function checkArchConstraint(directory, filePath) {
-  const constraintsPath = join18(codebaseDir(directory), "CONSTRAINTS.md");
-  if (!existsSync18(constraintsPath))
+  const constraintsPath = join24(codebaseDir(directory), "CONSTRAINTS.md");
+  if (!existsSync25(constraintsPath))
     return null;
   try {
-    const content = readFileSync17(constraintsPath, "utf-8");
+    const content = readFileSync24(constraintsPath, "utf-8");
     const match = content.match(/## Forbidden Paths\n([\s\S]*?)(?:\n##|$)/);
     if (!match)
       return null;
@@ -2455,9 +3339,9 @@ function isUiDesignApprovalRequired(directory) {
     return !(state.design_stage === "handoff_complete" && state.design_approved);
   }
   const planPath = phasePlanPath(directory, state.phase || 1);
-  if (!existsSync18(planPath))
+  if (!existsSync25(planPath))
     return false;
-  const planContent = readFileSync17(planPath, "utf-8");
+  const planContent = readFileSync24(planPath, "utf-8");
   if (!isUiHeavyTask(planContent))
     return false;
   return !(state.design_stage === "handoff_complete" && state.design_approved);
@@ -2486,18 +3370,18 @@ async function toolGuardHook(ctx, input, output) {
 }
 
 // src/hooks/session-start.ts
-import { existsSync as existsSync19, readFileSync as readFileSync18 } from "fs";
+import { existsSync as existsSync26, readFileSync as readFileSync25 } 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 (!existsSync19(planningDir2)) {
+  if (!existsSync26(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: existsSync19(codebaseDirectory),
+      flowdeck_has_codebase: existsSync26(codebaseDirectory),
       ...workspaceRoot && config?.sub_repos ? {
         flowdeck_workspace_root: workspaceRoot,
         flowdeck_sub_repos: config.sub_repos,
@@ -2508,7 +3392,7 @@ async function sessionStartHook(ctx) {
   }
   try {
     const stateFilePath = statePath(ctx.directory);
-    const content = readFileSync18(stateFilePath, "utf-8");
+    const content = readFileSync25(stateFilePath, "utf-8");
     const state = parseState(content);
     const currentPhase = state["current_phase"] || {};
     const result = {
@@ -2516,7 +3400,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: existsSync19(codebaseDirectory)
+      flowdeck_has_codebase: existsSync26(codebaseDirectory)
     };
     if (workspaceRoot && config?.sub_repos && config.sub_repos.length > 0) {
       result.flowdeck_workspace_root = workspaceRoot;
@@ -2531,7 +3415,7 @@ async function sessionStartHook(ctx) {
       flowdeck_phase: null,
       flowdeck_status: "error",
       flowdeck_warning: "State file unreadable. Continuing without flowdeck context.",
-      flowdeck_has_codebase: existsSync19(codebaseDirectory)
+      flowdeck_has_codebase: existsSync26(codebaseDirectory)
     };
     if (workspaceRoot && config?.sub_repos && config.sub_repos.length > 0) {
       result.flowdeck_workspace_root = workspaceRoot;
@@ -2670,13 +3554,13 @@ class NotificationController {
     return this.lastNotifiedKey;
   }
 }
-function notifyPermissionNeeded(tool17) {
-  notify("FlowDeck Permission Required", `Agent needs approval to use tool: ${tool17}`, "critical");
+function notifyPermissionNeeded(tool19) {
+  notify("FlowDeck Permission Required", `Agent needs approval to use tool: ${tool19}`, "critical");
 }
 
 // src/hooks/patch-trust.ts
-import { existsSync as existsSync20, readFileSync as readFileSync19 } from "fs";
-import { join as join19 } from "path";
+import { existsSync as existsSync27, readFileSync as readFileSync26 } from "fs";
+import { join as join25 } from "path";
 var HIGH_RISK_KEYWORDS = [
   "password",
   "secret",
@@ -2698,11 +3582,11 @@ var HIGH_RISK_KEYWORDS = [
   "privilege"
 ];
 function loadVolatility(directory) {
-  const p = join19(codebaseDir(directory), "VOLATILITY.json");
-  if (!existsSync20(p))
+  const p = join25(codebaseDir(directory), "VOLATILITY.json");
+  if (!existsSync27(p))
     return {};
   try {
-    const data = JSON.parse(readFileSync19(p, "utf-8"));
+    const data = JSON.parse(readFileSync26(p, "utf-8"));
     const map = {};
     for (const entry of data.entries ?? [])
       map[entry.path] = entry.stability;
@@ -2712,11 +3596,11 @@ function loadVolatility(directory) {
   }
 }
 function loadFailedPaths(directory) {
-  const p = join19(codebaseDir(directory), "FAILURES.json");
-  if (!existsSync20(p))
+  const p = join25(codebaseDir(directory), "FAILURES.json");
+  if (!existsSync27(p))
     return [];
   try {
-    const data = JSON.parse(readFileSync19(p, "utf-8"));
+    const data = JSON.parse(readFileSync26(p, "utf-8"));
     return (data.entries ?? []).flatMap((e) => e.affected_paths ?? []);
   } catch {
     return [];
@@ -2781,8 +3665,8 @@ async function patchTrustHook(ctx, input, output) {
 }
 
 // src/hooks/decision-trace-hook.ts
-import { existsSync as existsSync21, mkdirSync as mkdirSync11, appendFileSync as appendFileSync3 } from "fs";
-import { join as join20 } from "path";
+import { existsSync as existsSync28, mkdirSync as mkdirSync14, appendFileSync as appendFileSync4 } from "fs";
+import { join as join26 } from "path";
 async function decisionTraceHook(ctx, input, output) {
   if (input.tool !== "write" && input.tool !== "edit")
     return;
@@ -2791,8 +3675,8 @@ async function decisionTraceHook(ctx, input, output) {
     return;
   const base = codebaseDir(ctx.directory);
   try {
-    if (!existsSync21(base))
-      mkdirSync11(base, { recursive: true });
+    if (!existsSync28(base))
+      mkdirSync14(base, { recursive: true });
     const entry = {
       timestamp: new Date().toISOString(),
       file_path: filePath,
@@ -2804,30 +3688,30 @@ async function decisionTraceHook(ctx, input, output) {
       risk_level: "unknown",
       auto_recorded: true
     };
-    appendFileSync3(join20(base, "DECISIONS.jsonl"), JSON.stringify(entry) + `
+    appendFileSync4(join26(base, "DECISIONS.jsonl"), JSON.stringify(entry) + `
 `, "utf-8");
   } catch {}
 }
 
 // src/services/telemetry.ts
-import { existsSync as existsSync22, readFileSync as readFileSync20, appendFileSync as appendFileSync4, mkdirSync as mkdirSync12 } from "fs";
-import { join as join21 } from "path";
+import { existsSync as existsSync29, readFileSync as readFileSync27, appendFileSync as appendFileSync5, mkdirSync as mkdirSync15 } from "fs";
+import { join as join27 } from "path";
 import { randomUUID } from "crypto";
 function telemetryPath(dir) {
-  return join21(codebaseDir(dir), "TELEMETRY.jsonl");
+  return join27(codebaseDir(dir), "TELEMETRY.jsonl");
 }
-function appendEvent(dir, partial) {
+function appendEvent2(dir, partial) {
   if (process.env.TELEMETRY_ENABLED !== "true")
     return null;
   const cd = codebaseDir(dir);
-  if (!existsSync22(cd))
-    mkdirSync12(cd, { recursive: true });
+  if (!existsSync29(cd))
+    mkdirSync15(cd, { recursive: true });
   const event = {
     id: randomUUID(),
     ts: new Date().toISOString(),
     ...partial
   };
-  appendFileSync4(telemetryPath(dir), JSON.stringify(event) + `
+  appendFileSync5(telemetryPath(dir), JSON.stringify(event) + `
 `, "utf-8");
   return event;
 }
@@ -2857,34 +3741,34 @@ function inferStatus(output) {
 }
 async function telemetryHook(context, toolInput, output) {
   const dir = context.directory ?? process.cwd();
-  const tool17 = toolInput.name ?? toolInput.tool ?? "unknown";
+  const tool19 = toolInput.name ?? toolInput.tool ?? "unknown";
   const ids = resolveIds(toolInput);
-  appendEvent(dir, {
+  appendEvent2(dir, {
     session_id: ids.session_id,
     run_id: ids.run_id,
     event: "tool.call",
-    tool: tool17,
+    tool: tool19,
     status: "ok",
     meta: { parameters: output.args ?? {} }
   });
 }
 async function telemetryAfterHook(context, toolInput, output) {
   const dir = context.directory ?? process.cwd();
-  const tool17 = toolInput.name ?? toolInput.tool ?? "unknown";
+  const tool19 = toolInput.name ?? toolInput.tool ?? "unknown";
   const ids = resolveIds(toolInput);
   const status = inferStatus(output);
-  appendEvent(dir, {
+  appendEvent2(dir, {
     session_id: ids.session_id,
     run_id: ids.run_id,
     event: "tool.complete",
-    tool: tool17,
+    tool: tool19,
     status
   });
 }
 
 // src/services/approval-manager.ts
-import { existsSync as existsSync23, readFileSync as readFileSync21, writeFileSync as writeFileSync15, mkdirSync as mkdirSync13 } from "fs";
-import { join as join22 } from "path";
+import { existsSync as existsSync30, readFileSync as readFileSync28, writeFileSync as writeFileSync17, mkdirSync as mkdirSync16 } from "fs";
+import { join as join28 } from "path";
 var APPROVAL_TTL_MS = 30 * 60 * 1000;
 var SENSITIVE_PATTERNS = [
   /auth/i,
@@ -2921,14 +3805,14 @@ function isSensitivePath(filePath) {
   return SENSITIVE_PATTERNS.some((p) => p.test(filePath));
 }
 function approvalsPath(dir) {
-  return join22(codebaseDir(dir), "APPROVALS.json");
+  return join28(codebaseDir(dir), "APPROVALS.json");
 }
 function loadStore2(dir) {
   const p = approvalsPath(dir);
-  if (!existsSync23(p))
+  if (!existsSync30(p))
     return { requests: [] };
   try {
-    return JSON.parse(readFileSync21(p, "utf-8"));
+    return JSON.parse(readFileSync28(p, "utf-8"));
   } catch {
     return { requests: [] };
   }
@@ -2946,8 +3830,8 @@ async function approvalHook(context, toolInput, output) {
   if (!ENABLED2)
     return;
   const dir = context.directory ?? process.cwd();
-  const tool17 = toolInput.name ?? toolInput.tool ?? "";
-  if (!WRITE_TOOLS.has(tool17))
+  const tool19 = toolInput.name ?? toolInput.tool ?? "";
+  if (!WRITE_TOOLS.has(tool19))
     return;
   const args = output.args ?? {};
   const filePath = String(args.path ?? args.file_path ?? args.filename ?? "");
@@ -2958,11 +3842,11 @@ async function approvalHook(context, toolInput, output) {
   const approval = checkApproval(dir, filePath, "");
   if (approval)
     return;
-  appendEvent(dir, {
+  appendEvent2(dir, {
     session_id: process.env.OPENCODE_SESSION_ID ?? "session-0",
     run_id: process.env.OPENCODE_RUN_ID ?? "run-0",
     event: "approval.request",
-    tool: tool17,
+    tool: tool19,
     status: "blocked",
     files: [filePath],
     meta: { trigger: "sensitive_file", file: filePath }
@@ -3023,15 +3907,15 @@ function createContextWindowMonitorHook() {
 }
 
 // src/hooks/shell-env-hook.ts
-import { existsSync as existsSync24, readFileSync as readFileSync22 } from "fs";
-import { join as join23 } from "path";
-import { createRequire } from "module";
+import { existsSync as existsSync31, readFileSync as readFileSync29 } from "fs";
+import { join as join29 } from "path";
+import { createRequire as createRequire2 } from "module";
 var _version;
 function getVersion() {
   if (_version)
     return _version;
   try {
-    const require2 = createRequire(import.meta.url);
+    const require2 = createRequire2(import.meta.url);
     const pkg = require2("../../package.json");
     _version = pkg.version ?? "0.0.0";
   } catch {
@@ -3060,7 +3944,7 @@ var MARKER_TO_LANG = {
 };
 function detectPackageManager(root) {
   for (const [lockfile, pm] of Object.entries(LOCKFILE_TO_PM)) {
-    if (existsSync24(join23(root, lockfile)))
+    if (existsSync31(join29(root, lockfile)))
       return pm;
   }
   return;
@@ -3069,7 +3953,7 @@ function detectLanguages(root) {
   const langs = [];
   const seen = new Set;
   for (const [marker, lang] of Object.entries(MARKER_TO_LANG)) {
-    if (!seen.has(lang) && existsSync24(join23(root, marker))) {
+    if (!seen.has(lang) && existsSync31(join29(root, marker))) {
       langs.push(lang);
       seen.add(lang);
     }
@@ -3077,17 +3961,29 @@ function detectLanguages(root) {
   return langs;
 }
 function readCurrentPhase(root) {
-  const statePath2 = join23(root, ".planning", "STATE.md");
-  if (!existsSync24(statePath2))
+  const statePath2 = join29(root, ".planning", "STATE.md");
+  if (!existsSync31(statePath2))
     return;
   try {
-    const content = readFileSync22(statePath2, "utf-8");
+    const content = readFileSync29(statePath2, "utf-8");
     const match = content.match(/phase:\s*(\S+)/i);
     return match?.[1];
   } catch {
     return;
   }
 }
+var _rtkDetection;
+function getRtkDetection() {
+  if (_rtkDetection !== undefined)
+    return _rtkDetection;
+  try {
+    const det = detectRtk();
+    _rtkDetection = { installed: det.installed, binPath: det.binPath };
+  } catch {
+    _rtkDetection = { installed: false };
+  }
+  return _rtkDetection;
+}
 function createShellEnvHook(ctx) {
   const root = ctx.worktree || ctx.directory;
   return async (_input, output) => {
@@ -3105,6 +4001,14 @@ function createShellEnvHook(ctx) {
     const phase = readCurrentPhase(root);
     if (phase)
       output.env.FLOWDECK_PHASE = phase;
+    const rtk = getRtkDetection();
+    output.env.RTK_INSTALLED = rtk.installed ? "true" : "false";
+    if (rtk.installed && rtk.binPath) {
+      output.env.RTK_BIN = rtk.binPath;
+    }
+    if (rtk.installed) {
+      output.env.RTK_TELEMETRY_DISABLED = "1";
+    }
   };
 }
 
@@ -3186,8 +4090,8 @@ function createSessionIdleHook(client, tracker) {
 }
 
 // src/hooks/compaction-hook.ts
-import { existsSync as existsSync25, readFileSync as readFileSync23 } from "fs";
-import { join as join24 } from "path";
+import { existsSync as existsSync32, readFileSync as readFileSync30 } from "fs";
+import { join as join30 } from "path";
 var STRUCTURED_SUMMARY_PROMPT = `
 When summarizing this session, you MUST include the following sections:
 
@@ -3225,40 +4129,58 @@ List all background agent tasks spawned this session.
 For each: agent name, status, description, session_id.
 **RESUME, DON'T RESTART.** Use session_id to continue existing sessions.
 `;
+var _lastInjected = new Map;
 function readPlanningState2(directory) {
-  const statePath2 = join24(directory, ".planning", "STATE.md");
-  if (!existsSync25(statePath2))
+  const sp = statePath(directory);
+  if (!existsSync32(sp))
     return null;
   try {
-    const content = readFileSync23(statePath2, "utf-8");
-    return content.slice(0, 1500);
+    const content = readFileSync30(sp, "utf-8");
+    const parsed = parseState(content);
+    const version = typeof parsed.summaryVersion === "number" ? parsed.summaryVersion : 0;
+    return { content: content.slice(0, 1500), version };
   } catch {
     return null;
   }
 }
 function createCompactionHook(ctx, tracker) {
-  return async (_input, output) => {
+  return async (input, output) => {
     const sections = ["# FlowDeck Context (preserve across compaction)", ""];
-    const state = readPlanningState2(ctx.directory);
-    if (state) {
+    const stateData = readPlanningState2(ctx.directory);
+    const indexData = readCodebaseIndex(ctx.directory);
+    const currentStateVersion = stateData?.version ?? 0;
+    const currentIndexVersion = indexData.summaryVersion ?? 0;
+    const lastSnapshot = _lastInjected.get(input.sessionID);
+    const stateChanged = !lastSnapshot || lastSnapshot.stateVersion !== currentStateVersion;
+    const indexChanged = !lastSnapshot || lastSnapshot.indexVersion !== currentIndexVersion;
+    if (stateChanged && stateData) {
       sections.push("## Planning State");
       sections.push("```");
-      sections.push(state.trim());
+      sections.push(stateData.content.trim());
       sections.push("```");
       sections.push("");
+    } else if (stateData) {
+      sections.push(`## Planning State (unchanged, v${currentStateVersion})`);
+      sections.push(`_State unchanged since last compaction. summaryVersion=${currentStateVersion}_`);
+      sections.push("");
     }
-    const indexPath = join24(ctx.directory, ".planning", "CODEBASE_INDEX.md");
-    let indexSummary = "";
-    if (existsSync25(indexPath)) {
+    const indexPath2 = join30(ctx.directory, ".planning", "CODEBASE_INDEX.md");
+    if (indexChanged && existsSync32(indexPath2)) {
       try {
-        const indexContent = readFileSync23(indexPath, "utf-8");
-        indexSummary = "\n## Codebase Index\n```\n" + indexContent.slice(0, 800) + "\n```\n";
+        const indexContent = readFileSync30(indexPath2, "utf-8");
+        const indexSummary = "\n## Codebase Index\n```\n" + indexContent.slice(0, 800) + "\n```\n";
+        sections.push(indexSummary);
+        sections.push("");
       } catch {}
-    }
-    if (indexSummary) {
-      sections.push(indexSummary);
+    } else if (existsSync32(indexPath2)) {
+      sections.push(`## Codebase Index (unchanged, v${currentIndexVersion})`);
+      sections.push(`_Index unchanged since last compaction. summaryVersion=${currentIndexVersion}_`);
       sections.push("");
     }
+    _lastInjected.set(input.sessionID, {
+      stateVersion: currentStateVersion,
+      indexVersion: currentIndexVersion
+    });
     const edited = tracker.getEditedPaths();
     if (edited.length > 0) {
       sections.push("## Recently Edited Files");
@@ -7215,7 +8137,7 @@ function shouldProceed(decision, mode, canBlock) {
 }
 function _emitTelemetry(directory, decision, ctx) {
   try {
-    appendEvent(directory, {
+    appendEvent2(directory, {
       session_id: ctx.session_id ?? "session-0",
       run_id: ctx.run_id ?? "unknown",
       event: "supervisor.review",
@@ -7236,37 +8158,29 @@ function _emitTelemetry(directory, decision, ctx) {
 }
 
 // src/index.ts
-function loadRulePaths() {
-  const __dir = dirname4(fileURLToPath2(import.meta.url));
-  const rulesDir = join25(__dir, "..", "src", "rules");
-  if (!existsSync26(rulesDir))
-    return [];
-  const paths = [];
-  function walk(dir) {
-    for (const entry of readdirSync3(dir, { withFileTypes: true })) {
-      const full = join25(dir, entry.name);
-      if (entry.isDirectory()) {
-        walk(full);
-      } else if (entry.isFile() && entry.name.endsWith(".md") && entry.name !== "README.md") {
-        paths.push(full);
-      }
-    }
-  }
-  walk(rulesDir);
-  return paths;
+function lazyLoadRulePaths(projectRoot) {
+  const __dir = dirname5(fileURLToPath3(import.meta.url));
+  const rulesDir = join31(__dir, "..", "src", "rules");
+  if (!existsSync33(rulesDir))
+    return { paths: [], diagnostics: "[LazyRuleLoader] rules directory not found" };
+  const detectedLanguages = detectProjectLanguages(projectRoot);
+  const paths = getStartupRulePaths(rulesDir, detectedLanguages);
+  const selection = selectRulePaths(rulesDir, { languages: detectedLanguages });
+  const diagnostics = buildSelectionDiagnostics(selection, { languages: detectedLanguages });
+  return { paths, diagnostics };
 }
 function loadCommands() {
-  const __dir = dirname4(fileURLToPath2(import.meta.url));
-  const commandsDir = join25(__dir, "..", "src", "commands");
-  if (!existsSync26(commandsDir))
+  const __dir = dirname5(fileURLToPath3(import.meta.url));
+  const commandsDir = join31(__dir, "..", "src", "commands");
+  if (!existsSync33(commandsDir))
     return {};
   const commands = {};
   try {
-    for (const file of readdirSync3(commandsDir)) {
+    for (const file of readdirSync5(commandsDir)) {
       if (!file.endsWith(".md"))
         continue;
-      const name = basename(file, ".md");
-      const raw = readFileSync24(join25(commandsDir, file), "utf-8");
+      const name = basename2(file, ".md");
+      const raw = readFileSync31(join31(commandsDir, file), "utf-8");
       let description;
       let template = raw;
       const fmMatch = raw.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/);
@@ -7348,8 +8262,8 @@ var plugin = async (input, _options) => {
           }
         }
       }
-      const skillsDir = join25(dirname4(fileURLToPath2(import.meta.url)), "..", "src", "skills");
-      if (existsSync26(skillsDir)) {
+      const skillsDir = join31(dirname5(fileURLToPath3(import.meta.url)), "..", "src", "skills");
+      if (existsSync33(skillsDir)) {
         const cfgAny = cfg;
         if (!cfgAny.skills || typeof cfgAny.skills !== "object") {
           cfgAny.skills = { paths: [] };
@@ -7361,7 +8275,8 @@ var plugin = async (input, _options) => {
           cfgSkills.paths.push(skillsDir);
         }
       }
-      const rulePaths = loadRulePaths();
+      const { paths: rulePaths, diagnostics: rulesDiag } = lazyLoadRulePaths(directory);
+      appLog(rulesDiag);
       if (rulePaths.length > 0) {
         if (!Array.isArray(cfg.instructions)) {
           cfg.instructions = [];
@@ -7390,7 +8305,10 @@ var plugin = async (input, _options) => {
       "context-generator": contextGeneratorTool,
       "create-skill": createSkillTool,
       reflect: reflectTool,
-      codegraph: codegraphTool
+      codegraph: codegraphTool,
+      "load-rules": loadRulesTool,
+      "list-rules": listRulesTool,
+      "rtk-setup": rtkSetupTool
     },
     "shell.env": shellEnvHook,
     "todo.updated": todoHook,