@dv.nghiem/flowdeck 0.4.3 → 0.4.5

package/dist/index.js

@@ -2,10 +2,10 @@ import { createRequire } from "node:module";
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // src/index.ts
-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";
+import { readFileSync as readFileSync28, readdirSync as readdirSync4, existsSync as existsSync29 } from "fs";
+import { join as join27, basename as basename2 } from "path";
+import { dirname as dirname3 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/services/lazy-rule-loader.ts
 import { existsSync, readFileSync, readdirSync } from "fs";
@@ -393,14 +393,6 @@ function findWorkspaceRoot(startDir) {
   }
   return null;
 }
-function resolveSubRepos(configPath, subRepos) {
-  const configDir = dirname(configPath);
-  return subRepos.map((r) => {
-    if (resolve(r) === r)
-      return r;
-    return resolve(configDir, r);
-  });
-}
 function getWorkspaceConfig(dir) {
   const root = findWorkspaceRoot(dir);
   if (!root)
@@ -577,173 +569,30 @@ ${entry}`, "utf-8");
   }
 });
 
-// src/tools/workspace-state.ts
-import { tool as tool3 } from "@opencode-ai/plugin";
-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 = join5(planningDir(workspaceRoot), "STATE.md");
-  if (!existsSync5(sp))
-    return null;
-  return readFileSync5(sp, "utf-8");
-}
-function writeWorkspaceStateFile(workspaceRoot, content) {
-  const sp = join5(planningDir(workspaceRoot), "STATE.md");
-  writeFileSync4(sp, content, "utf-8");
-}
-function parseWorkspaceState(content) {
-  const result = {};
-  const lines = content.split(`
-`);
-  for (const line of lines) {
-    const kvMatch = line.match(/^\*\*([^:]+):\*\*\s*(.+)/);
-    if (kvMatch) {
-      result[kvMatch[1].trim()] = kvMatch[2].trim();
-    }
-  }
-  return result;
-}
-async function readWorkspaceContextAction(dir, mode, workspaceRoot) {
-  const stateContent = readWorkspaceStateFile(workspaceRoot);
-  if (!stateContent) {
-    return { error: "Workspace STATE.md not found. Initialize workspace first." };
-  }
-  const parsed = parseWorkspaceState(stateContent);
-  return { exists: true, workspace_root: workspaceRoot, workspace_mode: mode, ...parsed };
-}
-async function updateWorkspaceContextAction(dir, mode, workspaceRoot, updates) {
-  if (!updates)
-    return { error: "No updates provided" };
-  let content = readWorkspaceStateFile(workspaceRoot);
-  if (!content) {
-    content = `# Workspace State
-
----
-
-`;
-  }
-  if (updates.current_repo !== undefined) {
-    const regex = /^\*\*current_repo:\*\*.*/m;
-    if (regex.test(content)) {
-      content = content.replace(regex, `**current_repo:** ${updates.current_repo}`);
-    } else {
-      content = content.replace(/^---\n/, `---
-
-**current_repo:** ${updates.current_repo}
-`);
-    }
-  }
-  if (updates.status !== undefined) {
-    const regex = /^\*\*status:\*\*.*/m;
-    if (regex.test(content)) {
-      content = content.replace(regex, `**status:** ${updates.status}`);
-    }
-  }
-  writeWorkspaceStateFile(workspaceRoot, content);
-  return { success: true, updated_at: timestamp() };
-}
-async function listSubReposAction(dir, subRepos, workspaceRoot) {
-  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 = existsSync5(planningPath);
-    repos.push({
-      name: repoName,
-      path: repoPath,
-      status: hasPlanning ? "active" : "not_initialized"
-    });
-  }
-  return { repos };
-}
-async function getSubRepoStateAction(dir, repoName, subRepos, workspaceRoot, mode) {
-  if (!repoName)
-    return { error: "repo name is required" };
-  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 (!existsSync5(planningPath)) {
-    return { error: "not_found", path: targetPath };
-  }
-  const sp = statePath(targetPath);
-  if (!existsSync5(sp)) {
-    return { error: "not_found", path: targetPath, message: `.planning/STATE.md not found in ${repoName}` };
-  }
-  const stateContent = readFileSync5(sp, "utf-8");
-  const parsed = parseWorkspaceState(stateContent);
-  return {
-    repo_path: targetPath,
-    repo_name: repoName,
-    ...parsed
-  };
-}
-var workspaceStateTool = tool3({
-  description: "Manage workspace state across multiple repos: read workspace context, update context, list sub-repos, get sub-repo state",
-  args: {
-    action: tool3.schema.enum(["read_context", "update_context", "list_repos", "get_repo_state"]),
-    updates: tool3.schema.object({
-      current_repo: tool3.schema.string().optional(),
-      status: tool3.schema.string().optional(),
-      phase: tool3.schema.number().optional()
-    }).optional(),
-    repo: tool3.schema.string().optional()
-  },
-  async execute(args, context) {
-    const dir = context.directory ?? process.cwd();
-    const workspaceRoot = findWorkspaceRoot(dir);
-    if (!workspaceRoot) {
-      return JSON.stringify({ error: "Workspace root not found. No config.json with sub_repos found." });
-    }
-    const config = getWorkspaceConfig(dir);
-    if (!config) {
-      return JSON.stringify({ error: "Could not read workspace config." });
-    }
-    const mode = config.workspace_mode;
-    const subRepos = config.sub_repos || [];
-    switch (args.action) {
-      case "read_context":
-        return JSON.stringify(await readWorkspaceContextAction(dir, mode, workspaceRoot));
-      case "update_context":
-        return JSON.stringify(await updateWorkspaceContextAction(dir, mode, workspaceRoot, args.updates));
-      case "list_repos":
-        return JSON.stringify(await listSubReposAction(dir, subRepos, workspaceRoot));
-      case "get_repo_state":
-        return JSON.stringify(await getSubRepoStateAction(dir, args.repo, subRepos, workspaceRoot, mode));
-    }
-  }
-});
-
 // src/tools/run-pipeline.ts
-import { tool as tool4 } from "@opencode-ai/plugin";
+import { tool as tool3 } from "@opencode-ai/plugin";
 
 // src/services/agent-performance.ts
-import { existsSync as existsSync6, readFileSync as readFileSync6, writeFileSync as writeFileSync5, mkdirSync as mkdirSync2 } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync4, mkdirSync as mkdirSync2 } from "fs";
+import { join as join5 } from "path";
 function perfPath(dir) {
-  return join6(codebaseDir(dir), "AGENT_PERF.json");
+  return join5(codebaseDir(dir), "AGENT_PERF.json");
 }
 function loadStore(dir) {
   const p = perfPath(dir);
-  if (!existsSync6(p))
+  if (!existsSync5(p))
     return { entries: [], updated_at: new Date().toISOString() };
   try {
-    return JSON.parse(readFileSync6(p, "utf-8"));
+    return JSON.parse(readFileSync5(p, "utf-8"));
   } catch {
     return { entries: [], updated_at: new Date().toISOString() };
   }
 }
 function saveStore(dir, store) {
   const cd = codebaseDir(dir);
-  if (!existsSync6(cd))
+  if (!existsSync5(cd))
     mkdirSync2(cd, { recursive: true });
-  writeFileSync5(perfPath(dir), JSON.stringify(store, null, 2), "utf-8");
+  writeFileSync4(perfPath(dir), JSON.stringify(store, null, 2), "utf-8");
 }
 function makeKey(agent, model, task_type) {
   return `${agent}::${model}::${task_type}`;
@@ -873,18 +722,18 @@ function extractText(parts) {
 `);
 }
 function createRunPipelineTool(client) {
-  return tool4({
+  return tool3({
     description: "Run agents in sequential pipeline. Each step's output is appended to the next step's context. One fresh child session per step. Returns full trace with session ID, input/output/duration per step.",
     args: {
-      steps: tool4.schema.array(tool4.schema.object({
-        agent: tool4.schema.string(),
-        prompt: tool4.schema.string(),
-        task_type: tool4.schema.string().optional()
+      steps: tool3.schema.array(tool3.schema.object({
+        agent: tool3.schema.string(),
+        prompt: tool3.schema.string(),
+        task_type: tool3.schema.string().optional()
       })),
-      initial_context: tool4.schema.string().optional(),
-      abort_on_failure: tool4.schema.boolean().optional().default(true),
-      retry_attempts: tool4.schema.number().optional().default(1),
-      max_carry_chars: tool4.schema.number().optional()
+      initial_context: tool3.schema.string().optional(),
+      abort_on_failure: tool3.schema.boolean().optional().default(true),
+      retry_attempts: tool3.schema.number().optional().default(1),
+      max_carry_chars: tool3.schema.number().optional()
     },
     async execute(args, context) {
       const startTime = Date.now();
@@ -893,6 +742,7 @@ function createRunPipelineTool(client) {
       let aborted = false;
       const retryAttempts = typeof args.retry_attempts === "number" ? args.retry_attempts : 1;
       const maxRetries = Math.max(0, Math.floor(retryAttempts));
+      const totalSteps = args.steps.length;
       let inflightChildId = null;
       const abortHandler = () => {
         if (inflightChildId) {
@@ -904,7 +754,8 @@ function createRunPipelineTool(client) {
       };
       context.abort.addEventListener("abort", abortHandler);
       try {
-        for (const step of args.steps) {
+        for (let stepIdx = 0;stepIdx < args.steps.length; stepIdx++) {
+          const step = args.steps[stepIdx];
           if (context.abort.aborted) {
             aborted = true;
             break;
@@ -978,9 +829,10 @@ ${step.prompt}` : step.prompt;
       } finally {
         context.abort.removeEventListener("abort", abortHandler);
       }
+      const totalDuration = Date.now() - startTime;
       return JSON.stringify({
         steps: trace,
-        total_duration_ms: Date.now() - startTime,
+        total_duration_ms: totalDuration,
         aborted
       });
     }
@@ -988,13 +840,13 @@ ${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";
+import { tool as tool4 } from "@opencode-ai/plugin";
+import { existsSync as existsSync10, readFileSync as readFileSync10 } from "fs";
 
 // src/services/prompt-cache.ts
 import { createHash } from "crypto";
-import { existsSync as existsSync7, readFileSync as readFileSync7, writeFileSync as writeFileSync6, readdirSync as readdirSync3, statSync, mkdirSync as mkdirSync3 } from "fs";
-import { join as join7 } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync6, writeFileSync as writeFileSync5, readdirSync as readdirSync3, statSync, mkdirSync as mkdirSync3 } from "fs";
+import { join as join6 } from "path";
 var CACHEABLE_AGENTS = new Set([
   "researcher",
   "code-explorer",
@@ -1008,17 +860,17 @@ 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);
+  return join6(codebaseDir(dir), CACHE_DIR_NAME);
 }
 function entryPath(dir, key) {
-  return join7(cacheDir(dir), `${key}.json`);
+  return join6(cacheDir(dir), `${key}.json`);
 }
 function readEntry(dir, key, stateVersion, indexVersion) {
   const path = entryPath(dir, key);
-  if (!existsSync7(path))
+  if (!existsSync6(path))
     return null;
   try {
-    const entry = JSON.parse(readFileSync7(path, "utf-8"));
+    const entry = JSON.parse(readFileSync6(path, "utf-8"));
     const age = Date.now() - new Date(entry.created_at).getTime();
     if (age > entry.ttl_ms)
       return null;
@@ -1066,7 +918,7 @@ function setCached(dir, agent, prompt, context, stateVersion, indexVersion, resp
   if (!CACHEABLE_AGENTS.has(agent))
     return;
   const cd = cacheDir(dir);
-  if (!existsSync7(cd))
+  if (!existsSync6(cd))
     mkdirSync3(cd, { recursive: true });
   const key = hashKey(agent, prompt, context, stateVersion, indexVersion);
   const entry = {
@@ -1078,21 +930,21 @@ function setCached(dir, agent, prompt, context, stateVersion, indexVersion, resp
     ttl_ms,
     response
   };
-  writeFileSync6(entryPath(dir, key), JSON.stringify(entry, null, 2), "utf-8");
+  writeFileSync5(entryPath(dir, key), JSON.stringify(entry, null, 2), "utf-8");
   pruneExpired(dir);
 }
 function pruneExpired(dir) {
   const cd = cacheDir(dir);
-  if (!existsSync7(cd))
+  if (!existsSync6(cd))
     return;
   try {
     const files = readdirSync3(cd).filter((f) => f.endsWith(".json"));
     const now = Date.now();
     const entries = [];
     for (const f of files) {
-      const p = join7(cd, f);
+      const p = join6(cd, f);
       try {
-        const entry = JSON.parse(readFileSync7(p, "utf-8"));
+        const entry = JSON.parse(readFileSync6(p, "utf-8"));
         const age = now - new Date(entry.created_at).getTime();
         entries.push({ path: p, created_at: new Date(entry.created_at).getTime(), expired: age > entry.ttl_ms });
       } catch {
@@ -1119,15 +971,15 @@ function pruneExpired(dir) {
 }
 
 // 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";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync6, existsSync as existsSync7, mkdirSync as mkdirSync4 } from "fs";
+import { join as join7 } from "path";
 var CODEBASE_INDEX_FILE = "CODEBASE_INDEX.md";
 function indexPath(dir) {
-  return join8(planningDir(dir), CODEBASE_INDEX_FILE);
+  return join7(planningDir(dir), CODEBASE_INDEX_FILE);
 }
 function readCodebaseIndex(dir) {
   const path = indexPath(dir);
-  if (!existsSync8(path)) {
+  if (!existsSync7(path)) {
     return {
       exists: false,
       lastUpdatedAt: "",
@@ -1141,7 +993,7 @@ function readCodebaseIndex(dir) {
     };
   }
   try {
-    const content = readFileSync8(path, "utf-8");
+    const content = readFileSync7(path, "utf-8");
     return parseCodebaseIndexContent(content);
   } catch {
     return {
@@ -1217,17 +1069,17 @@ function parseCodebaseIndexContent(content) {
 }
 
 // src/services/token-metrics.ts
-import { existsSync as existsSync9, readFileSync as readFileSync9, appendFileSync, mkdirSync as mkdirSync5 } from "fs";
-import { join as join9 } from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync8, appendFileSync, mkdirSync as mkdirSync5 } from "fs";
+import { join as join8 } from "path";
 function estimateTokens(text) {
   return Math.ceil(text.length / 4);
 }
 function metricsPath(dir) {
-  return join9(codebaseDir(dir), "TOKEN_METRICS.jsonl");
+  return join8(codebaseDir(dir), "TOKEN_METRICS.jsonl");
 }
 function appendEvent(dir, event) {
   const cd = codebaseDir(dir);
-  if (!existsSync9(cd))
+  if (!existsSync8(cd))
     mkdirSync5(cd, { recursive: true });
   appendFileSync(metricsPath(dir), JSON.stringify(event) + `
 `, "utf-8");
@@ -1285,23 +1137,23 @@ function recordRetryCall(dir, workflow_id, stage, inputText, outputText, agent,
 var _workflowTimers = new Map;
 
 // src/config/loader.ts
-import { existsSync as existsSync10, readFileSync as readFileSync10 } from "fs";
-import { join as join10 } from "path";
+import { existsSync as existsSync9, readFileSync as readFileSync9 } from "fs";
+import { join as join9 } from "path";
 import { homedir } from "os";
 var CONFIG_FILENAME = "flowdeck.json";
 function getGlobalConfigDir() {
-  return process.env.OPENCODE_CONFIG_DIR || (process.env.XDG_CONFIG_HOME ? join10(process.env.XDG_CONFIG_HOME, "opencode") : join10(homedir(), ".config", "opencode"));
+  return process.env.OPENCODE_CONFIG_DIR || (process.env.XDG_CONFIG_HOME ? join9(process.env.XDG_CONFIG_HOME, "opencode") : join9(homedir(), ".config", "opencode"));
 }
 function loadFlowDeckConfig(directory) {
   const candidates = [];
   if (directory) {
-    candidates.push(join10(directory, ".opencode", CONFIG_FILENAME));
+    candidates.push(join9(directory, ".opencode", CONFIG_FILENAME));
   }
-  candidates.push(join10(getGlobalConfigDir(), CONFIG_FILENAME));
+  candidates.push(join9(getGlobalConfigDir(), CONFIG_FILENAME));
   for (const configPath of candidates) {
-    if (existsSync10(configPath)) {
+    if (existsSync9(configPath)) {
       try {
-        const content = readFileSync10(configPath, "utf-8");
+        const content = readFileSync9(configPath, "utf-8");
         return JSON.parse(content);
       } catch {
         console.warn(`[flowdeck] Failed to load config from ${configPath}`);
@@ -1387,18 +1239,18 @@ function extractText2(parts) {
 `);
 }
 function createDelegateTool(client) {
-  return tool5({
+  return tool4({
     description: "Delegate a task to a single agent via a child session. Returns the agent's output.",
     args: {
-      agent: tool5.schema.string(),
-      prompt: tool5.schema.string(),
-      context: tool5.schema.string().optional(),
-      task_type: tool5.schema.string().optional(),
-      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()
+      agent: tool4.schema.string(),
+      prompt: tool4.schema.string(),
+      context: tool4.schema.string().optional(),
+      task_type: tool4.schema.string().optional(),
+      retry_attempts: tool4.schema.number().optional().default(1),
+      safe_to_cache: tool4.schema.boolean().optional().default(false),
+      cache_ttl_ms: tool4.schema.number().optional(),
+      workflow_id: tool4.schema.string().optional(),
+      stage: tool4.schema.string().optional()
     },
     async execute(args, context) {
       const startTime = Date.now();
@@ -1423,7 +1275,7 @@ ${args.prompt}` : args.prompt;
       if (safe_to_cache) {
         const index = readCodebaseIndex(context.directory);
         const sp = statePath(context.directory);
-        const rawState = existsSync11(sp) ? readFileSync11(sp, "utf-8") : "";
+        const rawState = existsSync10(sp) ? readFileSync10(sp, "utf-8") : "";
         const state = rawState ? parseState(rawState) : {};
         stateVersion = typeof state.summaryVersion === "number" ? state.summaryVersion : 0;
         indexVersion = typeof index.summaryVersion === "number" ? index.summaryVersion : 0;
@@ -1491,12 +1343,13 @@ ${args.prompt}` : args.prompt;
         retriesUsed++;
       }
       if (!promptRes || promptRes.error) {
+        const errMsg = `Prompt failed: ${promptRes?.error?.detail ?? "unknown"}`;
         recordRun(context.directory, args.agent, "", taskType, false, Date.now() - startTime);
         return JSON.stringify({
           agent: args.agent,
           session_id: childId,
           success: false,
-          error: `Prompt failed: ${promptRes?.error?.detail ?? "unknown"}`,
+          error: errMsg,
           task_type: taskType,
           model: "",
           retries_used: retriesUsed,
@@ -1505,12 +1358,13 @@ ${args.prompt}` : args.prompt;
       }
       const info = promptRes.data?.info;
       if (info?.error) {
+        const errMsg = `Agent error: ${JSON.stringify(info.error)}`;
         recordRun(context.directory, args.agent, "", taskType, false, Date.now() - startTime);
         return JSON.stringify({
           agent: args.agent,
           session_id: childId,
           success: false,
-          error: `Agent error: ${JSON.stringify(info.error)}`,
+          error: errMsg,
           task_type: taskType,
           model: "",
           retries_used: retriesUsed,
@@ -1543,53 +1397,53 @@ ${args.prompt}` : args.prompt;
 }
 
 // src/tools/repo-memory.ts
-import { tool as tool6 } from "@opencode-ai/plugin";
-import { readFileSync as readFileSync12, writeFileSync as writeFileSync8, existsSync as existsSync12, mkdirSync as mkdirSync6 } from "fs";
-import { join as join11 } from "path";
+import { tool as tool5 } from "@opencode-ai/plugin";
+import { readFileSync as readFileSync11, writeFileSync as writeFileSync7, existsSync as existsSync11, mkdirSync as mkdirSync6 } from "fs";
+import { join as join10 } from "path";
 var MEMORY_FILE = "MEMORY.json";
 function memoryPath(directory) {
-  return join11(codebaseDir(directory), MEMORY_FILE);
+  return join10(codebaseDir(directory), MEMORY_FILE);
 }
 function emptyMemory() {
   return { version: "1.0", last_updated: new Date().toISOString(), nodes: {} };
 }
 function readMemory(directory) {
   const p = memoryPath(directory);
-  if (!existsSync12(p))
+  if (!existsSync11(p))
     return emptyMemory();
   try {
-    return JSON.parse(readFileSync12(p, "utf-8"));
+    return JSON.parse(readFileSync11(p, "utf-8"));
   } catch {
     return emptyMemory();
   }
 }
 function writeMemory(directory, memory) {
   const base = codebaseDir(directory);
-  if (!existsSync12(base))
+  if (!existsSync11(base))
     mkdirSync6(base, { recursive: true });
   memory.last_updated = new Date().toISOString();
-  writeFileSync8(memoryPath(directory), JSON.stringify(memory, null, 2), "utf-8");
+  writeFileSync7(memoryPath(directory), JSON.stringify(memory, null, 2), "utf-8");
 }
-var repoMemoryTool = tool6({
+var repoMemoryTool = tool5({
   description: "Repo Memory Graph: read/write/query persistent architecture graph in .codebase/MEMORY.json (modules, dependencies, ownership, bug history, conventions)",
   args: {
-    action: tool6.schema.enum(["read", "write_node", "query", "delete_node"]),
-    node_id: tool6.schema.string().optional(),
-    node: tool6.schema.object({
-      type: tool6.schema.enum(["module", "service", "api", "schema", "config"]),
-      path: tool6.schema.string(),
-      owner: tool6.schema.string().optional(),
-      tags: tool6.schema.array(tool6.schema.string()),
-      dependencies: tool6.schema.array(tool6.schema.string()),
-      dependents: tool6.schema.array(tool6.schema.string()),
-      bug_history: tool6.schema.array(tool6.schema.string()),
-      conventions: tool6.schema.array(tool6.schema.string())
+    action: tool5.schema.enum(["read", "write_node", "query", "delete_node"]),
+    node_id: tool5.schema.string().optional(),
+    node: tool5.schema.object({
+      type: tool5.schema.enum(["module", "service", "api", "schema", "config"]),
+      path: tool5.schema.string(),
+      owner: tool5.schema.string().optional(),
+      tags: tool5.schema.array(tool5.schema.string()),
+      dependencies: tool5.schema.array(tool5.schema.string()),
+      dependents: tool5.schema.array(tool5.schema.string()),
+      bug_history: tool5.schema.array(tool5.schema.string()),
+      conventions: tool5.schema.array(tool5.schema.string())
     }).optional(),
-    query: tool6.schema.object({
-      type: tool6.schema.enum(["module", "service", "api", "schema", "config"]).optional(),
-      owner: tool6.schema.string().optional(),
-      tag: tool6.schema.string().optional(),
-      path_prefix: tool6.schema.string().optional()
+    query: tool5.schema.object({
+      type: tool5.schema.enum(["module", "service", "api", "schema", "config"]).optional(),
+      owner: tool5.schema.string().optional(),
+      tag: tool5.schema.string().optional(),
+      path_prefix: tool5.schema.string().optional()
     }).optional()
   },
   async execute(args, context) {
@@ -1644,50 +1498,50 @@ var repoMemoryTool = tool6({
 });
 
 // src/tools/failure-replay.ts
-import { tool as tool7 } from "@opencode-ai/plugin";
-import { readFileSync as readFileSync13, writeFileSync as writeFileSync9, existsSync as existsSync13, mkdirSync as mkdirSync7 } from "fs";
-import { join as join12 } from "path";
+import { tool as tool6 } from "@opencode-ai/plugin";
+import { readFileSync as readFileSync12, writeFileSync as writeFileSync8, existsSync as existsSync12, mkdirSync as mkdirSync7 } from "fs";
+import { join as join11 } from "path";
 var FAILURES_FILE = "FAILURES.json";
 function failuresPath(directory) {
-  return join12(codebaseDir(directory), FAILURES_FILE);
+  return join11(codebaseDir(directory), FAILURES_FILE);
 }
 function readStore(directory) {
   const p = failuresPath(directory);
-  if (!existsSync13(p))
+  if (!existsSync12(p))
     return { version: "1.0", last_updated: new Date().toISOString(), entries: [] };
   try {
-    return JSON.parse(readFileSync13(p, "utf-8"));
+    return JSON.parse(readFileSync12(p, "utf-8"));
   } catch {
     return { version: "1.0", last_updated: new Date().toISOString(), entries: [] };
   }
 }
 function writeStore(directory, store) {
   const base = codebaseDir(directory);
-  if (!existsSync13(base))
+  if (!existsSync12(base))
     mkdirSync7(base, { recursive: true });
   store.last_updated = new Date().toISOString();
-  writeFileSync9(failuresPath(directory), JSON.stringify(store, null, 2), "utf-8");
+  writeFileSync8(failuresPath(directory), JSON.stringify(store, null, 2), "utf-8");
 }
-var failureReplayTool = tool7({
+var failureReplayTool = tool6({
   description: "Failure Replay Engine: record and query past failures (reverted commits, failed deployments, flaky tests, bug fixes) in .codebase/FAILURES.json so the agent avoids repeating mistakes",
   args: {
-    action: tool7.schema.enum(["record", "query", "list", "mark_resolved"]),
-    entry: tool7.schema.object({
-      id: tool7.schema.string(),
-      type: tool7.schema.enum(["reverted_commit", "failed_deployment", "flaky_test", "bug_fix", "build_failure"]),
-      description: tool7.schema.string(),
-      affected_paths: tool7.schema.array(tool7.schema.string()),
-      root_cause: tool7.schema.string().optional(),
-      fix_applied: tool7.schema.string().optional(),
-      tags: tool7.schema.array(tool7.schema.string())
+    action: tool6.schema.enum(["record", "query", "list", "mark_resolved"]),
+    entry: tool6.schema.object({
+      id: tool6.schema.string(),
+      type: tool6.schema.enum(["reverted_commit", "failed_deployment", "flaky_test", "bug_fix", "build_failure"]),
+      description: tool6.schema.string(),
+      affected_paths: tool6.schema.array(tool6.schema.string()),
+      root_cause: tool6.schema.string().optional(),
+      fix_applied: tool6.schema.string().optional(),
+      tags: tool6.schema.array(tool6.schema.string())
     }).optional(),
-    query: tool7.schema.object({
-      type: tool7.schema.enum(["reverted_commit", "failed_deployment", "flaky_test", "bug_fix", "build_failure"]).optional(),
-      path_prefix: tool7.schema.string().optional(),
-      tag: tool7.schema.string().optional(),
-      limit: tool7.schema.number().optional()
+    query: tool6.schema.object({
+      type: tool6.schema.enum(["reverted_commit", "failed_deployment", "flaky_test", "bug_fix", "build_failure"]).optional(),
+      path_prefix: tool6.schema.string().optional(),
+      tag: tool6.schema.string().optional(),
+      limit: tool6.schema.number().optional()
     }).optional(),
-    entry_id: tool7.schema.string().optional()
+    entry_id: tool6.schema.string().optional()
   },
   async execute(args, context) {
     const dir = context.directory ?? process.cwd();
@@ -1749,18 +1603,18 @@ var failureReplayTool = tool7({
 });
 
 // src/tools/decision-trace.ts
-import { tool as tool8 } from "@opencode-ai/plugin";
-import { readFileSync as readFileSync14, existsSync as existsSync14, mkdirSync as mkdirSync8, appendFileSync as appendFileSync2 } from "fs";
-import { join as join13 } from "path";
+import { tool as tool7 } from "@opencode-ai/plugin";
+import { readFileSync as readFileSync13, existsSync as existsSync13, mkdirSync as mkdirSync8, appendFileSync as appendFileSync2 } from "fs";
+import { join as join12 } from "path";
 var DECISIONS_FILE = "DECISIONS.jsonl";
 function decisionsPath(directory) {
-  return join13(codebaseDir(directory), DECISIONS_FILE);
+  return join12(codebaseDir(directory), DECISIONS_FILE);
 }
 function readDecisions(directory) {
   const p = decisionsPath(directory);
-  if (!existsSync14(p))
+  if (!existsSync13(p))
     return [];
-  return readFileSync14(p, "utf-8").split(`
+  return readFileSync13(p, "utf-8").split(`
 `).filter((l) => l.trim()).map((l) => {
     try {
       return JSON.parse(l);
@@ -1769,29 +1623,29 @@ function readDecisions(directory) {
     }
   }).filter(Boolean);
 }
-var decisionTraceTool = tool8({
+var decisionTraceTool = tool7({
   description: "Decision Trace: record why the agent changed something, what evidence was used, and assumptions made. Stored in .codebase/DECISIONS.jsonl for fast review.",
   args: {
-    action: tool8.schema.enum(["record", "query", "get_for_file"]),
-    entry: tool8.schema.object({
-      id: tool8.schema.string(),
-      file_path: tool8.schema.string(),
-      change_type: tool8.schema.enum(["create", "edit", "delete", "refactor"]),
-      rationale: tool8.schema.string(),
-      evidence: tool8.schema.array(tool8.schema.string()),
-      assumptions: tool8.schema.array(tool8.schema.string()),
-      alternatives_considered: tool8.schema.array(tool8.schema.string()),
-      risk_level: tool8.schema.enum(["low", "medium", "high"]),
-      agent: tool8.schema.string().optional(),
-      session_id: tool8.schema.string().optional()
+    action: tool7.schema.enum(["record", "query", "get_for_file"]),
+    entry: tool7.schema.object({
+      id: tool7.schema.string(),
+      file_path: tool7.schema.string(),
+      change_type: tool7.schema.enum(["create", "edit", "delete", "refactor"]),
+      rationale: tool7.schema.string(),
+      evidence: tool7.schema.array(tool7.schema.string()),
+      assumptions: tool7.schema.array(tool7.schema.string()),
+      alternatives_considered: tool7.schema.array(tool7.schema.string()),
+      risk_level: tool7.schema.enum(["low", "medium", "high"]),
+      agent: tool7.schema.string().optional(),
+      session_id: tool7.schema.string().optional()
     }).optional(),
-    query: tool8.schema.object({
-      file_path: tool8.schema.string().optional(),
-      change_type: tool8.schema.enum(["create", "edit", "delete", "refactor"]).optional(),
-      risk_level: tool8.schema.enum(["low", "medium", "high"]).optional(),
-      limit: tool8.schema.number().optional()
+    query: tool7.schema.object({
+      file_path: tool7.schema.string().optional(),
+      change_type: tool7.schema.enum(["create", "edit", "delete", "refactor"]).optional(),
+      risk_level: tool7.schema.enum(["low", "medium", "high"]).optional(),
+      limit: tool7.schema.number().optional()
     }).optional(),
-    file_path: tool8.schema.string().optional()
+    file_path: tool7.schema.string().optional()
   },
   async execute(args, context) {
     const dir = context.directory ?? process.cwd();
@@ -1800,7 +1654,7 @@ var decisionTraceTool = tool8({
       case "record": {
         if (!args.entry)
           return JSON.stringify({ error: "entry required" });
-        if (!existsSync14(base))
+        if (!existsSync13(base))
           mkdirSync8(base, { recursive: true });
         const entry = { ...args.entry, timestamp: new Date().toISOString() };
         appendFileSync2(decisionsPath(dir), JSON.stringify(entry) + `
@@ -1833,162 +1687,54 @@ var decisionTraceTool = tool8({
   }
 });
 
-// src/tools/volatility-map.ts
-import { tool as tool9 } from "@opencode-ai/plugin";
-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 join14(codebaseDir(directory), VOLATILITY_FILE);
-}
-function readStore2(directory) {
-  const p = volatilityPath(directory);
-  if (!existsSync15(p))
-    return { version: "1.0", last_updated: new Date().toISOString(), generated_at: new Date().toISOString(), entries: [] };
-  try {
-    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 (!existsSync15(base))
-    mkdirSync9(base, { recursive: true });
-  store.last_updated = new Date().toISOString();
-  writeFileSync11(volatilityPath(directory), JSON.stringify(store, null, 2), "utf-8");
-}
-function stabilityLabel(churn, hotfixes, todos) {
-  const score = churn + hotfixes * 10 + todos * 2;
-  if (score >= 80)
-    return "critical";
-  if (score >= 50)
-    return "volatile";
-  if (score >= 20)
-    return "moderate";
-  return "stable";
-}
-var volatilityMapTool = tool9({
-  description: "Codebase Volatility Map: read/write/query .codebase/VOLATILITY.json — highlights unstable zones based on churn, hotfix frequency, and TODO clusters",
-  args: {
-    action: tool9.schema.enum(["read", "write", "query_hotspots", "update_entry"]),
-    entries: tool9.schema.array(tool9.schema.object({
-      path: tool9.schema.string(),
-      churn_score: tool9.schema.number(),
-      hotfix_count: tool9.schema.number(),
-      todo_count: tool9.schema.number(),
-      last_breakage: tool9.schema.string().optional(),
-      notes: tool9.schema.array(tool9.schema.string())
-    })).optional(),
-    entry: tool9.schema.object({
-      path: tool9.schema.string(),
-      churn_score: tool9.schema.number(),
-      hotfix_count: tool9.schema.number(),
-      todo_count: tool9.schema.number(),
-      last_breakage: tool9.schema.string().optional(),
-      notes: tool9.schema.array(tool9.schema.string())
-    }).optional(),
-    threshold: tool9.schema.enum(["stable", "moderate", "volatile", "critical"]).optional(),
-    path_prefix: tool9.schema.string().optional(),
-    limit: tool9.schema.number().optional()
-  },
-  async execute(args, context) {
-    const dir = context.directory ?? process.cwd();
-    const store = readStore2(dir);
-    switch (args.action) {
-      case "read": {
-        return JSON.stringify({ last_updated: store.last_updated, count: store.entries.length, entries: store.entries });
-      }
-      case "write": {
-        if (!args.entries)
-          return JSON.stringify({ error: "entries required" });
-        store.entries = args.entries.map((e) => ({
-          ...e,
-          stability: stabilityLabel(e.churn_score, e.hotfix_count, e.todo_count)
-        }));
-        store.generated_at = new Date().toISOString();
-        writeStore2(dir, store);
-        return JSON.stringify({ success: true, count: store.entries.length });
-      }
-      case "update_entry": {
-        if (!args.entry)
-          return JSON.stringify({ error: "entry required" });
-        const idx = store.entries.findIndex((e) => e.path === args.entry.path);
-        const updated = {
-          ...args.entry,
-          stability: stabilityLabel(args.entry.churn_score, args.entry.hotfix_count, args.entry.todo_count)
-        };
-        if (idx >= 0) {
-          store.entries[idx] = updated;
-        } else {
-          store.entries.push(updated);
-        }
-        writeStore2(dir, store);
-        return JSON.stringify({ success: true, path: args.entry.path, stability: updated.stability });
-      }
-      case "query_hotspots": {
-        const levels = { stable: 0, moderate: 1, volatile: 2, critical: 3 };
-        const minLevel = levels[args.threshold ?? "volatile"] ?? 2;
-        let results = store.entries.filter((e) => (levels[e.stability] ?? 0) >= minLevel);
-        if (args.path_prefix)
-          results = results.filter((e) => e.path.startsWith(args.path_prefix));
-        results.sort((a, b) => levels[b.stability] - levels[a.stability] || b.churn_score - a.churn_score);
-        if (args.limit)
-          results = results.slice(0, args.limit);
-        return JSON.stringify({ count: results.length, hotspots: results });
-      }
-    }
-  }
-});
-
 // src/tools/policy-engine.ts
-import { tool as tool10 } from "@opencode-ai/plugin";
-import { readFileSync as readFileSync16, writeFileSync as writeFileSync12, existsSync as existsSync16, mkdirSync as mkdirSync10 } from "fs";
-import { join as join15 } from "path";
+import { tool as tool8 } from "@opencode-ai/plugin";
+import { readFileSync as readFileSync14, writeFileSync as writeFileSync10, existsSync as existsSync14, mkdirSync as mkdirSync9 } from "fs";
+import { join as join13 } from "path";
 var POLICIES_FILE = "POLICIES.json";
 function policiesPath(directory) {
-  return join15(codebaseDir(directory), POLICIES_FILE);
+  return join13(codebaseDir(directory), POLICIES_FILE);
 }
-function readStore3(directory) {
+function readStore2(directory) {
   const p = policiesPath(directory);
-  if (!existsSync16(p))
+  if (!existsSync14(p))
     return { version: "1.0", last_updated: new Date().toISOString(), policies: [] };
   try {
-    return JSON.parse(readFileSync16(p, "utf-8"));
+    return JSON.parse(readFileSync14(p, "utf-8"));
   } catch {
     return { version: "1.0", last_updated: new Date().toISOString(), policies: [] };
   }
 }
-function writeStore3(directory, store) {
+function writeStore2(directory, store) {
   const base = codebaseDir(directory);
-  if (!existsSync16(base))
-    mkdirSync10(base, { recursive: true });
+  if (!existsSync14(base))
+    mkdirSync9(base, { recursive: true });
   store.last_updated = new Date().toISOString();
-  writeFileSync12(policiesPath(directory), JSON.stringify(store, null, 2), "utf-8");
+  writeFileSync10(policiesPath(directory), JSON.stringify(store, null, 2), "utf-8");
 }
-var policyEngineTool = tool10({
+var policyEngineTool = tool8({
   description: "Self-Healing Policy Engine: manage .codebase/POLICIES.json — add, list, query, toggle, and record violations of editing policies learned from past failures",
   args: {
-    action: tool10.schema.enum(["list", "add", "record_violation", "toggle", "query"]),
-    policy: tool10.schema.object({
-      id: tool10.schema.string(),
-      name: tool10.schema.string(),
-      trigger: tool10.schema.string(),
-      rule: tool10.schema.string(),
-      source: tool10.schema.enum(["manual", "learned"]),
-      failure_count: tool10.schema.number()
+    action: tool8.schema.enum(["list", "add", "record_violation", "toggle", "query"]),
+    policy: tool8.schema.object({
+      id: tool8.schema.string(),
+      name: tool8.schema.string(),
+      trigger: tool8.schema.string(),
+      rule: tool8.schema.string(),
+      source: tool8.schema.enum(["manual", "learned"]),
+      failure_count: tool8.schema.number()
     }).optional(),
-    policy_id: tool10.schema.string().optional(),
-    active: tool10.schema.boolean().optional(),
-    query: tool10.schema.object({
-      source: tool10.schema.enum(["manual", "learned"]).optional(),
-      active_only: tool10.schema.boolean().optional(),
-      trigger_contains: tool10.schema.string().optional()
+    policy_id: tool8.schema.string().optional(),
+    active: tool8.schema.boolean().optional(),
+    query: tool8.schema.object({
+      source: tool8.schema.enum(["manual", "learned"]).optional(),
+      active_only: tool8.schema.boolean().optional(),
+      trigger_contains: tool8.schema.string().optional()
     }).optional()
   },
   async execute(args, context) {
     const dir = context.directory ?? process.cwd();
-    const store = readStore3(dir);
+    const store = readStore2(dir);
     switch (args.action) {
       case "list": {
         const active = store.policies.filter((p) => p.active);
@@ -2003,7 +1749,7 @@ var policyEngineTool = tool10({
         } else {
           store.policies.push({ ...args.policy, created_at: new Date().toISOString(), active: true });
         }
-        writeStore3(dir, store);
+        writeStore2(dir, store);
         return JSON.stringify({ success: true, id: args.policy.id });
       }
       case "record_violation": {
@@ -2014,7 +1760,7 @@ var policyEngineTool = tool10({
           return JSON.stringify({ error: `Policy not found: ${args.policy_id}` });
         policy.failure_count++;
         policy.last_violated = new Date().toISOString();
-        writeStore3(dir, store);
+        writeStore2(dir, store);
         return JSON.stringify({ success: true, policy_id: args.policy_id, failure_count: policy.failure_count });
       }
       case "toggle": {
@@ -2024,7 +1770,7 @@ var policyEngineTool = tool10({
         if (!policy)
           return JSON.stringify({ error: `Policy not found: ${args.policy_id}` });
         policy.active = args.active !== undefined ? args.active : !policy.active;
-        writeStore3(dir, store);
+        writeStore2(dir, store);
         return JSON.stringify({ success: true, policy_id: args.policy_id, active: policy.active });
       }
       case "query": {
@@ -2045,22 +1791,22 @@ var policyEngineTool = tool10({
 });
 
 // src/tools/hash-edit.ts
-import { tool as tool11 } from "@opencode-ai/plugin";
-import { readFileSync as readFileSync17, writeFileSync as writeFileSync13 } from "fs";
+import { tool as tool9 } from "@opencode-ai/plugin";
+import { readFileSync as readFileSync15, writeFileSync as writeFileSync11 } from "fs";
 import { createHash as createHash2 } from "crypto";
-var hashEditTool = tool11({
+var hashEditTool = tool9({
   description: "Reliable file editing with content verification. Takes a target content, its expected MD5 hash, and replacement content. Only applies if the hash matches, preventing edits on stale file versions.",
   args: {
-    filePath: tool11.schema.string(),
-    targetContent: tool11.schema.string(),
-    expectedHash: tool11.schema.string().optional(),
-    replacementContent: tool11.schema.string()
+    filePath: tool9.schema.string(),
+    targetContent: tool9.schema.string(),
+    expectedHash: tool9.schema.string().optional(),
+    replacementContent: tool9.schema.string()
   },
   async execute(args, context) {
     const fullPath = args.filePath.startsWith("/") ? args.filePath : `${context.directory}/${args.filePath}`;
     let content;
     try {
-      content = readFileSync17(fullPath, "utf-8");
+      content = readFileSync15(fullPath, "utf-8");
     } catch (e) {
       return `Error: Could not read file ${args.filePath}`;
     }
@@ -2074,17 +1820,17 @@ var hashEditTool = tool11({
       }
     }
     const newContent = content.replace(args.targetContent, args.replacementContent);
-    writeFileSync13(fullPath, newContent, "utf-8");
+    writeFileSync11(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 appendFileSync3, existsSync as existsSync17, mkdirSync as mkdirSync11 } from "fs";
-import { join as join16 } from "path";
+import { tool as tool10 } from "@opencode-ai/plugin";
+import { appendFileSync as appendFileSync3, existsSync as existsSync15, mkdirSync as mkdirSync10 } from "fs";
+import { join as join14 } from "path";
 import { createHash as createHash3 } from "crypto";
-import { readFileSync as readFileSync18 } from "fs";
+import { readFileSync as readFileSync16 } from "fs";
 var _councilCache = new Map;
 var COUNCIL_CACHE_TTL_MS = 20 * 60 * 1000;
 function councilCacheKey(task, agents, stateVersion, indexVersion) {
@@ -2105,20 +1851,20 @@ async function runWithConcurrencyLimit(tasks, limit) {
   return results;
 }
 function createCouncilTool(client) {
-  return tool12({
+  return tool10({
     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(),
-      force_fresh: tool12.schema.boolean().optional().default(false),
-      max_concurrency: tool12.schema.number().optional().default(3)
+      task: tool10.schema.string(),
+      agents: tool10.schema.array(tool10.schema.string()).optional(),
+      force_fresh: tool10.schema.boolean().optional().default(false),
+      max_concurrency: tool10.schema.number().optional().default(3)
     },
     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 rawState = existsSync15(sp) ? readFileSync16(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;
@@ -2194,117 +1940,18 @@ Please synthesize these results. Identify areas of agreement, resolve conflicts,
 function persistCouncilResult(directory, payload) {
   try {
     const base = codebaseDir(directory);
-    if (!existsSync17(base))
-      mkdirSync11(base, { recursive: true });
-    const path = join16(base, "COUNCILS.jsonl");
+    if (!existsSync15(base))
+      mkdirSync10(base, { recursive: true });
+    const path = join14(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 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: {
-    targetDir: tool13.schema.string().optional(),
-    force: tool13.schema.boolean().optional()
-  },
-  async execute(args, context) {
-    const root = context.directory;
-    const target = args.targetDir ? join17(root, args.targetDir) : root;
-    if (!existsSync18(target)) {
-      return `Error: Directory ${target} does not exist.`;
-    }
-    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 = join17(root, "package.json");
-    let projectName = "Project";
-    let techStack = "Unknown";
-    if (existsSync18(pkgPath)) {
-      try {
-        const pkg = JSON.parse(readFileSync19(pkgPath, "utf-8"));
-        projectName = pkg.name || projectName;
-        techStack = Object.keys(pkg.dependencies || {}).slice(0, 5).join(", ");
-      } catch {}
-    }
-    const content = `# AGENTS.md for ${projectName}
-
-## Context
-- **Tech Stack**: ${techStack}
-- **Primary Goal**: [Explain the main purpose of this directory/project]
-
-## Rules for Agents
-1. **Consistency**: Follow existing patterns in this directory.
-2. **Safety**: Do not modify files in \`node_modules\` or other sensitive areas.
-3. **Planning**: Always check \`.planning/STATE.md\` before executing major changes.
-
-## Directory Map
-${readdirSync4(target).slice(0, 10).map((f) => {
-      const s = statSync2(join17(target, f));
-      return `- \`${f}\`${s.isDirectory() ? "/" : ""} : [Description]`;
-    }).join(`
-`)}
-
----
-Generated by FlowDeck Context Generator.
-`;
-    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 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 = 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: {
-    name: tool14.schema.string().describe("Unique kebab-case skill name, e.g. 'api-rate-limiting'"),
-    description: tool14.schema.string().describe("One-sentence description of what this skill does"),
-    content: tool14.schema.string().describe("Full skill body in Markdown. Must include: ## When to Activate, ## Steps, and ## Examples sections."),
-    tags: tool14.schema.array(tool14.schema.string()).optional().describe("Optional tags for categorisation, e.g. ['performance', 'typescript']")
-  },
-  async execute(args) {
-    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.`;
-    }
-    const tagLine = args.tags?.length ? `
-tags: [${args.tags.join(", ")}]` : "";
-    const frontmatter = `---
-name: ${args.name}
-description: ${args.description}
-origin: FlowDeck (self-learned)${tagLine}
----
-
-`;
-    const fullContent = frontmatter + args.content.trimStart();
-    try {
-      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.`;
-    } catch (err) {
-      return `Error creating skill '${args.name}': ${err.message}`;
-    }
-  }
-});
-
 // src/tools/reflect.ts
-import { tool as tool15 } from "@opencode-ai/plugin";
-import { existsSync as existsSync20, readFileSync as readFileSync20 } from "fs";
-import { join as join19 } from "path";
+import { tool as tool11 } from "@opencode-ai/plugin";
+import { existsSync as existsSync16, readFileSync as readFileSync17 } from "fs";
+import { join as join15 } from "path";
 var MAX_ARTIFACT_BYTES = 4000;
 function tail(text, maxBytes) {
   if (text.length <= maxBytes)
@@ -2312,10 +1959,10 @@ function tail(text, maxBytes) {
   return `... (truncated) ...
 ` + text.slice(-maxBytes);
 }
-var reflectTool = tool15({
+var reflectTool = tool11({
   description: "Gather session artifacts (decisions, telemetry, failures, policies) and return a structured " + "reflection context that the agent can reason over to produce self-improvement proposals.",
   args: {
-    scope: tool15.schema.enum(["session", "project"]).optional().describe("'session' (default) uses only recent artifacts; 'project' includes all historical data")
+    scope: tool11.schema.enum(["session", "project"]).optional().describe("'session' (default) uses only recent artifacts; 'project' includes all historical data")
   },
   async execute(args, context) {
     const root = context.directory;
@@ -2333,11 +1980,11 @@ var reflectTool = tool15({
     ];
     let found = 0;
     for (const [rel, label] of ARTIFACT_PATHS) {
-      const full = join19(root, rel);
-      if (!existsSync20(full))
+      const full = join15(root, rel);
+      if (!existsSync16(full))
         continue;
       try {
-        const raw = readFileSync20(full, "utf-8").trim();
+        const raw = readFileSync17(full, "utf-8").trim();
         if (!raw)
           continue;
         const count = raw.split(`
@@ -2350,23 +1997,23 @@ var reflectTool = tool15({
       return `No FlowDeck artifacts found under .codebase/.
 ` + "Run some tasks first so decisions, telemetry, and failures are recorded.";
     }
-    sections.push("## What to do with this data", "Analyse the artifacts above and:", "1. **Identify patterns** — repeated tool sequences, recurring failure modes", "2. **Surface gaps** — knowledge or skills that were missing and had to be figured out", "3. **Propose improvements** — for each gap or pattern, either:", "   - Call `create-skill` to capture it as a reusable skill, OR", "   - Propose a new entry in `.codebase/POLICIES.json`", "4. **Summarise** — 3–5 bullet points of the most impactful takeaways");
+    sections.push("## What to do with this data", "Analyse the artifacts above and:", "1. **Identify patterns** — repeated tool sequences, recurring failure modes", "2. **Surface gaps** — knowledge or skills that were missing and had to be figured out", "3. **Propose improvements** — for each gap or pattern, either:", "   - Write a new skill markdown file under `src/skills/<name>/SKILL.md`, OR", "   - Propose a new entry in `.codebase/POLICIES.json`", "4. **Summarise** — 3–5 bullet points of the most impactful takeaways");
     return sections.join(`
 `);
   }
 });
 
 // src/tools/codegraph-tool.ts
-import { tool as tool16 } from "@opencode-ai/plugin";
+import { tool as tool12 } from "@opencode-ai/plugin";
 
 // src/services/codegraph.ts
 import { spawnSync } from "child_process";
-import { existsSync as existsSync21, readFileSync as readFileSync21, writeFileSync as writeFileSync16, mkdirSync as mkdirSync13 } from "fs";
-import { join as join20 } from "path";
+import { existsSync as existsSync17, readFileSync as readFileSync18, writeFileSync as writeFileSync12, mkdirSync as mkdirSync11 } from "fs";
+import { join as join16 } from "path";
 var CODEGRAPH_META_FILE = "CODEGRAPH.md";
 var MAX_FRESHNESS_MS = 30 * 60 * 1000;
 function metaPath(dir) {
-  return join20(codebaseDir(dir), CODEGRAPH_META_FILE);
+  return join16(codebaseDir(dir), CODEGRAPH_META_FILE);
 }
 function isCodegraphInstalled() {
   try {
@@ -2381,11 +2028,11 @@ function isCodegraphInstalled() {
   }
 }
 function isCodegraphIndexed(dir) {
-  return existsSync21(join20(dir, ".codegraph", "codegraph.db"));
+  return existsSync17(join16(dir, ".codegraph", "codegraph.db"));
 }
 function readCodegraphMeta(dir) {
   const path = metaPath(dir);
-  if (!existsSync21(path)) {
+  if (!existsSync17(path)) {
     return {
       installed: false,
       indexed: false,
@@ -2398,7 +2045,7 @@ function readCodegraphMeta(dir) {
     };
   }
   try {
-    const content = readFileSync21(path, "utf-8");
+    const content = readFileSync18(path, "utf-8");
     return parseCodegraphMeta(content);
   } catch {
     return {
@@ -2465,8 +2112,8 @@ function parseCodegraphMeta(content) {
 }
 function writeCodegraphMeta(dir, meta) {
   const base = codebaseDir(dir);
-  if (!existsSync21(base))
-    mkdirSync13(base, { recursive: true });
+  if (!existsSync17(base))
+    mkdirSync11(base, { recursive: true });
   const lines = [
     "# Codegraph Metadata",
     "",
@@ -2479,7 +2126,7 @@ function writeCodegraphMeta(dir, meta) {
     `**installLog:** ${meta.installLog}`,
     `**indexLog:** ${meta.indexLog}`
   ];
-  writeFileSync16(metaPath(dir), lines.join(`
+  writeFileSync12(metaPath(dir), lines.join(`
 `), "utf-8");
 }
 function isCodegraphFresh(dir, maxAgeMs = MAX_FRESHNESS_MS) {
@@ -2690,11 +2337,11 @@ function markCodegraphStale(dir) {
 }
 
 // src/tools/codegraph-tool.ts
-var codegraphTool = tool16({
+var codegraphTool = tool12({
   description: "Manage codegraph lifecycle only: check installation, install, init/rebuild the index, refresh (incremental sync), " + "query status, or mark-stale. Valid actions: check | install | init | refresh | status | mark-stale. " + "Do NOT use this tool for code intelligence queries (files, search, callers, callees, etc.) — " + "those are available as codegraph MCP tools (codegraph_files, codegraph_search, codegraph_context, " + "codegraph_explore, codegraph_callers, codegraph_callees, codegraph_impact, codegraph_trace) " + "when the index is ready.",
   args: {
-    action: tool16.schema.enum(["check", "install", "init", "refresh", "status", "mark-stale"]),
-    agent: tool16.schema.string().optional()
+    action: tool12.schema.enum(["check", "install", "init", "refresh", "status", "mark-stale"]),
+    agent: tool12.schema.string().optional()
   },
   async execute(args, context) {
     const dir = context.directory ?? process.cwd();
@@ -2783,21 +2430,21 @@ var codegraphTool = tool16({
 });
 
 // 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");
+import { tool as tool13 } from "@opencode-ai/plugin";
+import { existsSync as existsSync18, readFileSync as readFileSync19 } from "fs";
+import { join as join17, dirname as dirname2 } from "path";
+import { fileURLToPath } from "url";
+var RULES_DIR = join17(dirname2(fileURLToPath(import.meta.url)), "..", "rules");
 var _loadedPaths = new Set;
-var loadRulesTool = tool17({
+var loadRulesTool = tool13({
   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.")
+    stage: tool13.schema.string().optional().describe("Current workflow stage: discuss | plan | execute | verify | fix-bug | write-docs"),
+    languages: tool13.schema.array(tool13.schema.string()).optional().describe("Project languages to load rules for, e.g. ['typescript']. " + "Omit to use all languages (returns all matching stage rules)."),
+    force_reload: tool13.schema.boolean().optional().default(false).describe("When true, return rules even if they were already loaded in this session. " + "Use only when stage context has changed and you need a fresh load.")
   },
   async execute(args) {
-    const rulesDir = existsSync22(RULES_DIR) ? RULES_DIR : null;
+    const rulesDir = existsSync18(RULES_DIR) ? RULES_DIR : null;
     if (!rulesDir) {
       return JSON.stringify({
         loaded: [],
@@ -2823,7 +2470,7 @@ var loadRulesTool = tool17({
         continue;
       }
       try {
-        const text = readFileSync22(rule.path, "utf-8");
+        const text = readFileSync19(rule.path, "utf-8");
         contents.push(`## ${name}
 
 ${text}`);
@@ -2854,11 +2501,11 @@ ${text}`);
 function ruleShortName(rule) {
   return rule.path.replace(RULES_DIR + "/", "").replace(/\.md$/, "");
 }
-var listRulesTool = tool17({
+var listRulesTool = tool13({
   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;
+    const rulesDir = existsSync18(RULES_DIR) ? RULES_DIR : null;
     if (!rulesDir) {
       return JSON.stringify({ rules: [], error: `Rules directory not found at ${RULES_DIR}` });
     }
@@ -2878,13 +2525,13 @@ var listRulesTool = tool17({
 });
 
 // src/tools/rtk-setup.ts
-import { tool as tool18 } from "@opencode-ai/plugin";
+import { tool as tool14 } from "@opencode-ai/plugin";
 
 // src/services/rtk-manager.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import { existsSync as existsSync23 } from "fs";
+import { existsSync as existsSync19 } from "fs";
 import { homedir as homedir2 } from "os";
-import { join as join22 } from "path";
+import { join as join18 } from "path";
 
 // src/services/rtk-policy.ts
 var SUPPORTED_COMMANDS = new Set([
@@ -2930,7 +2577,7 @@ var INSTALL_INSTRUCTIONS = [
   "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"];
+var CANDIDATE_PATHS = [join18(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) {
@@ -2939,7 +2586,7 @@ function detectRtk() {
     return { installed: true, binPath: "rtk", version };
   }
   for (const candidate of CANDIDATE_PATHS) {
-    if (!existsSync23(candidate))
+    if (!existsSync19(candidate))
       continue;
     const result = spawnSync2(candidate, ["--version"], { encoding: "utf-8", timeout: 5000 });
     if (result.status === 0) {
@@ -3017,7 +2664,7 @@ function getRtkStatus(opts) {
 }
 
 // src/tools/rtk-setup.ts
-var rtkSetupTool = tool18({
+var rtkSetupTool = tool14({
   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%.",
@@ -3025,7 +2672,7 @@ var rtkSetupTool = tool18({
     "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.")
+    action: tool14.schema.enum(["status", "init"]).optional().describe("'status' — detect and report rtk state (default). " + "'init' — detect, then run `rtk init -g` to install the bash hook. " + "Use 'init' only once per environment setup.")
   },
   async execute(args) {
     const action = args.action ?? "status";
@@ -3065,15 +2712,15 @@ var rtkSetupTool = tool18({
 });
 
 // src/hooks/guard-rails.ts
-import { existsSync as existsSync24, readFileSync as readFileSync23 } from "fs";
-import { join as join23 } from "path";
+import { existsSync as existsSync20, readFileSync as readFileSync20 } from "fs";
+import { join as join19 } from "path";
 var PLANNING_DIR2 = ".planning";
 var CONFIG_FILE = "config.json";
 var STATE_FILE2 = "STATE.md";
 function resolveExecutionMode(configPath, trustScore, volatility) {
-  if (existsSync24(configPath)) {
+  if (existsSync20(configPath)) {
     try {
-      const config = JSON.parse(readFileSync23(configPath, "utf-8"));
+      const config = JSON.parse(readFileSync20(configPath, "utf-8"));
       if (config.execution_mode === "review-only")
         return "review-only";
       if (config.execution_mode === "guarded")
@@ -3127,22 +2774,22 @@ async function guardRailsHook(ctx, input, _output) {
   if (!ENABLED)
     return;
   const dir = ctx.directory;
-  const planningDirPath = join23(dir, PLANNING_DIR2);
+  const planningDirPath = join19(dir, PLANNING_DIR2);
   const codebaseDirectory = codebaseDir(dir);
-  const configPath = join23(planningDirPath, CONFIG_FILE);
-  const statePath2 = join23(planningDirPath, STATE_FILE2);
+  const configPath = join19(planningDirPath, CONFIG_FILE);
+  const statePath2 = join19(planningDirPath, STATE_FILE2);
   const workspaceRoot = findWorkspaceRoot(dir);
   if (workspaceRoot && dir !== workspaceRoot) {
     const config = getWorkspaceConfig(dir);
-    if (config && config.workspace_mode === "shared" && !existsSync24(planningDirPath)) {
+    if (config && config.workspace_mode === "shared" && !existsSync20(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 (!existsSync24(planningDirPath))
+    if (!existsSync20(planningDirPath))
       return;
-    if (!existsSync24(codebaseDirectory)) {
+    if (!existsSync20(codebaseDirectory)) {
       throw new Error(`[flowdeck] WARNING: .codebase/ not found. Run /fd-map-codebase to map the codebase.`);
     }
     const execMode = resolveExecutionMode(configPath, null);
@@ -3198,15 +2845,15 @@ function getDesignGateMessage(dir) {
 }
 function planSuggestsUiHeavy(dir, phase) {
   const planPath = phasePlanPath(dir, phase);
-  if (!existsSync24(planPath))
+  if (!existsSync20(planPath))
     return false;
-  const planContent = readFileSync23(planPath, "utf-8");
+  const planContent = readFileSync20(planPath, "utf-8");
   return isUiHeavyTask(planContent);
 }
 function effectiveSeverity(configPath, statePath2) {
-  if (existsSync24(configPath)) {
+  if (existsSync20(configPath)) {
     try {
-      const configContent = readFileSync23(configPath, "utf-8");
+      const configContent = readFileSync20(configPath, "utf-8");
       const config = JSON.parse(configContent);
       if (config.guard_enforcement === "warn")
         return "warn";
@@ -3222,10 +2869,10 @@ function getEffectiveSeverity(configPath, statePath2) {
   return effectiveSeverity(configPath, statePath2);
 }
 function getPlanConfirmed(statePath2) {
-  if (!existsSync24(statePath2))
+  if (!existsSync20(statePath2))
     return false;
   try {
-    const content = readFileSync23(statePath2, "utf-8");
+    const content = readFileSync20(statePath2, "utf-8");
     const match = content.match(/plan_confirmed:\s*(true|false)/i);
     return match ? match[1].toLowerCase() === "true" : false;
   } catch {
@@ -3233,32 +2880,32 @@ function getPlanConfirmed(statePath2) {
   }
 }
 function getWarningMessage(planningDir2) {
-  if (!existsSync24(join23(planningDir2, STATE_FILE2))) {
+  if (!existsSync20(join19(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 (!existsSync24(join23(planningDir2, STATE_FILE2))) {
+  if (!existsSync20(join19(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 existsSync25, readFileSync as readFileSync24 } from "fs";
-import { join as join24 } from "path";
+import { existsSync as existsSync21, readFileSync as readFileSync21 } from "fs";
+import { join as join20 } 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(tool19, args) {
-  const patterns = BLOCKED_PATTERNS[tool19];
+function isBlocked(tool15, args) {
+  const patterns = BLOCKED_PATTERNS[tool15];
   if (!patterns)
     return null;
-  if (tool19 === "bash") {
+  if (tool15 === "bash") {
     const cmd = args.command;
     if (!cmd)
       return null;
@@ -3269,7 +2916,7 @@ function isBlocked(tool19, args) {
     }
     return null;
   }
-  if (tool19 === "read") {
+  if (tool15 === "read") {
     const filePath = args.filePath;
     if (!filePath)
       return null;
@@ -3280,7 +2927,7 @@ function isBlocked(tool19, args) {
     }
     return null;
   }
-  if (tool19 === "write") {
+  if (tool15 === "write") {
     const filePath = args.filePath;
     if (!filePath)
       return null;
@@ -3294,11 +2941,11 @@ function isBlocked(tool19, args) {
   return null;
 }
 function checkArchConstraint(directory, filePath) {
-  const constraintsPath = join24(codebaseDir(directory), "CONSTRAINTS.md");
-  if (!existsSync25(constraintsPath))
+  const constraintsPath = join20(codebaseDir(directory), "CONSTRAINTS.md");
+  if (!existsSync21(constraintsPath))
     return null;
   try {
-    const content = readFileSync24(constraintsPath, "utf-8");
+    const content = readFileSync21(constraintsPath, "utf-8");
     const match = content.match(/## Forbidden Paths\n([\s\S]*?)(?:\n##|$)/);
     if (!match)
       return null;
@@ -3339,9 +2986,9 @@ function isUiDesignApprovalRequired(directory) {
     return !(state.design_stage === "handoff_complete" && state.design_approved);
   }
   const planPath = phasePlanPath(directory, state.phase || 1);
-  if (!existsSync25(planPath))
+  if (!existsSync21(planPath))
     return false;
-  const planContent = readFileSync24(planPath, "utf-8");
+  const planContent = readFileSync21(planPath, "utf-8");
   if (!isUiHeavyTask(planContent))
     return false;
   return !(state.design_stage === "handoff_complete" && state.design_approved);
@@ -3370,18 +3017,18 @@ async function toolGuardHook(ctx, input, output) {
 }
 
 // src/hooks/session-start.ts
-import { existsSync as existsSync26, readFileSync as readFileSync25 } from "fs";
+import { existsSync as existsSync22, readFileSync as readFileSync22 } 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 (!existsSync26(planningDir2)) {
+  if (!existsSync22(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: existsSync26(codebaseDirectory),
+      flowdeck_has_codebase: existsSync22(codebaseDirectory),
       ...workspaceRoot && config?.sub_repos ? {
         flowdeck_workspace_root: workspaceRoot,
         flowdeck_sub_repos: config.sub_repos,
@@ -3392,7 +3039,7 @@ async function sessionStartHook(ctx) {
   }
   try {
     const stateFilePath = statePath(ctx.directory);
-    const content = readFileSync25(stateFilePath, "utf-8");
+    const content = readFileSync22(stateFilePath, "utf-8");
     const state = parseState(content);
     const currentPhase = state["current_phase"] || {};
     const result = {
@@ -3400,7 +3047,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: existsSync26(codebaseDirectory)
+      flowdeck_has_codebase: existsSync22(codebaseDirectory)
     };
     if (workspaceRoot && config?.sub_repos && config.sub_repos.length > 0) {
       result.flowdeck_workspace_root = workspaceRoot;
@@ -3415,7 +3062,7 @@ async function sessionStartHook(ctx) {
       flowdeck_phase: null,
       flowdeck_status: "error",
       flowdeck_warning: "State file unreadable. Continuing without flowdeck context.",
-      flowdeck_has_codebase: existsSync26(codebaseDirectory)
+      flowdeck_has_codebase: existsSync22(codebaseDirectory)
     };
     if (workspaceRoot && config?.sub_repos && config.sub_repos.length > 0) {
       result.flowdeck_workspace_root = workspaceRoot;
@@ -3554,13 +3201,13 @@ class NotificationController {
     return this.lastNotifiedKey;
   }
 }
-function notifyPermissionNeeded(tool19) {
-  notify("FlowDeck Permission Required", `Agent needs approval to use tool: ${tool19}`, "critical");
+function notifyPermissionNeeded(tool15) {
+  notify("FlowDeck Permission Required", `Agent needs approval to use tool: ${tool15}`, "critical");
 }
 
 // src/hooks/patch-trust.ts
-import { existsSync as existsSync27, readFileSync as readFileSync26 } from "fs";
-import { join as join25 } from "path";
+import { existsSync as existsSync23, readFileSync as readFileSync23 } from "fs";
+import { join as join21 } from "path";
 var HIGH_RISK_KEYWORDS = [
   "password",
   "secret",
@@ -3581,26 +3228,12 @@ var HIGH_RISK_KEYWORDS = [
   "root",
   "privilege"
 ];
-function loadVolatility(directory) {
-  const p = join25(codebaseDir(directory), "VOLATILITY.json");
-  if (!existsSync27(p))
-    return {};
-  try {
-    const data = JSON.parse(readFileSync26(p, "utf-8"));
-    const map = {};
-    for (const entry of data.entries ?? [])
-      map[entry.path] = entry.stability;
-    return map;
-  } catch {
-    return {};
-  }
-}
 function loadFailedPaths(directory) {
-  const p = join25(codebaseDir(directory), "FAILURES.json");
-  if (!existsSync27(p))
+  const p = join21(codebaseDir(directory), "FAILURES.json");
+  if (!existsSync23(p))
     return [];
   try {
-    const data = JSON.parse(readFileSync26(p, "utf-8"));
+    const data = JSON.parse(readFileSync23(p, "utf-8"));
     return (data.entries ?? []).flatMap((e) => e.affected_paths ?? []);
   } catch {
     return [];
@@ -3609,18 +3242,6 @@ function loadFailedPaths(directory) {
 function scorePatch(directory, filePath, content) {
   let score = 100;
   const signals = [];
-  const volatility = loadVolatility(directory);
-  const stability = Object.entries(volatility).find(([path]) => filePath.includes(path))?.[1];
-  if (stability === "critical") {
-    score -= 40;
-    signals.push("file is in critical volatility zone");
-  } else if (stability === "volatile") {
-    score -= 25;
-    signals.push("file is in volatile zone");
-  } else if (stability === "moderate") {
-    score -= 10;
-    signals.push("file has moderate churn");
-  }
   const failedPaths = loadFailedPaths(directory);
   if (failedPaths.some((p) => filePath.includes(p))) {
     score -= 20;
@@ -3665,8 +3286,8 @@ async function patchTrustHook(ctx, input, output) {
 }
 
 // src/hooks/decision-trace-hook.ts
-import { existsSync as existsSync28, mkdirSync as mkdirSync14, appendFileSync as appendFileSync4 } from "fs";
-import { join as join26 } from "path";
+import { existsSync as existsSync24, mkdirSync as mkdirSync12, appendFileSync as appendFileSync4 } from "fs";
+import { join as join22 } from "path";
 async function decisionTraceHook(ctx, input, output) {
   if (input.tool !== "write" && input.tool !== "edit")
     return;
@@ -3675,8 +3296,8 @@ async function decisionTraceHook(ctx, input, output) {
     return;
   const base = codebaseDir(ctx.directory);
   try {
-    if (!existsSync28(base))
-      mkdirSync14(base, { recursive: true });
+    if (!existsSync24(base))
+      mkdirSync12(base, { recursive: true });
     const entry = {
       timestamp: new Date().toISOString(),
       file_path: filePath,
@@ -3688,87 +3309,14 @@ async function decisionTraceHook(ctx, input, output) {
       risk_level: "unknown",
       auto_recorded: true
     };
-    appendFileSync4(join26(base, "DECISIONS.jsonl"), JSON.stringify(entry) + `
+    appendFileSync4(join22(base, "DECISIONS.jsonl"), JSON.stringify(entry) + `
 `, "utf-8");
   } catch {}
 }
 
-// src/services/telemetry.ts
-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 join27(codebaseDir(dir), "TELEMETRY.jsonl");
-}
-function appendEvent2(dir, partial) {
-  if (process.env.TELEMETRY_ENABLED !== "true")
-    return null;
-  const cd = codebaseDir(dir);
-  if (!existsSync29(cd))
-    mkdirSync15(cd, { recursive: true });
-  const event = {
-    id: randomUUID(),
-    ts: new Date().toISOString(),
-    ...partial
-  };
-  appendFileSync5(telemetryPath(dir), JSON.stringify(event) + `
-`, "utf-8");
-  return event;
-}
-
-// src/hooks/telemetry-hook.ts
-function resolveIds(toolInput) {
-  const session_id = toolInput.sessionID ?? toolInput.sessionId ?? process.env.OPENCODE_SESSION_ID ?? "session-0";
-  const run_id = toolInput.messageID ?? toolInput.messageId ?? toolInput.runID ?? toolInput.runId ?? process.env.OPENCODE_RUN_ID ?? "run-0";
-  return { session_id, run_id };
-}
-function inferStatus(output) {
-  if (output.error)
-    return "error";
-  if (typeof output.output !== "string")
-    return "ok";
-  const text = output.output.trim();
-  if (!text)
-    return "ok";
-  try {
-    const parsed = JSON.parse(text);
-    if (parsed.success === false || parsed.error || parsed.status === "error")
-      return "error";
-    return "ok";
-  } catch {
-    return "ok";
-  }
-}
-async function telemetryHook(context, toolInput, output) {
-  const dir = context.directory ?? process.cwd();
-  const tool19 = toolInput.name ?? toolInput.tool ?? "unknown";
-  const ids = resolveIds(toolInput);
-  appendEvent2(dir, {
-    session_id: ids.session_id,
-    run_id: ids.run_id,
-    event: "tool.call",
-    tool: tool19,
-    status: "ok",
-    meta: { parameters: output.args ?? {} }
-  });
-}
-async function telemetryAfterHook(context, toolInput, output) {
-  const dir = context.directory ?? process.cwd();
-  const tool19 = toolInput.name ?? toolInput.tool ?? "unknown";
-  const ids = resolveIds(toolInput);
-  const status = inferStatus(output);
-  appendEvent2(dir, {
-    session_id: ids.session_id,
-    run_id: ids.run_id,
-    event: "tool.complete",
-    tool: tool19,
-    status
-  });
-}
-
 // src/services/approval-manager.ts
-import { existsSync as existsSync30, readFileSync as readFileSync28, writeFileSync as writeFileSync17, mkdirSync as mkdirSync16 } from "fs";
-import { join as join28 } from "path";
+import { existsSync as existsSync25, readFileSync as readFileSync24, writeFileSync as writeFileSync13, mkdirSync as mkdirSync13 } from "fs";
+import { join as join23 } from "path";
 var APPROVAL_TTL_MS = 30 * 60 * 1000;
 var SENSITIVE_PATTERNS = [
   /auth/i,
@@ -3805,14 +3353,14 @@ function isSensitivePath(filePath) {
   return SENSITIVE_PATTERNS.some((p) => p.test(filePath));
 }
 function approvalsPath(dir) {
-  return join28(codebaseDir(dir), "APPROVALS.json");
+  return join23(codebaseDir(dir), "APPROVALS.json");
 }
 function loadStore2(dir) {
   const p = approvalsPath(dir);
-  if (!existsSync30(p))
+  if (!existsSync25(p))
     return { requests: [] };
   try {
-    return JSON.parse(readFileSync28(p, "utf-8"));
+    return JSON.parse(readFileSync24(p, "utf-8"));
   } catch {
     return { requests: [] };
   }
@@ -3830,8 +3378,8 @@ async function approvalHook(context, toolInput, output) {
   if (!ENABLED2)
     return;
   const dir = context.directory ?? process.cwd();
-  const tool19 = toolInput.name ?? toolInput.tool ?? "";
-  if (!WRITE_TOOLS.has(tool19))
+  const tool15 = toolInput.name ?? toolInput.tool ?? "";
+  if (!WRITE_TOOLS.has(tool15))
     return;
   const args = output.args ?? {};
   const filePath = String(args.path ?? args.file_path ?? args.filename ?? "");
@@ -3842,20 +3390,305 @@ async function approvalHook(context, toolInput, output) {
   const approval = checkApproval(dir, filePath, "");
   if (approval)
     return;
-  appendEvent2(dir, {
-    session_id: process.env.OPENCODE_SESSION_ID ?? "session-0",
-    run_id: process.env.OPENCODE_RUN_ID ?? "run-0",
-    event: "approval.request",
-    tool: tool19,
-    status: "blocked",
-    files: [filePath],
-    meta: { trigger: "sensitive_file", file: filePath }
-  });
   throw new Error(`APPROVAL_REQUIRED: "${filePath}" is a sensitive file (auth/payment/secrets/infra).
 ` + `Risk level: HIGH — manual approval needed before editing.
 ` + `To proceed: run /fd-guarded-edit --file "${filePath}" to review and approve this change.`);
 }
 
+// src/services/event-logger.ts
+import { existsSync as existsSync26, mkdirSync as mkdirSync14, appendFileSync as appendFileSync5, readFileSync as readFileSync25, writeFileSync as writeFileSync14, renameSync, unlinkSync, statSync as statSync2 } from "fs";
+import { join as join24, resolve as resolve2, sep } from "path";
+var SENSITIVE_KEYS = [
+  "password",
+  "token",
+  "apikey",
+  "api_key",
+  "secret",
+  "authorization",
+  "auth",
+  "key",
+  "credential",
+  "privatekey",
+  "private_key",
+  "accesstoken",
+  "access_token",
+  "refreshtoken",
+  "refresh_token"
+];
+var currentAgent = null;
+function getCurrentAgent() {
+  return currentAgent;
+}
+function setCurrentAgent(agent) {
+  currentAgent = agent;
+}
+function sanitizeArgs(args) {
+  if (!args || typeof args !== "object")
+    return {};
+  const result = {};
+  for (const [key, value] of Object.entries(args)) {
+    const lowerKey = key.toLowerCase();
+    if (SENSITIVE_KEYS.some((sk) => lowerKey.includes(sk))) {
+      result[key] = "[REDACTED]";
+    } else if (key === "content" || key === "newString" || key === "oldString" || key === "template") {
+      if (typeof value === "string" && value.length > 100) {
+        result[key] = `[${value.length} chars truncated]`;
+      } else {
+        result[key] = value;
+      }
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function isValidDirectory(directory) {
+  const normalized = resolve2(directory);
+  if (normalized !== directory && !directory.startsWith(sep)) {
+    return false;
+  }
+  if (directory.includes("..") || directory.includes(".." + sep)) {
+    return false;
+  }
+  try {
+    const stats = statSync2(directory);
+    return stats.isDirectory();
+  } catch {
+    return false;
+  }
+}
+function logEvent(directory, event) {
+  if (process.env.FLOWDECK_EVENT_LOG === "off")
+    return;
+  if (!isValidDirectory(directory)) {
+    process.stderr.write(`[FlowDeck] Invalid log directory: ${directory}
+`);
+    return;
+  }
+  const logDir = join24(directory, ".opencode");
+  const logPath = join24(logDir, "flowdeck-events.jsonl");
+  try {
+    if (!existsSync26(logDir)) {
+      mkdirSync14(logDir, { recursive: true });
+    }
+    appendFileSync5(logPath, JSON.stringify(event) + `
+`, "utf-8");
+    rotateLogFile(logPath);
+    const line = formatEventForStderr(event);
+    process.stderr.write(line + `
+`);
+  } catch {}
+}
+function rotateLogFile(logPath) {
+  try {
+    const stats = statSync2(logPath);
+    if (stats.size < 5000)
+      return;
+    const content = readFileSync25(logPath, "utf-8");
+    const lines = content.split(`
+`).filter((l) => l.trim());
+    if (lines.length > 1000) {
+      const backupPath = logPath + ".backup";
+      renameSync(logPath, backupPath);
+      const keep = lines.slice(-1000);
+      writeFileSync14(logPath, keep.join(`
+`) + `
+`, "utf-8");
+      try {
+        unlinkSync(backupPath);
+      } catch {}
+    }
+  } catch {}
+}
+function formatEventForStderr(event) {
+  const time = event.timestamp.slice(11, 23);
+  const agent = event.agent ?? "unknown";
+  const dim = "\x1B[2m";
+  const reset = "\x1B[0m";
+  const cyan = "\x1B[36m";
+  switch (event.type) {
+    case "tool.before": {
+      let icon;
+      if (event.tool === "write" || event.tool === "edit")
+        icon = "✏️ ";
+      else if (event.tool === "read")
+        icon = "\uD83D\uDD0D";
+      else if (event.tool === "bash" || event.tool === "shell")
+        icon = "\uD83C\uDFC3";
+      else if (event.tool === "delegate")
+        icon = "\uD83E\uDD16";
+      else
+        icon = "\uD83D\uDD27";
+      const argStr = formatArgs(event.args);
+      const thinking = event.thinking ? ` "${event.thinking}"` : "";
+      return `${dim}[${time}]${reset} ${icon} ${cyan}${agent}${reset}  → ${event.tool}(${argStr})${thinking}`;
+    }
+    case "tool.after": {
+      let icon;
+      let statusColor;
+      if (event.status === "success") {
+        icon = "✅";
+        statusColor = "\x1B[32m";
+      } else if (event.status === "error") {
+        icon = "❌";
+        statusColor = "\x1B[31m";
+      } else if (event.status === "blocked") {
+        icon = "⛔";
+        statusColor = "\x1B[33m";
+      } else {
+        icon = "✅";
+        statusColor = "\x1B[32m";
+      }
+      const argStr = formatArgs(event.args);
+      const duration = event.duration_ms ? ` done in ${event.duration_ms}ms` : "";
+      const error = event.error ? ` error: ${event.error}` : "";
+      return `${dim}[${time}]${reset} ${icon} ${cyan}${agent}${reset}  → ${event.tool}(${argStr})${statusColor}${duration}${error}${reset}`;
+    }
+    case "agent.delegated": {
+      const thinking = event.thinking ? ` "${event.thinking}"` : "";
+      return `${dim}[${time}]${reset} \uD83E\uDD16 ${cyan}${agent}${reset}  → delegate(${thinking})`;
+    }
+    case "session.created":
+      return `${dim}[${time}]${reset} \uD83D\uDCC2 session created${event.session_id ? ` (${event.session_id})` : ""}`;
+    case "session.idle":
+      return `${dim}[${time}]${reset} \uD83D\uDCA4 session idle${event.session_id ? ` (${event.session_id})` : ""}`;
+    case "session.error":
+      return `${dim}[${time}]${reset} ❌ session error${event.error ? `: ${event.error}` : ""}`;
+    default:
+      return `${dim}[${time}]${reset} ${event.type}`;
+  }
+}
+function formatArgs(args) {
+  if (!args)
+    return "";
+  const parts = [];
+  for (const [key, value] of Object.entries(args)) {
+    if (key === "filePath" || key === "path" || key === "file") {
+      parts.push(String(value));
+    } else if (key === "agent") {
+      parts.push(`@${String(value)}`);
+    }
+  }
+  return parts.join(", ");
+}
+
+// src/hooks/event-log-hook.ts
+var toolStartTimes = new Map;
+var staleThresholdMs = 5 * 60 * 1000;
+var CLEANUP_INTERVAL = 50;
+var beforeHookCallCount = 0;
+function cleanupStaleToolStartTimes() {
+  const now = Date.now();
+  for (const [key, startTime] of toolStartTimes.entries()) {
+    if (now - startTime > staleThresholdMs) {
+      toolStartTimes.delete(key);
+    }
+  }
+}
+async function eventLogBeforeHook(ctx, toolInput, toolOutput) {
+  const toolName = toolInput.tool ?? toolInput.name ?? "unknown";
+  const sessionId = toolInput.sessionID ?? toolInput.sessionId ?? "unknown";
+  const args = toolOutput?.args ?? toolInput?.args ?? {};
+  const startKey = `${sessionId}:${toolName}`;
+  beforeHookCallCount++;
+  if (beforeHookCallCount >= CLEANUP_INTERVAL) {
+    beforeHookCallCount = 0;
+    cleanupStaleToolStartTimes();
+  }
+  toolStartTimes.set(startKey, Date.now());
+  const event = {
+    timestamp: new Date().toISOString(),
+    type: "tool.before",
+    agent: getCurrentAgent() ?? undefined,
+    tool: toolName,
+    args: sanitizeArgs(args),
+    session_id: sessionId
+  };
+  logEvent(ctx.directory, event);
+}
+async function eventLogAfterHook(ctx, toolInput, toolOutput) {
+  const toolName = toolInput.tool ?? toolInput.name ?? "unknown";
+  const sessionId = toolInput.sessionID ?? toolInput.sessionId ?? "unknown";
+  const args = toolOutput?.args ?? toolInput?.args ?? {};
+  const startKey = `${sessionId}:${toolName}`;
+  const startTime = toolStartTimes.get(startKey);
+  const durationMs = startTime ? Date.now() - startTime : undefined;
+  toolStartTimes.delete(startKey);
+  let status = "success";
+  let error;
+  if (toolOutput?.error != null) {
+    status = "error";
+    error = typeof toolOutput.error === "string" ? toolOutput.error : String(toolOutput.error);
+  } else if (toolOutput?.status === "error") {
+    status = "error";
+    error = typeof toolOutput.error === "string" ? toolOutput.error : "Unknown error";
+  } else if (toolOutput?.status === "blocked") {
+    status = "blocked";
+  }
+  const event = {
+    timestamp: new Date().toISOString(),
+    type: "tool.after",
+    agent: getCurrentAgent() ?? undefined,
+    tool: toolName,
+    args: sanitizeArgs(args),
+    duration_ms: durationMs,
+    status,
+    error,
+    session_id: sessionId
+  };
+  logEvent(ctx.directory, event);
+}
+async function eventLogSessionHook(ctx, event) {
+  const type = event?.type ?? "";
+  const props = event?.properties ?? {};
+  if (type === "session.created") {
+    if (props.parentID) {
+      const agentName = extractAgentFromEvent(props);
+      setCurrentAgent(agentName);
+    }
+    const toolEvent = {
+      timestamp: new Date().toISOString(),
+      type: "session.created",
+      session_id: props.id ?? props.sessionId ?? undefined
+    };
+    logEvent(ctx.directory, toolEvent);
+  } else if (type === "session.idle") {
+    if (props.parentID) {
+      setCurrentAgent(null);
+    }
+    const toolEvent = {
+      timestamp: new Date().toISOString(),
+      type: "session.idle",
+      session_id: props.id ?? props.sessionId ?? undefined
+    };
+    logEvent(ctx.directory, toolEvent);
+  } else if (type === "session.error") {
+    if (props.parentID) {
+      setCurrentAgent(null);
+    }
+    const err = props.error;
+    const errorMsg = (err && typeof err === "object" && "message" in err ? String(err.message) : undefined) ?? (typeof err === "string" ? err : undefined) ?? undefined;
+    const toolEvent = {
+      timestamp: new Date().toISOString(),
+      type: "session.error",
+      session_id: props.id ?? props.sessionId ?? undefined,
+      error: errorMsg
+    };
+    logEvent(ctx.directory, toolEvent);
+  }
+}
+function extractAgentFromEvent(props) {
+  if (typeof props.agent === "string")
+    return props.agent;
+  if (typeof props.name === "string")
+    return props.name;
+  const title = typeof props.title === "string" ? props.title : "";
+  const match = title.match(/^(.+)-delegate$/);
+  if (match)
+    return match[1];
+  return "unknown";
+}
+
 // src/hooks/context-window-monitor.ts
 var CONTEXT_WARNING_THRESHOLD = 0.7;
 var DEFAULT_CONTEXT_LIMIT = Number(process.env.FLOWDECK_CONTEXT_LIMIT) || 200000;
@@ -3907,8 +3740,8 @@ function createContextWindowMonitorHook() {
 }
 
 // src/hooks/shell-env-hook.ts
-import { existsSync as existsSync31, readFileSync as readFileSync29 } from "fs";
-import { join as join29 } from "path";
+import { existsSync as existsSync27, readFileSync as readFileSync26 } from "fs";
+import { join as join25 } from "path";
 import { createRequire as createRequire2 } from "module";
 var _version;
 function getVersion() {
@@ -3944,7 +3777,7 @@ var MARKER_TO_LANG = {
 };
 function detectPackageManager(root) {
   for (const [lockfile, pm] of Object.entries(LOCKFILE_TO_PM)) {
-    if (existsSync31(join29(root, lockfile)))
+    if (existsSync27(join25(root, lockfile)))
       return pm;
   }
   return;
@@ -3953,7 +3786,7 @@ function detectLanguages(root) {
   const langs = [];
   const seen = new Set;
   for (const [marker, lang] of Object.entries(MARKER_TO_LANG)) {
-    if (!seen.has(lang) && existsSync31(join29(root, marker))) {
+    if (!seen.has(lang) && existsSync27(join25(root, marker))) {
       langs.push(lang);
       seen.add(lang);
     }
@@ -3961,11 +3794,11 @@ function detectLanguages(root) {
   return langs;
 }
 function readCurrentPhase(root) {
-  const statePath2 = join29(root, ".planning", "STATE.md");
-  if (!existsSync31(statePath2))
+  const statePath2 = join25(root, ".planning", "STATE.md");
+  if (!existsSync27(statePath2))
     return;
   try {
-    const content = readFileSync29(statePath2, "utf-8");
+    const content = readFileSync26(statePath2, "utf-8");
     const match = content.match(/phase:\s*(\S+)/i);
     return match?.[1];
   } catch {
@@ -4090,8 +3923,8 @@ function createSessionIdleHook(client, tracker) {
 }
 
 // src/hooks/compaction-hook.ts
-import { existsSync as existsSync32, readFileSync as readFileSync30 } from "fs";
-import { join as join30 } from "path";
+import { existsSync as existsSync28, readFileSync as readFileSync27 } from "fs";
+import { join as join26 } from "path";
 var STRUCTURED_SUMMARY_PROMPT = `
 When summarizing this session, you MUST include the following sections:
 
@@ -4132,10 +3965,10 @@ For each: agent name, status, description, session_id.
 var _lastInjected = new Map;
 function readPlanningState2(directory) {
   const sp = statePath(directory);
-  if (!existsSync32(sp))
+  if (!existsSync28(sp))
     return null;
   try {
-    const content = readFileSync30(sp, "utf-8");
+    const content = readFileSync27(sp, "utf-8");
     const parsed = parseState(content);
     const version = typeof parsed.summaryVersion === "number" ? parsed.summaryVersion : 0;
     return { content: content.slice(0, 1500), version };
@@ -4164,15 +3997,15 @@ function createCompactionHook(ctx, tracker) {
       sections.push(`_State unchanged since last compaction. summaryVersion=${currentStateVersion}_`);
       sections.push("");
     }
-    const indexPath2 = join30(ctx.directory, ".planning", "CODEBASE_INDEX.md");
-    if (indexChanged && existsSync32(indexPath2)) {
+    const indexPath2 = join26(ctx.directory, ".planning", "CODEBASE_INDEX.md");
+    if (indexChanged && existsSync28(indexPath2)) {
       try {
-        const indexContent = readFileSync30(indexPath2, "utf-8");
+        const indexContent = readFileSync27(indexPath2, "utf-8");
         const indexSummary = "\n## Codebase Index\n```\n" + indexContent.slice(0, 800) + "\n```\n";
         sections.push(indexSummary);
         sections.push("");
       } catch {}
-    } else if (existsSync32(indexPath2)) {
+    } else if (existsSync28(indexPath2)) {
       sections.push(`## Codebase Index (unchanged, v${currentIndexVersion})`);
       sections.push(`_Index unchanged since last compaction. summaryVersion=${currentIndexVersion}_`);
       sections.push("");
@@ -4223,12 +4056,9 @@ var ALWAYS_ALLOWED = new Set([
   "council",
   "planning-state",
   "codebase-state",
-  "workspace-state",
   "repo-memory",
   "decision-trace",
   "policy-engine",
-  "context-generator",
-  "create-skill",
   "reflect"
 ]);
 function isDelegationTool(name) {
@@ -4339,7 +4169,7 @@ async function runAutoLearner(client, directory, appLog) {
       parts: [
         {
           type: "text",
-          text: "Run your automated self-improvement routine: call `reflect`, " + "identify patterns, and call `create-skill` for each one. " + "Complete silently without asking for input."
+          text: "Run your automated self-improvement routine: call `reflect`, " + "identify patterns, and write a skill markdown file under `src/skills/<name>/SKILL.md` for each one. " + "Complete silently without asking for input."
         }
       ],
       tools: { question: false }
@@ -4573,8 +4403,8 @@ Please advise.
 ## Self-Learning
 
 When a task required unusual human guidance, a novel solution strategy, or exposed a knowledge gap:
-1. After the task completes successfully, call the \`create-skill\` tool to capture the pattern
-2. Use a descriptive kebab-case name, a one-sentence description, and structured Markdown content
+1. After the task completes successfully, write a new skill markdown file under \`src/skills/<name>/SKILL.md\` to capture the pattern
+2. Use a descriptive kebab-case name for the directory, a one-sentence description in the frontmatter, and structured Markdown content
 3. Include: When to Activate, Steps, Examples, and Pitfalls sections
 
 Do NOT create a skill for routine tasks. Only capture genuinely novel or reusable patterns.`;
@@ -6720,7 +6550,6 @@ You receive a structured context with:
 - \`file_path\`: optional specific file being changed
 - \`trust_score\`: patch trust score (0–100; 80+ = safe, 40–79 = review-required, <40 = high-risk)
 - \`trust_signals\`: list of risk signals from the patch trust scorer
-- \`volatile_zones\`: paths marked as volatile or critical in VOLATILITY.json
 - \`prior_failures\`: failure entries from FAILURES.json that match this change
 - \`regression_categories\`: predicted regression categories for this change
 - \`confidence\`: system confidence score (0–100; based on how much codebase context data exists)
@@ -7179,7 +7008,7 @@ var AUTO_LEARNER_PROMPT = `You run automatically after a coding session to captu
    - Novel solutions that took non-obvious reasoning
    - Recurring tool sequences that indicate a reusable workflow
    - Knowledge gaps that had to be worked out from scratch
-3. For each valuable pattern, call \`create-skill\` immediately.
+3. For each valuable pattern, write a skill markdown file under \`src/skills/<name>/SKILL.md\` immediately.
 4. If nothing is worth capturing, output exactly: "No new skills identified."
 5. End with a one-line summary: "Auto-learn complete: N skill(s) created."
 
@@ -7544,12 +7373,9 @@ var CONTRACTS = [
       "council",
       "planning-state",
       "codebase-state",
-      "workspace-state",
       "repo-memory",
       "decision-trace",
       "policy-engine",
-      "context-generator",
-      "create-skill",
       "reflect"
     ],
     forbiddenActions: [
@@ -7584,7 +7410,7 @@ var CONTRACTS = [
     allowedTaskTypes: ["planning", "task-breakdown", "step-decomposition"],
     requiredInputs: ["task description or STATE.md"],
     expectedOutputFields: ["steps", "phase"],
-    allowedTools: ["read", "glob", "grep", "planning-state", "workspace-state"],
+    allowedTools: ["read", "glob", "grep", "planning-state"],
     forbiddenActions: [
       "write source files",
       "run bash commands",
@@ -8100,7 +7926,6 @@ function runSupervisorReview(directory, targetName, ctx = {}, clarificationQuest
       reviewPhase,
       timestamp: timestamp2
     };
-    _emitTelemetry(directory, decision2, ctx);
     return decision2;
   }
   const policyResult = targetType === "command" ? checkCommandPolicy(targetName, ctx) : checkAgentPolicy(targetName, ctx);
@@ -8122,7 +7947,6 @@ function runSupervisorReview(directory, targetName, ctx = {}, clarificationQuest
     timestamp: timestamp2,
     ...escalationQuestion ? { clarificationQuestion: escalationQuestion } : {}
   };
-  _emitTelemetry(directory, supervisorDecision, ctx);
   return supervisorDecision;
 }
 function shouldProceed(decision, mode, canBlock) {
@@ -8135,33 +7959,12 @@ function shouldProceed(decision, mode, canBlock) {
   }
   return decision.decision !== "block" || decision.confidenceScore > 0.3;
 }
-function _emitTelemetry(directory, decision, ctx) {
-  try {
-    appendEvent2(directory, {
-      session_id: ctx.session_id ?? "session-0",
-      run_id: ctx.run_id ?? "unknown",
-      event: "supervisor.review",
-      agent: "supervisor",
-      status: decision.decision === "approve" ? "ok" : decision.decision === "block" ? "blocked" : decision.decision === "escalate" ? "approved" : "ok",
-      meta: {
-        targetName: decision.targetName,
-        targetType: decision.targetType,
-        exists: decision.exists,
-        decision: decision.decision,
-        confidenceScore: decision.confidenceScore,
-        riskFlags: decision.riskFlags,
-        missingRequirements: decision.missingRequirements,
-        reviewPhase: decision.reviewPhase
-      }
-    });
-  } catch {}
-}
 
 // src/index.ts
 function lazyLoadRulePaths(projectRoot) {
-  const __dir = dirname5(fileURLToPath3(import.meta.url));
-  const rulesDir = join31(__dir, "..", "src", "rules");
-  if (!existsSync33(rulesDir))
+  const __dir = dirname3(fileURLToPath2(import.meta.url));
+  const rulesDir = join27(__dir, "..", "src", "rules");
+  if (!existsSync29(rulesDir))
     return { paths: [], diagnostics: "[LazyRuleLoader] rules directory not found" };
   const detectedLanguages = detectProjectLanguages(projectRoot);
   const paths = getStartupRulePaths(rulesDir, detectedLanguages);
@@ -8170,17 +7973,17 @@ function lazyLoadRulePaths(projectRoot) {
   return { paths, diagnostics };
 }
 function loadCommands() {
-  const __dir = dirname5(fileURLToPath3(import.meta.url));
-  const commandsDir = join31(__dir, "..", "src", "commands");
-  if (!existsSync33(commandsDir))
+  const __dir = dirname3(fileURLToPath2(import.meta.url));
+  const commandsDir = join27(__dir, "..", "src", "commands");
+  if (!existsSync29(commandsDir))
     return {};
   const commands = {};
   try {
-    for (const file of readdirSync5(commandsDir)) {
+    for (const file of readdirSync4(commandsDir)) {
       if (!file.endsWith(".md"))
         continue;
       const name = basename2(file, ".md");
-      const raw = readFileSync31(join31(commandsDir, file), "utf-8");
+      const raw = readFileSync28(join27(commandsDir, file), "utf-8");
       let description;
       let template = raw;
       const fmMatch = raw.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/);
@@ -8197,6 +8000,7 @@ function loadCommands() {
 }
 var plugin = async (input, _options) => {
   const { directory, client, worktree } = input;
+  const appLog = (msg) => client.app.log({ body: { service: "flowdeck", level: "info", message: msg } }).catch(() => {});
   const runPipelineTool = createRunPipelineTool(client);
   const delegateTool = createDelegateTool(client);
   const councilTool = createCouncilTool(client);
@@ -8208,11 +8012,11 @@ var plugin = async (input, _options) => {
   const sessionIdleHook = createSessionIdleHook(client, fileTracker);
   const compactionHook = createCompactionHook({ directory }, fileTracker);
   const orchestratorGuard = new OrchestratorGuard;
-  const appLog = (msg) => client.app.log({ body: { service: "flowdeck", level: "info", message: msg } }).catch(() => {});
   const autoLearnHook = createAutoLearnHook(client, fileTracker, directory, appLog);
   const notifCtrl = new NotificationController(undefined, appLog);
   const agentConfigs = getAgentConfigs({});
   const mcps = createFlowDeckMcps();
+  let lastExecutedCommand = null;
   return {
     name: "@dv.nghiem/flowdeck",
     agent: agentConfigs,
@@ -8262,8 +8066,8 @@ var plugin = async (input, _options) => {
           }
         }
       }
-      const skillsDir = join31(dirname5(fileURLToPath3(import.meta.url)), "..", "src", "skills");
-      if (existsSync33(skillsDir)) {
+      const skillsDir = join27(dirname3(fileURLToPath2(import.meta.url)), "..", "src", "skills");
+      if (existsSync29(skillsDir)) {
         const cfgAny = cfg;
         if (!cfgAny.skills || typeof cfgAny.skills !== "object") {
           cfgAny.skills = { paths: [] };
@@ -8292,18 +8096,14 @@ var plugin = async (input, _options) => {
     tool: {
       "planning-state": planningStateTool,
       "codebase-state": codebaseStateTool,
-      "workspace-state": workspaceStateTool,
       "run-pipeline": runPipelineTool,
       delegate: delegateTool,
       "repo-memory": repoMemoryTool,
       "failure-replay": failureReplayTool,
       "decision-trace": decisionTraceTool,
-      "volatility-map": volatilityMapTool,
       "policy-engine": policyEngineTool,
       "hash-edit": hashEditTool,
       council: councilTool,
-      "context-generator": contextGeneratorTool,
-      "create-skill": createSkillTool,
       reflect: reflectTool,
       codegraph: codegraphTool,
       "load-rules": loadRulesTool,
@@ -8315,7 +8115,9 @@ var plugin = async (input, _options) => {
     "file.edited": fileEdited,
     "file.watcher.updated": fileWatcherUpdated,
     "experimental.session.compacting": compactionHook,
-    "command.execute.before": async (_input, _output) => {},
+    "command.execute.before": async (input2, _output) => {
+      lastExecutedCommand = input2.command;
+    },
     "permission.ask": async (input2, _output) => {
       notifyPermissionNeeded(input2.title);
     },
@@ -8323,6 +8125,9 @@ var plugin = async (input, _options) => {
       const type = event?.type ?? "";
       if (type === "session.created" || type === "session.started") {
         await sessionStartHook({ directory });
+        if (type === "session.created") {
+          await eventLogSessionHook({ directory }, event);
+        }
       }
       if (type === "command.executed") {
         const commandName = event?.properties?.name ?? "";
@@ -8333,7 +8138,11 @@ var plugin = async (input, _options) => {
       await contextMonitor.event({ event });
       orchestratorGuard.onEvent(event);
       if (type === "session.idle") {
+        await eventLogSessionHook({ directory }, event);
         const hasEdits = fileTracker.getEditedPaths().length > 0;
+        if (lastExecutedCommand) {
+          lastExecutedCommand = null;
+        }
         notifCtrl.onSessionIdle(hasEdits);
         try {
           await sessionIdleHook();
@@ -8343,6 +8152,8 @@ var plugin = async (input, _options) => {
         }
       }
       if (type === "session.error") {
+        await eventLogSessionHook({ directory }, event);
+        lastExecutedCommand = null;
         const err = event?.properties?.error;
         const errorMsg = (err && typeof err === "object" && "message" in err ? String(err.message) : undefined) ?? (typeof err === "string" ? err : undefined) ?? "An unexpected error occurred";
         notifCtrl.onSessionError(errorMsg);
@@ -8387,15 +8198,15 @@ var plugin = async (input, _options) => {
           }
         }
       }
-      await telemetryHook({ directory }, toolInput, toolOutput);
       await approvalHook({ directory }, toolInput, toolOutput);
       await guardRailsHook({ directory }, toolInput, toolOutput);
       await toolGuardHook({ directory }, toolInput, toolOutput);
       await patchTrustHook({ directory }, toolInput, toolOutput);
       await decisionTraceHook({ directory }, toolInput, toolOutput);
+      await eventLogBeforeHook({ directory }, toolInput, toolOutput);
     },
     "tool.execute.after": async (toolInput, toolOutput) => {
-      await telemetryAfterHook({ directory }, toolInput, toolOutput);
+      await eventLogAfterHook({ directory }, toolInput, toolOutput);
       const afterToolName = toolInput.tool ?? toolInput.name ?? "";
       if (afterToolName === "delegate" || afterToolName === "run-pipeline") {
         try {