@dv.nghiem/flowdeck 0.2.4 → 0.3.1

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/index.ts
-import { readdirSync as readdirSync3, readFileSync as readFileSync22, existsSync as existsSync23 } from "fs";
+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,198 +507,22 @@ var workspaceStateTool = tool3({
   }
 });
 
-// src/tools/run-parallel.ts
+// src/tools/run-pipeline.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(`
 `);
 }
-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 dir = context.directory ?? process.cwd();
-      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);
-        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}
-
----
-
-${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) {
-          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,
-            success: false,
-            error: `Prompt failed: ${promptRes.error?.detail ?? "unknown"}`,
-            duration_ms: Date.now() - taskStart
-          };
-        }
-        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,
-            success: false,
-            error: `Agent error: ${JSON.stringify(info.error)}`,
-            duration_ms: Date.now() - taskStart
-          };
-        }
-        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,
-          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
-        };
-      });
-      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,
-        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();
@@ -771,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;
         }
@@ -788,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();
@@ -855,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,
@@ -868,53 +692,53 @@ ${args.prompt}` : args.prompt;
 }
 
 // src/tools/repo-memory.ts
-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 join7 } from "path";
+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";
 function memoryPath(directory) {
-  return join7(codebaseDir(directory), MEMORY_FILE);
+  return join5(codebaseDir(directory), MEMORY_FILE);
 }
 function emptyMemory() {
   return { version: "1.0", last_updated: new Date().toISOString(), nodes: {} };
 }
 function readMemory(directory) {
   const p = memoryPath(directory);
-  if (!existsSync6(p))
+  if (!existsSync5(p))
     return emptyMemory();
   try {
-    return JSON.parse(readFileSync6(p, "utf-8"));
+    return JSON.parse(readFileSync5(p, "utf-8"));
   } catch {
     return emptyMemory();
   }
 }
 function writeMemory(directory, memory) {
   const base = codebaseDir(directory);
-  if (!existsSync6(base))
-    mkdirSync3(base, { recursive: true });
+  if (!existsSync5(base))
+    mkdirSync2(base, { recursive: true });
   memory.last_updated = new Date().toISOString();
-  writeFileSync6(memoryPath(directory), JSON.stringify(memory, null, 2), "utf-8");
+  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) {
@@ -969,50 +793,50 @@ var repoMemoryTool = tool7({
 });
 
 // src/tools/failure-replay.ts
-import { tool as tool8 } from "@opencode-ai/plugin";
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync7, existsSync as existsSync7, mkdirSync as mkdirSync4 } from "fs";
-import { join as join8 } from "path";
+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";
 function failuresPath(directory) {
-  return join8(codebaseDir(directory), FAILURES_FILE);
+  return join6(codebaseDir(directory), FAILURES_FILE);
 }
 function readStore(directory) {
   const p = failuresPath(directory);
-  if (!existsSync7(p))
+  if (!existsSync6(p))
     return { version: "1.0", last_updated: new Date().toISOString(), entries: [] };
   try {
-    return JSON.parse(readFileSync7(p, "utf-8"));
+    return JSON.parse(readFileSync6(p, "utf-8"));
   } catch {
     return { version: "1.0", last_updated: new Date().toISOString(), entries: [] };
   }
 }
 function writeStore(directory, store) {
   const base = codebaseDir(directory);
-  if (!existsSync7(base))
-    mkdirSync4(base, { recursive: true });
+  if (!existsSync6(base))
+    mkdirSync3(base, { recursive: true });
   store.last_updated = new Date().toISOString();
-  writeFileSync7(failuresPath(directory), JSON.stringify(store, null, 2), "utf-8");
+  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();
@@ -1074,18 +898,18 @@ var failureReplayTool = tool8({
 });
 
 // src/tools/decision-trace.ts
-import { tool as tool9 } from "@opencode-ai/plugin";
-import { readFileSync as readFileSync8, existsSync as existsSync8, mkdirSync as mkdirSync5, appendFileSync as appendFileSync2 } from "fs";
-import { join as join9 } from "path";
+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";
 function decisionsPath(directory) {
-  return join9(codebaseDir(directory), DECISIONS_FILE);
+  return join7(codebaseDir(directory), DECISIONS_FILE);
 }
 function readDecisions(directory) {
   const p = decisionsPath(directory);
-  if (!existsSync8(p))
+  if (!existsSync7(p))
     return [];
-  return readFileSync8(p, "utf-8").split(`
+  return readFileSync7(p, "utf-8").split(`
 `).filter((l) => l.trim()).map((l) => {
     try {
       return JSON.parse(l);
@@ -1094,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();
@@ -1125,10 +949,10 @@ var decisionTraceTool = tool9({
       case "record": {
         if (!args.entry)
           return JSON.stringify({ error: "entry required" });
-        if (!existsSync8(base))
-          mkdirSync5(base, { recursive: true });
+        if (!existsSync7(base))
+          mkdirSync4(base, { recursive: true });
         const entry = { ...args.entry, timestamp: new Date().toISOString() };
-        appendFileSync2(decisionsPath(dir), JSON.stringify(entry) + `
+        appendFileSync(decisionsPath(dir), JSON.stringify(entry) + `
 `, "utf-8");
         return JSON.stringify({ success: true, id: args.entry.id });
       }
@@ -1159,29 +983,29 @@ var decisionTraceTool = tool9({
 });
 
 // src/tools/volatility-map.ts
-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 join10 } from "path";
+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";
 function volatilityPath(directory) {
-  return join10(codebaseDir(directory), VOLATILITY_FILE);
+  return join8(codebaseDir(directory), VOLATILITY_FILE);
 }
 function readStore2(directory) {
   const p = volatilityPath(directory);
-  if (!existsSync9(p))
+  if (!existsSync8(p))
     return { version: "1.0", last_updated: new Date().toISOString(), generated_at: new Date().toISOString(), entries: [] };
   try {
-    return JSON.parse(readFileSync9(p, "utf-8"));
+    return JSON.parse(readFileSync8(p, "utf-8"));
   } catch {
     return { version: "1.0", last_updated: new Date().toISOString(), generated_at: new Date().toISOString(), entries: [] };
   }
 }
 function writeStore2(directory, store) {
   const base = codebaseDir(directory);
-  if (!existsSync9(base))
-    mkdirSync6(base, { recursive: true });
+  if (!existsSync8(base))
+    mkdirSync5(base, { recursive: true });
   store.last_updated = new Date().toISOString();
-  writeFileSync9(volatilityPath(directory), JSON.stringify(store, null, 2), "utf-8");
+  writeFileSync8(volatilityPath(directory), JSON.stringify(store, null, 2), "utf-8");
 }
 function stabilityLabel(churn, hotfixes, todos) {
   const score = churn + hotfixes * 10 + todos * 2;
@@ -1193,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();
@@ -1267,48 +1091,48 @@ var volatilityMapTool = tool10({
 });
 
 // src/tools/policy-engine.ts
-import { tool as tool11 } from "@opencode-ai/plugin";
-import { readFileSync as readFileSync10, writeFileSync as writeFileSync10, existsSync as existsSync10, mkdirSync as mkdirSync7 } from "fs";
-import { join as join11 } from "path";
+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";
 function policiesPath(directory) {
-  return join11(codebaseDir(directory), POLICIES_FILE);
+  return join9(codebaseDir(directory), POLICIES_FILE);
 }
 function readStore3(directory) {
   const p = policiesPath(directory);
-  if (!existsSync10(p))
+  if (!existsSync9(p))
     return { version: "1.0", last_updated: new Date().toISOString(), policies: [] };
   try {
-    return JSON.parse(readFileSync10(p, "utf-8"));
+    return JSON.parse(readFileSync9(p, "utf-8"));
   } catch {
     return { version: "1.0", last_updated: new Date().toISOString(), policies: [] };
   }
 }
 function writeStore3(directory, store) {
   const base = codebaseDir(directory);
-  if (!existsSync10(base))
-    mkdirSync7(base, { recursive: true });
+  if (!existsSync9(base))
+    mkdirSync6(base, { recursive: true });
   store.last_updated = new Date().toISOString();
-  writeFileSync10(policiesPath(directory), JSON.stringify(store, null, 2), "utf-8");
+  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) {
@@ -1370,22 +1194,22 @@ var policyEngineTool = tool11({
 });
 
 // src/tools/hash-edit.ts
-import { tool as tool12 } from "@opencode-ai/plugin";
-import { readFileSync as readFileSync11, writeFileSync as writeFileSync11 } from "fs";
+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}`;
     let content;
     try {
-      content = readFileSync11(fullPath, "utf-8");
+      content = readFileSync10(fullPath, "utf-8");
     } catch (e) {
       return `Error: Could not read file ${args.filePath}`;
     }
@@ -1399,19 +1223,19 @@ var hashEditTool = tool12({
       }
     }
     const newContent = content.replace(args.targetContent, args.replacementContent);
-    writeFileSync11(fullPath, newContent, "utf-8");
+    writeFileSync10(fullPath, newContent, "utf-8");
     return `Successfully updated ${args.filePath} using hash-anchored edit.`;
   }
 });
 
 // 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"];
@@ -1467,31 +1291,31 @@ 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 writeFileSync12, existsSync as existsSync11, readFileSync as readFileSync12, readdirSync as readdirSync2, statSync } from "fs";
-import { join as join12 } from "path";
-var contextGeneratorTool = tool14({
+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 = 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;
-    const target = args.targetDir ? join12(root, args.targetDir) : root;
-    if (!existsSync11(target)) {
+    const target = args.targetDir ? join10(root, args.targetDir) : root;
+    if (!existsSync10(target)) {
       return `Error: Directory ${target} does not exist.`;
     }
-    const agentsMdPath = join12(target, "AGENTS.md");
-    if (existsSync11(agentsMdPath) && !args.force) {
+    const agentsMdPath = join10(target, "AGENTS.md");
+    if (existsSync10(agentsMdPath) && !args.force) {
       return `AGENTS.md already exists in ${target}. Use force: true to overwrite.`;
     }
-    const pkgPath = join12(root, "package.json");
+    const pkgPath = join10(root, "package.json");
     let projectName = "Project";
     let techStack = "Unknown";
-    if (existsSync11(pkgPath)) {
+    if (existsSync10(pkgPath)) {
       try {
-        const pkg = JSON.parse(readFileSync12(pkgPath, "utf-8"));
+        const pkg = JSON.parse(readFileSync11(pkgPath, "utf-8"));
         projectName = pkg.name || projectName;
         techStack = Object.keys(pkg.dependencies || {}).slice(0, 5).join(", ");
       } catch {}
@@ -1509,7 +1333,7 @@ var contextGeneratorTool = tool14({
 
 ## Directory Map
 ${readdirSync2(target).slice(0, 10).map((f) => {
-      const s = statSync(join12(target, f));
+      const s = statSync(join10(target, f));
       return `- \`${f}\`${s.isDirectory() ? "/" : ""} : [Description]`;
     }).join(`
 `)}
