@dv.nghiem/flowdeck 0.3.3 → 0.3.5

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 readFileSync23, existsSync as existsSync27 } from "fs";
+import { join as join26, basename } from "path";
 import { dirname as dirname4 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
@@ -128,6 +128,8 @@ function parseState(content) {
         result[key] = value.replace(/[\[\]]/g, "").split(",").map((s) => s.trim()).filter(Boolean);
       } else if (key === "plan_confirmed") {
         result[key] = value === "true";
+      } else if (key === "requires_design_first" || key === "design_approved" || key === "design_override") {
+        result[key] = value === "true";
       } else if (value !== "" && !isNaN(Number(value)) && key !== "plan_file" && key !== "confirmed_at") {
         result[key] = Number(value);
       } else {
@@ -155,7 +157,21 @@ ${entry}
 function readPlanningState(dir) {
   const sp = statePath(dir);
   if (!existsSync2(sp)) {
-    return { phase: 0, status: "", plan_confirmed: false, steps_complete: [], steps_pending: [], last_action: "", next_action: "", blockers: [], tdd: undefined };
+    return {
+      phase: 0,
+      status: "",
+      plan_confirmed: false,
+      requires_design_first: false,
+      design_stage: "pending",
+      design_approved: false,
+      design_override: false,
+      steps_complete: [],
+      steps_pending: [],
+      last_action: "",
+      next_action: "",
+      blockers: [],
+      tdd: undefined
+    };
   }
   const content = readFileSync2(sp, "utf-8");
   const parsed = parseState(content);
@@ -163,6 +179,13 @@ function readPlanningState(dir) {
     phase: parsed.phase || 1,
     status: parsed.status || "",
     plan_confirmed: Boolean(parsed.plan_confirmed),
+    task_type: parsed.task_type || undefined,
+    requires_design_first: Boolean(parsed.requires_design_first),
+    design_stage: parsed.design_stage || "pending",
+    design_approved: Boolean(parsed.design_approved),
+    design_override: Boolean(parsed.design_override),
+    design_override_reason: parsed.design_override_reason || undefined,
+    design_artifact: parsed.design_artifact || undefined,
     steps_complete: parsed.steps_complete || [],
     steps_pending: parsed.steps_pending || [],
     last_action: parsed.last_action || "",
@@ -251,6 +274,13 @@ var planningStateTool = tool2({
       plan_file: tool2.schema.string().optional(),
       plan_confirmed: tool2.schema.boolean().optional(),
       confirmed_at: tool2.schema.string().optional(),
+      task_type: tool2.schema.string().optional(),
+      requires_design_first: tool2.schema.boolean().optional(),
+      design_stage: tool2.schema.enum(["pending", "discovery", "ux_planning", "wireframe_layout", "visual_system_definition", "design_approval", "handoff_complete"]).optional(),
+      design_approved: tool2.schema.boolean().optional(),
+      design_override: tool2.schema.boolean().optional(),
+      design_override_reason: tool2.schema.string().optional(),
+      design_artifact: tool2.schema.string().optional(),
       steps_complete: tool2.schema.array(tool2.schema.number()).optional(),
       steps_pending: tool2.schema.array(tool2.schema.number()).optional()
     }).optional(),
@@ -273,16 +303,24 @@ var planningStateTool = tool2({
         if (!u)
           return JSON.stringify({ error: "No updates provided" });
         let content = readFileSync3(sp, "utf-8");
+        const upsertLine = (current, key, value) => {
+          const pattern = new RegExp(`^${key}:\\s*.*$`, "m");
+          if (pattern.test(current))
+            return current.replace(pattern, `${key}: ${value}`);
+          return `${current.trimEnd()}
+${key}: ${value}
+`;
+        };
         if (u.phase !== undefined)
-          content = content.replace(/^phase:\s*.*/m, `phase: ${u.phase}`);
+          content = upsertLine(content, "phase", `${u.phase}`);
         if (u.status !== undefined)
-          content = content.replace(/^status:\s*.*/m, `status: ${u.status}`);
+          content = upsertLine(content, "status", `${u.status}`);
         if (u.last_action !== undefined) {
-          content = content.replace(/^last_action:\s*.*/m, `last_action: "${u.last_action}"`);
+          content = upsertLine(content, "last_action", `"${u.last_action}"`);
           content = appendHistory(content, u.last_action);
         }
         if (u.next_action !== undefined)
-          content = content.replace(/^next_action:\s*.*/m, `next_action: "${u.next_action}"`);
+          content = upsertLine(content, "next_action", `"${u.next_action}"`);
         if (u.blockers !== undefined) {
           const blockersMd = u.blockers.map((b) => `- ${b}`).join(`
 `);
@@ -291,15 +329,29 @@ ${blockersMd}
 `);
         }
         if (u.plan_file !== undefined)
-          content = content.replace(/^plan_file:\s*.*/m, `plan_file: ${u.plan_file}`);
+          content = upsertLine(content, "plan_file", `${u.plan_file}`);
         if (u.plan_confirmed !== undefined)
-          content = content.replace(/^plan_confirmed:\s*.*/m, `plan_confirmed: ${u.plan_confirmed}`);
+          content = upsertLine(content, "plan_confirmed", `${u.plan_confirmed}`);
         if (u.confirmed_at !== undefined)
-          content = content.replace(/^confirmed_at:\s*.*/m, `confirmed_at: ${u.confirmed_at}`);
+          content = upsertLine(content, "confirmed_at", `${u.confirmed_at}`);
+        if (u.task_type !== undefined)
+          content = upsertLine(content, "task_type", `"${u.task_type}"`);
+        if (u.requires_design_first !== undefined)
+          content = upsertLine(content, "requires_design_first", `${u.requires_design_first}`);
+        if (u.design_stage !== undefined)
+          content = upsertLine(content, "design_stage", `"${u.design_stage}"`);
+        if (u.design_approved !== undefined)
+          content = upsertLine(content, "design_approved", `${u.design_approved}`);
+        if (u.design_override !== undefined)
+          content = upsertLine(content, "design_override", `${u.design_override}`);
+        if (u.design_override_reason !== undefined)
+          content = upsertLine(content, "design_override_reason", `"${u.design_override_reason}"`);
+        if (u.design_artifact !== undefined)
+          content = upsertLine(content, "design_artifact", `'${u.design_artifact.replace(/'/g, "''")}'`);
         if (u.steps_complete !== undefined)
-          content = content.replace(/^steps_complete:\s*.*/m, `steps_complete: [${u.steps_complete.join(", ")}]`);
+          content = upsertLine(content, "steps_complete", `[${u.steps_complete.join(", ")}]`);
         if (u.steps_pending !== undefined)
-          content = content.replace(/^steps_pending:\s*.*/m, `steps_pending: [${u.steps_pending.join(", ")}]`);
+          content = upsertLine(content, "steps_pending", `[${u.steps_pending.join(", ")}]`);
         writeFileSync3(sp, content, "utf-8");
         return JSON.stringify({ success: true, updated_at: timestamp() });
       }
@@ -509,6 +561,152 @@ 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/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("design") || a.includes("ui-ux"))
+    return "design";
+  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 === "design" || value === "implementation" || value === "debugging" || value === "review" || value === "testing" || value === "documentation" || value === "analysis" || value === "security" || value === "orchestration";
+}
+var UI_HEAVY_KEYWORDS = [
+  "landing page",
+  "marketing site",
+  "website",
+  "web app",
+  "mobile app",
+  "app screen",
+  "dashboard",
+  "admin panel",
+  "settings page",
+  "onboarding ux",
+  "kanban",
+  "design system",
+  "responsive",
+  "ui",
+  "ux",
+  "cta",
+  "conversion flow",
+  "saas interface",
+  "user-facing"
+];
+var NON_UI_KEYWORDS = [
+  "backend",
+  "infrastructure",
+  "migration",
+  "pipeline",
+  "api only",
+  "database only",
+  "cli",
+  "worker"
+];
+function isUiHeavyTask(input) {
+  const normalized = input.trim().toLowerCase();
+  if (!normalized)
+    return false;
+  const hasUiSignal = UI_HEAVY_KEYWORDS.some((keyword) => normalized.includes(keyword));
+  if (!hasUiSignal)
+    return false;
+  const hasOnlyNonUiSignals = NON_UI_KEYWORDS.some((keyword) => normalized.includes(keyword)) && !normalized.includes("frontend");
+  return !hasOnlyNonUiSignals;
+}
+
+// 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 +717,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 +748,7 @@ function createRunPipelineTool(client) {
             break;
           }
           const stepStart = Date.now();
+          const taskType = normalizeTaskType(step.task_type, step.agent);
           const stepInput = carryContext ? `${carryContext}
 
 ---
@@ -557,28 +760,36 @@ ${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: "", 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,
+                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: "", input: stepInput, output: `${errMsg}${retriesUsed > 0 ? ` (retries: ${retriesUsed})` : ""}`, duration_ms: Date.now() - stepStart, success: false });
+            recordRun(context.directory, step.agent, "", taskType, false, Date.now() - stepStart);
             if (args.abort_on_failure) {
               aborted = true;
               break;
@@ -588,7 +799,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: "", input: stepInput, output: `${errMsg}${retriesUsed > 0 ? ` (retries: ${retriesUsed})` : ""}`, duration_ms: Date.now() - stepStart, success: false });
+            recordRun(context.directory, step.agent, "", taskType, false, Date.now() - stepStart);
             if (args.abort_on_failure) {
               aborted = true;
               break;
@@ -596,7 +808,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: "", input: stepInput, output: output || "(no text output)", duration_ms: Date.now() - stepStart, success: true });
+          recordRun(context.directory, step.agent, "", taskType, true, Date.now() - stepStart);
           carryContext = output;
         }
       } finally {
@@ -623,10 +836,15 @@ 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 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 +869,59 @@ 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,
+            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, "", 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: "",
+          retries_used: retriesUsed,
           duration_ms: Date.now() - startTime
         });
       }
       const info = promptRes.data?.info;
       if (info?.error) {
+        recordRun(context.directory, args.agent, "", taskType, false, Date.now() - startTime);
         return JSON.stringify({
           agent: args.agent,
           session_id: childId,
           success: false,
           error: `Agent error: ${JSON.stringify(info.error)}`,
+          task_type: taskType,
+          model: "",
+          retries_used: retriesUsed,
           duration_ms: Date.now() - startTime
         });
       }
       const output = extractText2(promptRes.data?.parts ?? []);
+      recordRun(context.directory, args.agent, "", 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: "",
+        retries_used: retriesUsed,
         duration_ms: Date.now() - startTime
       });
     }
@@ -693,31 +930,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 readFileSync6, writeFileSync as writeFileSync6, existsSync as existsSync6, mkdirSync as mkdirSync3 } from "fs";
+import { join as join6 } from "path";
 var MEMORY_FILE = "MEMORY.json";
 function memoryPath(directory) {
-  return join5(codebaseDir(directory), MEMORY_FILE);
+  return join6(codebaseDir(directory), MEMORY_FILE);
 }
 function emptyMemory() {
   return { version: "1.0", last_updated: new Date().toISOString(), nodes: {} };
 }
 function readMemory(directory) {
   const p = memoryPath(directory);
-  if (!existsSync5(p))
+  if (!existsSync6(p))
     return emptyMemory();
   try {
-    return JSON.parse(readFileSync5(p, "utf-8"));
+    return JSON.parse(readFileSync6(p, "utf-8"));
   } catch {
     return emptyMemory();
   }
 }
 function writeMemory(directory, memory) {
   const base = codebaseDir(directory);
-  if (!existsSync5(base))
-    mkdirSync2(base, { recursive: true });
+  if (!existsSync6(base))
+    mkdirSync3(base, { recursive: true });
   memory.last_updated = new Date().toISOString();
-  writeFileSync5(memoryPath(directory), JSON.stringify(memory, null, 2), "utf-8");
+  writeFileSync6(memoryPath(directory), JSON.stringify(memory, null, 2), "utf-8");
 }
 var repoMemoryTool = tool6({
   description: "Repo Memory Graph: read/write/query persistent architecture graph in .codebase/MEMORY.json (modules, dependencies, ownership, bug history, conventions)",
@@ -794,28 +1031,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 readFileSync7, writeFileSync as writeFileSync7, existsSync as existsSync7, mkdirSync as mkdirSync4 } from "fs";
+import { join as join7 } from "path";
 var FAILURES_FILE = "FAILURES.json";
 function failuresPath(directory) {
-  return join6(codebaseDir(directory), FAILURES_FILE);
+  return join7(codebaseDir(directory), FAILURES_FILE);
 }
 function readStore(directory) {
   const p = failuresPath(directory);
-  if (!existsSync6(p))
+  if (!existsSync7(p))
     return { version: "1.0", last_updated: new Date().toISOString(), entries: [] };
   try {
-    return JSON.parse(readFileSync6(p, "utf-8"));
+    return JSON.parse(readFileSync7(p, "utf-8"));
   } catch {
     return { version: "1.0", last_updated: new Date().toISOString(), entries: [] };
   }
 }
 function writeStore(directory, store) {
   const base = codebaseDir(directory);
-  if (!existsSync6(base))
-    mkdirSync3(base, { recursive: true });
+  if (!existsSync7(base))
+    mkdirSync4(base, { recursive: true });
   store.last_updated = new Date().toISOString();
-  writeFileSync6(failuresPath(directory), JSON.stringify(store, null, 2), "utf-8");
+  writeFileSync7(failuresPath(directory), JSON.stringify(store, null, 2), "utf-8");
 }
 var failureReplayTool = 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 +1136,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 readFileSync8, existsSync as existsSync8, mkdirSync as mkdirSync5, appendFileSync } from "fs";
+import { join as join8 } from "path";
 var DECISIONS_FILE = "DECISIONS.jsonl";
 function decisionsPath(directory) {
-  return join7(codebaseDir(directory), DECISIONS_FILE);
+  return join8(codebaseDir(directory), DECISIONS_FILE);
 }
 function readDecisions(directory) {
   const p = decisionsPath(directory);
-  if (!existsSync7(p))
+  if (!existsSync8(p))
     return [];
-  return readFileSync7(p, "utf-8").split(`
+  return readFileSync8(p, "utf-8").split(`
 `).filter((l) => l.trim()).map((l) => {
     try {
       return JSON.parse(l);
@@ -949,8 +1186,8 @@ var decisionTraceTool = tool8({
       case "record": {
         if (!args.entry)
           return JSON.stringify({ error: "entry required" });
-        if (!existsSync7(base))
-          mkdirSync4(base, { recursive: true });
+        if (!existsSync8(base))
+          mkdirSync5(base, { recursive: true });
         const entry = { ...args.entry, timestamp: new Date().toISOString() };
         appendFileSync(decisionsPath(dir), JSON.stringify(entry) + `
 `, "utf-8");
@@ -984,28 +1221,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 readFileSync9, writeFileSync as writeFileSync9, existsSync as existsSync9, mkdirSync as mkdirSync6 } from "fs";
+import { join as join9 } from "path";
 var VOLATILITY_FILE = "VOLATILITY.json";
 function volatilityPath(directory) {
-  return join8(codebaseDir(directory), VOLATILITY_FILE);
+  return join9(codebaseDir(directory), VOLATILITY_FILE);
 }
 function readStore2(directory) {
   const p = volatilityPath(directory);
-  if (!existsSync8(p))
+  if (!existsSync9(p))
     return { version: "1.0", last_updated: new Date().toISOString(), generated_at: new Date().toISOString(), entries: [] };
   try {
-    return JSON.parse(readFileSync8(p, "utf-8"));
+    return JSON.parse(readFileSync9(p, "utf-8"));
   } catch {
     return { version: "1.0", last_updated: new Date().toISOString(), generated_at: new Date().toISOString(), entries: [] };
   }
 }
 function writeStore2(directory, store) {
   const base = codebaseDir(directory);
-  if (!existsSync8(base))
-    mkdirSync5(base, { recursive: true });
+  if (!existsSync9(base))
+    mkdirSync6(base, { recursive: true });
   store.last_updated = new Date().toISOString();
-  writeFileSync8(volatilityPath(directory), JSON.stringify(store, null, 2), "utf-8");
+  writeFileSync9(volatilityPath(directory), JSON.stringify(store, null, 2), "utf-8");
 }
 function stabilityLabel(churn, hotfixes, todos) {
   const score = churn + hotfixes * 10 + todos * 2;
@@ -1092,28 +1329,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 readFileSync10, writeFileSync as writeFileSync10, existsSync as existsSync10, mkdirSync as mkdirSync7 } from "fs";
+import { join as join10 } from "path";
 var POLICIES_FILE = "POLICIES.json";
 function policiesPath(directory) {
-  return join9(codebaseDir(directory), POLICIES_FILE);
+  return join10(codebaseDir(directory), POLICIES_FILE);
 }
 function readStore3(directory) {
   const p = policiesPath(directory);
-  if (!existsSync9(p))
+  if (!existsSync10(p))
     return { version: "1.0", last_updated: new Date().toISOString(), policies: [] };
   try {
-    return JSON.parse(readFileSync9(p, "utf-8"));
+    return JSON.parse(readFileSync10(p, "utf-8"));
   } catch {
     return { version: "1.0", last_updated: new Date().toISOString(), policies: [] };
   }
 }
 function writeStore3(directory, store) {
   const base = codebaseDir(directory);
-  if (!existsSync9(base))
-    mkdirSync6(base, { recursive: true });
+  if (!existsSync10(base))
+    mkdirSync7(base, { recursive: true });
   store.last_updated = new Date().toISOString();
-  writeFileSync9(policiesPath(directory), JSON.stringify(store, null, 2), "utf-8");
+  writeFileSync10(policiesPath(directory), JSON.stringify(store, null, 2), "utf-8");
 }
 var policyEngineTool = 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 +1432,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 readFileSync11, 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 +1446,7 @@ var hashEditTool = tool11({
     const fullPath = args.filePath.startsWith("/") ? args.filePath : `${context.directory}/${args.filePath}`;
     let content;
     try {
-      content = readFileSync10(fullPath, "utf-8");
+      content = readFileSync11(fullPath, "utf-8");
     } catch (e) {
       return `Error: Could not read file ${args.filePath}`;
     }
@@ -1223,13 +1460,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 existsSync11, mkdirSync as mkdirSync8 } from "fs";
+import { join as join11 } 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.",
@@ -1238,7 +1477,7 @@ function createCouncilTool(client) {
       agents: tool12.schema.array(tool12.schema.string()).optional()
     },
     async execute(args, context) {
-      const agents = args.agents || ["architect", "reviewer", "coder"];
+      const agents = args.agents || ["architect", "reviewer", "backend-coder"];
       const tasks = agents.map((agent) => ({
         agent,
         prompt: `TASK: ${args.task}
@@ -1284,16 +1523,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 (!existsSync11(base))
+      mkdirSync8(base, { recursive: true });
+    const path = join11(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 existsSync12, readFileSync as readFileSync12, readdirSync as readdirSync2, statSync } from "fs";
+import { join as join12 } 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 +1559,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 ? join12(root, args.targetDir) : root;
+    if (!existsSync12(target)) {
       return `Error: Directory ${target} does not exist.`;
     }
-    const agentsMdPath = join10(target, "AGENTS.md");
-    if (existsSync10(agentsMdPath) && !args.force) {
+    const agentsMdPath = join12(target, "AGENTS.md");
+    if (existsSync12(agentsMdPath) && !args.force) {
       return `AGENTS.md already exists in ${target}. Use force: true to overwrite.`;
     }
-    const pkgPath = join10(root, "package.json");
+    const pkgPath = join12(root, "package.json");
     let projectName = "Project";
     let techStack = "Unknown";
-    if (existsSync10(pkgPath)) {
+    if (existsSync12(pkgPath)) {
       try {
-        const pkg = JSON.parse(readFileSync11(pkgPath, "utf-8"));
+        const pkg = JSON.parse(readFileSync12(pkgPath, "utf-8"));
         projectName = pkg.name || projectName;
         techStack = Object.keys(pkg.dependencies || {}).slice(0, 5).join(", ");
       } catch {}
@@ -1333,7 +1590,7 @@ var contextGeneratorTool = tool13({
 
 ## Directory Map
 ${readdirSync2(target).slice(0, 10).map((f) => {
-      const s = statSync(join10(target, f));
+      const s = statSync(join12(target, f));
       return `- \`${f}\`${s.isDirectory() ? "/" : ""} : [Description]`;
     }).join(`
 `)}
@@ -1341,17 +1598,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 existsSync13 } from "fs";
+import { join as join13, dirname as dirname3 } from "path";
 import { fileURLToPath } from "url";
-var SKILLS_DIR = join11(dirname3(fileURLToPath(import.meta.url)), "..", "skills");
+var SKILLS_DIR = join13(dirname3(fileURLToPath(import.meta.url)), "..", "skills");
 var createSkillTool = 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 +1618,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 = join13(SKILLS_DIR, args.name);
+    const skillFile = join13(skillDir, "SKILL.md");
+    if (existsSync13(skillFile)) {
       return `Skill '${args.name}' already exists at ${skillFile}.
 ` + `Use a different name or delete the existing skill directory first.`;
     }
@@ -1378,8 +1635,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 +1648,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 existsSync14, readFileSync as readFileSync13 } from "fs";
+import { join as join14 } from "path";
 var MAX_ARTIFACT_BYTES = 4000;
 function tail(text, maxBytes) {
   if (text.length <= maxBytes)
@@ -1421,11 +1678,11 @@ var reflectTool = tool15({
     ];
     let found = 0;
     for (const [rel, label] of ARTIFACT_PATHS) {
-      const full = join12(root, rel);
-      if (!existsSync12(full))
+      const full = join14(root, rel);
+      if (!existsSync14(full))
         continue;
       try {
-        const raw = readFileSync12(full, "utf-8").trim();
+        const raw = readFileSync13(full, "utf-8").trim();
         if (!raw)
           continue;
         const count = raw.split(`
@@ -1449,14 +1706,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 existsSync15, mkdirSync as mkdirSync10 } from "fs";
+import { join as join15 } from "path";
 import { homedir } from "os";
-var MEMORY_DIR = join13(homedir(), ".flowdeck-memory");
-var DB_PATH = join13(MEMORY_DIR, "memory.db");
+var MEMORY_DIR = join15(homedir(), ".flowdeck-memory");
+var DB_PATH = join15(MEMORY_DIR, "memory.db");
 function ensureDir() {
-  if (!existsSync13(MEMORY_DIR)) {
-    mkdirSync8(MEMORY_DIR, { recursive: true });
+  if (!existsSync15(MEMORY_DIR)) {
+    mkdirSync10(MEMORY_DIR, { recursive: true });
   }
 }
 var db = null;
@@ -1734,16 +1991,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 existsSync16 } from "fs";
+import { join as join16 } from "path";
 import { homedir as homedir2 } from "os";
-var DB_PATH2 = join14(homedir2(), ".flowdeck-memory", "memory.db");
+var DB_PATH2 = join16(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 = existsSync16(DB_PATH2);
       const result = {
         database_exists: exists,
         path: DB_PATH2,
@@ -1900,15 +2157,58 @@ 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";
+
+// src/config/loader.ts
+import { existsSync as existsSync17, readFileSync as readFileSync14 } from "fs";
+import { join as join17 } 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 ? join17(process.env.XDG_CONFIG_HOME, "opencode") : join17(homedir3(), ".config", "opencode"));
+}
+function loadFlowDeckConfig(directory) {
+  const candidates = [];
+  if (directory) {
+    candidates.push(join17(directory, ".opencode", CONFIG_FILENAME));
+  }
+  candidates.push(join17(getGlobalConfigDir(), CONFIG_FILENAME));
+  for (const configPath of candidates) {
+    if (existsSync17(configPath)) {
+      try {
+        const content = readFileSync14(configPath, "utf-8");
+        return JSON.parse(content);
+      } catch {
+        console.warn(`[flowdeck] Failed to load config from ${configPath}`);
+      }
+    }
+  }
+  return {};
+}
+function resolveDesignFirstConfig(config) {
+  return {
+    enabled: config.designFirst?.enabled ?? true,
+    enforcement: config.designFirst?.enforcement ?? "strict",
+    requireApprovalBeforeImplementation: config.designFirst?.requireApprovalBeforeImplementation ?? true,
+    modelOverrides: config.designFirst?.modelOverrides ?? {},
+    defaultSkillsByTaskType: config.designFirst?.defaultSkillsByTaskType ?? {
+      "landing-page": ["landing-page-design", "wireframe-planning", "design-system-definition", "frontend-handoff"],
+      dashboard: ["dashboard-design", "ui-ux-planning", "wireframe-planning", "responsive-review"],
+      "admin-panel": ["ui-ux-planning", "wireframe-planning", "design-system-definition", "frontend-handoff"],
+      "app-screen": ["app-shell-design", "ui-ux-planning", "wireframe-planning", "responsive-review"],
+      "general-ui": ["ui-ux-planning", "wireframe-planning", "design-system-definition", "frontend-handoff"]
+    }
+  };
+}
+// src/hooks/guard-rails.ts
 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 +2262,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);
@@ -1987,6 +2287,10 @@ async function guardRailsHook(ctx, input, _output) {
     if (execMode === "guarded") {
       throw new Error(`[flowdeck] GUARDED MODE: edit will proceed but flag for human review.`);
     }
+    const designGateMessage = getDesignGateMessage(dir);
+    if (designGateMessage) {
+      throw new Error(designGateMessage);
+    }
     const effectiveSeverity = getEffectiveSeverity(configPath, statePath2);
     if (effectiveSeverity === null)
       return;
@@ -2009,10 +2313,35 @@ async function guardRailsHook(ctx, input, _output) {
     }
   }
 }
+function getDesignGateMessage(dir) {
+  const designConfig = resolveDesignFirstConfig(loadFlowDeckConfig(dir));
+  if (!designConfig.enabled || !designConfig.requireApprovalBeforeImplementation)
+    return null;
+  const state = readPlanningState(dir);
+  if (state.design_override && state.design_override_reason && state.design_override_reason.trim().length > 0)
+    return null;
+  const designApproved = state.design_stage === "handoff_complete" && state.design_approved;
+  if (state.requires_design_first || state.task_type && isUiHeavyTask(state.task_type) || planSuggestsUiHeavy(dir, state.phase || 1)) {
+    if (designApproved)
+      return null;
+    if (designConfig.enforcement === "advisory") {
+      return "[flowdeck] WARNING: UI-heavy task detected without approved design handoff. Run /fd-design --mode=draft first.";
+    }
+    return "[flowdeck] BLOCK: UI-heavy task requires approved design handoff. Run /fd-design --mode=draft or set explicit design override in STATE.md.";
+  }
+  return null;
+}
+function planSuggestsUiHeavy(dir, phase) {
+  const planPath = phasePlanPath(dir, phase);
+  if (!existsSync18(planPath))
+    return false;
+  const planContent = readFileSync15(planPath, "utf-8");
+  return isUiHeavyTask(planContent);
+}
 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 +2357,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 +2368,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 +2429,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;
@@ -2121,12 +2450,37 @@ function checkArchConstraint(directory, filePath) {
 function checkPhaseEnforcement(directory) {
   try {
     const state = readPlanningState(directory);
+    const flowdeckConfig = resolveDesignFirstConfig(loadFlowDeckConfig(directory));
     if (state.phase > 0 && state.phase < 3) {
       return `FLOWDECK [phase-gate]: writing to codebase is blocked in phase ${state.phase} (${state.phase === 1 ? "discuss" : "plan"}). Run /fd-plan --confirm to enter execute phase.`;
     }
+    if (flowdeckConfig.enabled && flowdeckConfig.requireApprovalBeforeImplementation && isUiDesignApprovalRequired(directory)) {
+      if (flowdeckConfig.enforcement === "advisory") {
+        return `FLOWDECK [design-gate]: advisory design-first mode detected missing approval. Run /fd-design --mode=draft or set design_override=true in STATE.md.`;
+      }
+      return `FLOWDECK [design-gate]: UI-heavy task requires approved design handoff before implementation. Run /fd-design --mode=draft and ensure design_stage=handoff_complete + design_approved=true, or set explicit design_override with reason.`;
+    }
   } catch {}
   return null;
 }
+function isUiDesignApprovalRequired(directory) {
+  const state = readPlanningState(directory);
+  if (state.design_override && state.design_override_reason && state.design_override_reason.trim().length > 0)
+    return false;
+  if (state.requires_design_first) {
+    return !(state.design_stage === "handoff_complete" && state.design_approved);
+  }
+  if (state.task_type && isUiHeavyTask(state.task_type)) {
+    return !(state.design_stage === "handoff_complete" && state.design_approved);
+  }
+  const planPath = phasePlanPath(directory, state.phase || 1);
+  if (!existsSync19(planPath))
+    return false;
+  const planContent = readFileSync16(planPath, "utf-8");
+  if (!isUiHeavyTask(planContent))
+    return false;
+  return !(state.design_stage === "handoff_complete" && state.design_approved);
+}
 async function toolGuardHook(ctx, input, output) {
   if (!IS_ENABLED())
     return;
@@ -2151,18 +2505,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 +2527,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 +2535,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 +2550,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 +2616,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 +2639,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 +2653,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 +2722,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 +2732,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 +2745,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 +2862,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 +2964,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 +3001,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 +3010,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 +3018,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 +3116,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 +3161,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;
@@ -2871,7 +3249,9 @@ function blockMessage(toolName) {
 ` + `The orchestrator is a coordinator — it must delegate all implementation work.
 
 ` + `Use the \`delegate\` tool to hand this off:
-` + `  delegate({ agent: "@coder", prompt: "..." })      — code writing / editing
+` + `  delegate({ agent: "@backend-coder", prompt: "..." })      — backend code writing / editing
+` + `  delegate({ agent: "@frontend-coder", prompt: "..." })     — frontend code writing / editing
+` + `  delegate({ agent: "@devops", prompt: "..." })             — CI/CD, deploy, and infra changes
 ` + `  delegate({ agent: "@mapper", prompt: "..." })     — codebase mapping
 ` + `  delegate({ agent: "@researcher", prompt: "..." }) — research / file analysis
 ` + `  delegate({ agent: "@tester", prompt: "..." })     — tests / commands
@@ -2882,13 +3262,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 +3295,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;
@@ -3048,11 +3453,22 @@ For each incomplete step in PLAN.md:
 5. Re-read STATE.md to confirm state
 6. Move to the next incomplete step
 
+## Implementation Routing
+
+When a plan step requires implementation, route to a role-specific agent:
+- Use @backend-coder for server, API, business logic, database, and non-UI application code.
+- Use @frontend-coder for UI components, client state, styling, and interaction behavior.
+- Use @devops for CI/CD workflows, deployment, infrastructure, runtime config, and operations scripts.
+- If a step mixes multiple domains, split it into multiple delegated tasks by domain.
+
 ## Agent Team
 
 | Agent | Invoke | Best For |
 |-------|--------|----------|
-| Coder | @coder | All code implementation |
+| Design | @design | Discovery, UX planning, wireframes, visual system, implementation handoff, design fidelity review |
+| Backend Coder | @backend-coder | Backend code implementation |
+| Frontend Coder | @frontend-coder | Frontend code implementation |
+| DevOps | @devops | CI/CD and infrastructure implementation |
 | Researcher | @researcher | API docs, library usage |
 | Tester | @tester | Writing and running tests |
 | Reviewer | @reviewer | Code quality review |
@@ -3063,7 +3479,6 @@ For each incomplete step in PLAN.md:
 | Code Explorer | @code-explorer | Reading unfamiliar code |
 | Debug Specialist | @debug-specialist | Root cause analysis |
 | Build Resolver | @build-error-resolver | Build/compile failures |
-| Parallel Coordinator | @parallel-coordinator | Multi-track parallel work |
 | Doc Updater | @doc-updater | Updating existing docs |
 | Task Splitter | @task-splitter | Decomposing complex tasks |
 | Discusser | @discusser | Requirements extraction |
@@ -3076,12 +3491,13 @@ For each incomplete step in PLAN.md:
 ## Phase State Machine
 
 \`\`\`
-discuss → plan → execute → review
+discuss → plan → design (for UI-heavy tasks) → execute → review
 \`\`\`
 
 - **discuss**: Requirements extraction with @discusser
 - **plan**: Plan creation with @planner, review with @plan-checker
-- **execute**: Implementation with @coder, @tester, @researcher in parallel where possible
+- **design**: UX structure, wireframe/layout planning, and visual system definition with @design
+- **execute**: Implementation with @backend-coder, @frontend-coder, @devops, @tester, and @researcher in parallel where possible, only after approved design handoff for UI-heavy tasks
 - **review**: Review with @reviewer, @security-auditor
 
 ## Tracking
@@ -3103,7 +3519,7 @@ If a delegated agent fails:
 3. If still failing, escalate:
 
 \`\`\`
-BLOCKED: @coder failed on step 3 (add payment endpoint).
+BLOCKED: implementation agent failed on step 3 (add payment endpoint).
 Error: [exact error message]
 Retried once with clarification. Still failing.
 
@@ -3124,11 +3540,26 @@ When a task required unusual human guidance, a novel solution strategy, or expos
 
 Do NOT create a skill for routine tasks. Only capture genuinely novel or reusable patterns.`;
 var AGENT_DESCRIPTIONS = {
-  coder: `@coder
-- Role: Implements features and fixes based on confirmed plans
+  design: `@design
+- Role: Runs design-first workflow for user-facing tasks
+- Permissions: Read/write files
+- Best for: UX structure, wireframes, visual direction, tokens, and frontend handoff
+- **Delegate when:** Task includes website/app/dashboard/admin/user-facing UI work`,
+  "backend-coder": `@backend-coder
+- Role: Implements backend features and fixes based on confirmed plans
+- Permissions: Read/write files
+- Best for: API, services, data layer, and business logic
+- **Delegate when:** Backend or server-side implementation work`,
+  "frontend-coder": `@frontend-coder
+- Role: Implements frontend features and fixes based on confirmed plans
+- Permissions: Read/write files
+- Best for: UI components, client state, rendering, and interaction behavior
+- **Delegate when:** Frontend implementation work`,
+  devops: `@devops
+- Role: Implements DevOps and infrastructure changes based on confirmed plans
 - Permissions: Read/write files
-- Best for: All code implementation tasks
-- **Delegate when:** Implementation work, following a plan`,
+- Best for: CI/CD, deployment config, infra scripts, and runtime operations
+- **Delegate when:** Infrastructure, pipeline, or operations implementation work`,
   researcher: `@researcher
 - Role: Researches documentation, APIs, and best practices
 - Permissions: Read files
@@ -3200,11 +3631,6 @@ var AGENT_DESCRIPTIONS = {
 - Permissions: Read/write files
 - Best for: Requirements extraction
 - **Delegate when:** Starting new feature or project phase`,
-  "parallel-coordinator": `@parallel-coordinator
-- Role: Coordinates multi-wave parallel execution
-- Permissions: Read files
-- Best for: Multi-track parallel work
-- **Delegate when:** Need to execute multiple tasks in parallel`,
   planner: `@planner
 - Role: Creates detailed implementation plans
 - Permissions: Read files
@@ -3506,7 +3932,7 @@ var createPlanCheckerAgent = (model, customPrompt, customAppendPrompt) => {
 };
 
 // src/agents/coder.ts
-var CODER_PROMPT = `You implement features and fix bugs. You follow the plan exactly. You do not invent requirements.
+var BASE_IMPLEMENTER_PROMPT = `You implement features and fix bugs. You follow the plan exactly. You do not invent requirements.
 
 ## Before Writing Code
 
@@ -3616,11 +4042,62 @@ After implementing, report:
 - Tests added or updated
 - Any deviations from the plan and why
 - Next step ready to execute`;
-var createCoderAgent = (model, customPrompt, customAppendPrompt) => {
-  const prompt = resolvePrompt(CODER_PROMPT, customPrompt, customAppendPrompt);
+var BACKEND_CODER_PROMPT = `${BASE_IMPLEMENTER_PROMPT}
+
+## Domain Focus
+
+Prioritize backend and platform code:
+- Server handlers, services, repositories, jobs, and business logic
+- Database and persistence-layer changes
+- API contracts and boundary validation
+`;
+var FRONTEND_CODER_PROMPT = `${BASE_IMPLEMENTER_PROMPT}
+
+## Domain Focus
+
+Prioritize frontend implementation quality:
+- UI components, client state, accessibility, and interaction behavior
+- Styling consistency with existing design system/tokens
+- Browser/runtime safety (no server-only assumptions in client code)
+`;
+var DEVOPS_PROMPT = `${BASE_IMPLEMENTER_PROMPT}
+
+## Domain Focus
+
+Prioritize infrastructure and delivery tasks:
+- CI/CD workflows, build pipelines, deployment configuration
+- Environment/runtime configuration and operational scripts
+- Reliability and rollback safety for production-facing changes
+`;
+var createBackendCoderAgent = (model, customPrompt, customAppendPrompt) => {
+  const prompt = resolvePrompt(BACKEND_CODER_PROMPT, customPrompt, customAppendPrompt);
   return {
-    name: "coder",
-    description: "Implements features and fixes based on confirmed plans. Follows existing code patterns and project conventions. Use for all code implementation tasks.",
+    name: "backend-coder",
+    description: "Implements backend features and fixes based on confirmed plans. Follows existing code patterns and project conventions.",
+    config: {
+      model,
+      temperature: 0.1,
+      prompt
+    }
+  };
+};
+var createFrontendCoderAgent = (model, customPrompt, customAppendPrompt) => {
+  const prompt = resolvePrompt(FRONTEND_CODER_PROMPT, customPrompt, customAppendPrompt);
+  return {
+    name: "frontend-coder",
+    description: "Implements frontend features and fixes based on confirmed plans. Follows existing code patterns and project conventions.",
+    config: {
+      model,
+      temperature: 0.1,
+      prompt
+    }
+  };
+};
+var createDevopsAgent = (model, customPrompt, customAppendPrompt) => {
+  const prompt = resolvePrompt(DEVOPS_PROMPT, customPrompt, customAppendPrompt);
+  return {
+    name: "devops",
+    description: "Implements DevOps and infrastructure changes based on confirmed plans. Follows existing repo conventions and operational safety practices.",
     config: {
       model,
       temperature: 0.1,
@@ -3767,6 +4244,13 @@ var REVIEWER_PROMPT = `You review code for correctness, security, and quality. Y
 4. Apply the checklist below
 5. Report by severity — CRITICAL first, then HIGH, MEDIUM, PASS
 
+If the task is UI-heavy and a design artifact is available, include design fidelity checks:
+- visual hierarchy and spacing consistency
+- CTA flow quality
+- responsive behavior
+- accessibility semantics and states
+- empty/loading/error/success state coverage
+
 ## Security Checklist — CRITICAL
 
 **Hardcoded credentials:**
@@ -3971,7 +4455,7 @@ Never fabricate information to appear more helpful.
 ## Scope Boundaries
 
 - Report facts only. Do not make implementation decisions.
-- Do not write code unless asked. Return research findings for the coder to act on.
+- Do not write code unless asked. Return research findings for the implementation agent to act on.
 - If you find a better approach than what was requested, mention it as an option — do not substitute it.
 
 ## Research Areas
@@ -4091,7 +4575,7 @@ var createWriterAgent = (model, customPrompt, customAppendPrompt) => {
 };
 
 // src/agents/security-auditor.ts
-var SECURITY_AUDITOR_PROMPT = `You audit code for security vulnerabilities. You report findings with severity and specific remediation. You do not fix — that is @coder's job.
+var SECURITY_AUDITOR_PROMPT = `You audit code for security vulnerabilities. You report findings with severity and specific remediation. You do not fix — that is the implementation agent's job (@backend-coder, @frontend-coder, or @devops).
 
 ## Audit Scope
 
@@ -4194,7 +4678,7 @@ For high/critical vulnerabilities: report exact package, CVE ID, and whether it'
 
 ## After Finding Issues
 
-Report only. Do not fix. Tag @coder with specific remediations for each finding.`;
+Report only. Do not fix. Tag the appropriate implementation agent (@backend-coder, @frontend-coder, or @devops) with specific remediations for each finding.`;
 var createSecurityAuditorAgent = (model, customPrompt, customAppendPrompt) => {
   const prompt = resolvePrompt(SECURITY_AUDITOR_PROMPT, customPrompt, customAppendPrompt);
   return {
@@ -4542,7 +5026,7 @@ request → router → UserController.create() → UserService.create() → ❌
 
 ## Scope
 
-Report only. Do not implement the fix. Tag @coder with the recommended fix.`;
+Report only. Do not implement the fix. Tag the appropriate implementation agent (@backend-coder, @frontend-coder, or @devops) with the recommended fix.`;
 var BUILD_ERROR_RESOLVER_PROMPT = `You fix build failures. You read the full error output, find the root cause, and apply the minimum fix to get the build green.
 
 ## Diagnostic Commands
@@ -4645,7 +5129,7 @@ npx tsc --noEmit src/path/to/file.ts
 
 - Build fails because of architectural problems → @architect
 - A feature is not working correctly → @debug-specialist
-- Missing functionality needs to be written → @coder`;
+- Missing functionality needs to be written → @backend-coder/@frontend-coder/@devops`;
 var createDebugSpecialistAgent = (model, customPrompt, customAppendPrompt) => {
   const prompt = resolvePrompt(DEBUG_SPECIALIST_PROMPT, customPrompt, customAppendPrompt);
   return {
@@ -4672,7 +5156,7 @@ var createBuildErrorResolverAgent = (model, customPrompt, customAppendPrompt) =>
 };
 
 // src/agents/specialist.ts
-var TASK_SPLITTER_PROMPT = `You decompose complex tasks into parallel workstreams. You identify dependencies, group independent work into waves, and produce a plan that @parallel-coordinator can execute.
+var TASK_SPLITTER_PROMPT = `You decompose complex tasks into parallel workstreams. You identify dependencies, group independent work into waves, and produce a plan that @orchestrator can execute.
 
 ## Wave-Structured Output
 
@@ -4682,7 +5166,7 @@ var TASK_SPLITTER_PROMPT = `You decompose complex tasks into parallel workstream
 ### Wave 1 (parallel — start simultaneously)
 
 **Track A — [description]**
-- Agent: @coder
+- Agent: @backend-coder
 - Files: \`src/auth/user.ts\`, \`src/auth/types.ts\`
 - Task: [specific implementation task]
 - Verify: [how to confirm it's done]
@@ -4702,7 +5186,7 @@ var TASK_SPLITTER_PROMPT = `You decompose complex tasks into parallel workstream
 ### Wave 2 (after Wave 1 completes)
 
 **Track D — Integration**
-- Agent: @coder
+- Agent: @backend-coder
 - Depends on: Track A, Track C
 - Task: Wire together outputs from Wave 1
 
@@ -4742,7 +5226,9 @@ After Wave 2: @reviewer reviews all changes together
 | Agent | Best For |
 |-------|---------|
 | @architect | Interface contracts, ADRs |
-| @coder | Implementation |
+| @backend-coder | Backend implementation |
+| @frontend-coder | Frontend implementation |
+| @devops | Infrastructure implementation |
 | @researcher | API docs, library research |
 | @tester | Test writing and coverage |
 | @reviewer | Code quality review |
@@ -4880,200 +5366,6 @@ Discussion is complete when:
 - No open questions remain
 
 Report: "Requirements gathering complete. N decisions recorded. Ready for /plan."`;
-var PARALLEL_COORDINATOR_PROMPT = `You orchestrate multi-wave parallel execution. At the start of every job you emit a WAVE TABLE, then delegate agents by wave, wait for wave completion before advancing, and merge outputs when parallel tracks converge.
-
-## Your Outputs
-
-1. **WAVE TABLE** — printed at job start, shows every agent slot and its dependencies
-2. **Agent briefings** — full context packet per agent (they are stateless — give them everything)
-3. **Wave reports** — status after each wave closes
-4. **Merge resolution** — reconcile outputs when two tracks touched the same conceptual area
-
-## WAVE TABLE Format
-
-Print this at the start of every job before delegating any agents:
-
-\`\`\`
-╔══════════════════════════════════════════════════════════════╗
-║  WAVE TABLE — [Job Title]                                    ║
-╠══════════════════════════════════════════════════════════════╣
-║  Wave 1 (parallel)  │ @researcher + @code-explorer          ║
-║  Wave 2 (serial)    │ @architect                             ║
-║  Wave 3 (parallel)  │ @coder + @tester                      ║
-║  Wave 4 (parallel)  │ @reviewer + @security-auditor         ║
-╠══════════════════════════════════════════════════════════════╣
-║  Est. sequential:   │ 8h                                     ║
-║  Est. parallel:     │ 4.5h                                   ║
-║  Dependency locks:  │ Wave 3 blocked on Wave 2 output        ║
-╚══════════════════════════════════════════════════════════════╝
-\`\`\`
-
-Adjust lanes based on actual task content. Remove any wave whose agents have no work.
-
-## Standard Wave Delegation Syntax
-
-**Wave 1 — Discovery (parallelize):**
-\`\`\`
-@researcher: [exact research task with sources to check]
-@code-explorer: [exact files/modules to map — list paths]
-\`\`\`
-Start both simultaneously. Do not wait for one before sending the other.
-
-**Wave 2 — Architecture (serial, depends on Wave 1):**
-\`\`\`
-@architect: [design task — attach Wave 1 outputs as context]
-\`\`\`
-One agent. Must complete before Wave 3 starts.
-
-**Wave 3 — Implementation (parallelize, depends on Wave 2):**
-\`\`\`
-@coder: [implementation task — attach @architect output + relevant Wave 1 findings]
-@tester: [test task — attach interface contracts from @architect, NOT @coder output]
-\`\`\`
-Start both simultaneously once Wave 2 output is in hand. @tester works from contracts, not @coder's code, so they are truly parallel.
-
-**Wave 4 — Validation (parallelize):**
-\`\`\`
-@reviewer: [review scope — list files changed by Wave 3]
-@security-auditor: [audit scope — list entry points, auth surfaces, data flows]
-\`\`\`
-Start both once Wave 3 is complete.
-
-## Parallelism Rules
-
-**Safe to parallelize:**
-- Tasks touching different files with no shared output
-- Research alongside implementation (research produces inputs, not outputs of implementation)
-- Test writing from interface contracts alongside implementation
-- Documentation alongside implementation when writing to different files
-
-**Must be sequential:**
-- Task B's design depends on decisions Task A makes
-- Task B reads a file Task A will write
-- Both tasks modify the same file
-
-**Not worth parallelizing:**
-- Total estimated work is under 20 minutes
-- File ownership is ambiguous — if unclear who owns a file, serialize it
-
-## Agent Team
-
-| Agent | Best For |
-|-------|---------|
-| @architect | Interface contracts, ADRs, system design |
-| @coder | All code implementation |
-| @researcher | API docs, library usage, best practices |
-| @tester | Test writing and coverage |
-| @reviewer | Code quality review |
-| @security-auditor | Security vulnerability audit |
-| @writer | New documentation |
-| @doc-updater | Updating existing documentation |
-| @code-explorer | Mapping unfamiliar code |
-| @debug-specialist | Root cause analysis |
-| @build-error-resolver | Build and compile failures |
-
-## Merging Parallel Outputs
-
-When two Wave 3+ agents both worked on the same conceptual area (e.g., both touched auth logic, both proposed an interface for the same type):
-
-**Step 1 — Detect the overlap.** After each wave, compare the file sets each agent reported touching. Any overlap is a merge candidate.
-
-**Step 2 — Classify the overlap:**
-- **Additive** (different functions in the same file): safe to auto-merge, reconcile manually.
-- **Structural** (same type, same interface, same function signature): do not auto-merge — escalate.
-- **Contradictory** (one agent added a field, another removed it): escalate.
-
-**Step 3 — Resolve:**
-- Additive: apply both changesets, verify no symbol collisions, verify tests pass.
-- Structural or contradictory: invoke the conflict resolution protocol below.
-
-## Conflict Resolution Protocol
-
-Trigger when two tracks produced incompatible changes to the same logical unit.
-
-\`\`\`
-CONFLICT DETECTED
-  Track A (@coder): added \`refreshToken: string\` to UserSession in src/types/session.ts
-  Track B (@tester): wrote tests assuming UserSession has no refresh field
-  Classification: Structural — interface mismatch
-
-RESOLUTION PLAN
-  1. Suspend Track B output (do not apply tests yet)
-  2. Delegate to @coder: reconcile both versions sequentially
-     - Brief: "Track A and Track B produced incompatible changes. [Attach both outputs.]
-       Produce a single unified version that satisfies both intents."
-  3. Once @coder delivers unified version: re-run @tester against it
-  4. Mark original conflict as resolved, continue to Wave 4
-\`\`\`
-
-Never silently pick one side. Always surface what was lost in the merge and why.
-
-## Failure Handling
-
-**Wave failure does not block independent waves.**
-
-Before each wave starts, classify each task as:
-- **Blocking** — downstream waves need its output
-- **Independent** — downstream waves do not depend on it
-
-If a blocking task fails:
-\`\`\`
-Wave 1 FAILURE — @researcher: could not retrieve bcrypt API docs
-Impact: Wave 3 @coder task "implement password hashing" is blocked.
-Action: Pause that specific Wave 3 slot. Continue all other Wave 3 slots.
-Retry: Re-run @researcher with a fallback source list, then unblock the Wave 3 slot.
-\`\`\`
-
-If an independent task fails:
-\`\`\`
-Wave 4 FAILURE — @security-auditor: process timed out
-Impact: None — @reviewer completed independently.
-Action: Log failure. Do not block Wave 4 close. Re-run @security-auditor as a follow-up.
-\`\`\`
-
-Wave gates work per-slot, not per-wave: a wave closes when all blocking slots complete. Independent failures are retried async.
-
-## Full Execution Report Format
-
-\`\`\`markdown
-## Parallel Execution Report — [Job Title]
-
-### Wave 1 Results (Discovery)
-| Track | Agent | Status | Output |
-|-------|-------|--------|--------|
-| A | @researcher | ✅ | \`.planning/research/bcrypt.md\` |
-| B | @code-explorer | ✅ | \`.codebase/auth-module-map.md\` |
-
-### Wave 1 → Wave 2 Gate
-- All blocking slots complete: ✅
-- Merge check: no file conflicts
-
-### Wave 2 Results (Architecture)
-| Track | Agent | Status | Output |
-|-------|-------|--------|--------|
-| A | @architect | ✅ | \`.planning/adr/auth-design.md\`, interface contracts |
-
-### Wave 3 Results (Implementation)
-| Track | Agent | Status | Output |
-|-------|-------|--------|--------|
-| A | @coder | ✅ | \`src/auth/service.ts\`, \`src/auth/session.ts\` |
-| B | @tester | ✅ | \`src/auth/service.test.ts\` — 14 tests, 14 passing |
-
-### Wave 3 Merge Check
-- File overlap: none
-- Conceptual overlap: @coder and @tester both reference UserSession — compatible ✅
-
-### Wave 4 Results (Validation)
-| Track | Agent | Status | Output |
-|-------|-------|--------|--------|
-| A | @reviewer | ✅ | 2 non-blocking suggestions filed |
-| B | @security-auditor | ⚠️ FAILED | Timeout — retrying async |
-
-### Final Status
-- All blocking work complete ✅
-- @security-auditor re-run scheduled as follow-up
-- Elapsed: 4h 20m (vs 8h sequential)
-\`\`\``;
 var createTaskSplitterAgent = (model, customPrompt, customAppendPrompt) => {
   const prompt = resolvePrompt(TASK_SPLITTER_PROMPT, customPrompt, customAppendPrompt);
   return {
@@ -5098,18 +5390,6 @@ var createDiscusserAgent = (model, customPrompt, customAppendPrompt) => {
     }
   };
 };
-var createParallelCoordinatorAgent = (model, customPrompt, customAppendPrompt) => {
-  const prompt = resolvePrompt(PARALLEL_COORDINATOR_PROMPT, customPrompt, customAppendPrompt);
-  return {
-    name: "parallel-coordinator",
-    description: "Coordinates parallel agent execution for multi-track workstreams. Manages wave execution, handles merge conflicts, and maximizes throughput.",
-    config: {
-      model,
-      temperature: 0.1,
-      prompt
-    }
-  };
-};
 
 // src/agents/architect.ts
 var ARCHITECT_PROMPT = `You design system architecture, create Architecture Decision Records (ADRs), and define API contracts before implementation begins.
@@ -5756,11 +6036,81 @@ function createAutoLearnerAgent(model) {
   return definition;
 }
 
+// src/agents/design.ts
+var DESIGN_PROMPT = `You are the dedicated design architect for user-facing products. Your work is mandatory before coding for UI-heavy tasks unless an explicit override is recorded.
+
+## Scope
+
+Use this workflow for website, web app, mobile app, dashboard, admin panel, landing page, SaaS interface, onboarding UX, and other user-facing surfaces.
+
+## Required Execution Stages
+
+For UI-heavy tasks, produce all stages in order:
+1. discovery
+2. ux_planning
+3. wireframe_layout
+4. visual_system_definition
+5. design_approval
+6. implementation_handoff
+
+Do not skip or merge stages.
+
+## Structured Output Contract
+
+Always return machine-readable markdown sections with these keys:
+- task_type
+- user_goals
+- target_audience
+- core_user_flows
+- page_map_or_screen_map
+- section_structure
+- layout_plan
+- component_list
+- state_list (loading, empty, error, success)
+- responsive_behavior_notes
+- visual_direction
+- design_tokens_guidance
+- accessibility_notes
+- implementation_handoff_checklist
+- approval_status
+
+## Design Review Mode
+
+When asked to review an implemented UI, compare against approved design artifacts and report:
+- design mismatches
+- hierarchy issues
+- spacing inconsistency
+- weak call-to-action flow
+- responsiveness issues
+- accessibility concerns
+- component inconsistency
+- missing empty/error states
+
+## Constraints
+
+- Do not write implementation code in design mode.
+- Do not claim approval without explicit pass/fail rationale.
+- Keep output concise but complete enough for frontend handoff.`;
+var createDesignAgent = (model, customPrompt, customAppendPrompt) => {
+  const prompt = resolvePrompt(DESIGN_PROMPT, customPrompt, customAppendPrompt);
+  return {
+    name: "design",
+    description: "Design-first specialist for UX structure, wireframe planning, visual system definition, and frontend handoff before implementation.",
+    config: {
+      model,
+      temperature: 0.1,
+      prompt
+    }
+  };
+};
+
 // src/agents/index.ts
 var AGENT_NAMES = [
   "orchestrator",
   "planner",
-  "coder",
+  "backend-coder",
+  "frontend-coder",
+  "devops",
   "plan-checker",
   "tester",
   "reviewer",
@@ -5774,13 +6124,13 @@ var AGENT_NAMES = [
   "build-error-resolver",
   "task-splitter",
   "discusser",
-  "parallel-coordinator",
   "architect",
   "risk-analyst",
   "policy-enforcer",
   "performance-optimizer",
   "refactor-guide",
-  "auto-learner"
+  "auto-learner",
+  "design"
 ];
 var PRIMARY_AGENTS = new Set(["orchestrator"]);
 var ALL_MODES_AGENTS = new Set;
@@ -5800,8 +6150,12 @@ function createAgent(name, model, customPrompt, customAppendPrompt) {
       return createOrchestratorAgent(model, customPrompt, customAppendPrompt);
     case "planner":
       return createPlannerAgent(model, customPrompt, customAppendPrompt);
-    case "coder":
-      return createCoderAgent(model, customPrompt, customAppendPrompt);
+    case "backend-coder":
+      return createBackendCoderAgent(model, customPrompt, customAppendPrompt);
+    case "frontend-coder":
+      return createFrontendCoderAgent(model, customPrompt, customAppendPrompt);
+    case "devops":
+      return createDevopsAgent(model, customPrompt, customAppendPrompt);
     case "plan-checker":
       return createPlanCheckerAgent(model, customPrompt, customAppendPrompt);
     case "tester":
@@ -5828,8 +6182,6 @@ function createAgent(name, model, customPrompt, customAppendPrompt) {
       return createTaskSplitterAgent(model, customPrompt, customAppendPrompt);
     case "discusser":
       return createDiscusserAgent(model, customPrompt, customAppendPrompt);
-    case "parallel-coordinator":
-      return createParallelCoordinatorAgent(model, customPrompt, customAppendPrompt);
     case "architect":
       return createArchitectAgent(model, customPrompt, customAppendPrompt);
     case "risk-analyst":
@@ -5842,6 +6194,8 @@ function createAgent(name, model, customPrompt, customAppendPrompt) {
       return createRefactorGuideAgent(model, customPrompt, customAppendPrompt);
     case "auto-learner":
       return createAutoLearnerAgent(model);
+    case "design":
+      return createDesignAgent(model, customPrompt, customAppendPrompt);
     default:
       console.warn(`[flowdeck] Unknown agent: ${name}`);
       return;
@@ -5879,42 +6233,16 @@ function getAgentConfigs(agentModels) {
   return configs;
 }
 
-// src/config/loader.ts
-import { existsSync as existsSync24, readFileSync as readFileSync21 } from "fs";
-import { join as join23 } 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"));
-}
-function loadFlowDeckConfig(directory) {
-  const candidates = [];
-  if (directory) {
-    candidates.push(join23(directory, ".opencode", CONFIG_FILENAME));
-  }
-  candidates.push(join23(getGlobalConfigDir(), CONFIG_FILENAME));
-  for (const configPath of candidates) {
-    if (existsSync24(configPath)) {
-      try {
-        const content = readFileSync21(configPath, "utf-8");
-        return JSON.parse(content);
-      } catch {
-        console.warn(`[flowdeck] Failed to load config from ${configPath}`);
-      }
-    }
-  }
-  return {};
-}
 // src/index.ts
 function loadRulePaths() {
   const __dir = dirname4(fileURLToPath2(import.meta.url));
-  const rulesDir = join24(__dir, "..", "src", "rules");
-  if (!existsSync25(rulesDir))
+  const rulesDir = join26(__dir, "..", "src", "rules");
+  if (!existsSync27(rulesDir))
     return [];
   const paths = [];
   function walk(dir) {
     for (const entry of readdirSync3(dir, { withFileTypes: true })) {
-      const full = join24(dir, entry.name);
+      const full = join26(dir, entry.name);
       if (entry.isDirectory()) {
         walk(full);
       } else if (entry.isFile() && entry.name.endsWith(".md") && entry.name !== "README.md") {
@@ -5927,8 +6255,8 @@ function loadRulePaths() {
 }
 function loadCommands() {
   const __dir = dirname4(fileURLToPath2(import.meta.url));
-  const commandsDir = join24(__dir, "..", "src", "commands");
-  if (!existsSync25(commandsDir))
+  const commandsDir = join26(__dir, "..", "src", "commands");
+  if (!existsSync27(commandsDir))
     return {};
   const commands = {};
   try {
@@ -5936,7 +6264,7 @@ function loadCommands() {
       if (!file.endsWith(".md"))
         continue;
       const name = basename(file, ".md");
-      const raw = readFileSync22(join24(commandsDir, file), "utf-8");
+      const raw = readFileSync23(join26(commandsDir, file), "utf-8");
       let description;
       let template = raw;
       const fmMatch = raw.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/);
@@ -5977,12 +6305,16 @@ var plugin = async (input, _options) => {
         cfg.default_agent = "orchestrator";
       }
       const flowdeckConfig = loadFlowDeckConfig(directory);
+      const designFirstConfig = resolveDesignFirstConfig(flowdeckConfig);
       const agentModels = {};
       for (const [name, agentCfg] of Object.entries(flowdeckConfig.agents ?? {})) {
         if (agentCfg.model) {
           agentModels[name] = agentCfg.model;
         }
       }
+      if (designFirstConfig.modelOverrides.design) {
+        agentModels.design = designFirstConfig.modelOverrides.design;
+      }
       const resolvedAgentConfigs = getAgentConfigs(agentModels);
       if (!cfg.agent) {
         cfg.agent = { ...resolvedAgentConfigs };
@@ -6013,8 +6345,8 @@ var plugin = async (input, _options) => {
           }
         }
       }
-      const skillsDir = join24(dirname4(fileURLToPath2(import.meta.url)), "..", "src", "skills");
-      if (existsSync25(skillsDir)) {
+      const skillsDir = join26(dirname4(fileURLToPath2(import.meta.url)), "..", "src", "skills");
+      if (existsSync27(skillsDir)) {
         const cfgAny = cfg;
         if (!cfgAny.skills || typeof cfgAny.skills !== "object") {
           cfgAny.skills = { paths: [] };
@@ -6100,8 +6432,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) => {