@dv.nghiem/flowdeck 0.2.2 → 0.2.4

package/dist/index.js

@@ -1,6 +1,6 @@
 // src/index.ts
 import { readdirSync as readdirSync3, readFileSync as readFileSync22, existsSync as existsSync23 } from "fs";
-import { join as join22, basename } from "path";
+import { join as join23, basename } from "path";
 import { dirname as dirname4 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
@@ -509,6 +509,33 @@ var workspaceStateTool = tool3({
 
 // src/tools/run-parallel.ts
 import { tool as tool4 } from "@opencode-ai/plugin";
+
+// src/services/telemetry.ts
+import { existsSync as existsSync5, readFileSync as readFileSync5, appendFileSync, mkdirSync as mkdirSync2 } from "fs";
+import { join as join5 } from "path";
+import { randomUUID } from "crypto";
+function telemetryPath(dir) {
+  return join5(codebaseDir(dir), "TELEMETRY.jsonl");
+}
+function appendEvent(dir, partial) {
+  if (process.env.TELEMETRY_ENABLED !== "true")
+    return null;
+  const cd = codebaseDir(dir);
+  if (!existsSync5(cd))
+    mkdirSync2(cd, { recursive: true });
+  const event = {
+    id: randomUUID(),
+    ts: new Date().toISOString(),
+    ...partial
+  };
+  appendFileSync(telemetryPath(dir), JSON.stringify(event) + `
+`, "utf-8");
+  return event;
+}
+
+// src/tools/run-parallel.ts
+import { writeFileSync as writeFileSync5 } from "fs";
+import { join as join6 } from "path";
 function extractText(parts) {
   return parts.filter((p) => p.type === "text" && typeof p.text === "string").map((p) => p.text).join(`
 `);
@@ -534,6 +561,7 @@ function createRunParallelTool(client) {
           }).catch(() => {});
         }
       });