@@ -1517,29 +1341,29 @@ ${readdirSync2(target).slice(0, 10).map((f) => {
 ---
 Generated by FlowDeck Context Generator.
 `;
-    writeFileSync12(agentsMdPath, content, "utf-8");
+    writeFileSync11(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 mkdirSync8, writeFileSync as writeFileSync13, existsSync as existsSync12 } from "fs";
-import { join as join13, dirname as dirname3 } from "path";
+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 = join13(dirname3(fileURLToPath(import.meta.url)), "..", "skills");
-var createSkillTool = tool15({
+var SKILLS_DIR = join11(dirname3(fileURLToPath(import.meta.url)), "..", "skills");
+var createSkillTool = tool14({
   description: "Create a new reusable skill in the FlowDeck skill library (src/skills/). " + "Use this when you discover a repeatable pattern, solve a novel problem with human guidance, " + "or want to capture domain knowledge for future sessions.",
   args: {
-    name: 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 = join13(SKILLS_DIR, args.name);
-    const skillFile = join13(skillDir, "SKILL.md");
-    if (existsSync12(skillFile)) {
+    const skillDir = join11(SKILLS_DIR, args.name);
+    const skillFile = join11(skillDir, "SKILL.md");
+    if (existsSync11(skillFile)) {
       return `Skill '${args.name}' already exists at ${skillFile}.
 ` + `Use a different name or delete the existing skill directory first.`;
     }
@@ -1554,8 +1378,8 @@ origin: FlowDeck (self-learned)${tagLine}
 `;
     const fullContent = frontmatter + args.content.trimStart();
     try {
-      mkdirSync8(skillDir, { recursive: true });
-      writeFileSync13(skillFile, fullContent, "utf-8");
+      mkdirSync7(skillDir, { recursive: true });
+      writeFileSync12(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.`;
@@ -1566,9 +1390,9 @@ origin: FlowDeck (self-learned)${tagLine}
 });
 
 // src/tools/reflect.ts
-import { tool as tool16 } from "@opencode-ai/plugin";
-import { existsSync as existsSync13, readFileSync as readFileSync13 } from "fs";
-import { join as join14 } from "path";
+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;
 function tail(text, maxBytes) {
   if (text.length <= maxBytes)
@@ -1576,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;
@@ -1597,11 +1421,11 @@ var reflectTool = tool16({
     ];
     let found = 0;
     for (const [rel, label] of ARTIFACT_PATHS) {
-      const full = join14(root, rel);
-      if (!existsSync13(full))
+      const full = join12(root, rel);
+      if (!existsSync12(full))
         continue;
       try {
-        const raw = readFileSync13(full, "utf-8").trim();
+        const raw = readFileSync12(full, "utf-8").trim();
         if (!raw)
           continue;
         const count = raw.split(`
@@ -1620,16 +1444,401 @@ var reflectTool = tool16({
   }
 });
 
+// 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 readFileSync14 } from "fs";
-import { join as join15 } from "path";
+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 (existsSync14(configPath)) {
     try {
-      const config = JSON.parse(readFileSync14(configPath, "utf-8"));
+      const config = JSON.parse(readFileSync13(configPath, "utf-8"));
       if (config.execution_mode === "review-only")
         return "review-only";
       if (config.execution_mode === "guarded")
@@ -1678,12 +1887,15 @@ var BUILD_DEPLOY_PATTERNS = [
   "rails deploy",
   "rake deploy"
 ];
+var ENABLED = process.env.FLOWDECK_GUARD_RAILS_ENABLED === "on";
 async function guardRailsHook(ctx, input, _output) {
+  if (!ENABLED)
+    return;
   const dir = ctx.directory;
-  const planningDirPath = join15(dir, PLANNING_DIR2);
+  const planningDirPath = join14(dir, PLANNING_DIR2);
   const codebaseDirectory = codebaseDir(dir);
-  const configPath = join15(planningDirPath, CONFIG_FILE);
-  const statePath2 = join15(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);
@@ -1709,11 +1921,10 @@ async function guardRailsHook(ctx, input, _output) {
     if (effectiveSeverity === null)
       return;
     if (effectiveSeverity === "warn") {
-      const warning = getWarningMessage(statePath2, planningDirPath);
+      const warning = getWarningMessage(planningDirPath);
       throw new Error(`[flowdeck] WARNING: ${warning}`);
-      return;
     }
-    const blockMessage = getBlockMessage(statePath2, planningDirPath);
+    const blockMessage = getBlockMessage(planningDirPath);
     throw new Error(`[flowdeck] BLOCK: ${blockMessage}`);
   }
   if (input.tool === "bash") {
@@ -1721,7 +1932,6 @@ async function guardRailsHook(ctx, input, _output) {
     for (const pattern of BUILD_DEPLOY_PATTERNS) {
       if (cmd.includes(pattern)) {
         if (!getPlanConfirmed(statePath2)) {
-          const msg = "Build/deploy command detected but plan is not confirmed. Run /plan first.";
           throw new Error(`[flowdeck] WARNING: Build/deploy command detected but plan is not confirmed. Run /plan first.`);
         }
         break;
@@ -1732,7 +1942,7 @@ async function guardRailsHook(ctx, input, _output) {
 function effectiveSeverity(configPath, statePath2) {
   if (existsSync14(configPath)) {
     try {
-      const configContent = readFileSync14(configPath, "utf-8");
+      const configContent = readFileSync13(configPath, "utf-8");
       const config = JSON.parse(configContent);
       if (config.guard_enforcement === "warn")
         return "warn";
@@ -1751,29 +1961,30 @@ function getPlanConfirmed(statePath2) {
   if (!existsSync14(statePath2))
     return false;
   try {
-    const content = readFileSync14(statePath2, "utf-8");
+    const content = readFileSync13(statePath2, "utf-8");
     const match = content.match(/plan_confirmed:\s*(true|false)/i);
     return match ? match[1].toLowerCase() === "true" : false;
   } catch {
     return false;
   }
 }
-function getWarningMessage(statePath2, planningDir3) {
-  if (!existsSync14(join15(planningDir3, STATE_FILE2))) {
+function getWarningMessage(planningDir2) {
+  if (!existsSync14(join14(planningDir2, 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 (!existsSync14(join15(planningDir3, STATE_FILE2))) {
+function getBlockMessage(planningDir2) {
+  if (!existsSync14(join14(planningDir2, 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 existsSync15, readFileSync as readFileSync15 } from "fs";
-import { join as join16 } from "path";
+import { existsSync as existsSync15, readFileSync as readFileSync14 } from "fs";
+import { join as join15 } from "path";
+var IS_ENABLED = () => process.env.FLOWDECK_TOOL_GUARD_ENABLED === "on";
 var BLOCKED_PATTERNS = {
   read: [".env", ".pem", ".key", ".secret"],
   write: ["node_modules"],
@@ -1819,11 +2030,11 @@ function isBlocked(tool17, args) {
   return null;
 }
 function checkArchConstraint(directory, filePath) {
-  const constraintsPath = join16(codebaseDir(directory), "CONSTRAINTS.md");
+  const constraintsPath = join15(codebaseDir(directory), "CONSTRAINTS.md");
   if (!existsSync15(constraintsPath))
     return null;
   try {
-    const content = readFileSync15(constraintsPath, "utf-8");
+    const content = readFileSync14(constraintsPath, "utf-8");
     const match = content.match(/## Forbidden Paths\n([\s\S]*?)(?:\n##|$)/);
     if (!match)
       return null;
@@ -1847,6 +2058,8 @@ function checkPhaseEnforcement(directory) {
   return null;
 }
 async function toolGuardHook(ctx, input, output) {
+  if (!IS_ENABLED())
+    return;
   if (input.tool !== "bash" && input.tool !== "read" && input.tool !== "write" && input.tool !== "edit") {
     return;
   }
@@ -1868,13 +2081,13 @@ async function toolGuardHook(ctx, input, output) {
 }
 
 // src/hooks/session-start.ts
-import { existsSync as existsSync16, readFileSync as readFileSync16 } from "fs";
+import { existsSync as existsSync16, readFileSync as readFileSync15 } from "fs";
 async function sessionStartHook(ctx) {
-  const planningDir3 = ctx.directory + "/.planning";
+  const planningDir2 = ctx.directory + "/.planning";
   const codebaseDirectory = codebaseDir(ctx.directory);
   const workspaceRoot = findWorkspaceRoot(ctx.directory);
   const config = workspaceRoot ? getWorkspaceConfig(ctx.directory) : null;
-  if (!existsSync16(planningDir3)) {
+  if (!existsSync16(planningDir2)) {
     return {
       flowdeck_phase: null,
       flowdeck_status: "no_plan",
@@ -1890,7 +2103,7 @@ async function sessionStartHook(ctx) {
   }
   try {
     const stateFilePath = statePath(ctx.directory);
-    const content = readFileSync16(stateFilePath, "utf-8");
+    const content = readFileSync15(stateFilePath, "utf-8");
     const state = parseState(content);
     const currentPhase = state["current_phase"] || {};
     const result = {
@@ -1979,8 +2192,8 @@ function notifyPermissionNeeded(tool17) {
 }
 
 // src/hooks/patch-trust.ts
-import { existsSync as existsSync17, readFileSync as readFileSync17 } from "fs";
-import { join as join17 } from "path";
+import { existsSync as existsSync17, readFileSync as readFileSync16 } from "fs";
+import { join as join16 } from "path";
 var HIGH_RISK_KEYWORDS = [
   "password",
   "secret",
@@ -2002,11 +2215,11 @@ var HIGH_RISK_KEYWORDS = [
   "privilege"
 ];
 function loadVolatility(directory) {
-  const p = join17(codebaseDir(directory), "VOLATILITY.json");
+  const p = join16(codebaseDir(directory), "VOLATILITY.json");
   if (!existsSync17(p))
     return {};
   try {
-    const data = JSON.parse(readFileSync17(p, "utf-8"));
+    const data = JSON.parse(readFileSync16(p, "utf-8"));
     const map = {};
     for (const entry of data.entries ?? [])
       map[entry.path] = entry.stability;
@@ -2016,11 +2229,11 @@ function loadVolatility(directory) {
   }
 }
 function loadFailedPaths(directory) {
-  const p = join17(codebaseDir(directory), "FAILURES.json");
+  const p = join16(codebaseDir(directory), "FAILURES.json");
   if (!existsSync17(p))
     return [];
   try {
-    const data = JSON.parse(readFileSync17(p, "utf-8"));
+    const data = JSON.parse(readFileSync16(p, "utf-8"));
     return (data.entries ?? []).flatMap((e) => e.affected_paths ?? []);
   } catch {
     return [];
@@ -2067,6 +2280,10 @@ async function patchTrustHook(ctx, input, output) {
     return;
   const trust = scorePatch(ctx.directory, filePath, content);
   if (trust.verdict === "high-risk") {
+    const highRiskEnabled = process.env.FLOWDECK_PATCH_TRUST_HIGH_RISK_ENABLED;
+    if (highRiskEnabled !== "true" && highRiskEnabled !== "1") {
+      return;
+    }
     throw new Error(`[flowdeck] PATCH-TRUST HIGH-RISK (score=${trust.score}): ${filePath}
   Signals: ${trust.signals.join("; ")}
   This edit requires explicit human review before applying.`);
@@ -2077,8 +2294,8 @@ async function patchTrustHook(ctx, input, output) {
 }
 
 // src/hooks/decision-trace-hook.ts
-import { existsSync as existsSync18, mkdirSync as mkdirSync9, appendFileSync as appendFileSync3 } from "fs";
-import { join as join18 } 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;
@@ -2100,11 +2317,34 @@ async function decisionTraceHook(ctx, input, output) {
       risk_level: "unknown",
       auto_recorded: true
     };
-    appendFileSync3(join18(base, "DECISIONS.jsonl"), JSON.stringify(entry) + `
+    appendFileSync2(join17(base, "DECISIONS.jsonl"), JSON.stringify(entry) + `
 `, "utf-8");
   } catch {}
 }
 
+// src/services/telemetry.ts
+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 join18(codebaseDir(dir), "TELEMETRY.jsonl");
+}
+function appendEvent(dir, partial) {
+  if (process.env.TELEMETRY_ENABLED !== "true")
+    return null;
+  const cd = codebaseDir(dir);
+  if (!existsSync19(cd))
+    mkdirSync10(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();
@@ -2131,7 +2371,7 @@ async function telemetryAfterHook(context, toolInput, _output) {
 }
 
 // src/services/approval-manager.ts
-import { existsSync as existsSync19, readFileSync as readFileSync18, writeFileSync as writeFileSync14, mkdirSync as mkdirSync10 } from "fs";
+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 = [
@@ -2173,7 +2413,7 @@ function approvalsPath(dir) {
 }
 function loadStore(dir) {
   const p = approvalsPath(dir);
-  if (!existsSync19(p))
+  if (!existsSync20(p))
     return { requests: [] };
   try {
     return JSON.parse(readFileSync18(p, "utf-8"));
@@ -2188,8 +2428,11 @@ function checkApproval(dir, file_path, command) {
 }
 
 // src/hooks/approval-hook.ts
+var ENABLED2 = process.env.FLOWDECK_APPROVAL_HOOK_ENABLED === "on";
 var WRITE_TOOLS = new Set(["write_file", "edit_file", "create_file", "apply_patch", "str_replace_editor", "write"]);
 async function approvalHook(context, toolInput, output) {
+  if (!ENABLED2)
+    return;
   const dir = context.directory ?? process.cwd();
   const tool17 = toolInput.name ?? toolInput.tool ?? "";
   if (!WRITE_TOOLS.has(tool17))
@@ -2268,7 +2511,7 @@ function createContextWindowMonitorHook() {
 }
 
 // src/hooks/shell-env-hook.ts
-import { existsSync as existsSync20, readFileSync as readFileSync19 } from "fs";
+import { existsSync as existsSync21, readFileSync as readFileSync19 } from "fs";
 import { join as join20 } from "path";
 import { createRequire } from "module";
 var _version;
@@ -2305,7 +2548,7 @@ var MARKER_TO_LANG = {
 };
 function detectPackageManager(root) {
   for (const [lockfile, pm] of Object.entries(LOCKFILE_TO_PM)) {
-    if (existsSync20(join20(root, lockfile)))
+    if (existsSync21(join20(root, lockfile)))
       return pm;
   }
   return;
@@ -2314,7 +2557,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(join20(root, marker))) {
+    if (!seen.has(lang) && existsSync21(join20(root, marker))) {
       langs.push(lang);
       seen.add(lang);
     }
@@ -2323,7 +2566,7 @@ function detectLanguages(root) {
 }
 function readCurrentPhase(root) {
   const statePath2 = join20(root, ".planning", "STATE.md");
-  if (!existsSync20(statePath2))
+  if (!existsSync21(statePath2))
     return;
   try {
     const content = readFileSync19(statePath2, "utf-8");
@@ -2356,7 +2599,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)
@@ -2425,7 +2669,7 @@ function createSessionIdleHook(client, tracker) {
 }
 
 // src/hooks/compaction-hook.ts
-import { existsSync as existsSync21, readFileSync as readFileSync20 } from "fs";
+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:
@@ -2466,7 +2710,7 @@ For each: agent name, status, description, session_id.
 `;
 function readPlanningState2(directory) {
   const statePath2 = join21(directory, ".planning", "STATE.md");
-  if (!existsSync21(statePath2))
+  if (!existsSync22(statePath2))
     return null;
   try {
     const content = readFileSync20(statePath2, "utf-8");
@@ -2524,7 +2768,6 @@ var BLOCKED_TOOLS = new Set([
 ]);
 var ALWAYS_ALLOWED = new Set([
   "delegate",
-  "run-parallel",
   "run-pipeline",
   "council",
   "planning-state",
@@ -5563,12 +5806,12 @@ function getAgentConfigs(agentModels) {
 }
 
 // src/config/loader.ts
-import { existsSync as existsSync22, readFileSync as readFileSync21 } from "fs";
+import { existsSync as existsSync23, readFileSync as readFileSync21 } from "fs";
 import { join as join22 } from "path";
-import { homedir } from "os";
+import { homedir as homedir2 } from "os";
 var CONFIG_FILENAME = "flowdeck.json";
 function getGlobalConfigDir() {
-  return process.env.OPENCODE_CONFIG_DIR || (process.env.XDG_CONFIG_HOME ? join22(process.env.XDG_CONFIG_HOME, "opencode") : join22(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 = [];
@@ -5577,7 +5820,7 @@ function loadFlowDeckConfig(directory) {
   }
   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);
@@ -5589,10 +5832,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 = join23(__dir, "..", "src", "commands");
-  if (!existsSync23(commandsDir))
+  if (!existsSync24(commandsDir))
     return {};
   const commands = {};
   try {
@@ -5617,7 +5879,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);
@@ -5679,7 +5940,7 @@ var plugin = async (input, _options) => {
         }
       }
       const skillsDir = join23(dirname4(fileURLToPath2(import.meta.url)), "..", "src", "skills");
-      if (existsSync23(skillsDir)) {
+      if (existsSync24(skillsDir)) {
         const cfgAny = cfg;
         if (!cfgAny.skills || typeof cfgAny.skills !== "object") {
           cfgAny.skills = { paths: [] };
@@ -5691,12 +5952,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,
@@ -5708,7 +5980,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,
@@ -5720,11 +5993,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();
       }
@@ -5740,6 +6036,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);
     }
   };