@dv.nghiem/flowdeck 0.2.3 → 0.3.0

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 { readdirSync as readdirSync3, readFileSync as readFileSync22, existsSync as existsSync24 } from "fs";
+import { join as join23, basename } from "path";
 import { dirname as dirname4 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
@@ -507,127 +507,22 @@ var workspaceStateTool = tool3({
   }
 });
 
-// src/tools/run-parallel.ts
+// src/tools/run-pipeline.ts
 import { tool as tool4 } from "@opencode-ai/plugin";
 function extractText(parts) {
   return parts.filter((p) => p.type === "text" && typeof p.text === "string").map((p) => p.text).join(`
 `);
 }
-function createRunParallelTool(client) {
-  return tool4({
-    description: "Run multiple agents in parallel. All tasks execute simultaneously via child sessions. Returns combined results with per-agent wall time. Partial results returned on failure.",
-    args: {
-      tasks: tool4.schema.array(tool4.schema.object({
-        agent: tool4.schema.string(),
-        prompt: tool4.schema.string(),
-        context: tool4.schema.string().optional()
-      }))
-    },
-    async execute(args, context) {
-      const startTime = Date.now();
-      const childSessionIds = [];
-      context.abort.addEventListener("abort", () => {
-        for (const id of childSessionIds) {
-          client.session.abort({
-            path: { id },
-            query: { directory: context.directory }
-          }).catch(() => {});
-        }
-      });
-      const promises = args.tasks.map(async (task) => {
-        const taskStart = Date.now();
-        const createRes = await client.session.create({
-          body: { parentID: context.sessionID, title: `${task.agent}-subtask` },
-          query: { directory: context.directory }
-        });
-        if (createRes.error || !createRes.data?.id) {
-          return {
-            agent: task.agent,
-            success: false,
-            error: `Failed to create session: ${createRes.error?.detail ?? "unknown"}`,
-            duration_ms: Date.now() - taskStart
-          };
-        }
-        const childId = createRes.data.id;
-        childSessionIds.push(childId);
-        const fullPrompt = task.context ? `${task.context}
-
----
-
-${task.prompt}` : task.prompt;
-        const promptRes = await client.session.prompt({
-          path: { id: childId },
-          body: {
-            agent: task.agent,
-            parts: [{ type: "text", text: fullPrompt }],
-            tools: { question: false }
-          },
-          query: { directory: context.directory }
-        });
-        if (promptRes.error) {
-          return {
-            agent: task.agent,
-            session_id: childId,
-            success: false,
-            error: `Prompt failed: ${promptRes.error?.detail ?? "unknown"}`,
-            duration_ms: Date.now() - taskStart
-          };
-        }
-        const info = promptRes.data?.info;
-        if (info?.error) {
-          return {
-            agent: task.agent,
-            session_id: childId,
-            success: false,
-            error: `Agent error: ${JSON.stringify(info.error)}`,
-            duration_ms: Date.now() - taskStart
-          };
-        }
-        const output = extractText(promptRes.data?.parts ?? []);
-        return {
-          agent: task.agent,
-          session_id: childId,
-          success: true,
-          output: output || "(no text output)",
-          duration_ms: Date.now() - taskStart
-        };
-      });
-      const settled = await Promise.allSettled(promises);
-      const results = settled.map((result, i) => {
-        if (result.status === "fulfilled")
-          return result.value;
-        return {
-          agent: args.tasks[i].agent,
-          success: false,
-          error: result.reason?.message || String(result.reason),
-          duration_ms: Date.now() - startTime
-        };
-      });
-      return JSON.stringify({
-        results,
-        total_duration_ms: Date.now() - startTime,
-        failures: results.filter((r) => !r.success).map((r) => r.agent)
-      });
-    }
-  });
-}
-
-// src/tools/run-pipeline.ts
-import { tool as tool5 } from "@opencode-ai/plugin";
-function extractText2(parts) {
-  return parts.filter((p) => p.type === "text" && typeof p.text === "string").map((p) => p.text).join(`
-`);
-}
 function createRunPipelineTool(client) {
-  return tool5({
+  return tool4({
     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: tool5.schema.array(tool5.schema.object({
-        agent: tool5.schema.string(),
-        prompt: tool5.schema.string()
+      steps: tool4.schema.array(tool4.schema.object({
+        agent: tool4.schema.string(),
+        prompt: tool4.schema.string()
       })),
-      initial_context: tool5.schema.string().optional(),
-      abort_on_failure: tool5.schema.boolean().optional().default(true)
+      initial_context: tool4.schema.string().optional(),
+      abort_on_failure: tool4.schema.boolean().optional().default(true)
     },
     async execute(args, context) {
       const startTime = Date.now();
@@ -700,7 +595,7 @@ ${step.prompt}` : step.prompt;
             }
             continue;
           }
-          const output = extractText2(promptRes.data?.parts ?? []);
+          const output = extractText(promptRes.data?.parts ?? []);
           trace.push({ agent: step.agent, session_id: createRes.data.id, input: stepInput, output: output || "(no text output)", duration_ms: Date.now() - stepStart, success: true });
           carryContext = output;
         }
@@ -717,18 +612,18 @@ ${step.prompt}` : step.prompt;
 }
 
 // src/tools/delegate.ts
-import { tool as tool6 } from "@opencode-ai/plugin";
-function extractText3(parts) {
+import { tool as tool5 } from "@opencode-ai/plugin";
+function extractText2(parts) {
   return parts.filter((p) => p.type === "text" && typeof p.text === "string").map((p) => p.text).join(`
 `);
 }
 function createDelegateTool(client) {
-  return tool6({
+  return tool5({
     description: "Delegate a task to a single agent via a child session. Returns the agent's output.",
     args: {
-      agent: tool6.schema.string(),
-      prompt: tool6.schema.string(),
-      context: tool6.schema.string().optional()
+      agent: tool5.schema.string(),
+      prompt: tool5.schema.string(),
+      context: tool5.schema.string().optional()
     },
     async execute(args, context) {
       const startTime = Date.now();
@@ -784,7 +679,7 @@ ${args.prompt}` : args.prompt;
           duration_ms: Date.now() - startTime
         });
       }
-      const output = extractText3(promptRes.data?.parts ?? []);
+      const output = extractText2(promptRes.data?.parts ?? []);
       return JSON.stringify({
         agent: args.agent,
         session_id: childId,
@@ -797,7 +692,7 @@ ${args.prompt}` : args.prompt;
 }
 
 // src/tools/repo-memory.ts
-import { tool as tool7 } from "@opencode-ai/plugin";
+import { tool as tool6 } 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";
 var MEMORY_FILE = "MEMORY.json";
@@ -824,26 +719,26 @@ function writeMemory(directory, memory) {
   memory.last_updated = new Date().toISOString();
   writeFileSync5(memoryPath(directory), JSON.stringify(memory, null, 2), "utf-8");
 }
-var repoMemoryTool = tool7({
+var repoMemoryTool = tool6({
   description: "Repo Memory Graph: read/write/query persistent architecture graph in .codebase/MEMORY.json (modules, dependencies, ownership, bug history, conventions)",
   args: {
-    action: tool7.schema.enum(["read", "write_node", "query", "delete_node"]),
-    node_id: tool7.schema.string().optional(),
-    node: tool7.schema.object({
-      type: tool7.schema.enum(["module", "service", "api", "schema", "config"]),
-      path: tool7.schema.string(),
-      owner: tool7.schema.string().optional(),
-      tags: tool7.schema.array(tool7.schema.string()),
-      dependencies: tool7.schema.array(tool7.schema.string()),
-      dependents: tool7.schema.array(tool7.schema.string()),
-      bug_history: tool7.schema.array(tool7.schema.string()),
-      conventions: tool7.schema.array(tool7.schema.string())
+    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())
     }).optional(),
-    query: tool7.schema.object({
-      type: tool7.schema.enum(["module", "service", "api", "schema", "config"]).optional(),
-      owner: tool7.schema.string().optional(),
-      tag: tool7.schema.string().optional(),
-      path_prefix: tool7.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()
     }).optional()
   },
   async execute(args, context) {
@@ -898,7 +793,7 @@ var repoMemoryTool = tool7({
 });
 
 // src/tools/failure-replay.ts
-import { tool as tool8 } from "@opencode-ai/plugin";
+import { tool as tool7 } 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";
 var FAILURES_FILE = "FAILURES.json";
@@ -922,26 +817,26 @@ function writeStore(directory, store) {
   store.last_updated = new Date().toISOString();
   writeFileSync6(failuresPath(directory), JSON.stringify(store, null, 2), "utf-8");
 }
-var failureReplayTool = tool8({
+var failureReplayTool = tool7({
   description: "Failure Replay Engine: record and query past failures (reverted commits, failed deployments, flaky tests, bug fixes) in .codebase/FAILURES.json so the agent avoids repeating mistakes",
   args: {
-    action: tool8.schema.enum(["record", "query", "list", "mark_resolved"]),
-    entry: tool8.schema.object({
-      id: tool8.schema.string(),
-      type: tool8.schema.enum(["reverted_commit", "failed_deployment", "flaky_test", "bug_fix", "build_failure"]),
-      description: tool8.schema.string(),
-      affected_paths: tool8.schema.array(tool8.schema.string()),
-      root_cause: tool8.schema.string().optional(),
-      fix_applied: tool8.schema.string().optional(),
-      tags: tool8.schema.array(tool8.schema.string())
+    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())
     }).optional(),
-    query: tool8.schema.object({
-      type: tool8.schema.enum(["reverted_commit", "failed_deployment", "flaky_test", "bug_fix", "build_failure"]).optional(),
-      path_prefix: tool8.schema.string().optional(),
-      tag: tool8.schema.string().optional(),
-      limit: tool8.schema.number().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()
     }).optional(),
-    entry_id: tool8.schema.string().optional()
+    entry_id: tool7.schema.string().optional()
   },
   async execute(args, context) {
     const dir = context.directory ?? process.cwd();
@@ -1003,7 +898,7 @@ var failureReplayTool = tool8({
 });
 
 // src/tools/decision-trace.ts
-import { tool as tool9 } from "@opencode-ai/plugin";
+import { tool as tool8 } from "@opencode-ai/plugin";
 import { readFileSync as readFileSync7, existsSync as existsSync7, mkdirSync as mkdirSync4, appendFileSync } from "fs";
 import { join as join7 } from "path";
 var DECISIONS_FILE = "DECISIONS.jsonl";
@@ -1023,29 +918,29 @@ function readDecisions(directory) {
     }
   }).filter(Boolean);
 }
-var decisionTraceTool = tool9({
+var decisionTraceTool = tool8({
   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: tool9.schema.enum(["record", "query", "get_for_file"]),
-    entry: tool9.schema.object({
-      id: tool9.schema.string(),
-      file_path: tool9.schema.string(),
-      change_type: tool9.schema.enum(["create", "edit", "delete", "refactor"]),
-      rationale: tool9.schema.string(),
-      evidence: tool9.schema.array(tool9.schema.string()),
-      assumptions: tool9.schema.array(tool9.schema.string()),
-      alternatives_considered: tool9.schema.array(tool9.schema.string()),
-      risk_level: tool9.schema.enum(["low", "medium", "high"]),
-      agent: tool9.schema.string().optional(),
-      session_id: tool9.schema.string().optional()
+    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()
     }).optional(),
-    query: tool9.schema.object({
-      file_path: tool9.schema.string().optional(),
-      change_type: tool9.schema.enum(["create", "edit", "delete", "refactor"]).optional(),
-      risk_level: tool9.schema.enum(["low", "medium", "high"]).optional(),
-      limit: tool9.schema.number().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()
     }).optional(),
-    file_path: tool9.schema.string().optional()
+    file_path: tool8.schema.string().optional()
   },
   async execute(args, context) {
     const dir = context.directory ?? process.cwd();
@@ -1088,7 +983,7 @@ var decisionTraceTool = tool9({
 });
 
 // src/tools/volatility-map.ts
-import { tool as tool10 } from "@opencode-ai/plugin";
+import { tool as tool9 } 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";
 var VOLATILITY_FILE = "VOLATILITY.json";
@@ -1122,29 +1017,29 @@ function stabilityLabel(churn, hotfixes, todos) {
     return "moderate";
   return "stable";
 }
-var volatilityMapTool = tool10({
+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: tool10.schema.enum(["read", "write", "query_hotspots", "update_entry"]),
-    entries: tool10.schema.array(tool10.schema.object({
-      path: tool10.schema.string(),
-      churn_score: tool10.schema.number(),
-      hotfix_count: tool10.schema.number(),
-      todo_count: tool10.schema.number(),
-      last_breakage: tool10.schema.string().optional(),
-      notes: tool10.schema.array(tool10.schema.string())
+    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: tool10.schema.object({
-      path: tool10.schema.string(),
-      churn_score: tool10.schema.number(),
-      hotfix_count: tool10.schema.number(),
-      todo_count: tool10.schema.number(),
-      last_breakage: tool10.schema.string().optional(),
-      notes: tool10.schema.array(tool10.schema.string())
+    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: tool10.schema.enum(["stable", "moderate", "volatile", "critical"]).optional(),
-    path_prefix: tool10.schema.string().optional(),
-    limit: tool10.schema.number().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();
@@ -1196,7 +1091,7 @@ var volatilityMapTool = tool10({
 });
 
 // src/tools/policy-engine.ts
-import { tool as tool11 } from "@opencode-ai/plugin";
+import { tool as tool10 } 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";
 var POLICIES_FILE = "POLICIES.json";
@@ -1220,24 +1115,24 @@ function writeStore3(directory, store) {
   store.last_updated = new Date().toISOString();
   writeFileSync9(policiesPath(directory), JSON.stringify(store, null, 2), "utf-8");
 }
-var policyEngineTool = tool11({
+var policyEngineTool = tool10({
   description: "Self-Healing Policy Engine: manage .codebase/POLICIES.json — add, list, query, toggle, and record violations of editing policies learned from past failures",
   args: {
-    action: tool11.schema.enum(["list", "add", "record_violation", "toggle", "query"]),
-    policy: tool11.schema.object({
-      id: tool11.schema.string(),
-      name: tool11.schema.string(),
-      trigger: tool11.schema.string(),
-      rule: tool11.schema.string(),
-      source: tool11.schema.enum(["manual", "learned"]),
-      failure_count: tool11.schema.number()
+    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()
     }).optional(),
-    policy_id: tool11.schema.string().optional(),
-    active: tool11.schema.boolean().optional(),
-    query: tool11.schema.object({
-      source: tool11.schema.enum(["manual", "learned"]).optional(),
-      active_only: tool11.schema.boolean().optional(),
-      trigger_contains: tool11.schema.string().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()
     }).optional()
   },
   async execute(args, context) {
@@ -1299,16 +1194,16 @@ var policyEngineTool = tool11({
 });
 
 // src/tools/hash-edit.ts
-import { tool as tool12 } from "@opencode-ai/plugin";
+import { tool as tool11 } from "@opencode-ai/plugin";
 import { readFileSync as readFileSync10, writeFileSync as writeFileSync10 } from "fs";
 import { createHash } from "crypto";
-var hashEditTool = tool12({
+var hashEditTool = tool11({
   description: "Reliable file editing with content verification. Takes a target content, its expected MD5 hash, and replacement content. Only applies if the hash matches, preventing edits on stale file versions.",
   args: {
-    filePath: tool12.schema.string(),
-    targetContent: tool12.schema.string(),
-    expectedHash: tool12.schema.string().optional(),
-    replacementContent: tool12.schema.string()
+    filePath: tool11.schema.string(),
+    targetContent: tool11.schema.string(),
+    expectedHash: tool11.schema.string().optional(),
+    replacementContent: tool11.schema.string()
   },
   async execute(args, context) {
     const fullPath = args.filePath.startsWith("/") ? args.filePath : `${context.directory}/${args.filePath}`;
@@ -1334,13 +1229,13 @@ var hashEditTool = tool12({
 });
 
 // src/tools/council.ts
-import { tool as tool13 } from "@opencode-ai/plugin";
+import { tool as tool12 } from "@opencode-ai/plugin";
 function createCouncilTool(client) {
-  return tool13({
+  return tool12({
     description: "Run an ensemble of agents (Council) on the same task to reach consensus or compare approaches. Runs 3 specialized agents in parallel and returns their synthesized outputs.",
     args: {
-      task: tool13.schema.string(),
-      agents: tool13.schema.array(tool13.schema.string()).optional()
+      task: tool12.schema.string(),
+      agents: tool12.schema.array(tool12.schema.string()).optional()
     },
     async execute(args, context) {
       const agents = args.agents || ["architect", "reviewer", "coder"];
@@ -1396,14 +1291,14 @@ Please synthesize these results. Identify areas of agreement, resolve conflicts,
 }
 
 // src/tools/context-generator.ts
-import { tool as tool14 } from "@opencode-ai/plugin";
+import { tool as tool13 } 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";
-var contextGeneratorTool = tool14({
+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: tool14.schema.string().optional(),
-    force: tool14.schema.boolean().optional()
+    targetDir: tool13.schema.string().optional(),
+    force: tool13.schema.boolean().optional()
   },
   async execute(args, context) {
     const root = context.directory;
@@ -1452,18 +1347,18 @@ Generated by FlowDeck Context Generator.
 });
 
 // src/tools/create-skill.ts
-import { tool as tool15 } from "@opencode-ai/plugin";
+import { tool as tool14 } 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 { fileURLToPath } from "url";
 var SKILLS_DIR = join11(dirname3(fileURLToPath(import.meta.url)), "..", "skills");
-var createSkillTool = tool15({
+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: tool15.schema.string().describe("Unique kebab-case skill name, e.g. 'api-rate-limiting'"),
-    description: tool15.schema.string().describe("One-sentence description of what this skill does"),
-    content: tool15.schema.string().describe("Full skill body in Markdown. Must include: ## When to Activate, ## Steps, and ## Examples sections."),
-    tags: tool15.schema.array(tool15.schema.string()).optional().describe("Optional tags for categorisation, e.g. ['performance', 'typescript']")
+    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 = join11(SKILLS_DIR, args.name);
@@ -1495,7 +1390,7 @@ origin: FlowDeck (self-learned)${tagLine}
 });
 
 // src/tools/reflect.ts
-import { tool as tool16 } from "@opencode-ai/plugin";
+import { tool as tool15 } from "@opencode-ai/plugin";
 import { existsSync as existsSync12, readFileSync as readFileSync12 } from "fs";
 import { join as join12 } from "path";
 var MAX_ARTIFACT_BYTES = 4000;
@@ -1505,10 +1400,10 @@ function tail(text, maxBytes) {
   return `... (truncated) ...
 ` + text.slice(-maxBytes);
 }
-var reflectTool = tool16({
+var reflectTool = tool15({
   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: tool16.schema.enum(["session", "project"]).optional().describe("'session' (default) uses only recent artifacts; 'project' includes all historical data")
+    scope: tool15.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;
@@ -1549,14 +1444,399 @@ var reflectTool = tool16({
   }
 });
 
-// src/hooks/guard-rails.ts
-import { existsSync as existsSync13, readFileSync as readFileSync13 } from "fs";
+// src/tools/memory-search.ts
+import { tool as tool16 } from "@opencode-ai/plugin";
+
+// src/services/memory-store.ts
+import { Database } from "bun:sqlite";
+import { existsSync as existsSync13, mkdirSync as mkdirSync8 } from "fs";
 import { join as join13 } from "path";
+import { homedir } from "os";
+var MEMORY_DIR = join13(homedir(), ".flowdeck-memory");
+var DB_PATH = join13(MEMORY_DIR, "memory.db");
+function ensureDir() {
+  if (!existsSync13(MEMORY_DIR)) {
+    mkdirSync8(MEMORY_DIR, { recursive: true });
+  }
+}
+var db = null;
+function getDb() {
+  if (!db) {
+    ensureDir();
+    db = new Database(DB_PATH);
+    initializeSchema(db);
+  }
+  return db;
+}
+function initializeSchema(database) {
+  const schema = `
+    CREATE TABLE IF NOT EXISTS sessions (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      content_session_id TEXT NOT NULL UNIQUE,
+      project TEXT NOT NULL,
+      directory TEXT NOT NULL,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      last_active_at TEXT NOT NULL DEFAULT (datetime('now')),
+      summary TEXT,
+      prompt_count INTEGER DEFAULT 0
+    );
+
+    CREATE TABLE IF NOT EXISTS observations (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id INTEGER NOT NULL,
+      tool_name TEXT NOT NULL,
+      tool_input TEXT,
+      tool_response TEXT,
+      directory TEXT NOT NULL,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      FOREIGN KEY (session_id) REFERENCES sessions(id)
+    );
+
+    CREATE TABLE IF NOT EXISTS summaries (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id INTEGER NOT NULL UNIQUE,
+      content TEXT NOT NULL,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      FOREIGN KEY (session_id) REFERENCES sessions(id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_observations_session ON observations(session_id);
+    CREATE INDEX IF NOT EXISTS idx_observations_directory ON observations(directory);
+    CREATE INDEX IF NOT EXISTS idx_observations_tool ON observations(tool_name);
+    CREATE INDEX IF NOT EXISTS idx_sessions_project ON sessions(project);
+    CREATE INDEX IF NOT EXISTS idx_sessions_directory ON sessions(directory);
+  `;
+  database.run(schema);
+}
+function serializeToolInput(input) {
+  if (!input)
+    return null;
+  try {
+    return JSON.stringify(input);
+  } catch {
+    return String(input);
+  }
+}
+function parseToolInput(input) {
+  if (!input)
+    return null;
+  try {
+    return JSON.parse(input);
+  } catch {
+    return null;
+  }
+}
+function initSession(contentSessionId, project, directory) {
+  const database = getDb();
+  const now = new Date().toISOString();
+  const existing = database.prepare("SELECT * FROM sessions WHERE content_session_id = ?").get(contentSessionId);
+  if (existing) {
+    database.prepare("UPDATE sessions SET last_active_at = ?, prompt_count = prompt_count + 1 WHERE id = ?").run(now, existing.id);
+    return { ...existing, last_active_at: now, prompt_count: (existing.prompt_count || 0) + 1 };
+  }
+  const result = database.prepare("INSERT INTO sessions (content_session_id, project, directory, created_at, last_active_at) VALUES (?, ?, ?, ?, ?)").run(contentSessionId, project, directory, now, now);
+  return {
+    id: result.lastInsertRowid,
+    content_session_id: contentSessionId,
+    project,
+    directory,
+    created_at: now,
+    last_active_at: now,
+    prompt_count: 1
+  };
+}
+function storeObservation(sessionId, toolName, toolInput, toolResponse, directory) {
+  const database = getDb();
+  const now = new Date().toISOString();
+  const result = database.prepare("INSERT INTO observations (session_id, tool_name, tool_input, tool_response, directory, created_at) VALUES (?, ?, ?, ?, ?, ?)").run(sessionId, toolName, serializeToolInput(toolInput), toolResponse ? toolResponse.slice(0, 1e4) : null, directory, now);
+  database.prepare("UPDATE sessions SET last_active_at = ? WHERE id = ?").run(now, sessionId);
+  return {
+    id: result.lastInsertRowid,
+    session_id: sessionId,
+    tool_name: toolName,
+    tool_input: parseToolInput(serializeToolInput(toolInput)),
+    tool_response: toolResponse ? toolResponse.slice(0, 1e4) : null,
+    directory,
+    created_at: now
+  };
+}
+function storeSummary(sessionId, content) {
+  const database = getDb();
+  const now = new Date().toISOString();
+  database.prepare("INSERT OR REPLACE INTO summaries (session_id, content, created_at) VALUES (?, ?, ?)").run(sessionId, content, now);
+  database.prepare("UPDATE sessions SET summary = ? WHERE id = ?").run(content, sessionId);
+  return {
+    id: database.prepare("SELECT last_insert_rowid() as id").get().id,
+    session_id: sessionId,
+    content,
+    created_at: now
+  };
+}
+function getRecentSessions(directory, limit = 5) {
+  const database = getDb();
+  return database.prepare(`SELECT * FROM sessions
+       WHERE directory = ?
+       ORDER BY last_active_at DESC
+       LIMIT ?`).all(directory, limit);
+}
+function getObservationsForSession(sessionId) {
+  const database = getDb();
+  const observations = database.prepare("SELECT * FROM observations WHERE session_id = ? ORDER BY created_at ASC").all(sessionId);
+  return observations.map((obs) => ({
+    ...obs,
+    tool_input: parseToolInput(obs.tool_input)
+  }));
+}
+function getRecentObservations(directory, limit = 50) {
+  const database = getDb();
+  const rows = database.prepare(`SELECT o.*, s.project, s.content_session_id, s.created_at as session_created
+       FROM observations o
+       JOIN sessions s ON o.session_id = s.id
+       WHERE o.directory = ?
+       ORDER BY o.created_at DESC
+       LIMIT ?`).all(directory, limit);
+  return rows.map((row) => ({
+    observation: {
+      ...row,
+      tool_input: parseToolInput(row.tool_input)
+    },
+    session: {
+      content_session_id: row.content_session_id,
+      project: row.project,
+      directory,
+      created_at: row.session_created
+    }
+  }));
+}
+function searchObservations(directory, query, limit = 10) {
+  const database = getDb();
+  const pattern = `%${query}%`;
+  const rows = database.prepare(`SELECT o.*, s.project, s.content_session_id, s.created_at as session_created
+       FROM observations o
+       JOIN sessions s ON o.session_id = s.id
+       WHERE o.directory = ? AND (o.tool_name LIKE ? OR o.tool_input LIKE ? OR o.tool_response LIKE ?)
+       ORDER BY o.created_at DESC
+       LIMIT ?`).all(directory, pattern, pattern, pattern, limit);
+  return rows.map((row) => ({
+    observation: {
+      ...row,
+      tool_input: parseToolInput(row.tool_input)
+    },
+    session: {
+      content_session_id: row.content_session_id,
+      project: row.project,
+      directory,
+      created_at: row.session_created
+    }
+  }));
+}
+function getContextForDirectory(directory, maxObservations = 20) {
+  const recentObs = getRecentObservations(directory, maxObservations);
+  if (recentObs.length === 0)
+    return "";
+  const lines = ["## Recent Context"];
+  for (const { observation, session } of recentObs) {
+    const date = observation.created_at ? new Date(observation.created_at).toLocaleDateString() : "unknown";
+    lines.push(`
+### [${date}] ${session.project} - ${observation.tool_name}`);
+    if (observation.tool_input && Object.keys(observation.tool_input).length > 0) {
+      const preview = JSON.stringify(observation.tool_input).slice(0, 200);
+      lines.push(`Input: ${preview}${preview.length >= 200 ? "..." : ""}`);
+    }
+    if (observation.tool_response) {
+      const preview = observation.tool_response.slice(0, 300);
+      lines.push(`Output: ${preview}${observation.tool_response.length > 300 ? "..." : ""}`);
+    }
+  }
+  const summaries = getDb().prepare(`SELECT su.* FROM summaries su
+       JOIN sessions s ON su.session_id = s.id
+       WHERE s.directory = ?
+       ORDER BY su.created_at DESC
+       LIMIT 3`).all(directory);
+  if (summaries.length > 0) {
+    lines.push(`
+## Session Summaries`);
+    for (const sum of summaries) {
+      const date = sum.created_at ? new Date(sum.created_at).toLocaleDateString() : "unknown";
+      lines.push(`
+### [${date}]`);
+      lines.push(sum.content.slice(0, 500));
+    }
+  }
+  return lines.join(`
+`);
+}
+
+// src/tools/memory-search.ts
+var memorySearchTool = tool16({
+  description: "Search FlowDeck memory for past observations, sessions, and context. Use to recall what was worked on previously.",
+  args: {
+    query: tool16.schema.string().optional().describe("Search query for memory (searches tool names, inputs, and outputs)"),
+    session_id: tool16.schema.string().optional().describe("Specific session ID to retrieve observations from"),
+    limit: tool16.schema.number().optional().describe("Maximum number of results (default: 10)")
+  },
+  async execute(args, context) {
+    const directory = context.directory ?? process.cwd();
+    const limit = args.limit ?? 10;
+    if (args.session_id) {
+      const sessions2 = getRecentSessions(directory, 100);
+      const targetSession = sessions2.find((s) => String(s.id) === args.session_id || s.content_session_id === args.session_id);
+      if (!targetSession) {
+        return JSON.stringify({ error: "Session not found", session_id: args.session_id });
+      }
+      const observations = getObservationsForSession(targetSession.id);
+      return JSON.stringify({
+        session: targetSession,
+        observations: observations.map((o) => ({
+          tool_name: o.tool_name,
+          tool_input: o.tool_input,
+          tool_response: o.tool_response ? o.tool_response.slice(0, 500) + (o.tool_response.length > 500 ? "..." : "") : null,
+          created_at: o.created_at
+        }))
+      });
+    }
+    if (args.query) {
+      const results = searchObservations(directory, args.query, limit);
+      if (results.length === 0) {
+        return JSON.stringify({ message: `No results found for "${args.query}"`, results: [] });
+      }
+      return JSON.stringify({
+        query: args.query,
+        count: results.length,
+        results: results.map(({ observation, session }) => ({
+          tool_name: observation.tool_name,
+          tool_input: observation.tool_input,
+          tool_response: observation.tool_response ? observation.tool_response.slice(0, 300) + (observation.tool_response.length > 300 ? "..." : "") : null,
+          project: session.project,
+          date: observation.created_at
+        }))
+      });
+    }
+    const sessions = getRecentSessions(directory, limit);
+    if (sessions.length === 0) {
+      return JSON.stringify({ message: "No previous sessions found in this directory", sessions: [] });
+    }
+    return JSON.stringify({
+      message: "Recent sessions",
+      count: sessions.length,
+      sessions: sessions.map((s) => ({
+        id: s.id,
+        content_session_id: s.content_session_id,
+        project: s.project,
+        created_at: s.created_at,
+        last_active_at: s.last_active_at,
+        summary: s.summary
+      }))
+    });
+  }
+});
+
+// src/hooks/memory-hook.ts
+var MAX_TOOL_RESPONSE = 1e4;
+var MAX_PROMPT_LENGTH = 2000;
+var activeSessions = new Map;
+function extractProjectFromDirectory(directory) {
+  const parts = directory.split("/");
+  return parts[parts.length - 1] || "unknown";
+}
+function truncate(str, max) {
+  if (!str || str.length <= max)
+    return str || "";
+  return str.slice(0, max);
+}
+function onSessionCreated(directory, contentSessionId, prompt) {
+  const project = extractProjectFromDirectory(directory);
+  const session = initSession(contentSessionId, project, directory);
+  activeSessions.set(contentSessionId, {
+    sessionId: session.id,
+    contentSessionId,
+    project,
+    directory
+  });
+  return session;
+}
+function onToolExecuted(contentSessionId, toolName, toolInput, toolResponse, directory) {
+  let ctx = activeSessions.get(contentSessionId);
+  if (!ctx) {
+    const project = extractProjectFromDirectory(directory);
+    const session = initSession(contentSessionId, project, directory);
+    ctx = {
+      sessionId: session.id,
+      contentSessionId,
+      project,
+      directory
+    };
+    activeSessions.set(contentSessionId, ctx);
+  }
+  storeObservation(ctx.sessionId, truncate(toolName, 200), toolInput, toolResponse ? truncate(toolResponse, MAX_TOOL_RESPONSE) : null, directory);
+}
+function onMessageUpdated(contentSessionId, role, content, directory) {
+  if (role !== "assistant")
+    return;
+  if (!content || !content.trim())
+    return;
+  let ctx = activeSessions.get(contentSessionId);
+  if (!ctx) {
+    const project = extractProjectFromDirectory(directory);
+    const session = initSession(contentSessionId, project, directory);
+    ctx = {
+      sessionId: session.id,
+      contentSessionId,
+      project,
+      directory
+    };
+    activeSessions.set(contentSessionId, ctx);
+  }
+  storeObservation(ctx.sessionId, "assistant_message", { role }, truncate(content, MAX_TOOL_RESPONSE), directory);
+}
+function onSessionCompact(contentSessionId, summary) {
+  const ctx = activeSessions.get(contentSessionId);
+  if (!ctx)
+    return;
+  storeSummary(ctx.sessionId, truncate(summary, MAX_PROMPT_LENGTH));
+}
+function onSessionEnd(contentSessionId, lastMessage) {
+  const ctx = activeSessions.get(contentSessionId);
+  if (!ctx)
+    return;
+  if (lastMessage && lastMessage.trim()) {
+    storeSummary(ctx.sessionId, truncate(lastMessage, MAX_PROMPT_LENGTH));
+  }
+  activeSessions.delete(contentSessionId);
+}
+function getSessionContext(directory, contentSessionId) {
+  const context = getContextForDirectory(directory, 30);
+  const previousSessions = getRecentSessions(directory, 5);
+  if (previousSessions.length > 0 && activeSessions.has(contentSessionId)) {
+    const ctx = activeSessions.get(contentSessionId);
+    for (const prev of previousSessions) {
+      if (prev.content_session_id === contentSessionId)
+        continue;
+    }
+  }
+  return { context, previousSessions };
+}
+function clearSession(contentSessionId) {
+  activeSessions.delete(contentSessionId);
+}
+var memoryHook = {
+  onSessionCreated,
+  onToolExecuted,
+  onMessageUpdated,
+  onSessionCompact,
+  onSessionEnd,
+  getSessionContext,
+  clearSession
+};
+
+// src/hooks/guard-rails.ts
+import { existsSync as existsSync14, readFileSync as readFileSync13 } from "fs";
+import { join as join14 } 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"));
       if (config.execution_mode === "review-only")
@@ -1609,22 +1889,22 @@ var BUILD_DEPLOY_PATTERNS = [
 ];
 async function guardRailsHook(ctx, input, _output) {
   const dir = ctx.directory;
-  const planningDirPath = join13(dir, PLANNING_DIR2);
+  const planningDirPath = join14(dir, PLANNING_DIR2);
   const codebaseDirectory = codebaseDir(dir);
-  const configPath = join13(planningDirPath, CONFIG_FILE);
-  const statePath2 = join13(planningDirPath, STATE_FILE2);
+  const configPath = join14(planningDirPath, CONFIG_FILE);
+  const statePath2 = join14(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,7 +1939,7 @@ async function guardRailsHook(ctx, input, _output) {
   }
 }
 function effectiveSeverity(configPath, statePath2) {
-  if (existsSync13(configPath)) {
+  if (existsSync14(configPath)) {
     try {
       const configContent = readFileSync13(configPath, "utf-8");
       const config = JSON.parse(configContent);
@@ -1677,7 +1957,7 @@ 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");
@@ -1688,21 +1968,21 @@ function getPlanConfirmed(statePath2) {
   }
 }
 function getWarningMessage(statePath2, planningDir3) {
-  if (!existsSync13(join13(planningDir3, STATE_FILE2))) {
+  if (!existsSync14(join14(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(join14(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 readFileSync14 } from "fs";
+import { join as join15 } from "path";
 var BLOCKED_PATTERNS = {
   read: [".env", ".pem", ".key", ".secret"],
   write: ["node_modules"],
@@ -1748,8 +2028,8 @@ function isBlocked(tool17, args) {
   return null;
 }
 function checkArchConstraint(directory, filePath) {
-  const constraintsPath = join14(codebaseDir(directory), "CONSTRAINTS.md");
-  if (!existsSync14(constraintsPath))
+  const constraintsPath = join15(codebaseDir(directory), "CONSTRAINTS.md");
+  if (!existsSync15(constraintsPath))
     return null;
   try {
     const content = readFileSync14(constraintsPath, "utf-8");
@@ -1797,18 +2077,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 readFileSync15 } 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,
@@ -1827,7 +2107,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 +2122,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 +2188,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 readFileSync16 } from "fs";
+import { join as join16 } from "path";
 var HIGH_RISK_KEYWORDS = [
   "password",
   "secret",
@@ -1931,8 +2211,8 @@ var HIGH_RISK_KEYWORDS = [
   "privilege"
 ];
 function loadVolatility(directory) {
-  const p = join15(codebaseDir(directory), "VOLATILITY.json");
-  if (!existsSync16(p))
+  const p = join16(codebaseDir(directory), "VOLATILITY.json");
+  if (!existsSync17(p))
     return {};
   try {
     const data = JSON.parse(readFileSync16(p, "utf-8"));
@@ -1945,8 +2225,8 @@ function loadVolatility(directory) {
   }
 }
 function loadFailedPaths(directory) {
-  const p = join15(codebaseDir(directory), "FAILURES.json");
-  if (!existsSync16(p))
+  const p = join16(codebaseDir(directory), "FAILURES.json");
+  if (!existsSync17(p))
     return [];
   try {
     const data = JSON.parse(readFileSync16(p, "utf-8"));
@@ -2006,8 +2286,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 appendFileSync2 } from "fs";
+import { join as join17 } from "path";
 async function decisionTraceHook(ctx, input, output) {
   if (input.tool !== "write" && input.tool !== "edit")
     return;
@@ -2016,8 +2296,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,22 +2309,24 @@ async function decisionTraceHook(ctx, input, output) {
       risk_level: "unknown",
       auto_recorded: true
     };
-    appendFileSync2(join16(base, "DECISIONS.jsonl"), JSON.stringify(entry) + `
+    appendFileSync2(join17(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 { existsSync as existsSync19, readFileSync as readFileSync17, appendFileSync as appendFileSync3, mkdirSync as mkdirSync10 } from "fs";
+import { join as join18 } from "path";
 import { randomUUID } from "crypto";
 function telemetryPath(dir) {
-  return join17(codebaseDir(dir), "TELEMETRY.jsonl");
+  return join18(codebaseDir(dir), "TELEMETRY.jsonl");
 }
 function appendEvent(dir, partial) {
+  if (process.env.TELEMETRY_ENABLED !== "true")
+    return null;
   const cd = codebaseDir(dir);
-  if (!existsSync18(cd))
-    mkdirSync9(cd, { recursive: true });
+  if (!existsSync19(cd))
+    mkdirSync10(cd, { recursive: true });
   const event = {
     id: randomUUID(),
     ts: new Date().toISOString(),
@@ -2081,8 +2363,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 existsSync20, readFileSync as readFileSync18, writeFileSync as writeFileSync13, mkdirSync as mkdirSync11 } from "fs";
+import { join as join19 } from "path";
 var APPROVAL_TTL_MS = 30 * 60 * 1000;
 var SENSITIVE_PATTERNS = [
   /auth/i,
@@ -2119,11 +2401,11 @@ 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);
-  if (!existsSync19(p))
+  if (!existsSync20(p))
     return { requests: [] };
   try {
     return JSON.parse(readFileSync18(p, "utf-8"));
@@ -2218,8 +2500,8 @@ function createContextWindowMonitorHook() {
 }
 
 // src/hooks/shell-env-hook.ts
-import { existsSync as existsSync20, readFileSync as readFileSync19 } from "fs";
-import { join as join19 } from "path";
+import { existsSync as existsSync21, readFileSync as readFileSync19 } from "fs";
+import { join as join20 } from "path";
 import { createRequire } from "module";
 var _version;
 function getVersion() {
@@ -2255,7 +2537,7 @@ var MARKER_TO_LANG = {
 };
 function detectPackageManager(root) {
   for (const [lockfile, pm] of Object.entries(LOCKFILE_TO_PM)) {
-    if (existsSync20(join19(root, lockfile)))
+    if (existsSync21(join20(root, lockfile)))
       return pm;
   }
   return;
@@ -2264,7 +2546,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) && existsSync21(join20(root, marker))) {
       langs.push(lang);
       seen.add(lang);
     }
@@ -2272,8 +2554,8 @@ function detectLanguages(root) {
   return langs;
 }
 function readCurrentPhase(root) {
-  const statePath2 = join19(root, ".planning", "STATE.md");
-  if (!existsSync20(statePath2))
+  const statePath2 = join20(root, ".planning", "STATE.md");
+  if (!existsSync21(statePath2))
     return;
   try {
     const content = readFileSync19(statePath2, "utf-8");
@@ -2306,7 +2588,8 @@ function createShellEnvHook(ctx) {
 // src/hooks/todo-hook.ts
 function createTodoHook(client) {
   return async (event) => {
-    const todos = event.todos ?? [];
+    const rawTodos = event.todos;
+    const todos = Array.isArray(rawTodos) ? rawTodos : [];
     const completed = todos.filter((t) => t.done || t.status === "completed").length;
     const total = todos.length;
     if (total === 0)
@@ -2375,8 +2658,8 @@ 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 { existsSync as existsSync22, readFileSync as readFileSync20 } from "fs";
+import { join as join21 } from "path";
 var STRUCTURED_SUMMARY_PROMPT = `
 When summarizing this session, you MUST include the following sections:
 
@@ -2415,8 +2698,8 @@ 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");
-  if (!existsSync21(statePath2))
+  const statePath2 = join21(directory, ".planning", "STATE.md");
+  if (!existsSync22(statePath2))
     return null;
   try {
     const content = readFileSync20(statePath2, "utf-8");
@@ -2453,7 +2736,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",
@@ -2474,7 +2757,6 @@ var BLOCKED_TOOLS = new Set([
 ]);
 var ALWAYS_ALLOWED = new Set([
   "delegate",
-  "run-parallel",
   "run-pipeline",
   "council",
   "planning-state",
@@ -2509,7 +2791,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 {
@@ -5513,21 +5795,21 @@ function getAgentConfigs(agentModels) {
 }
 
 // src/config/loader.ts
-import { existsSync as existsSync22, readFileSync as readFileSync21 } from "fs";
-import { join as join21 } from "path";
-import { homedir } from "os";
+import { existsSync as existsSync23, readFileSync as readFileSync21 } from "fs";
+import { join as join22 } from "path";
+import { homedir as homedir2 } from "os";
 var CONFIG_FILENAME = "flowdeck.json";
 function getGlobalConfigDir() {
-  return process.env.OPENCODE_CONFIG_DIR || (process.env.XDG_CONFIG_HOME ? 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(homedir2(), ".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)) {
+    if (existsSync23(configPath)) {
       try {
         const content = readFileSync21(configPath, "utf-8");
         return JSON.parse(content);
@@ -5539,10 +5821,29 @@ function loadFlowDeckConfig(directory) {
   return {};
 }
 // src/index.ts
+function loadRulePaths() {
+  const __dir = dirname4(fileURLToPath2(import.meta.url));
+  const rulesDir = join23(__dir, "..", "src", "rules");
+  if (!existsSync24(rulesDir))
+    return [];
+  const paths = [];
+  function walk(dir) {
+    for (const entry of readdirSync3(dir, { withFileTypes: true })) {
+      const full = join23(dir, entry.name);
+      if (entry.isDirectory()) {
+        walk(full);
+      } else if (entry.isFile() && entry.name.endsWith(".md") && entry.name !== "README.md") {
+        paths.push(full);
+      }
+    }
+  }
+  walk(rulesDir);
+  return paths;
+}
 function loadCommands() {
   const __dir = dirname4(fileURLToPath2(import.meta.url));
-  const commandsDir = join22(__dir, "..", "src", "commands");
-  if (!existsSync23(commandsDir))
+  const commandsDir = join23(__dir, "..", "src", "commands");
+  if (!existsSync24(commandsDir))
     return {};
   const commands = {};
   try {
@@ -5550,7 +5851,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]*)$/);
@@ -5567,7 +5868,6 @@ function loadCommands() {
 }
 var plugin = async (input, _options) => {
   const { directory, client, worktree } = input;
-  const runParallelTool = createRunParallelTool(client);
   const runPipelineTool = createRunPipelineTool(client);
   const delegateTool = createDelegateTool(client);
   const councilTool = createCouncilTool(client);
@@ -5628,8 +5928,8 @@ var plugin = async (input, _options) => {
           }
         }
       }
-      const skillsDir = join22(dirname4(fileURLToPath2(import.meta.url)), "..", "src", "skills");
-      if (existsSync23(skillsDir)) {
+      const skillsDir = join23(dirname4(fileURLToPath2(import.meta.url)), "..", "src", "skills");
+      if (existsSync24(skillsDir)) {
         const cfgAny = cfg;
         if (!cfgAny.skills || typeof cfgAny.skills !== "object") {
           cfgAny.skills = { paths: [] };
@@ -5641,12 +5941,23 @@ var plugin = async (input, _options) => {
           cfgSkills.paths.push(skillsDir);
         }
       }
+      const rulePaths = loadRulePaths();
+      if (rulePaths.length > 0) {
+        if (!Array.isArray(cfg.instructions)) {
+          cfg.instructions = [];
+        }
+        const existing = new Set(cfg.instructions);
+        for (const p of rulePaths) {
+          if (!existing.has(p)) {
+            cfg.instructions.push(p);
+          }
+        }
+      }
     },
     tool: {
       "planning-state": planningStateTool,
       "codebase-state": codebaseStateTool,
       "workspace-state": workspaceStateTool,
-      "run-parallel": runParallelTool,
       "run-pipeline": runPipelineTool,
       delegate: delegateTool,
       "repo-memory": repoMemoryTool,
@@ -5658,7 +5969,8 @@ var plugin = async (input, _options) => {
       council: councilTool,
       "context-generator": contextGeneratorTool,
       "create-skill": createSkillTool,
-      reflect: reflectTool
+      reflect: reflectTool,
+      "memory-search": memorySearchTool
     },
     "shell.env": shellEnvHook,
     "todo.updated": todoHook,
@@ -5670,11 +5982,34 @@ var plugin = async (input, _options) => {
     },
     event: async ({ event }) => {
       const type = event?.type ?? "";
-      await contextMonitor.event({ event });
-      orchestratorGuard.onEvent(event);
       if (type === "session.created" || type === "session.started") {
+        const sessionId = event?.sessionID ?? event?.sessionId ?? "";
+        if (sessionId) {
+          memoryHook.onSessionCreated(directory, sessionId, event?.prompt);
+        }
         await sessionStartHook({ directory });
-      } else if (type === "session.idle") {
+      } else if (type === "message.updated" && event?.event) {
+        const msgEvent = event.event;
+        const sessionId = msgEvent?.sessionID ?? msgEvent?.sessionId ?? "";
+        if (sessionId) {
+          memoryHook.onMessageUpdated(sessionId, msgEvent.role, msgEvent.content, directory);
+        }
+      } else if (type === "session.compacted" && event?.event) {
+        const compactEvent = event.event;
+        const sessionId = compactEvent?.sessionID ?? compactEvent?.sessionId ?? "";
+        if (sessionId) {
+          memoryHook.onSessionCompact(sessionId, compactEvent.summary ?? "");
+        }
+      } else if (type === "session.deleted" && event?.event) {
+        const delEvent = event.event;
+        const sessionId = delEvent?.sessionID ?? delEvent?.sessionId ?? "";
+        if (sessionId) {
+          memoryHook.clearSession(sessionId);
+        }
+      }
+      await contextMonitor.event({ event });
+      orchestratorGuard.onEvent(event);
+      if (type === "session.idle") {
         await sessionIdleHook();
         await autoLearnHook();
       }
@@ -5690,6 +6025,10 @@ var plugin = async (input, _options) => {
     },
     "tool.execute.after": async (toolInput, toolOutput) => {
       await telemetryAfterHook({ directory }, toolInput, toolOutput);
+      const sessionId = toolInput?.sessionID ?? toolInput?.sessionId ?? "";
+      if (sessionId && toolInput?.tool) {
+        memoryHook.onToolExecuted(sessionId, toolInput.tool, toolInput, toolOutput?.output ?? null, directory);
+      }
       await contextMonitor["tool.execute.after"](toolInput, toolOutput);
     }
   };