@dv.nghiem/flowdeck 0.3.3 → 0.3.4

package/dist/index.js

@@ -1,6 +1,6 @@
 // src/index.ts
-import { readdirSync as readdirSync3, readFileSync as readFileSync22, existsSync as existsSync25 } from "fs";
-import { join as join24, basename } from "path";
+import { readdirSync as readdirSync3, readFileSync as readFileSync24, existsSync as existsSync28 } from "fs";
+import { join as join27, basename } from "path";
 import { dirname as dirname4 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
@@ -509,6 +509,154 @@ var workspaceStateTool = tool3({
 
 // src/tools/run-pipeline.ts
 import { tool as tool4 } from "@opencode-ai/plugin";
+
+// src/services/agent-performance.ts
+import { existsSync as existsSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync5, mkdirSync as mkdirSync2 } from "fs";
+import { join as join5 } from "path";
+function perfPath(dir) {
+  return join5(codebaseDir(dir), "AGENT_PERF.json");
+}
+function loadStore(dir) {
+  const p = perfPath(dir);
+  if (!existsSync5(p))
+    return { entries: [], updated_at: new Date().toISOString() };
+  try {
+    return JSON.parse(readFileSync5(p, "utf-8"));
+  } catch {
+    return { entries: [], updated_at: new Date().toISOString() };
+  }
+}
+function saveStore(dir, store) {
+  const cd = codebaseDir(dir);
+  if (!existsSync5(cd))
+    mkdirSync2(cd, { recursive: true });
+  writeFileSync5(perfPath(dir), JSON.stringify(store, null, 2), "utf-8");
+}
+function makeKey(agent, model, task_type) {
+  return `${agent}::${model}::${task_type}`;
+}
+function recordRun(dir, agent, model, task_type, success, duration_ms, cost = 0) {
+  const store = loadStore(dir);
+  const key = makeKey(agent, model, task_type);
+  const existing = store.entries.find((e) => makeKey(e.agent, e.model, e.task_type) === key);
+  if (existing) {
+    existing.runs++;
+    if (success)
+      existing.successes++;
+    else
+      existing.failures++;
+    existing.total_duration_ms += duration_ms;
+    existing.total_cost += cost;
+    existing.last_run = new Date().toISOString();
+    existing.last_status = success ? "success" : "failure";
+  } else {
+    store.entries.push({
+      agent,
+      model,
+      task_type,
+      runs: 1,
+      successes: success ? 1 : 0,
+      failures: success ? 0 : 1,
+      total_duration_ms: duration_ms,
+      total_cost: cost,
+      last_run: new Date().toISOString(),
+      last_status: success ? "success" : "failure"
+    });
+  }
+  store.updated_at = new Date().toISOString();
+  saveStore(dir, store);
+}
+
+// src/services/model-router.ts
+import { existsSync as existsSync6, readFileSync as readFileSync6 } from "fs";
+import { join as join6 } from "path";
+var DEFAULT_ROUTING = {
+  planning: { primary: "claude-sonnet-4-5", temperature: 0.3, reasoning_effort: "medium" },
+  implementation: { primary: "claude-opus-4-5", fallback: "claude-sonnet-4-5", high_risk_override: "claude-opus-4-5", temperature: 0.2, reasoning_effort: "high" },
+  debugging: { primary: "claude-sonnet-4-5", high_risk_override: "claude-opus-4-5", temperature: 0.2, reasoning_effort: "high" },
+  review: { primary: "gemini-2.5-flash", fallback: "claude-haiku-4-5", temperature: 0.1, reasoning_effort: "medium" },
+  testing: { primary: "claude-haiku-4-5", fallback: "gemini-2.5-flash", temperature: 0.1, reasoning_effort: "low" },
+  documentation: { primary: "claude-sonnet-4-5", fallback: "gemini-2.5-flash", temperature: 0.3, reasoning_effort: "low" },
+  analysis: { primary: "claude-sonnet-4-5", temperature: 0.3, reasoning_effort: "medium" },
+  security: { primary: "claude-opus-4-5", high_risk_override: "claude-opus-4-5", temperature: 0.1, reasoning_effort: "high" },
+  orchestration: { primary: "claude-sonnet-4-5", temperature: 0.3, reasoning_effort: "medium" }
+};
+function getRouterConfig(dir) {
+  const p = join6(codebaseDir(dir), "MODEL_ROUTER.json");
+  if (!existsSync6(p))
+    return DEFAULT_ROUTING;
+  try {
+    const overrides = JSON.parse(readFileSync6(p, "utf-8"));
+    return { ...DEFAULT_ROUTING, ...overrides };
+  } catch {
+    return DEFAULT_ROUTING;
+  }
+}
+function routeModel(dir, task_type, risk_score = 100) {
+  const config = getRouterConfig(dir);
+  const route = config[task_type] ?? DEFAULT_ROUTING.implementation;
+  const is_high_risk = risk_score < 40;
+  let model = route.primary;
+  let is_override = false;
+  if (is_high_risk && route.high_risk_override) {
+    model = route.high_risk_override;
+    is_override = true;
+  }
+  return {
+    model,
+    temperature: route.temperature ?? 0.3,
+    reasoning_effort: route.reasoning_effort,
+    task_type,
+    is_high_risk,
+    is_override
+  };
+}
+
+// src/tools/dispatch-routing.ts
+function shouldRetry(promptRes) {
+  if (!promptRes)
+    return false;
+  const detail = promptRes.error?.detail;
+  if (isTransientError(detail))
+    return true;
+  const infoError = promptRes.data?.info?.error;
+  const text = typeof infoError === "string" ? infoError : JSON.stringify(infoError ?? "");
+  return isTransientError(text);
+}
+function isTransientError(text) {
+  if (!text)
+    return false;
+  const haystack = text.toLowerCase();
+  return haystack.includes("overload") || haystack.includes("rate limit") || haystack.includes("timeout") || haystack.includes("temporar") || haystack.includes("econnreset");
+}
+function normalizeTaskType(taskType, agent) {
+  const normalized = (taskType ?? "").trim().toLowerCase();
+  if (isTaskType(normalized))
+    return normalized;
+  const a = agent.toLowerCase();
+  if (a.includes("review"))
+    return "review";
+  if (a.includes("test"))
+    return "testing";
+  if (a.includes("debug"))
+    return "debugging";
+  if (a.includes("security"))
+    return "security";
+  if (a.includes("doc"))
+    return "documentation";
+  if (a.includes("architect") || a.includes("planner"))
+    return "planning";
+  if (a.includes("orchestrator") || a.includes("coordinator"))
+    return "orchestration";
+  if (a.includes("analyst") || a.includes("research"))
+    return "analysis";
+  return "implementation";
+}
+function isTaskType(value) {
+  return value === "planning" || value === "implementation" || value === "debugging" || value === "review" || value === "testing" || value === "documentation" || value === "analysis" || value === "security" || value === "orchestration";
+}
+
+// src/tools/run-pipeline.ts
 function extractText(parts) {
   return parts.filter((p) => p.type === "text" && typeof p.text === "string").map((p) => p.text).join(`
 `);
@@ -519,16 +667,20 @@ function createRunPipelineTool(client) {
     args: {
       steps: tool4.schema.array(tool4.schema.object({
         agent: tool4.schema.string(),
-        prompt: tool4.schema.string()
+        prompt: tool4.schema.string(),
+        task_type: tool4.schema.string().optional()
       })),
       initial_context: tool4.schema.string().optional(),
-      abort_on_failure: tool4.schema.boolean().optional().default(true)
+      abort_on_failure: tool4.schema.boolean().optional().default(true),
+      retry_attempts: tool4.schema.number().optional().default(1)
     },
     async execute(args, context) {
       const startTime = Date.now();
       const trace = [];
       let carryContext = args.initial_context ?? "";
       let aborted = false;
+      const retryAttempts = typeof args.retry_attempts === "number" ? args.retry_attempts : 1;
+      const maxRetries = Math.max(0, Math.floor(retryAttempts));
       let inflightChildId = null;
       const abortHandler = () => {
         if (inflightChildId) {
@@ -546,6 +698,8 @@ function createRunPipelineTool(client) {
             break;
           }
           const stepStart = Date.now();
+          const taskType = normalizeTaskType(step.task_type, step.agent);
+          const routing = routeModel(context.directory, taskType);
           const stepInput = carryContext ? `${carryContext}
 
 ---
@@ -557,28 +711,37 @@ ${step.prompt}` : step.prompt;
           });
           if (createRes.error || !createRes.data?.id) {
             const errMsg = `Failed to create session: ${createRes.error?.detail ?? "unknown"}`;
-            trace.push({ agent: step.agent, input: stepInput, output: errMsg, duration_ms: Date.now() - stepStart, success: false });
+            trace.push({ agent: step.agent, task_type: taskType, model: routing.model, input: stepInput, output: errMsg, duration_ms: Date.now() - stepStart, success: false });
             aborted = true;
             break;
           }
           inflightChildId = createRes.data.id;
-          const promptRes = await client.session.prompt({
-            path: { id: inflightChildId },
-            body: {
-              agent: step.agent,
-              parts: [{ type: "text", text: stepInput }],
-              tools: { question: false }
-            },
-            query: { directory: context.directory }
-          });
+          let promptRes = null;
+          let retriesUsed = 0;
+          for (let attempt = 0;attempt <= maxRetries; attempt++) {
+            promptRes = await client.session.prompt({
+              path: { id: inflightChildId },
+              body: {
+                agent: step.agent,
+                model: routing.model,
+                parts: [{ type: "text", text: stepInput }],
+                tools: { question: false }
+              },
+              query: { directory: context.directory }
+            });
+            if (!shouldRetry(promptRes) || attempt === maxRetries)
+              break;
+            retriesUsed++;
+          }
           inflightChildId = null;
           if (context.abort.aborted) {
             aborted = true;
             break;
           }
-          if (promptRes.error) {
-            const errMsg = `Prompt failed: ${promptRes.error?.detail ?? "unknown"}`;
-            trace.push({ agent: step.agent, session_id: createRes.data.id, input: stepInput, output: errMsg, duration_ms: Date.now() - stepStart, success: false });
+          if (!promptRes || promptRes.error) {
+            const errMsg = `Prompt failed: ${promptRes?.error?.detail ?? "unknown"}`;
+            trace.push({ agent: step.agent, session_id: createRes.data.id, task_type: taskType, model: routing.model, input: stepInput, output: `${errMsg}${retriesUsed > 0 ? ` (retries: ${retriesUsed})` : ""}`, duration_ms: Date.now() - stepStart, success: false });
+            recordRun(context.directory, step.agent, routing.model, taskType, false, Date.now() - stepStart);
             if (args.abort_on_failure) {
               aborted = true;
               break;
@@ -588,7 +751,8 @@ ${step.prompt}` : step.prompt;
           const info = promptRes.data?.info;
           if (info?.error) {
             const errMsg = `Agent error: ${JSON.stringify(info.error)}`;
-            trace.push({ agent: step.agent, session_id: createRes.data.id, input: stepInput, output: errMsg, duration_ms: Date.now() - stepStart, success: false });
+            trace.push({ agent: step.agent, session_id: createRes.data.id, task_type: taskType, model: routing.model, input: stepInput, output: `${errMsg}${retriesUsed > 0 ? ` (retries: ${retriesUsed})` : ""}`, duration_ms: Date.now() - stepStart, success: false });
+            recordRun(context.directory, step.agent, routing.model, taskType, false, Date.now() - stepStart);
             if (args.abort_on_failure) {
               aborted = true;
               break;
@@ -596,7 +760,8 @@ ${step.prompt}` : step.prompt;
             continue;
           }
           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 });
+          trace.push({ agent: step.agent, session_id: createRes.data.id, task_type: taskType, model: routing.model, input: stepInput, output: output || "(no text output)", duration_ms: Date.now() - stepStart, success: true });
+          recordRun(context.directory, step.agent, routing.model, taskType, true, Date.now() - stepStart);
           carryContext = output;
         }
       } finally {
@@ -623,10 +788,16 @@ function createDelegateTool(client) {
     args: {
       agent: tool5.schema.string(),
       prompt: tool5.schema.string(),
-      context: tool5.schema.string().optional()
+      context: tool5.schema.string().optional(),
+      task_type: tool5.schema.string().optional(),
+      retry_attempts: tool5.schema.number().optional().default(1)
     },
     async execute(args, context) {
       const startTime = Date.now();
+      const taskType = normalizeTaskType(args.task_type, args.agent);
+      const routing = routeModel(context.directory, taskType);
+      const retryAttempts = typeof args.retry_attempts === "number" ? args.retry_attempts : 1;
+      const maxRetries = Math.max(0, Math.floor(retryAttempts));
       const createRes = await client.session.create({
         body: { parentID: context.sessionID, title: `${args.agent}-delegate` },
         query: { directory: context.directory }
@@ -651,40 +822,60 @@ function createDelegateTool(client) {
 ---
 
 ${args.prompt}` : args.prompt;
-      const promptRes = await client.session.prompt({
-        path: { id: childId },
-        body: {
-          agent: args.agent,
-          parts: [{ type: "text", text: fullPrompt }],
-          tools: { question: false }
-        },
-        query: { directory: context.directory }
-      });
-      if (promptRes.error) {
+      let promptRes = null;
+      let retriesUsed = 0;
+      for (let attempt = 0;attempt <= maxRetries; attempt++) {
+        promptRes = await client.session.prompt({
+          path: { id: childId },
+          body: {
+            agent: args.agent,
+            model: routing.model,
+            parts: [{ type: "text", text: fullPrompt }],
+            tools: { question: false }
+          },
+          query: { directory: context.directory }
+        });
+        if (!shouldRetry(promptRes) || attempt === maxRetries)
+          break;
+        retriesUsed++;
+      }
+      if (!promptRes || promptRes.error) {
+        recordRun(context.directory, args.agent, routing.model, taskType, false, Date.now() - startTime);
         return JSON.stringify({
           agent: args.agent,
           session_id: childId,
           success: false,
-          error: `Prompt failed: ${promptRes.error?.detail ?? "unknown"}`,
+          error: `Prompt failed: ${promptRes?.error?.detail ?? "unknown"}`,
+          task_type: taskType,
+          model: routing.model,
+          retries_used: retriesUsed,
           duration_ms: Date.now() - startTime
         });
       }
       const info = promptRes.data?.info;
       if (info?.error) {
+        recordRun(context.directory, args.agent, routing.model, taskType, false, Date.now() - startTime);
         return JSON.stringify({
           agent: args.agent,
           session_id: childId,
           success: false,
           error: `Agent error: ${JSON.stringify(info.error)}`,
+          task_type: taskType,
+          model: routing.model,
+          retries_used: retriesUsed,
           duration_ms: Date.now() - startTime
         });
       }
       const output = extractText2(promptRes.data?.parts ?? []);
+      recordRun(context.directory, args.agent, routing.model, taskType, true, Date.now() - startTime);
       return JSON.stringify({
         agent: args.agent,
         session_id: childId,
         success: true,
         output: output || "(no text output)",
+        task_type: taskType,
+        model: routing.model,
+        retries_used: retriesUsed,
         duration_ms: Date.now() - startTime
       });
     }
@@ -693,31 +884,31 @@ ${args.prompt}` : args.prompt;
 
 // src/tools/repo-memory.ts
 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";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync6, existsSync as existsSync7, mkdirSync as mkdirSync3 } from "fs";
+import { join as join7 } from "path";
 var MEMORY_FILE = "MEMORY.json";
 function memoryPath(directory) {
-  return join5(codebaseDir(directory), MEMORY_FILE);
+  return join7(codebaseDir(directory), MEMORY_FILE);
 }
 function emptyMemory() {
   return { version: "1.0", last_updated: new Date().toISOString(), nodes: {} };
 }
 function readMemory(directory) {
   const p = memoryPath(directory);
-  if (!existsSync5(p))
+  if (!existsSync7(p))
     return emptyMemory();
   try {
-    return JSON.parse(readFileSync5(p, "utf-8"));
+    return JSON.parse(readFileSync7(p, "utf-8"));
   } catch {
     return emptyMemory();
   }
 }
 function writeMemory(directory, memory) {
   const base = codebaseDir(directory);
-  if (!existsSync5(base))
-    mkdirSync2(base, { recursive: true });
+  if (!existsSync7(base))
+    mkdirSync3(base, { recursive: true });
   memory.last_updated = new Date().toISOString();
-  writeFileSync5(memoryPath(directory), JSON.stringify(memory, null, 2), "utf-8");
+  writeFileSync6(memoryPath(directory), JSON.stringify(memory, null, 2), "utf-8");
 }
 var repoMemoryTool = tool6({
   description: "Repo Memory Graph: read/write/query persistent architecture graph in .codebase/MEMORY.json (modules, dependencies, ownership, bug history, conventions)",
@@ -794,28 +985,28 @@ var repoMemoryTool = tool6({
 
 // src/tools/failure-replay.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 join6 } from "path";
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync7, existsSync as existsSync8, mkdirSync as mkdirSync4 } from "fs";
+import { join as join8 } from "path";
 var FAILURES_FILE = "FAILURES.json";
 function failuresPath(directory) {
-  return join6(codebaseDir(directory), FAILURES_FILE);
+  return join8(codebaseDir(directory), FAILURES_FILE);
 }
 function readStore(directory) {
   const p = failuresPath(directory);
-  if (!existsSync6(p))
+  if (!existsSync8(p))
     return { version: "1.0", last_updated: new Date().toISOString(), entries: [] };
   try {
-    return JSON.parse(readFileSync6(p, "utf-8"));
+    return JSON.parse(readFileSync8(p, "utf-8"));
   } catch {
     return { version: "1.0", last_updated: new Date().toISOString(), entries: [] };
   }
 }
 function writeStore(directory, store) {
   const base = codebaseDir(directory);
-  if (!existsSync6(base))
-    mkdirSync3(base, { recursive: true });
+  if (!existsSync8(base))
+    mkdirSync4(base, { recursive: true });
   store.last_updated = new Date().toISOString();
-  writeFileSync6(failuresPath(directory), JSON.stringify(store, null, 2), "utf-8");
+  writeFileSync7(failuresPath(directory), JSON.stringify(store, null, 2), "utf-8");
 }
 var failureReplayTool = 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",
@@ -899,17 +1090,17 @@ var failureReplayTool = tool7({
 
 // src/tools/decision-trace.ts
 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";
+import { readFileSync as readFileSync9, existsSync as existsSync9, mkdirSync as mkdirSync5, appendFileSync } from "fs";
+import { join as join9 } from "path";
 var DECISIONS_FILE = "DECISIONS.jsonl";
 function decisionsPath(directory) {
-  return join7(codebaseDir(directory), DECISIONS_FILE);
+  return join9(codebaseDir(directory), DECISIONS_FILE);
 }
 function readDecisions(directory) {
   const p = decisionsPath(directory);
-  if (!existsSync7(p))
+  if (!existsSync9(p))
     return [];
-  return readFileSync7(p, "utf-8").split(`
+  return readFileSync9(p, "utf-8").split(`
 `).filter((l) => l.trim()).map((l) => {
     try {
       return JSON.parse(l);
@@ -949,8 +1140,8 @@ var decisionTraceTool = tool8({
       case "record": {
         if (!args.entry)
           return JSON.stringify({ error: "entry required" });
-        if (!existsSync7(base))
-          mkdirSync4(base, { recursive: true });
+        if (!existsSync9(base))
+          mkdirSync5(base, { recursive: true });
         const entry = { ...args.entry, timestamp: new Date().toISOString() };
         appendFileSync(decisionsPath(dir), JSON.stringify(entry) + `
 `, "utf-8");
@@ -984,28 +1175,28 @@ var decisionTraceTool = tool8({
 
 // src/tools/volatility-map.ts
 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";
+import { readFileSync as readFileSync10, writeFileSync as writeFileSync9, existsSync as existsSync10, mkdirSync as mkdirSync6 } from "fs";
+import { join as join10 } from "path";
 var VOLATILITY_FILE = "VOLATILITY.json";
 function volatilityPath(directory) {
-  return join8(codebaseDir(directory), VOLATILITY_FILE);
+  return join10(codebaseDir(directory), VOLATILITY_FILE);
 }
 function readStore2(directory) {
   const p = volatilityPath(directory);
-  if (!existsSync8(p))
+  if (!existsSync10(p))
     return { version: "1.0", last_updated: new Date().toISOString(), generated_at: new Date().toISOString(), entries: [] };
   try {
-    return JSON.parse(readFileSync8(p, "utf-8"));
+    return JSON.parse(readFileSync10(p, "utf-8"));
   } catch {
     return { version: "1.0", last_updated: new Date().toISOString(), generated_at: new Date().toISOString(), entries: [] };
   }
 }
 function writeStore2(directory, store) {
   const base = codebaseDir(directory);
-  if (!existsSync8(base))
-    mkdirSync5(base, { recursive: true });
+  if (!existsSync10(base))
+    mkdirSync6(base, { recursive: true });
   store.last_updated = new Date().toISOString();
-  writeFileSync8(volatilityPath(directory), JSON.stringify(store, null, 2), "utf-8");
+  writeFileSync9(volatilityPath(directory), JSON.stringify(store, null, 2), "utf-8");
 }
 function stabilityLabel(churn, hotfixes, todos) {
   const score = churn + hotfixes * 10 + todos * 2;
@@ -1092,28 +1283,28 @@ var volatilityMapTool = tool9({
 
 // src/tools/policy-engine.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 join9 } from "path";
+import { readFileSync as readFileSync11, writeFileSync as writeFileSync10, existsSync as existsSync11, mkdirSync as mkdirSync7 } from "fs";
+import { join as join11 } from "path";
 var POLICIES_FILE = "POLICIES.json";
 function policiesPath(directory) {
-  return join9(codebaseDir(directory), POLICIES_FILE);
+  return join11(codebaseDir(directory), POLICIES_FILE);
 }
 function readStore3(directory) {
   const p = policiesPath(directory);
-  if (!existsSync9(p))
+  if (!existsSync11(p))
     return { version: "1.0", last_updated: new Date().toISOString(), policies: [] };
   try {
-    return JSON.parse(readFileSync9(p, "utf-8"));
+    return JSON.parse(readFileSync11(p, "utf-8"));
   } catch {
     return { version: "1.0", last_updated: new Date().toISOString(), policies: [] };
   }
 }
 function writeStore3(directory, store) {
   const base = codebaseDir(directory);
-  if (!existsSync9(base))
-    mkdirSync6(base, { recursive: true });
+  if (!existsSync11(base))
+    mkdirSync7(base, { recursive: true });
   store.last_updated = new Date().toISOString();
-  writeFileSync9(policiesPath(directory), JSON.stringify(store, null, 2), "utf-8");
+  writeFileSync10(policiesPath(directory), JSON.stringify(store, null, 2), "utf-8");
 }
 var policyEngineTool = tool10({
   description: "Self-Healing Policy Engine: manage .codebase/POLICIES.json — add, list, query, toggle, and record violations of editing policies learned from past failures",
@@ -1195,7 +1386,7 @@ var policyEngineTool = tool10({
 
 // src/tools/hash-edit.ts
 import { tool as tool11 } from "@opencode-ai/plugin";
-import { readFileSync as readFileSync10, writeFileSync as writeFileSync10 } from "fs";
+import { readFileSync as readFileSync12, writeFileSync as writeFileSync11 } from "fs";
 import { createHash } from "crypto";
 var hashEditTool = tool11({
   description: "Reliable file editing with content verification. Takes a target content, its expected MD5 hash, and replacement content. Only applies if the hash matches, preventing edits on stale file versions.",
@@ -1209,7 +1400,7 @@ var hashEditTool = tool11({
     const fullPath = args.filePath.startsWith("/") ? args.filePath : `${context.directory}/${args.filePath}`;
     let content;
     try {
-      content = readFileSync10(fullPath, "utf-8");
+      content = readFileSync12(fullPath, "utf-8");
     } catch (e) {
       return `Error: Could not read file ${args.filePath}`;
     }
@@ -1223,13 +1414,15 @@ var hashEditTool = tool11({
       }
     }
     const newContent = content.replace(args.targetContent, args.replacementContent);
-    writeFileSync10(fullPath, newContent, "utf-8");
+    writeFileSync11(fullPath, newContent, "utf-8");
     return `Successfully updated ${args.filePath} using hash-anchored edit.`;
   }
 });
 
 // src/tools/council.ts
 import { tool as tool12 } from "@opencode-ai/plugin";
+import { appendFileSync as appendFileSync2, existsSync as existsSync12, mkdirSync as mkdirSync8 } from "fs";
+import { join as join12 } from "path";
 function createCouncilTool(client) {
   return tool12({
     description: "Run an ensemble of agents (Council) on the same task to reach consensus or compare approaches. Runs 3 specialized agents in parallel and returns their synthesized outputs.",
@@ -1284,16 +1477,34 @@ Please synthesize these results. Identify areas of agreement, resolve conflicts,
         },
         query: { directory: context.directory }
       });
-      return (finalRes.data?.parts ?? []).filter((p) => p.type === "text").map((p) => p.text).join(`
+      const synthesis = (finalRes.data?.parts ?? []).filter((p) => p.type === "text").map((p) => p.text).join(`
 `);
+      persistCouncilResult(context.directory, {
+        task: args.task,
+        agents,
+        results,
+        synthesis,
+        created_at: new Date().toISOString()
+      });
+      return synthesis;
     }
   });
 }
+function persistCouncilResult(directory, payload) {
+  try {
+    const base = codebaseDir(directory);
+    if (!existsSync12(base))
+      mkdirSync8(base, { recursive: true });
+    const path = join12(base, "COUNCILS.jsonl");
+    appendFileSync2(path, JSON.stringify(payload) + `
+`, "utf-8");
+  } catch {}
+}
 
 // src/tools/context-generator.ts
 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";
+import { writeFileSync as writeFileSync12, existsSync as existsSync13, readFileSync as readFileSync13, readdirSync as readdirSync2, statSync } from "fs";
+import { join as join13 } 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: {
@@ -1302,20 +1513,20 @@ var contextGeneratorTool = tool13({
   },
   async execute(args, context) {
     const root = context.directory;
-    const target = args.targetDir ? join10(root, args.targetDir) : root;
-    if (!existsSync10(target)) {
+    const target = args.targetDir ? join13(root, args.targetDir) : root;
+    if (!existsSync13(target)) {
       return `Error: Directory ${target} does not exist.`;
     }
-    const agentsMdPath = join10(target, "AGENTS.md");
-    if (existsSync10(agentsMdPath) && !args.force) {
+    const agentsMdPath = join13(target, "AGENTS.md");
+    if (existsSync13(agentsMdPath) && !args.force) {
       return `AGENTS.md already exists in ${target}. Use force: true to overwrite.`;
     }
-    const pkgPath = join10(root, "package.json");
+    const pkgPath = join13(root, "package.json");
     let projectName = "Project";
     let techStack = "Unknown";
-    if (existsSync10(pkgPath)) {
+    if (existsSync13(pkgPath)) {
       try {
-        const pkg = JSON.parse(readFileSync11(pkgPath, "utf-8"));
+        const pkg = JSON.parse(readFileSync13(pkgPath, "utf-8"));
         projectName = pkg.name || projectName;
         techStack = Object.keys(pkg.dependencies || {}).slice(0, 5).join(", ");
       } catch {}
@@ -1333,7 +1544,7 @@ var contextGeneratorTool = tool13({
 
 ## Directory Map
 ${readdirSync2(target).slice(0, 10).map((f) => {
-      const s = statSync(join10(target, f));
+      const s = statSync(join13(target, f));
       return `- \`${f}\`${s.isDirectory() ? "/" : ""} : [Description]`;
     }).join(`
 `)}
@@ -1341,17 +1552,17 @@ ${readdirSync2(target).slice(0, 10).map((f) => {
 ---
 Generated by FlowDeck Context Generator.
 `;
-    writeFileSync11(agentsMdPath, content, "utf-8");
+    writeFileSync12(agentsMdPath, content, "utf-8");
     return `Successfully generated AGENTS.md in ${target}.`;
   }
 });
 
 // src/tools/create-skill.ts
 import { tool as 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 { mkdirSync as mkdirSync9, writeFileSync as writeFileSync13, existsSync as existsSync14 } from "fs";
+import { join as join14, dirname as dirname3 } from "path";
 import { fileURLToPath } from "url";
-var SKILLS_DIR = join11(dirname3(fileURLToPath(import.meta.url)), "..", "skills");
+var SKILLS_DIR = join14(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: {
@@ -1361,9 +1572,9 @@ var createSkillTool = tool14({
     tags: tool14.schema.array(tool14.schema.string()).optional().describe("Optional tags for categorisation, e.g. ['performance', 'typescript']")
   },
   async execute(args) {
-    const skillDir = join11(SKILLS_DIR, args.name);
-    const skillFile = join11(skillDir, "SKILL.md");
-    if (existsSync11(skillFile)) {
+    const skillDir = join14(SKILLS_DIR, args.name);
+    const skillFile = join14(skillDir, "SKILL.md");
+    if (existsSync14(skillFile)) {
       return `Skill '${args.name}' already exists at ${skillFile}.
 ` + `Use a different name or delete the existing skill directory first.`;
     }
@@ -1378,8 +1589,8 @@ origin: FlowDeck (self-learned)${tagLine}
 `;
     const fullContent = frontmatter + args.content.trimStart();
     try {
-      mkdirSync7(skillDir, { recursive: true });
-      writeFileSync12(skillFile, fullContent, "utf-8");
+      mkdirSync9(skillDir, { recursive: true });
+      writeFileSync13(skillFile, fullContent, "utf-8");
       return `✓ Skill '${args.name}' created at ${skillFile}
 
 ` + `The skill is now part of the FlowDeck library. Restart OpenCode to load it into the active session.`;
@@ -1391,8 +1602,8 @@ origin: FlowDeck (self-learned)${tagLine}
 
 // src/tools/reflect.ts
 import { tool as tool15 } from "@opencode-ai/plugin";
-import { existsSync as existsSync12, readFileSync as readFileSync12 } from "fs";
-import { join as join12 } from "path";
+import { existsSync as existsSync15, readFileSync as readFileSync14 } from "fs";
+import { join as join15 } from "path";
 var MAX_ARTIFACT_BYTES = 4000;
 function tail(text, maxBytes) {
   if (text.length <= maxBytes)
@@ -1421,11 +1632,11 @@ var reflectTool = tool15({
     ];
     let found = 0;
     for (const [rel, label] of ARTIFACT_PATHS) {
-      const full = join12(root, rel);
-      if (!existsSync12(full))
+      const full = join15(root, rel);
+      if (!existsSync15(full))
         continue;
       try {
-        const raw = readFileSync12(full, "utf-8").trim();
+        const raw = readFileSync14(full, "utf-8").trim();
         if (!raw)
           continue;
         const count = raw.split(`
@@ -1449,14 +1660,14 @@ 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 { existsSync as existsSync16, mkdirSync as mkdirSync10 } from "fs";
+import { join as join16 } from "path";
 import { homedir } from "os";
-var MEMORY_DIR = join13(homedir(), ".flowdeck-memory");
-var DB_PATH = join13(MEMORY_DIR, "memory.db");
+var MEMORY_DIR = join16(homedir(), ".flowdeck-memory");
+var DB_PATH = join16(MEMORY_DIR, "memory.db");
 function ensureDir() {
-  if (!existsSync13(MEMORY_DIR)) {
-    mkdirSync8(MEMORY_DIR, { recursive: true });
+  if (!existsSync16(MEMORY_DIR)) {
+    mkdirSync10(MEMORY_DIR, { recursive: true });
   }
 }
 var db = null;
@@ -1734,16 +1945,16 @@ var memorySearchTool = tool16({
 // src/tools/memory-status.ts
 import { tool as tool17 } from "@opencode-ai/plugin";
 import { Database as Database2 } from "bun:sqlite";
-import { existsSync as existsSync14 } from "fs";
-import { join as join14 } from "path";
+import { existsSync as existsSync17 } from "fs";
+import { join as join17 } from "path";
 import { homedir as homedir2 } from "os";
-var DB_PATH2 = join14(homedir2(), ".flowdeck-memory", "memory.db");
+var DB_PATH2 = join17(homedir2(), ".flowdeck-memory", "memory.db");
 var memoryStatusTool = tool17({
   description: "Check FlowDeck memory database status, statistics, and recent sessions",
   args: {},
   async execute(_args, _context) {
     try {
-      const exists = existsSync14(DB_PATH2);
+      const exists = existsSync17(DB_PATH2);
       const result = {
         database_exists: exists,
         path: DB_PATH2,
@@ -1900,15 +2111,15 @@ var memoryHook = {
 };
 
 // src/hooks/guard-rails.ts
-import { existsSync as existsSync15, readFileSync as readFileSync13 } from "fs";
-import { join as join15 } from "path";
+import { existsSync as existsSync18, readFileSync as readFileSync15 } from "fs";
+import { join as join18 } from "path";
 var PLANNING_DIR2 = ".planning";
 var CONFIG_FILE = "config.json";
 var STATE_FILE2 = "STATE.md";
 function resolveExecutionMode(configPath, trustScore, volatility) {
-  if (existsSync15(configPath)) {
+  if (existsSync18(configPath)) {
     try {
-      const config = JSON.parse(readFileSync13(configPath, "utf-8"));
+      const config = JSON.parse(readFileSync15(configPath, "utf-8"));
       if (config.execution_mode === "review-only")
         return "review-only";
       if (config.execution_mode === "guarded")
@@ -1962,22 +2173,22 @@ async function guardRailsHook(ctx, input, _output) {
   if (!ENABLED)
     return;
   const dir = ctx.directory;
-  const planningDirPath = join15(dir, PLANNING_DIR2);
+  const planningDirPath = join18(dir, PLANNING_DIR2);
   const codebaseDirectory = codebaseDir(dir);
-  const configPath = join15(planningDirPath, CONFIG_FILE);
-  const statePath2 = join15(planningDirPath, STATE_FILE2);
+  const configPath = join18(planningDirPath, CONFIG_FILE);
+  const statePath2 = join18(planningDirPath, STATE_FILE2);
   const workspaceRoot = findWorkspaceRoot(dir);
   if (workspaceRoot && dir !== workspaceRoot) {
     const config = getWorkspaceConfig(dir);
-    if (config && config.workspace_mode === "shared" && !existsSync15(planningDirPath)) {
+    if (config && config.workspace_mode === "shared" && !existsSync18(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 (!existsSync15(planningDirPath))
+    if (!existsSync18(planningDirPath))
       return;
-    if (!existsSync15(codebaseDirectory)) {
+    if (!existsSync18(codebaseDirectory)) {
       throw new Error(`[flowdeck] WARNING: .codebase/ not found. Run /map-codebase to map the codebase.`);
     }
     const execMode = resolveExecutionMode(configPath, null);
@@ -2010,9 +2221,9 @@ async function guardRailsHook(ctx, input, _output) {
   }
 }
 function effectiveSeverity(configPath, statePath2) {
-  if (existsSync15(configPath)) {
+  if (existsSync18(configPath)) {
     try {
-      const configContent = readFileSync13(configPath, "utf-8");
+      const configContent = readFileSync15(configPath, "utf-8");
       const config = JSON.parse(configContent);
       if (config.guard_enforcement === "warn")
         return "warn";
@@ -2028,10 +2239,10 @@ function getEffectiveSeverity(configPath, statePath2) {
   return effectiveSeverity(configPath, statePath2);
 }
 function getPlanConfirmed(statePath2) {
-  if (!existsSync15(statePath2))
+  if (!existsSync18(statePath2))
     return false;
   try {
-    const content = readFileSync13(statePath2, "utf-8");
+    const content = readFileSync15(statePath2, "utf-8");
     const match = content.match(/plan_confirmed:\s*(true|false)/i);
     return match ? match[1].toLowerCase() === "true" : false;
   } catch {
@@ -2039,21 +2250,21 @@ function getPlanConfirmed(statePath2) {
   }
 }
 function getWarningMessage(planningDir2) {
-  if (!existsSync15(join15(planningDir2, STATE_FILE2))) {
+  if (!existsSync18(join18(planningDir2, STATE_FILE2))) {
     return "No .planning/ found. Run /new-project first.";
   }
   return "Plan not confirmed. Run /plan and confirm to enable execution.";
 }
 function getBlockMessage(planningDir2) {
-  if (!existsSync15(join15(planningDir2, STATE_FILE2))) {
+  if (!existsSync18(join18(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 existsSync16, readFileSync as readFileSync14 } from "fs";
-import { join as join16 } from "path";
+import { existsSync as existsSync19, readFileSync as readFileSync16 } from "fs";
+import { join as join19 } from "path";
 var IS_ENABLED = () => process.env.FLOWDECK_TOOL_GUARD_ENABLED === "on";
 var BLOCKED_PATTERNS = {
   read: [".env", ".pem", ".key", ".secret"],
@@ -2100,11 +2311,11 @@ function isBlocked(tool18, args) {
   return null;
 }
 function checkArchConstraint(directory, filePath) {
-  const constraintsPath = join16(codebaseDir(directory), "CONSTRAINTS.md");
-  if (!existsSync16(constraintsPath))
+  const constraintsPath = join19(codebaseDir(directory), "CONSTRAINTS.md");
+  if (!existsSync19(constraintsPath))
     return null;
   try {
-    const content = readFileSync14(constraintsPath, "utf-8");
+    const content = readFileSync16(constraintsPath, "utf-8");
     const match = content.match(/## Forbidden Paths\n([\s\S]*?)(?:\n##|$)/);
     if (!match)
       return null;
@@ -2151,18 +2362,18 @@ async function toolGuardHook(ctx, input, output) {
 }
 
 // src/hooks/session-start.ts
-import { existsSync as existsSync17, readFileSync as readFileSync15 } from "fs";
+import { existsSync as existsSync20, readFileSync as readFileSync17 } from "fs";
 async function sessionStartHook(ctx) {
   const planningDir2 = ctx.directory + "/.planning";
   const codebaseDirectory = codebaseDir(ctx.directory);
   const workspaceRoot = findWorkspaceRoot(ctx.directory);
   const config = workspaceRoot ? getWorkspaceConfig(ctx.directory) : null;
-  if (!existsSync17(planningDir2)) {
+  if (!existsSync20(planningDir2)) {
     return {
       flowdeck_phase: null,
       flowdeck_status: "no_plan",
       flowdeck_warning: "Run /new-project or /map-codebase to initialize.",
-      flowdeck_has_codebase: existsSync17(codebaseDirectory),
+      flowdeck_has_codebase: existsSync20(codebaseDirectory),
       ...workspaceRoot && config?.sub_repos ? {
         flowdeck_workspace_root: workspaceRoot,
         flowdeck_sub_repos: config.sub_repos,
@@ -2173,7 +2384,7 @@ async function sessionStartHook(ctx) {
   }
   try {
     const stateFilePath = statePath(ctx.directory);
-    const content = readFileSync15(stateFilePath, "utf-8");
+    const content = readFileSync17(stateFilePath, "utf-8");
     const state = parseState(content);
     const currentPhase = state["current_phase"] || {};
     const result = {
@@ -2181,7 +2392,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: existsSync17(codebaseDirectory)
+      flowdeck_has_codebase: existsSync20(codebaseDirectory)
     };
     if (workspaceRoot && config?.sub_repos && config.sub_repos.length > 0) {
       result.flowdeck_workspace_root = workspaceRoot;
@@ -2196,7 +2407,7 @@ async function sessionStartHook(ctx) {
       flowdeck_phase: null,
       flowdeck_status: "error",
       flowdeck_warning: "State file unreadable. Continuing without flowdeck context.",
-      flowdeck_has_codebase: existsSync17(codebaseDirectory)
+      flowdeck_has_codebase: existsSync20(codebaseDirectory)
     };
     if (workspaceRoot && config?.sub_repos && config.sub_repos.length > 0) {
       result.flowdeck_workspace_root = workspaceRoot;
@@ -2262,8 +2473,8 @@ function notifyPermissionNeeded(tool18) {
 }
 
 // src/hooks/patch-trust.ts
-import { existsSync as existsSync18, readFileSync as readFileSync16 } from "fs";
-import { join as join17 } from "path";
+import { existsSync as existsSync21, readFileSync as readFileSync18 } from "fs";
+import { join as join20 } from "path";
 var HIGH_RISK_KEYWORDS = [
   "password",
   "secret",
@@ -2285,11 +2496,11 @@ var HIGH_RISK_KEYWORDS = [
   "privilege"
 ];
 function loadVolatility(directory) {
-  const p = join17(codebaseDir(directory), "VOLATILITY.json");
-  if (!existsSync18(p))
+  const p = join20(codebaseDir(directory), "VOLATILITY.json");
+  if (!existsSync21(p))
     return {};
   try {
-    const data = JSON.parse(readFileSync16(p, "utf-8"));
+    const data = JSON.parse(readFileSync18(p, "utf-8"));
     const map = {};
     for (const entry of data.entries ?? [])
       map[entry.path] = entry.stability;
@@ -2299,11 +2510,11 @@ function loadVolatility(directory) {
   }
 }
 function loadFailedPaths(directory) {
-  const p = join17(codebaseDir(directory), "FAILURES.json");
-  if (!existsSync18(p))
+  const p = join20(codebaseDir(directory), "FAILURES.json");
+  if (!existsSync21(p))
     return [];
   try {
-    const data = JSON.parse(readFileSync16(p, "utf-8"));
+    const data = JSON.parse(readFileSync18(p, "utf-8"));
     return (data.entries ?? []).flatMap((e) => e.affected_paths ?? []);
   } catch {
     return [];
@@ -2368,8 +2579,8 @@ async function patchTrustHook(ctx, input, output) {
 }
 
 // src/hooks/decision-trace-hook.ts
-import { existsSync as existsSync19, mkdirSync as mkdirSync9, appendFileSync as appendFileSync2 } from "fs";
-import { join as join18 } from "path";
+import { existsSync as existsSync22, mkdirSync as mkdirSync11, appendFileSync as appendFileSync3 } from "fs";
+import { join as join21 } from "path";
 async function decisionTraceHook(ctx, input, output) {
   if (input.tool !== "write" && input.tool !== "edit")
     return;
@@ -2378,8 +2589,8 @@ async function decisionTraceHook(ctx, input, output) {
     return;
   const base = codebaseDir(ctx.directory);
   try {
-    if (!existsSync19(base))
-      mkdirSync9(base, { recursive: true });
+    if (!existsSync22(base))
+      mkdirSync11(base, { recursive: true });
     const entry = {
       timestamp: new Date().toISOString(),
       file_path: filePath,
@@ -2391,62 +2602,87 @@ async function decisionTraceHook(ctx, input, output) {
       risk_level: "unknown",
       auto_recorded: true
     };
-    appendFileSync2(join18(base, "DECISIONS.jsonl"), JSON.stringify(entry) + `
+    appendFileSync3(join21(base, "DECISIONS.jsonl"), JSON.stringify(entry) + `
 `, "utf-8");
   } catch {}
 }
 
 // src/services/telemetry.ts
-import { existsSync as existsSync20, readFileSync as readFileSync17, appendFileSync as appendFileSync3, mkdirSync as mkdirSync10 } from "fs";
-import { join as join19 } from "path";
+import { existsSync as existsSync23, readFileSync as readFileSync19, appendFileSync as appendFileSync4, mkdirSync as mkdirSync12 } from "fs";
+import { join as join22 } from "path";
 import { randomUUID } from "crypto";
 function telemetryPath(dir) {
-  return join19(codebaseDir(dir), "TELEMETRY.jsonl");
+  return join22(codebaseDir(dir), "TELEMETRY.jsonl");
 }
 function appendEvent(dir, partial) {
   if (process.env.TELEMETRY_ENABLED !== "true")
     return null;
   const cd = codebaseDir(dir);
-  if (!existsSync20(cd))
-    mkdirSync10(cd, { recursive: true });
+  if (!existsSync23(cd))
+    mkdirSync12(cd, { recursive: true });
   const event = {
     id: randomUUID(),
     ts: new Date().toISOString(),
     ...partial
   };
-  appendFileSync3(telemetryPath(dir), JSON.stringify(event) + `
+  appendFileSync4(telemetryPath(dir), JSON.stringify(event) + `
 `, "utf-8");
   return event;
 }
 
 // src/hooks/telemetry-hook.ts
+function resolveIds(toolInput) {
+  const session_id = toolInput.sessionID ?? toolInput.sessionId ?? process.env.OPENCODE_SESSION_ID ?? "session-0";
+  const run_id = toolInput.messageID ?? toolInput.messageId ?? toolInput.runID ?? toolInput.runId ?? process.env.OPENCODE_RUN_ID ?? "run-0";
+  return { session_id, run_id };
+}
+function inferStatus(output) {
+  if (output.error)
+    return "error";
+  if (typeof output.output !== "string")
+    return "ok";
+  const text = output.output.trim();
+  if (!text)
+    return "ok";
+  try {
+    const parsed = JSON.parse(text);
+    if (parsed.success === false || parsed.error || parsed.status === "error")
+      return "error";
+    return "ok";
+  } catch {
+    return "ok";
+  }
+}
 async function telemetryHook(context, toolInput, output) {
   const dir = context.directory ?? process.cwd();
   const tool18 = toolInput.name ?? toolInput.tool ?? "unknown";
+  const ids = resolveIds(toolInput);
   appendEvent(dir, {
-    session_id: process.env.OPENCODE_SESSION_ID ?? "session-0",
-    run_id: process.env.OPENCODE_RUN_ID ?? "run-0",
+    session_id: ids.session_id,
+    run_id: ids.run_id,
     event: "tool.call",
     tool: tool18,
     status: "ok",
     meta: { parameters: output.args ?? {} }
   });
 }
-async function telemetryAfterHook(context, toolInput, _output) {
+async function telemetryAfterHook(context, toolInput, output) {
   const dir = context.directory ?? process.cwd();
   const tool18 = toolInput.name ?? toolInput.tool ?? "unknown";
+  const ids = resolveIds(toolInput);
+  const status = inferStatus(output);
   appendEvent(dir, {
-    session_id: process.env.OPENCODE_SESSION_ID ?? "session-0",
-    run_id: process.env.OPENCODE_RUN_ID ?? "run-0",
+    session_id: ids.session_id,
+    run_id: ids.run_id,
     event: "tool.complete",
     tool: tool18,
-    status: "ok"
+    status
   });
 }
 
 // src/services/approval-manager.ts
-import { existsSync as existsSync21, readFileSync as readFileSync18, writeFileSync as writeFileSync13, mkdirSync as mkdirSync11 } from "fs";
-import { join as join20 } from "path";
+import { existsSync as existsSync24, readFileSync as readFileSync20, writeFileSync as writeFileSync14, mkdirSync as mkdirSync13 } from "fs";
+import { join as join23 } from "path";
 var APPROVAL_TTL_MS = 30 * 60 * 1000;
 var SENSITIVE_PATTERNS = [
   /auth/i,
@@ -2483,20 +2719,20 @@ function isSensitivePath(filePath) {
   return SENSITIVE_PATTERNS.some((p) => p.test(filePath));
 }
 function approvalsPath(dir) {
-  return join20(codebaseDir(dir), "APPROVALS.json");
+  return join23(codebaseDir(dir), "APPROVALS.json");
 }
-function loadStore(dir) {
+function loadStore2(dir) {
   const p = approvalsPath(dir);
-  if (!existsSync21(p))
+  if (!existsSync24(p))
     return { requests: [] };
   try {
-    return JSON.parse(readFileSync18(p, "utf-8"));
+    return JSON.parse(readFileSync20(p, "utf-8"));
   } catch {
     return { requests: [] };
   }
 }
 function checkApproval(dir, file_path, command) {
-  const store = loadStore(dir);
+  const store = loadStore2(dir);
   const now = Date.now();
   return store.requests.filter((r) => r.status === "approved" && r.resolved_at && (r.file_path === file_path || r.trigger === command) && now - new Date(r.resolved_at).getTime() < APPROVAL_TTL_MS).sort((a, b) => b.resolved_at.localeCompare(a.resolved_at)).at(0) ?? null;
 }
@@ -2585,8 +2821,8 @@ function createContextWindowMonitorHook() {
 }
 
 // src/hooks/shell-env-hook.ts
-import { existsSync as existsSync22, readFileSync as readFileSync19 } from "fs";
-import { join as join21 } from "path";
+import { existsSync as existsSync25, readFileSync as readFileSync21 } from "fs";
+import { join as join24 } from "path";
 import { createRequire } from "module";
 var _version;
 function getVersion() {
@@ -2622,7 +2858,7 @@ var MARKER_TO_LANG = {
 };
 function detectPackageManager(root) {
   for (const [lockfile, pm] of Object.entries(LOCKFILE_TO_PM)) {
-    if (existsSync22(join21(root, lockfile)))
+    if (existsSync25(join24(root, lockfile)))
       return pm;
   }
   return;
@@ -2631,7 +2867,7 @@ function detectLanguages(root) {
   const langs = [];
   const seen = new Set;
   for (const [marker, lang] of Object.entries(MARKER_TO_LANG)) {
-    if (!seen.has(lang) && existsSync22(join21(root, marker))) {
+    if (!seen.has(lang) && existsSync25(join24(root, marker))) {
       langs.push(lang);
       seen.add(lang);
     }
@@ -2639,11 +2875,11 @@ function detectLanguages(root) {
   return langs;
 }
 function readCurrentPhase(root) {
-  const statePath2 = join21(root, ".planning", "STATE.md");
-  if (!existsSync22(statePath2))
+  const statePath2 = join24(root, ".planning", "STATE.md");
+  if (!existsSync25(statePath2))
     return;
   try {
-    const content = readFileSync19(statePath2, "utf-8");
+    const content = readFileSync21(statePath2, "utf-8");
     const match = content.match(/phase:\s*(\S+)/i);
     return match?.[1];
   } catch {
@@ -2737,14 +2973,13 @@ function createSessionIdleHook(client, tracker) {
       if (edited.length > 10) {
         await client.app.log({ body: { service: "flowdeck", level: "info", message: `  … and ${edited.length - 10} more` } }).catch(() => {});
       }
-      tracker.clear();
     } catch {}
   };
 }
 
 // src/hooks/compaction-hook.ts
-import { existsSync as existsSync23, readFileSync as readFileSync20 } from "fs";
-import { join as join22 } from "path";
+import { existsSync as existsSync26, readFileSync as readFileSync22 } from "fs";
+import { join as join25 } from "path";
 var STRUCTURED_SUMMARY_PROMPT = `
 When summarizing this session, you MUST include the following sections:
 
@@ -2783,11 +3018,11 @@ For each: agent name, status, description, session_id.
 **RESUME, DON'T RESTART.** Use session_id to continue existing sessions.
 `;
 function readPlanningState2(directory) {
-  const statePath2 = join22(directory, ".planning", "STATE.md");
-  if (!existsSync23(statePath2))
+  const statePath2 = join25(directory, ".planning", "STATE.md");
+  if (!existsSync26(statePath2))
     return null;
   try {
-    const content = readFileSync20(statePath2, "utf-8");
+    const content = readFileSync22(statePath2, "utf-8");
     return content.slice(0, 1500);
   } catch {
     return null;
@@ -2882,13 +3117,24 @@ function blockMessage(toolName) {
 class OrchestratorGuard {
   primarySessionId = null;
   onEvent(event) {
-    if ((event.type === "session.created" || event.type === "session.started") && this.primarySessionId === null) {
-      const props = event.properties;
-      const id = props?.info?.id;
-      if (id) {
-        this.primarySessionId = id;
+    const eventType = event.type ?? "";
+    if (eventType === "session.deleted") {
+      const deletedId = extractSessionId(event);
+      if (deletedId && deletedId === this.primarySessionId) {
+        this.primarySessionId = null;
       }
+      return;
     }
+    if (eventType !== "session.created" && eventType !== "session.started")
+      return;
+    if (this.primarySessionId !== null)
+      return;
+    const id = extractSessionId(event);
+    if (!id)
+      return;
+    if (extractParentSessionId(event))
+      return;
+    this.primarySessionId = id;
   }
   check(sessionId, toolName) {
     if (DISABLED)
@@ -2904,6 +3150,20 @@ class OrchestratorGuard {
     }
   }
 }
+function extractSessionId(event) {
+  const props = event.properties;
+  const inner = event.event;
+  const info = props?.info;
+  const id = event.sessionID ?? event.sessionId ?? inner?.sessionID ?? inner?.sessionId ?? info?.id;
+  return id ?? null;
+}
+function extractParentSessionId(event) {
+  const props = event.properties;
+  const inner = event.event;
+  const info = props?.info;
+  const parentId = inner?.parentID ?? inner?.parentId ?? info?.parentID ?? info?.parentId;
+  return parentId ?? null;
+}
 
 // src/hooks/auto-learn-hook.ts
 var MIN_EDITS = 1;
@@ -5880,23 +6140,23 @@ function getAgentConfigs(agentModels) {
 }
 
 // src/config/loader.ts
-import { existsSync as existsSync24, readFileSync as readFileSync21 } from "fs";
-import { join as join23 } from "path";
+import { existsSync as existsSync27, readFileSync as readFileSync23 } from "fs";
+import { join as join26 } from "path";
 import { homedir as homedir3 } from "os";
 var CONFIG_FILENAME = "flowdeck.json";
 function getGlobalConfigDir() {
-  return process.env.OPENCODE_CONFIG_DIR || (process.env.XDG_CONFIG_HOME ? join23(process.env.XDG_CONFIG_HOME, "opencode") : join23(homedir3(), ".config", "opencode"));
+  return process.env.OPENCODE_CONFIG_DIR || (process.env.XDG_CONFIG_HOME ? join26(process.env.XDG_CONFIG_HOME, "opencode") : join26(homedir3(), ".config", "opencode"));
 }
 function loadFlowDeckConfig(directory) {
   const candidates = [];
   if (directory) {
-    candidates.push(join23(directory, ".opencode", CONFIG_FILENAME));
+    candidates.push(join26(directory, ".opencode", CONFIG_FILENAME));
   }
-  candidates.push(join23(getGlobalConfigDir(), CONFIG_FILENAME));
+  candidates.push(join26(getGlobalConfigDir(), CONFIG_FILENAME));
   for (const configPath of candidates) {
-    if (existsSync24(configPath)) {
+    if (existsSync27(configPath)) {
       try {
-        const content = readFileSync21(configPath, "utf-8");
+        const content = readFileSync23(configPath, "utf-8");
         return JSON.parse(content);
       } catch {
         console.warn(`[flowdeck] Failed to load config from ${configPath}`);
@@ -5908,13 +6168,13 @@ function loadFlowDeckConfig(directory) {
 // src/index.ts
 function loadRulePaths() {
   const __dir = dirname4(fileURLToPath2(import.meta.url));
-  const rulesDir = join24(__dir, "..", "src", "rules");
-  if (!existsSync25(rulesDir))
+  const rulesDir = join27(__dir, "..", "src", "rules");
+  if (!existsSync28(rulesDir))
     return [];
   const paths = [];
   function walk(dir) {
     for (const entry of readdirSync3(dir, { withFileTypes: true })) {
-      const full = join24(dir, entry.name);
+      const full = join27(dir, entry.name);
       if (entry.isDirectory()) {
         walk(full);
       } else if (entry.isFile() && entry.name.endsWith(".md") && entry.name !== "README.md") {
@@ -5927,8 +6187,8 @@ function loadRulePaths() {
 }
 function loadCommands() {
   const __dir = dirname4(fileURLToPath2(import.meta.url));
-  const commandsDir = join24(__dir, "..", "src", "commands");
-  if (!existsSync25(commandsDir))
+  const commandsDir = join27(__dir, "..", "src", "commands");
+  if (!existsSync28(commandsDir))
     return {};
   const commands = {};
   try {
@@ -5936,7 +6196,7 @@ function loadCommands() {
       if (!file.endsWith(".md"))
         continue;
       const name = basename(file, ".md");
-      const raw = readFileSync22(join24(commandsDir, file), "utf-8");
+      const raw = readFileSync24(join27(commandsDir, file), "utf-8");
       let description;
       let template = raw;
       const fmMatch = raw.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/);
@@ -6013,8 +6273,8 @@ var plugin = async (input, _options) => {
           }
         }
       }
-      const skillsDir = join24(dirname4(fileURLToPath2(import.meta.url)), "..", "src", "skills");
-      if (existsSync25(skillsDir)) {
+      const skillsDir = join27(dirname4(fileURLToPath2(import.meta.url)), "..", "src", "skills");
+      if (existsSync28(skillsDir)) {
         const cfgAny = cfg;
         if (!cfgAny.skills || typeof cfgAny.skills !== "object") {
           cfgAny.skills = { paths: [] };
@@ -6100,8 +6360,12 @@ var plugin = async (input, _options) => {
       await contextMonitor.event({ event });
       orchestratorGuard.onEvent(event);
       if (type === "session.idle") {
-        await sessionIdleHook();
-        await autoLearnHook();
+        try {
+          await sessionIdleHook();
+          await autoLearnHook();
+        } finally {
+          fileTracker.clear();
+        }
       }
     },
     "tool.execute.before": async (toolInput, toolOutput) => {