+      const dir = context.directory ?? process.cwd();
       const promises = args.tasks.map(async (task) => {
         const taskStart = Date.now();
         const createRes = await client.session.create({
@@ -550,6 +578,14 @@ function createRunParallelTool(client) {
         }
         const childId = createRes.data.id;
         childSessionIds.push(childId);
+        appendEvent(dir, {
+          session_id: context.sessionID,
+          run_id: process.env.OPENCODE_RUN_ID ?? "run-0",
+          event: "agent.dispatch",
+          agent: task.agent,
+          status: "ok",
+          meta: { child_session_id: childId, task_index: args.tasks.findIndex((t) => t.agent === task.agent) }
+        });
         const fullPrompt = task.context ? `${task.context}
 
 ---
@@ -565,6 +601,15 @@ ${task.prompt}` : task.prompt;
           query: { directory: context.directory }
         });
         if (promptRes.error) {
+          appendEvent(dir, {
+            session_id: context.sessionID,
+            run_id: process.env.OPENCODE_RUN_ID ?? "run-0",
+            event: "agent.complete",
+            agent: task.agent,
+            status: "error",
+            duration_ms: Date.now() - taskStart,
+            meta: { child_session_id: childId, error: `Prompt failed: ${promptRes.error?.detail ?? "unknown"}` }
+          });
           return {
             agent: task.agent,
             session_id: childId,
@@ -575,6 +620,15 @@ ${task.prompt}` : task.prompt;
         }
         const info = promptRes.data?.info;
         if (info?.error) {
+          appendEvent(dir, {
+            session_id: context.sessionID,
+            run_id: process.env.OPENCODE_RUN_ID ?? "run-0",
+            event: "agent.complete",
+            agent: task.agent,
+            status: "error",
+            duration_ms: Date.now() - taskStart,
+            meta: { child_session_id: childId, error: JSON.stringify(info.error) }
+          });
           return {
             agent: task.agent,
             session_id: childId,
@@ -584,6 +638,15 @@ ${task.prompt}` : task.prompt;
           };
         }
         const output = extractText(promptRes.data?.parts ?? []);
+        appendEvent(dir, {
+          session_id: context.sessionID,
+          run_id: process.env.OPENCODE_RUN_ID ?? "run-0",
+          event: "agent.complete",
+          agent: task.agent,
+          status: "ok",
+          duration_ms: Date.now() - taskStart,
+          meta: { child_session_id: childId, output_length: output?.length ?? 0 }
+        });
         return {
           agent: task.agent,
           session_id: childId,
@@ -603,6 +666,14 @@ ${task.prompt}` : task.prompt;
           duration_ms: Date.now() - startTime
         };
       });
+      const progress = {
+        total: args.tasks.length,
+        completed: results.filter((r) => r.success || r.error).length,
+        in_progress: childSessionIds.length,
+        results: results.map((r) => ({ agent: r.agent, success: r.success, duration_ms: r.duration_ms })),
+        total_duration_ms: Date.now() - startTime
+      };
+      writeFileSync5(join6(codebaseDir(dir), "parallel-progress.json"), JSON.stringify(progress, null, 2));
       return JSON.stringify({
         results,
         total_duration_ms: Date.now() - startTime,
@@ -798,31 +869,31 @@ ${args.prompt}` : args.prompt;
 
 // src/tools/repo-memory.ts
 import { tool as tool7 } from "@opencode-ai/plugin";
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync5, existsSync as existsSync5, mkdirSync as mkdirSync2 } from "fs";
-import { join as join5 } from "path";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync6, existsSync as existsSync6, mkdirSync as mkdirSync3 } from "fs";
+import { join as join7 } from "path";
 var MEMORY_FILE = "MEMORY.json";
 function memoryPath(directory) {
-  return join5(codebaseDir(directory), MEMORY_FILE);
+  return join7(codebaseDir(directory), MEMORY_FILE);
 }
 function emptyMemory() {
   return { version: "1.0", last_updated: new Date().toISOString(), nodes: {} };
 }
 function readMemory(directory) {
   const p = memoryPath(directory);
-  if (!existsSync5(p))
+  if (!existsSync6(p))
     return emptyMemory();
   try {
-    return JSON.parse(readFileSync5(p, "utf-8"));
+    return JSON.parse(readFileSync6(p, "utf-8"));
   } catch {
     return emptyMemory();
   }
 }
 function writeMemory(directory, memory) {
   const base = codebaseDir(directory);
-  if (!existsSync5(base))
-    mkdirSync2(base, { recursive: true });
+  if (!existsSync6(base))
+    mkdirSync3(base, { recursive: true });
   memory.last_updated = new Date().toISOString();
-  writeFileSync5(memoryPath(directory), JSON.stringify(memory, null, 2), "utf-8");
+  writeFileSync6(memoryPath(directory), JSON.stringify(memory, null, 2), "utf-8");
 }
 var repoMemoryTool = tool7({
   description: "Repo Memory Graph: read/write/query persistent architecture graph in .codebase/MEMORY.json (modules, dependencies, ownership, bug history, conventions)",
@@ -899,28 +970,28 @@ var repoMemoryTool = tool7({
 
 // src/tools/failure-replay.ts
 import { tool as tool8 } from "@opencode-ai/plugin";
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync6, existsSync as existsSync6, mkdirSync as mkdirSync3 } from "fs";
-import { join as join6 } from "path";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync7, existsSync as existsSync7, mkdirSync as mkdirSync4 } from "fs";
+import { join as join8 } from "path";
 var FAILURES_FILE = "FAILURES.json";
 function failuresPath(directory) {
-  return join6(codebaseDir(directory), FAILURES_FILE);
+  return join8(codebaseDir(directory), FAILURES_FILE);
 }
 function readStore(directory) {
   const p = failuresPath(directory);
-  if (!existsSync6(p))
+  if (!existsSync7(p))
     return { version: "1.0", last_updated: new Date().toISOString(), entries: [] };
   try {
-    return JSON.parse(readFileSync6(p, "utf-8"));
+    return JSON.parse(readFileSync7(p, "utf-8"));
   } catch {
     return { version: "1.0", last_updated: new Date().toISOString(), entries: [] };
   }
 }
 function writeStore(directory, store) {
   const base = codebaseDir(directory);
-  if (!existsSync6(base))
-    mkdirSync3(base, { recursive: true });
+  if (!existsSync7(base))
+    mkdirSync4(base, { recursive: true });
   store.last_updated = new Date().toISOString();
-  writeFileSync6(failuresPath(directory), JSON.stringify(store, null, 2), "utf-8");
+  writeFileSync7(failuresPath(directory), JSON.stringify(store, null, 2), "utf-8");
 }
 var failureReplayTool = tool8({
   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",
@@ -1004,17 +1075,17 @@ var failureReplayTool = tool8({
 
 // src/tools/decision-trace.ts
 import { tool as tool9 } from "@opencode-ai/plugin";
-import { readFileSync as readFileSync7, existsSync as existsSync7, mkdirSync as mkdirSync4, appendFileSync } from "fs";
-import { join as join7 } from "path";
+import { readFileSync as readFileSync8, existsSync as existsSync8, mkdirSync as mkdirSync5, appendFileSync as appendFileSync2 } from "fs";
+import { join as join9 } from "path";
 var DECISIONS_FILE = "DECISIONS.jsonl";
 function decisionsPath(directory) {
-  return join7(codebaseDir(directory), DECISIONS_FILE);
+  return join9(codebaseDir(directory), DECISIONS_FILE);
 }
 function readDecisions(directory) {
   const p = decisionsPath(directory);
-  if (!existsSync7(p))
+  if (!existsSync8(p))
     return [];
-  return readFileSync7(p, "utf-8").split(`
+  return readFileSync8(p, "utf-8").split(`
 `).filter((l) => l.trim()).map((l) => {
     try {
       return JSON.parse(l);
@@ -1054,10 +1125,10 @@ var decisionTraceTool = tool9({
       case "record": {
         if (!args.entry)
           return JSON.stringify({ error: "entry required" });
-        if (!existsSync7(base))
-          mkdirSync4(base, { recursive: true });
+        if (!existsSync8(base))
+          mkdirSync5(base, { recursive: true });
         const entry = { ...args.entry, timestamp: new Date().toISOString() };
-        appendFileSync(decisionsPath(dir), JSON.stringify(entry) + `
+        appendFileSync2(decisionsPath(dir), JSON.stringify(entry) + `
 `, "utf-8");
         return JSON.stringify({ success: true, id: args.entry.id });
       }
@@ -1089,28 +1160,28 @@ var decisionTraceTool = tool9({
 
 // src/tools/volatility-map.ts
 import { tool as tool10 } from "@opencode-ai/plugin";
-import { readFileSync as readFileSync8, writeFileSync as writeFileSync8, existsSync as existsSync8, mkdirSync as mkdirSync5 } from "fs";
-import { join as join8 } from "path";
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync9, existsSync as existsSync9, mkdirSync as mkdirSync6 } from "fs";
+import { join as join10 } from "path";
 var VOLATILITY_FILE = "VOLATILITY.json";
 function volatilityPath(directory) {
-  return join8(codebaseDir(directory), VOLATILITY_FILE);
+  return join10(codebaseDir(directory), VOLATILITY_FILE);
 }
 function readStore2(directory) {
   const p = volatilityPath(directory);
-  if (!existsSync8(p))
+  if (!existsSync9(p))
     return { version: "1.0", last_updated: new Date().toISOString(), generated_at: new Date().toISOString(), entries: [] };
   try {
-    return JSON.parse(readFileSync8(p, "utf-8"));
+    return JSON.parse(readFileSync9(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 (!existsSync8(base))
-    mkdirSync5(base, { recursive: true });
+  if (!existsSync9(base))
+    mkdirSync6(base, { recursive: true });
   store.last_updated = new Date().toISOString();
-  writeFileSync8(volatilityPath(directory), JSON.stringify(store, null, 2), "utf-8");
+  writeFileSync9(volatilityPath(directory), JSON.stringify(store, null, 2), "utf-8");
 }
 function stabilityLabel(churn, hotfixes, todos) {
   const score = churn + hotfixes * 10 + todos * 2;
@@ -1197,28 +1268,28 @@ var volatilityMapTool = tool10({
 
 // src/tools/policy-engine.ts
 import { tool as tool11 } from "@opencode-ai/plugin";
-import { readFileSync as readFileSync9, writeFileSync as writeFileSync9, existsSync as existsSync9, mkdirSync as mkdirSync6 } from "fs";
-import { join as join9 } from "path";
+import { readFileSync as readFileSync10, writeFileSync as writeFileSync10, existsSync as existsSync10, mkdirSync as mkdirSync7 } from "fs";
+import { join as join11 } from "path";
 var POLICIES_FILE = "POLICIES.json";
 function policiesPath(directory) {
-  return join9(codebaseDir(directory), POLICIES_FILE);
+  return join11(codebaseDir(directory), POLICIES_FILE);
 }
 function readStore3(directory) {
   const p = policiesPath(directory);
-  if (!existsSync9(p))
+  if (!existsSync10(p))
     return { version: "1.0", last_updated: new Date().toISOString(), policies: [] };
   try {
-    return JSON.parse(readFileSync9(p, "utf-8"));
+    return JSON.parse(readFileSync10(p, "utf-8"));
   } catch {
     return { version: "1.0", last_updated: new Date().toISOString(), policies: [] };
   }
 }
 function writeStore3(directory, store) {
   const base = codebaseDir(directory);
-  if (!existsSync9(base))
-    mkdirSync6(base, { recursive: true });
+  if (!existsSync10(base))
+    mkdirSync7(base, { recursive: true });
   store.last_updated = new Date().toISOString();
-  writeFileSync9(policiesPath(directory), JSON.stringify(store, null, 2), "utf-8");
+  writeFileSync10(policiesPath(directory), JSON.stringify(store, null, 2), "utf-8");
 }
 var policyEngineTool = tool11({
   description: "Self-Healing Policy Engine: manage .codebase/POLICIES.json — add, list, query, toggle, and record violations of editing policies learned from past failures",
@@ -1300,7 +1371,7 @@ var policyEngineTool = tool11({
 
 // src/tools/hash-edit.ts
 import { tool as tool12 } from "@opencode-ai/plugin";
-import { readFileSync as readFileSync10, writeFileSync as writeFileSync10 } from "fs";
+import { readFileSync as readFileSync11, writeFileSync as writeFileSync11 } from "fs";
 import { createHash } from "crypto";
 var hashEditTool = tool12({
   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.",
@@ -1314,7 +1385,7 @@ var hashEditTool = tool12({
     const fullPath = args.filePath.startsWith("/") ? args.filePath : `${context.directory}/${args.filePath}`;
     let content;
     try {
-      content = readFileSync10(fullPath, "utf-8");
+      content = readFileSync11(fullPath, "utf-8");
     } catch (e) {
       return `Error: Could not read file ${args.filePath}`;
     }
@@ -1328,7 +1399,7 @@ var hashEditTool = tool12({
       }
     }
     const newContent = content.replace(args.targetContent, args.replacementContent);
-    writeFileSync10(fullPath, newContent, "utf-8");
+    writeFileSync11(fullPath, newContent, "utf-8");
     return `Successfully updated ${args.filePath} using hash-anchored edit.`;
   }
 });
@@ -1397,8 +1468,8 @@ Please synthesize these results. Identify areas of agreement, resolve conflicts,
 
 // src/tools/context-generator.ts
 import { tool as tool14 } from "@opencode-ai/plugin";
-import { writeFileSync as writeFileSync11, existsSync as existsSync10, readFileSync as readFileSync11, readdirSync as readdirSync2, statSync } from "fs";
-import { join as join10 } from "path";
+import { writeFileSync as writeFileSync12, existsSync as existsSync11, readFileSync as readFileSync12, readdirSync as readdirSync2, statSync } from "fs";
+import { join as join12 } from "path";
 var contextGeneratorTool = tool14({
   description: "Auto-generate or update hierarchical context files (AGENTS.md, CLAUDE.md) throughout the project. These files provide critical grounding for AI agents.",
   args: {
@@ -1407,20 +1478,20 @@ var contextGeneratorTool = tool14({
   },
   async execute(args, context) {
     const root = context.directory;
-    const target = args.targetDir ? join10(root, args.targetDir) : root;
-    if (!existsSync10(target)) {
+    const target = args.targetDir ? join12(root, args.targetDir) : root;
+    if (!existsSync11(target)) {
       return `Error: Directory ${target} does not exist.`;
     }
-    const agentsMdPath = join10(target, "AGENTS.md");
-    if (existsSync10(agentsMdPath) && !args.force) {
+    const agentsMdPath = join12(target, "AGENTS.md");
+    if (existsSync11(agentsMdPath) && !args.force) {
       return `AGENTS.md already exists in ${target}. Use force: true to overwrite.`;
     }
-    const pkgPath = join10(root, "package.json");
+    const pkgPath = join12(root, "package.json");
     let projectName = "Project";
     let techStack = "Unknown";
-    if (existsSync10(pkgPath)) {
+    if (existsSync11(pkgPath)) {
       try {
-        const pkg = JSON.parse(readFileSync11(pkgPath, "utf-8"));
+        const pkg = JSON.parse(readFileSync12(pkgPath, "utf-8"));
         projectName = pkg.name || projectName;
         techStack = Object.keys(pkg.dependencies || {}).slice(0, 5).join(", ");
       } catch {}
@@ -1438,7 +1509,7 @@ var contextGeneratorTool = tool14({
 
 ## Directory Map
 ${readdirSync2(target).slice(0, 10).map((f) => {
-      const s = statSync(join10(target, f));
+      const s = statSync(join12(target, f));
       return `- \`${f}\`${s.isDirectory() ? "/" : ""} : [Description]`;
     }).join(`
 `)}
@@ -1446,17 +1517,17 @@ ${readdirSync2(target).slice(0, 10).map((f) => {
 ---
 Generated by FlowDeck Context Generator.
 `;
-    writeFileSync11(agentsMdPath, content, "utf-8");
+    writeFileSync12(agentsMdPath, content, "utf-8");
     return `Successfully generated AGENTS.md in ${target}.`;
   }
 });
 
 // src/tools/create-skill.ts
 import { tool as tool15 } from "@opencode-ai/plugin";
-import { mkdirSync as mkdirSync7, writeFileSync as writeFileSync12, existsSync as existsSync11 } from "fs";
-import { join as join11, dirname as dirname3 } from "path";
+import { mkdirSync as mkdirSync8, writeFileSync as writeFileSync13, existsSync as existsSync12 } from "fs";
+import { join as join13, dirname as dirname3 } from "path";
 import { fileURLToPath } from "url";
-var SKILLS_DIR = join11(dirname3(fileURLToPath(import.meta.url)), "..", "skills");
+var SKILLS_DIR = join13(dirname3(fileURLToPath(import.meta.url)), "..", "skills");
 var createSkillTool = tool15({
   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: {
@@ -1466,9 +1537,9 @@ var createSkillTool = tool15({
     tags: tool15.schema.array(tool15.schema.string()).optional().describe("Optional tags for categorisation, e.g. ['performance', 'typescript']")
   },
   async execute(args) {
-    const skillDir = join11(SKILLS_DIR, args.name);
-    const skillFile = join11(skillDir, "SKILL.md");
-    if (existsSync11(skillFile)) {
+    const skillDir = join13(SKILLS_DIR, args.name);
+    const skillFile = join13(skillDir, "SKILL.md");
+    if (existsSync12(skillFile)) {
       return `Skill '${args.name}' already exists at ${skillFile}.
 ` + `Use a different name or delete the existing skill directory first.`;
     }
@@ -1483,8 +1554,8 @@ origin: FlowDeck (self-learned)${tagLine}
 `;
     const fullContent = frontmatter + args.content.trimStart();
     try {
-      mkdirSync7(skillDir, { recursive: true });
-      writeFileSync12(skillFile, fullContent, "utf-8");
+      mkdirSync8(skillDir, { recursive: true });
+      writeFileSync13(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.`;
@@ -1496,8 +1567,8 @@ origin: FlowDeck (self-learned)${tagLine}
 
 // src/tools/reflect.ts
 import { tool as tool16 } from "@opencode-ai/plugin";
-import { existsSync as existsSync12, readFileSync as readFileSync12 } from "fs";
-import { join as join12 } from "path";
+import { existsSync as existsSync13, readFileSync as readFileSync13 } from "fs";
+import { join as join14 } from "path";
 var MAX_ARTIFACT_BYTES = 4000;
 function tail(text, maxBytes) {
   if (text.length <= maxBytes)
@@ -1526,11 +1597,11 @@ var reflectTool = tool16({
     ];
     let found = 0;
     for (const [rel, label] of ARTIFACT_PATHS) {
-      const full = join12(root, rel);
-      if (!existsSync12(full))
+      const full = join14(root, rel);
+      if (!existsSync13(full))
         continue;
       try {
-        const raw = readFileSync12(full, "utf-8").trim();
+        const raw = readFileSync13(full, "utf-8").trim();
         if (!raw)
           continue;
         const count = raw.split(`
@@ -1550,15 +1621,15 @@ var reflectTool = tool16({
 });
 
 // src/hooks/guard-rails.ts
-import { existsSync as existsSync13, readFileSync as readFileSync13 } from "fs";
-import { join as join13 } from "path";
+import { existsSync as existsSync14, readFileSync as readFileSync14 } from "fs";
+import { join as join15 } from "path";
 var PLANNING_DIR2 = ".planning";
 var CONFIG_FILE = "config.json";
 var STATE_FILE2 = "STATE.md";
 function resolveExecutionMode(configPath, trustScore, volatility) {
-  if (existsSync13(configPath)) {
+  if (existsSync14(configPath)) {
     try {
-      const config = JSON.parse(readFileSync13(configPath, "utf-8"));
+      const config = JSON.parse(readFileSync14(configPath, "utf-8"));
       if (config.execution_mode === "review-only")
         return "review-only";
       if (config.execution_mode === "guarded")
@@ -1609,22 +1680,22 @@ var BUILD_DEPLOY_PATTERNS = [
 ];
 async function guardRailsHook(ctx, input, _output) {
   const dir = ctx.directory;
-  const planningDirPath = join13(dir, PLANNING_DIR2);
+  const planningDirPath = join15(dir, PLANNING_DIR2);
   const codebaseDirectory = codebaseDir(dir);
-  const configPath = join13(planningDirPath, CONFIG_FILE);
-  const statePath2 = join13(planningDirPath, STATE_FILE2);
+  const configPath = join15(planningDirPath, CONFIG_FILE);
+  const statePath2 = join15(planningDirPath, STATE_FILE2);
   const workspaceRoot = findWorkspaceRoot(dir);
   if (workspaceRoot && dir !== workspaceRoot) {
     const config = getWorkspaceConfig(dir);
-    if (config && config.workspace_mode === "shared" && !existsSync13(planningDirPath)) {
+    if (config && config.workspace_mode === "shared" && !existsSync14(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 (!existsSync13(planningDirPath))
+    if (!existsSync14(planningDirPath))
       return;
-    if (!existsSync13(codebaseDirectory)) {
+    if (!existsSync14(codebaseDirectory)) {
       throw new Error(`[flowdeck] WARNING: .codebase/ not found. Run /map-codebase to map the codebase.`);
     }
     const execMode = resolveExecutionMode(configPath, null);
@@ -1659,9 +1730,9 @@ async function guardRailsHook(ctx, input, _output) {
   }
 }
 function effectiveSeverity(configPath, statePath2) {
-  if (existsSync13(configPath)) {
+  if (existsSync14(configPath)) {
     try {
-      const configContent = readFileSync13(configPath, "utf-8");
+      const configContent = readFileSync14(configPath, "utf-8");
       const config = JSON.parse(configContent);
       if (config.guard_enforcement === "warn")
         return "warn";
@@ -1677,10 +1748,10 @@ function getEffectiveSeverity(configPath, statePath2) {
   return effectiveSeverity(configPath, statePath2);
 }
 function getPlanConfirmed(statePath2) {
-  if (!existsSync13(statePath2))
+  if (!existsSync14(statePath2))
     return false;
   try {
-    const content = readFileSync13(statePath2, "utf-8");
+    const content = readFileSync14(statePath2, "utf-8");
     const match = content.match(/plan_confirmed:\s*(true|false)/i);
     return match ? match[1].toLowerCase() === "true" : false;
   } catch {
@@ -1688,21 +1759,21 @@ function getPlanConfirmed(statePath2) {
   }
 }
 function getWarningMessage(statePath2, planningDir3) {
-  if (!existsSync13(join13(planningDir3, STATE_FILE2))) {
+  if (!existsSync14(join15(planningDir3, STATE_FILE2))) {
     return "No .planning/ found. Run /new-project first.";
   }
   return "Plan not confirmed. Run /plan and confirm to enable execution.";
 }
 function getBlockMessage(statePath2, planningDir3) {
-  if (!existsSync13(join13(planningDir3, STATE_FILE2))) {
+  if (!existsSync14(join15(planningDir3, STATE_FILE2))) {
     return "No .planning/ found. Run /new-project first.";
   }
   return "Plan not confirmed. Run /plan and confirm to enable execution.";
 }
 
 // src/hooks/tool-guard.ts
-import { existsSync as existsSync14, readFileSync as readFileSync14 } from "fs";
-import { join as join14 } from "path";
+import { existsSync as existsSync15, readFileSync as readFileSync15 } from "fs";
+import { join as join16 } from "path";
 var BLOCKED_PATTERNS = {
   read: [".env", ".pem", ".key", ".secret"],
   write: ["node_modules"],
@@ -1748,11 +1819,11 @@ function isBlocked(tool17, args) {
   return null;
 }
 function checkArchConstraint(directory, filePath) {
-  const constraintsPath = join14(codebaseDir(directory), "CONSTRAINTS.md");
-  if (!existsSync14(constraintsPath))
+  const constraintsPath = join16(codebaseDir(directory), "CONSTRAINTS.md");
+  if (!existsSync15(constraintsPath))
     return null;
   try {
-    const content = readFileSync14(constraintsPath, "utf-8");
+    const content = readFileSync15(constraintsPath, "utf-8");
     const match = content.match(/## Forbidden Paths\n([\s\S]*?)(?:\n##|$)/);
     if (!match)
       return null;
@@ -1797,18 +1868,18 @@ async function toolGuardHook(ctx, input, output) {
 }
 
 // src/hooks/session-start.ts
-import { existsSync as existsSync15, readFileSync as readFileSync15 } from "fs";
+import { existsSync as existsSync16, readFileSync as readFileSync16 } from "fs";
 async function sessionStartHook(ctx) {
   const planningDir3 = ctx.directory + "/.planning";
   const codebaseDirectory = codebaseDir(ctx.directory);
   const workspaceRoot = findWorkspaceRoot(ctx.directory);
   const config = workspaceRoot ? getWorkspaceConfig(ctx.directory) : null;
-  if (!existsSync15(planningDir3)) {
+  if (!existsSync16(planningDir3)) {
     return {
       flowdeck_phase: null,
       flowdeck_status: "no_plan",
       flowdeck_warning: "Run /new-project or /map-codebase to initialize.",
-      flowdeck_has_codebase: existsSync15(codebaseDirectory),
+      flowdeck_has_codebase: existsSync16(codebaseDirectory),
       ...workspaceRoot && config?.sub_repos ? {
         flowdeck_workspace_root: workspaceRoot,
         flowdeck_sub_repos: config.sub_repos,
@@ -1819,7 +1890,7 @@ async function sessionStartHook(ctx) {
   }
   try {
     const stateFilePath = statePath(ctx.directory);
-    const content = readFileSync15(stateFilePath, "utf-8");
+    const content = readFileSync16(stateFilePath, "utf-8");
     const state = parseState(content);
     const currentPhase = state["current_phase"] || {};
     const result = {
@@ -1827,7 +1898,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: existsSync15(codebaseDirectory)
+      flowdeck_has_codebase: existsSync16(codebaseDirectory)
     };
     if (workspaceRoot && config?.sub_repos && config.sub_repos.length > 0) {
       result.flowdeck_workspace_root = workspaceRoot;
@@ -1842,7 +1913,7 @@ async function sessionStartHook(ctx) {
       flowdeck_phase: null,
       flowdeck_status: "error",
       flowdeck_warning: "State file unreadable. Continuing without flowdeck context.",
-      flowdeck_has_codebase: existsSync15(codebaseDirectory)
+      flowdeck_has_codebase: existsSync16(codebaseDirectory)
     };
     if (workspaceRoot && config?.sub_repos && config.sub_repos.length > 0) {
       result.flowdeck_workspace_root = workspaceRoot;
@@ -1908,8 +1979,8 @@ function notifyPermissionNeeded(tool17) {
 }
 
 // src/hooks/patch-trust.ts
-import { existsSync as existsSync16, readFileSync as readFileSync16 } from "fs";
-import { join as join15 } from "path";
+import { existsSync as existsSync17, readFileSync as readFileSync17 } from "fs";
+import { join as join17 } from "path";
 var HIGH_RISK_KEYWORDS = [
   "password",
   "secret",
@@ -1931,11 +2002,11 @@ var HIGH_RISK_KEYWORDS = [
   "privilege"
 ];
 function loadVolatility(directory) {
-  const p = join15(codebaseDir(directory), "VOLATILITY.json");
-  if (!existsSync16(p))
+  const p = join17(codebaseDir(directory), "VOLATILITY.json");
+  if (!existsSync17(p))
     return {};
   try {
-    const data = JSON.parse(readFileSync16(p, "utf-8"));
+    const data = JSON.parse(readFileSync17(p, "utf-8"));
     const map = {};
     for (const entry of data.entries ?? [])
       map[entry.path] = entry.stability;
@@ -1945,11 +2016,11 @@ function loadVolatility(directory) {
   }
 }
 function loadFailedPaths(directory) {
-  const p = join15(codebaseDir(directory), "FAILURES.json");
-  if (!existsSync16(p))
+  const p = join17(codebaseDir(directory), "FAILURES.json");
+  if (!existsSync17(p))
     return [];
   try {
-    const data = JSON.parse(readFileSync16(p, "utf-8"));
+    const data = JSON.parse(readFileSync17(p, "utf-8"));
     return (data.entries ?? []).flatMap((e) => e.affected_paths ?? []);
   } catch {
     return [];
@@ -2006,8 +2077,8 @@ async function patchTrustHook(ctx, input, output) {
 }
 
 // src/hooks/decision-trace-hook.ts
-import { existsSync as existsSync17, mkdirSync as mkdirSync8, appendFileSync as appendFileSync2 } from "fs";
-import { join as join16 } from "path";
+import { existsSync as existsSync18, mkdirSync as mkdirSync9, appendFileSync as appendFileSync3 } from "fs";
+import { join as join18 } from "path";
 async function decisionTraceHook(ctx, input, output) {
   if (input.tool !== "write" && input.tool !== "edit")
     return;
@@ -2016,8 +2087,8 @@ async function decisionTraceHook(ctx, input, output) {
     return;
   const base = codebaseDir(ctx.directory);
   try {
-    if (!existsSync17(base))
-      mkdirSync8(base, { recursive: true });
+    if (!existsSync18(base))
+      mkdirSync9(base, { recursive: true });
     const entry = {
       timestamp: new Date().toISOString(),
       file_path: filePath,
@@ -2029,32 +2100,11 @@ async function decisionTraceHook(ctx, input, output) {
       risk_level: "unknown",
       auto_recorded: true
     };
-    appendFileSync2(join16(base, "DECISIONS.jsonl"), JSON.stringify(entry) + `
+    appendFileSync3(join18(base, "DECISIONS.jsonl"), JSON.stringify(entry) + `
 `, "utf-8");
   } catch {}
 }
 
-// src/services/telemetry.ts
-import { existsSync as existsSync18, readFileSync as readFileSync17, appendFileSync as appendFileSync3, mkdirSync as mkdirSync9 } from "fs";
-import { join as join17 } from "path";
-import { randomUUID } from "crypto";
-function telemetryPath(dir) {
-  return join17(codebaseDir(dir), "TELEMETRY.jsonl");
-}
-function appendEvent(dir, partial) {
-  const cd = codebaseDir(dir);
-  if (!existsSync18(cd))
-    mkdirSync9(cd, { recursive: true });
-  const event = {
-    id: randomUUID(),
-    ts: new Date().toISOString(),
-    ...partial
-  };
-  appendFileSync3(telemetryPath(dir), JSON.stringify(event) + `
-`, "utf-8");
-  return event;
-}
-
 // src/hooks/telemetry-hook.ts
 async function telemetryHook(context, toolInput, output) {
   const dir = context.directory ?? process.cwd();
@@ -2081,8 +2131,8 @@ async function telemetryAfterHook(context, toolInput, _output) {
 }
 
 // src/services/approval-manager.ts
-import { existsSync as existsSync19, readFileSync as readFileSync18, writeFileSync as writeFileSync13, mkdirSync as mkdirSync10 } from "fs";
-import { join as join18 } from "path";
+import { existsSync as existsSync19, readFileSync as readFileSync18, writeFileSync as writeFileSync14, mkdirSync as mkdirSync10 } from "fs";
+import { join as join19 } from "path";
 var APPROVAL_TTL_MS = 30 * 60 * 1000;
 var SENSITIVE_PATTERNS = [
   /auth/i,
@@ -2119,7 +2169,7 @@ function isSensitivePath(filePath) {
   return SENSITIVE_PATTERNS.some((p) => p.test(filePath));
 }
 function approvalsPath(dir) {
-  return join18(codebaseDir(dir), "APPROVALS.json");
+  return join19(codebaseDir(dir), "APPROVALS.json");
 }
 function loadStore(dir) {
   const p = approvalsPath(dir);
@@ -2219,7 +2269,7 @@ function createContextWindowMonitorHook() {
 
 // src/hooks/shell-env-hook.ts
 import { existsSync as existsSync20, readFileSync as readFileSync19 } from "fs";
-import { join as join19 } from "path";
+import { join as join20 } from "path";
 import { createRequire } from "module";
 var _version;
 function getVersion() {
@@ -2255,7 +2305,7 @@ var MARKER_TO_LANG = {
 };
 function detectPackageManager(root) {
   for (const [lockfile, pm] of Object.entries(LOCKFILE_TO_PM)) {
-    if (existsSync20(join19(root, lockfile)))
+    if (existsSync20(join20(root, lockfile)))
       return pm;
   }
   return;
@@ -2264,7 +2314,7 @@ function detectLanguages(root) {
   const langs = [];
   const seen = new Set;
   for (const [marker, lang] of Object.entries(MARKER_TO_LANG)) {
-    if (!seen.has(lang) && existsSync20(join19(root, marker))) {
+    if (!seen.has(lang) && existsSync20(join20(root, marker))) {
       langs.push(lang);
       seen.add(lang);
     }
@@ -2272,7 +2322,7 @@ function detectLanguages(root) {
   return langs;
 }
 function readCurrentPhase(root) {
-  const statePath2 = join19(root, ".planning", "STATE.md");
+  const statePath2 = join20(root, ".planning", "STATE.md");
   if (!existsSync20(statePath2))
     return;
   try {
@@ -2376,7 +2426,7 @@ function createSessionIdleHook(client, tracker) {
 
 // src/hooks/compaction-hook.ts
 import { existsSync as existsSync21, readFileSync as readFileSync20 } from "fs";
-import { join as join20 } from "path";
+import { join as join21 } from "path";
 var STRUCTURED_SUMMARY_PROMPT = `
 When summarizing this session, you MUST include the following sections:
 
@@ -2415,7 +2465,7 @@ For each: agent name, status, description, session_id.
 **RESUME, DON'T RESTART.** Use session_id to continue existing sessions.
 `;
 function readPlanningState2(directory) {
-  const statePath2 = join20(directory, ".planning", "STATE.md");
+  const statePath2 = join21(directory, ".planning", "STATE.md");
   if (!existsSync21(statePath2))
     return null;
   try {
@@ -2453,7 +2503,7 @@ function createCompactionHook(ctx, tracker) {
 }
 
 // src/hooks/orchestrator-guard-hook.ts
-var DISABLED = process.env.FLOWDECK_ORCHESTRATOR_GUARD === "off";
+var DISABLED = process.env.FLOWDECK_ORCHESTRATOR_GUARD !== "on";
 var BLOCKED_TOOLS = new Set([
   "write_file",
   "write",
@@ -2509,7 +2559,7 @@ function blockMessage(toolName) {
 ` + `  delegate({ agent: "@researcher", prompt: "..." }) — research / file analysis
 ` + `  delegate({ agent: "@tester", prompt: "..." })     — tests / commands
 
-` + `To disable this guard: set FLOWDECK_ORCHESTRATOR_GUARD=off`;
+` + `To enable this guard: set FLOWDECK_ORCHESTRATOR_GUARD=on`;
 }
 
 class OrchestratorGuard {
@@ -5514,18 +5564,18 @@ function getAgentConfigs(agentModels) {
 
 // src/config/loader.ts
 import { existsSync as existsSync22, readFileSync as readFileSync21 } from "fs";
-import { join as join21 } from "path";
+import { join as join22 } from "path";
 import { homedir } from "os";
 var CONFIG_FILENAME = "flowdeck.json";
 function getGlobalConfigDir() {
-  return process.env.OPENCODE_CONFIG_DIR || (process.env.XDG_CONFIG_HOME ? join21(process.env.XDG_CONFIG_HOME, "opencode") : join21(homedir(), ".config", "opencode"));
+  return process.env.OPENCODE_CONFIG_DIR || (process.env.XDG_CONFIG_HOME ? join22(process.env.XDG_CONFIG_HOME, "opencode") : join22(homedir(), ".config", "opencode"));
 }
 function loadFlowDeckConfig(directory) {
   const candidates = [];
   if (directory) {
-    candidates.push(join21(directory, ".opencode", CONFIG_FILENAME));
+    candidates.push(join22(directory, ".opencode", CONFIG_FILENAME));
   }
-  candidates.push(join21(getGlobalConfigDir(), CONFIG_FILENAME));
+  candidates.push(join22(getGlobalConfigDir(), CONFIG_FILENAME));
   for (const configPath of candidates) {
     if (existsSync22(configPath)) {
       try {
@@ -5541,7 +5591,7 @@ function loadFlowDeckConfig(directory) {
 // src/index.ts
 function loadCommands() {
   const __dir = dirname4(fileURLToPath2(import.meta.url));
-  const commandsDir = join22(__dir, "..", "src", "commands");
+  const commandsDir = join23(__dir, "..", "src", "commands");
   if (!existsSync23(commandsDir))
     return {};
   const commands = {};
@@ -5550,7 +5600,7 @@ function loadCommands() {
       if (!file.endsWith(".md"))
         continue;
       const name = basename(file, ".md");
-      const raw = readFileSync22(join22(commandsDir, file), "utf-8");
+      const raw = readFileSync22(join23(commandsDir, file), "utf-8");
       let description;
       let template = raw;
       const fmMatch = raw.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/);
@@ -5628,6 +5678,19 @@ var plugin = async (input, _options) => {
           }
         }
       }
+      const skillsDir = join23(dirname4(fileURLToPath2(import.meta.url)), "..", "src", "skills");
+      if (existsSync23(skillsDir)) {
+        const cfgAny = cfg;
+        if (!cfgAny.skills || typeof cfgAny.skills !== "object") {
+          cfgAny.skills = { paths: [] };
+        }
+        const cfgSkills = cfgAny.skills;
+        if (!cfgSkills.paths)
+          cfgSkills.paths = [];
+        if (!cfgSkills.paths.includes(skillsDir)) {
+          cfgSkills.paths.push(skillsDir);
+        }
+      }
     },
     tool: {
       "planning-state": planningStateTool,