@dv.nghiem/flowdeck 0.3.4 → 0.3.6

package/dist/index.js

@@ -1,6 +1,6 @@
 // src/index.ts
-import { readdirSync as readdirSync3, readFileSync as readFileSync24, existsSync as existsSync28 } from "fs";
-import { join as join27, 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() });
       }
@@ -567,51 +619,6 @@ function recordRun(dir, agent, model, task_type, success, duration_ms, cost = 0)
   saveStore(dir, store);
 }
 
-// src/services/model-router.ts
-import { existsSync as existsSync6, readFileSync as readFileSync6 } from "fs";
-import { join as join6 } from "path";
-var DEFAULT_ROUTING = {
-  planning: { primary: "claude-sonnet-4-5", temperature: 0.3, reasoning_effort: "medium" },
-  implementation: { primary: "claude-opus-4-5", fallback: "claude-sonnet-4-5", high_risk_override: "claude-opus-4-5", temperature: 0.2, reasoning_effort: "high" },
-  debugging: { primary: "claude-sonnet-4-5", high_risk_override: "claude-opus-4-5", temperature: 0.2, reasoning_effort: "high" },
-  review: { primary: "gemini-2.5-flash", fallback: "claude-haiku-4-5", temperature: 0.1, reasoning_effort: "medium" },
-  testing: { primary: "claude-haiku-4-5", fallback: "gemini-2.5-flash", temperature: 0.1, reasoning_effort: "low" },
-  documentation: { primary: "claude-sonnet-4-5", fallback: "gemini-2.5-flash", temperature: 0.3, reasoning_effort: "low" },
-  analysis: { primary: "claude-sonnet-4-5", temperature: 0.3, reasoning_effort: "medium" },
-  security: { primary: "claude-opus-4-5", high_risk_override: "claude-opus-4-5", temperature: 0.1, reasoning_effort: "high" },
-  orchestration: { primary: "claude-sonnet-4-5", temperature: 0.3, reasoning_effort: "medium" }
-};
-function getRouterConfig(dir) {
-  const p = join6(codebaseDir(dir), "MODEL_ROUTER.json");
-  if (!existsSync6(p))
-    return DEFAULT_ROUTING;
-  try {
-    const overrides = JSON.parse(readFileSync6(p, "utf-8"));
-    return { ...DEFAULT_ROUTING, ...overrides };
-  } catch {
-    return DEFAULT_ROUTING;
-  }
-}
-function routeModel(dir, task_type, risk_score = 100) {
-  const config = getRouterConfig(dir);
-  const route = config[task_type] ?? DEFAULT_ROUTING.implementation;
-  const is_high_risk = risk_score < 40;
-  let model = route.primary;
-  let is_override = false;
-  if (is_high_risk && route.high_risk_override) {
-    model = route.high_risk_override;
-    is_override = true;
-  }
-  return {
-    model,
-    temperature: route.temperature ?? 0.3,
-    reasoning_effort: route.reasoning_effort,
-    task_type,
-    is_high_risk,
-    is_override
-  };
-}
-
 // src/tools/dispatch-routing.ts
 function shouldRetry(promptRes) {
   if (!promptRes)
@@ -634,6 +641,8 @@ function normalizeTaskType(taskType, agent) {
   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"))
@@ -653,7 +662,48 @@ function normalizeTaskType(taskType, agent) {
   return "implementation";
 }
 function isTaskType(value) {
-  return value === "planning" || value === "implementation" || value === "debugging" || value === "review" || value === "testing" || value === "documentation" || value === "analysis" || value === "security" || value === "orchestration";
+  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
@@ -699,7 +749,6 @@ function createRunPipelineTool(client) {
           }
           const stepStart = Date.now();
           const taskType = normalizeTaskType(step.task_type, step.agent);
-          const routing = routeModel(context.directory, taskType);
           const stepInput = carryContext ? `${carryContext}
 
 ---
@@ -711,7 +760,7 @@ ${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, task_type: taskType, model: routing.model, 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;
           }
@@ -723,7 +772,6 @@ ${step.prompt}` : step.prompt;
               path: { id: inflightChildId },
               body: {
                 agent: step.agent,
-                model: routing.model,
                 parts: [{ type: "text", text: stepInput }],
                 tools: { question: false }
               },
@@ -740,8 +788,8 @@ ${step.prompt}` : step.prompt;
           }
           if (!promptRes || promptRes.error) {
             const errMsg = `Prompt failed: ${promptRes?.error?.detail ?? "unknown"}`;
-            trace.push({ agent: step.agent, session_id: createRes.data.id, task_type: taskType, model: routing.model, input: stepInput, output: `${errMsg}${retriesUsed > 0 ? ` (retries: ${retriesUsed})` : ""}`, duration_ms: Date.now() - stepStart, success: false });
-            recordRun(context.directory, step.agent, routing.model, taskType, false, Date.now() - stepStart);
+            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;
@@ -751,8 +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, task_type: taskType, model: routing.model, input: stepInput, output: `${errMsg}${retriesUsed > 0 ? ` (retries: ${retriesUsed})` : ""}`, duration_ms: Date.now() - stepStart, success: false });
-            recordRun(context.directory, step.agent, routing.model, taskType, false, Date.now() - stepStart);
+            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;
@@ -760,8 +808,8 @@ ${step.prompt}` : step.prompt;
             continue;
           }
           const output = extractText(promptRes.data?.parts ?? []);
-          trace.push({ agent: step.agent, session_id: createRes.data.id, task_type: taskType, model: routing.model, input: stepInput, output: output || "(no text output)", duration_ms: Date.now() - stepStart, success: true });
-          recordRun(context.directory, step.agent, routing.model, taskType, true, Date.now() - stepStart);
+          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 {
@@ -795,7 +843,6 @@ function createDelegateTool(client) {
     async execute(args, context) {
       const startTime = Date.now();
       const taskType = normalizeTaskType(args.task_type, args.agent);
-      const routing = routeModel(context.directory, taskType);
       const retryAttempts = typeof args.retry_attempts === "number" ? args.retry_attempts : 1;
       const maxRetries = Math.max(0, Math.floor(retryAttempts));
       const createRes = await client.session.create({
@@ -829,7 +876,6 @@ ${args.prompt}` : args.prompt;
           path: { id: childId },
           body: {
             agent: args.agent,
-            model: routing.model,
             parts: [{ type: "text", text: fullPrompt }],
             tools: { question: false }
           },
@@ -840,41 +886,41 @@ ${args.prompt}` : args.prompt;
         retriesUsed++;
       }
       if (!promptRes || promptRes.error) {
-        recordRun(context.directory, args.agent, routing.model, taskType, false, Date.now() - startTime);
+        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"}`,
           task_type: taskType,
-          model: routing.model,
+          model: "",
           retries_used: retriesUsed,
           duration_ms: Date.now() - startTime
         });
       }
       const info = promptRes.data?.info;
       if (info?.error) {
-        recordRun(context.directory, args.agent, routing.model, taskType, false, Date.now() - startTime);
+        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: routing.model,
+          model: "",
           retries_used: retriesUsed,
           duration_ms: Date.now() - startTime
         });
       }
       const output = extractText2(promptRes.data?.parts ?? []);
-      recordRun(context.directory, args.agent, routing.model, taskType, true, Date.now() - startTime);
+      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: routing.model,
+        model: "",
         retries_used: retriesUsed,
         duration_ms: Date.now() - startTime
       });
@@ -884,28 +930,28 @@ ${args.prompt}` : args.prompt;
 
 // src/tools/repo-memory.ts
 import { tool as tool6 } from "@opencode-ai/plugin";
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync6, existsSync as existsSync7, mkdirSync as mkdirSync3 } from "fs";
-import { join as join7 } 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 join7(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 (!existsSync7(p))
+  if (!existsSync6(p))
     return emptyMemory();
   try {
-    return JSON.parse(readFileSync7(p, "utf-8"));
+    return JSON.parse(readFileSync6(p, "utf-8"));
   } catch {
     return emptyMemory();
   }
 }
 function writeMemory(directory, memory) {
   const base = codebaseDir(directory);
-  if (!existsSync7(base))
+  if (!existsSync6(base))
     mkdirSync3(base, { recursive: true });
   memory.last_updated = new Date().toISOString();
   writeFileSync6(memoryPath(directory), JSON.stringify(memory, null, 2), "utf-8");
@@ -985,25 +1031,25 @@ var repoMemoryTool = tool6({
 
 // src/tools/failure-replay.ts
 import { tool as tool7 } from "@opencode-ai/plugin";
-import { readFileSync as readFileSync8, writeFileSync as writeFileSync7, existsSync as existsSync8, mkdirSync as mkdirSync4 } from "fs";
-import { join as join8 } 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 join8(codebaseDir(directory), FAILURES_FILE);
+  return join7(codebaseDir(directory), FAILURES_FILE);
 }
 function readStore(directory) {
   const p = failuresPath(directory);
-  if (!existsSync8(p))
+  if (!existsSync7(p))
     return { version: "1.0", last_updated: new Date().toISOString(), entries: [] };
   try {
-    return JSON.parse(readFileSync8(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 (!existsSync8(base))
+  if (!existsSync7(base))
     mkdirSync4(base, { recursive: true });
   store.last_updated = new Date().toISOString();
   writeFileSync7(failuresPath(directory), JSON.stringify(store, null, 2), "utf-8");
@@ -1090,17 +1136,17 @@ var failureReplayTool = tool7({
 
 // src/tools/decision-trace.ts
 import { tool as tool8 } from "@opencode-ai/plugin";
-import { readFileSync as readFileSync9, existsSync as existsSync9, mkdirSync as mkdirSync5, appendFileSync } from "fs";
-import { join as join9 } 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 join9(codebaseDir(directory), DECISIONS_FILE);
+  return join8(codebaseDir(directory), DECISIONS_FILE);
 }
 function readDecisions(directory) {
   const p = decisionsPath(directory);
-  if (!existsSync9(p))
+  if (!existsSync8(p))
     return [];
-  return readFileSync9(p, "utf-8").split(`
+  return readFileSync8(p, "utf-8").split(`
 `).filter((l) => l.trim()).map((l) => {
     try {
       return JSON.parse(l);
@@ -1140,7 +1186,7 @@ var decisionTraceTool = tool8({
       case "record": {
         if (!args.entry)
           return JSON.stringify({ error: "entry required" });
-        if (!existsSync9(base))
+        if (!existsSync8(base))
           mkdirSync5(base, { recursive: true });
         const entry = { ...args.entry, timestamp: new Date().toISOString() };
         appendFileSync(decisionsPath(dir), JSON.stringify(entry) + `
@@ -1175,25 +1221,25 @@ var decisionTraceTool = tool8({
 
 // src/tools/volatility-map.ts
 import { tool as tool9 } from "@opencode-ai/plugin";
-import { readFileSync as readFileSync10, writeFileSync as writeFileSync9, existsSync as existsSync10, mkdirSync as mkdirSync6 } from "fs";
-import { join as join10 } 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 join10(codebaseDir(directory), VOLATILITY_FILE);
+  return join9(codebaseDir(directory), VOLATILITY_FILE);
 }
 function readStore2(directory) {
   const p = volatilityPath(directory);
-  if (!existsSync10(p))
+  if (!existsSync9(p))
     return { version: "1.0", last_updated: new Date().toISOString(), generated_at: new Date().toISOString(), entries: [] };
   try {
-    return JSON.parse(readFileSync10(p, "utf-8"));
+    return JSON.parse(readFileSync9(p, "utf-8"));
   } catch {
     return { version: "1.0", last_updated: new Date().toISOString(), generated_at: new Date().toISOString(), entries: [] };
   }
 }
 function writeStore2(directory, store) {
   const base = codebaseDir(directory);
-  if (!existsSync10(base))
+  if (!existsSync9(base))
     mkdirSync6(base, { recursive: true });
   store.last_updated = new Date().toISOString();
   writeFileSync9(volatilityPath(directory), JSON.stringify(store, null, 2), "utf-8");
@@ -1283,25 +1329,25 @@ var volatilityMapTool = tool9({
 
 // src/tools/policy-engine.ts
 import { tool as tool10 } from "@opencode-ai/plugin";
-import { readFileSync as readFileSync11, writeFileSync as writeFileSync10, existsSync as existsSync11, mkdirSync as mkdirSync7 } from "fs";
-import { join as join11 } 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 join11(codebaseDir(directory), POLICIES_FILE);
+  return join10(codebaseDir(directory), POLICIES_FILE);
 }
 function readStore3(directory) {
   const p = policiesPath(directory);
-  if (!existsSync11(p))
+  if (!existsSync10(p))
     return { version: "1.0", last_updated: new Date().toISOString(), policies: [] };
   try {
-    return JSON.parse(readFileSync11(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 (!existsSync11(base))
+  if (!existsSync10(base))
     mkdirSync7(base, { recursive: true });
   store.last_updated = new Date().toISOString();
   writeFileSync10(policiesPath(directory), JSON.stringify(store, null, 2), "utf-8");
@@ -1386,7 +1432,7 @@ var policyEngineTool = tool10({
 
 // src/tools/hash-edit.ts
 import { tool as tool11 } from "@opencode-ai/plugin";
-import { readFileSync as readFileSync12, writeFileSync as writeFileSync11 } 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.",
@@ -1400,7 +1446,7 @@ var hashEditTool = tool11({
     const fullPath = args.filePath.startsWith("/") ? args.filePath : `${context.directory}/${args.filePath}`;
     let content;
     try {
-      content = readFileSync12(fullPath, "utf-8");
+      content = readFileSync11(fullPath, "utf-8");
     } catch (e) {
       return `Error: Could not read file ${args.filePath}`;
     }
@@ -1421,8 +1467,8 @@ var hashEditTool = tool11({
 
 // src/tools/council.ts
 import { tool as tool12 } from "@opencode-ai/plugin";
-import { appendFileSync as appendFileSync2, existsSync as existsSync12, mkdirSync as mkdirSync8 } from "fs";
-import { join as join12 } from "path";
+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.",
@@ -1431,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}
@@ -1493,9 +1539,9 @@ Please synthesize these results. Identify areas of agreement, resolve conflicts,
 function persistCouncilResult(directory, payload) {
   try {
     const base = codebaseDir(directory);
-    if (!existsSync12(base))
+    if (!existsSync11(base))
       mkdirSync8(base, { recursive: true });
-    const path = join12(base, "COUNCILS.jsonl");
+    const path = join11(base, "COUNCILS.jsonl");
     appendFileSync2(path, JSON.stringify(payload) + `
 `, "utf-8");
   } catch {}
@@ -1503,8 +1549,8 @@ function persistCouncilResult(directory, payload) {
 
 // src/tools/context-generator.ts
 import { tool as tool13 } from "@opencode-ai/plugin";
-import { writeFileSync as writeFileSync12, existsSync as existsSync13, readFileSync as readFileSync13, readdirSync as readdirSync2, statSync } from "fs";
-import { join as join13 } 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: {
@@ -1513,20 +1559,20 @@ var contextGeneratorTool = tool13({
   },
   async execute(args, context) {
     const root = context.directory;
-    const target = args.targetDir ? join13(root, args.targetDir) : root;
-    if (!existsSync13(target)) {
+    const target = args.targetDir ? join12(root, args.targetDir) : root;
+    if (!existsSync12(target)) {
       return `Error: Directory ${target} does not exist.`;
     }
-    const agentsMdPath = join13(target, "AGENTS.md");
-    if (existsSync13(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 = join13(root, "package.json");
+    const pkgPath = join12(root, "package.json");
     let projectName = "Project";
     let techStack = "Unknown";
-    if (existsSync13(pkgPath)) {
+    if (existsSync12(pkgPath)) {
       try {
-        const pkg = JSON.parse(readFileSync13(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 {}
@@ -1544,7 +1590,7 @@ var contextGeneratorTool = tool13({
 
 ## Directory Map
 ${readdirSync2(target).slice(0, 10).map((f) => {
-      const s = statSync(join13(target, f));
+      const s = statSync(join12(target, f));
       return `- \`${f}\`${s.isDirectory() ? "/" : ""} : [Description]`;
     }).join(`
 `)}
@@ -1559,10 +1605,10 @@ Generated by FlowDeck Context Generator.
 
 // src/tools/create-skill.ts
 import { tool as tool14 } from "@opencode-ai/plugin";
-import { mkdirSync as mkdirSync9, writeFileSync as writeFileSync13, existsSync as existsSync14 } from "fs";
-import { join as join14, 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 = join14(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: {
@@ -1572,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 = join14(SKILLS_DIR, args.name);
-    const skillFile = join14(skillDir, "SKILL.md");
-    if (existsSync14(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.`;
     }
@@ -1602,8 +1648,8 @@ origin: FlowDeck (self-learned)${tagLine}
 
 // src/tools/reflect.ts
 import { tool as tool15 } from "@opencode-ai/plugin";
-import { existsSync as existsSync15, readFileSync as readFileSync14 } from "fs";
-import { join as join15 } from "path";
+import { existsSync as existsSync14, readFileSync as readFileSync13 } from "fs";
+import { join as join14 } from "path";
 var MAX_ARTIFACT_BYTES = 4000;
 function tail(text, maxBytes) {
   if (text.length <= maxBytes)
@@ -1632,11 +1678,11 @@ var reflectTool = tool15({
     ];
     let found = 0;
     for (const [rel, label] of ARTIFACT_PATHS) {
-      const full = join15(root, rel);
-      if (!existsSync15(full))
+      const full = join14(root, rel);
+      if (!existsSync14(full))
         continue;
       try {
-        const raw = readFileSync14(full, "utf-8").trim();
+        const raw = readFileSync13(full, "utf-8").trim();
         if (!raw)
           continue;
         const count = raw.split(`
@@ -1660,26 +1706,37 @@ import { tool as tool16 } from "@opencode-ai/plugin";
 
 // src/services/memory-store.ts
 import { Database } from "bun:sqlite";
-import { existsSync as existsSync16, mkdirSync as mkdirSync10 } from "fs";
-import { join as join16 } from "path";
+import { existsSync as existsSync15, mkdirSync as mkdirSync10 } from "fs";
+import { join as join15 } from "path";
 import { homedir } from "os";
-var MEMORY_DIR = join16(homedir(), ".flowdeck-memory");
-var DB_PATH = join16(MEMORY_DIR, "memory.db");
-function ensureDir() {
-  if (!existsSync16(MEMORY_DIR)) {
-    mkdirSync10(MEMORY_DIR, { recursive: true });
-  }
+function resolveMemoryDir() {
+  return process.env.FLOWDECK_MEMORY_DIR ?? join15(homedir(), ".flowdeck-memory");
 }
+var JS_RETRY_COUNT = 3;
+var JS_RETRY_BASE_MS = 50;
 var db = null;
+function debugLog(msg) {
+  if (process.env.FLOWDECK_MEMORY_DEBUG) {
+    console.error(`[FlowDeck Memory] ${msg}`);
+  }
+}
 function getDb() {
   if (!db) {
-    ensureDir();
-    db = new Database(DB_PATH);
+    const dir = resolveMemoryDir();
+    if (!existsSync15(dir))
+      mkdirSync10(dir, { recursive: true });
+    const dbPath = join15(dir, "memory.db");
+    db = new Database(dbPath);
+    debugLog(`DB opened: ${dbPath}`);
     initializeSchema(db);
   }
   return db;
 }
 function initializeSchema(database) {
+  database.run("PRAGMA journal_mode = WAL");
+  database.run("PRAGMA busy_timeout = 5000");
+  database.run("PRAGMA synchronous = NORMAL");
+  database.run("PRAGMA wal_autocheckpoint = 1000");
   const schema = `
     CREATE TABLE IF NOT EXISTS sessions (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -1707,6 +1764,7 @@ function initializeSchema(database) {
       id INTEGER PRIMARY KEY AUTOINCREMENT,
       session_id INTEGER NOT NULL UNIQUE,
       content TEXT NOT NULL,
+      metadata TEXT,
       created_at TEXT NOT NULL DEFAULT (datetime('now')),
       FOREIGN KEY (session_id) REFERENCES sessions(id)
     );
@@ -1718,6 +1776,49 @@ function initializeSchema(database) {
     CREATE INDEX IF NOT EXISTS idx_sessions_directory ON sessions(directory);
   `;
   database.run(schema);
+  const summaryColumns = database.prepare("PRAGMA table_info(summaries)").all().map((c) => c.name);
+  if (!summaryColumns.includes("metadata")) {
+    database.run("ALTER TABLE summaries ADD COLUMN metadata TEXT");
+    debugLog("Migrated summaries table: added metadata column");
+  }
+}
+function isBusyError(err) {
+  if (!err || typeof err !== "object")
+    return false;
+  const e = err;
+  return e.code === "SQLITE_BUSY" || (e.message?.includes("database is locked") ?? false);
+}
+function sleepSync(ms) {
+  try {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+  } catch {
+    const end = Date.now() + ms;
+    while (Date.now() < end) {}
+  }
+}
+function executeWrite(fn, context) {
+  for (let attempt = 0;attempt <= JS_RETRY_COUNT; attempt++) {
+    const start = Date.now();
+    try {
+      const result = fn();
+      const duration = Date.now() - start;
+      if (attempt > 0) {
+        debugLog(`${context}: succeeded after ${attempt} JS retr${attempt === 1 ? "y" : "ies"} (${duration}ms)`);
+      } else {
+        debugLog(`${context}: completed in ${duration}ms`);
+      }
+      return result;
+    } catch (err) {
+      if (isBusyError(err) && attempt < JS_RETRY_COUNT) {
+        const delay = JS_RETRY_BASE_MS * (attempt + 1);
+        debugLog(`${context}: SQLITE_BUSY — JS retry ${attempt + 1}/${JS_RETRY_COUNT} after ${delay}ms`);
+        sleepSync(delay);
+        continue;
+      }
+      throw err;
+    }
+  }
+  throw new Error(`${context}: exhausted all retries`);
 }
 function serializeToolInput(input) {
   if (!input)
@@ -1745,7 +1846,7 @@ function initSession(contentSessionId, project, directory) {
     database.prepare("UPDATE sessions SET last_active_at = ?, prompt_count = prompt_count + 1 WHERE id = ?").run(now, existing.id);
     return { ...existing, last_active_at: now, prompt_count: (existing.prompt_count || 0) + 1 };
   }
-  const result = database.prepare("INSERT INTO sessions (content_session_id, project, directory, created_at, last_active_at) VALUES (?, ?, ?, ?, ?)").run(contentSessionId, project, directory, now, now);
+  const result = database.prepare("INSERT INTO sessions (content_session_id, project, directory, created_at, last_active_at, prompt_count) VALUES (?, ?, ?, ?, ?, ?)").run(contentSessionId, project, directory, now, now, 1);
   return {
     id: result.lastInsertRowid,
     content_session_id: contentSessionId,
@@ -1759,27 +1860,38 @@ function initSession(contentSessionId, project, directory) {
 function storeObservation(sessionId, toolName, toolInput, toolResponse, directory) {
   const database = getDb();
   const now = new Date().toISOString();
-  const result = database.prepare("INSERT INTO observations (session_id, tool_name, tool_input, tool_response, directory, created_at) VALUES (?, ?, ?, ?, ?, ?)").run(sessionId, toolName, serializeToolInput(toolInput), toolResponse ? toolResponse.slice(0, 1e4) : null, directory, now);
-  database.prepare("UPDATE sessions SET last_active_at = ? WHERE id = ?").run(now, sessionId);
+  const serializedInput = serializeToolInput(toolInput);
+  const truncatedResponse = toolResponse ? toolResponse.slice(0, 1e4) : null;
+  const result = executeWrite(database.transaction(() => {
+    const r = database.prepare("INSERT INTO observations (session_id, tool_name, tool_input, tool_response, directory, created_at) VALUES (?, ?, ?, ?, ?, ?)").run(sessionId, toolName, serializedInput, truncatedResponse, directory, now);
+    database.prepare("UPDATE sessions SET last_active_at = ? WHERE id = ?").run(now, sessionId);
+    return r;
+  }), `storeObservation(${toolName})`);
   return {
     id: result.lastInsertRowid,
     session_id: sessionId,
     tool_name: toolName,
-    tool_input: parseToolInput(serializeToolInput(toolInput)),
-    tool_response: toolResponse ? toolResponse.slice(0, 1e4) : null,
+    tool_input: parseToolInput(serializedInput),
+    tool_response: truncatedResponse,
     directory,
     created_at: now
   };
 }
-function storeSummary(sessionId, content) {
+function storeSummary(sessionId, content, metadata) {
   const database = getDb();
   const now = new Date().toISOString();
-  database.prepare("INSERT OR REPLACE INTO summaries (session_id, content, created_at) VALUES (?, ?, ?)").run(sessionId, content, now);
-  database.prepare("UPDATE sessions SET summary = ? WHERE id = ?").run(content, sessionId);
+  const serializedMetadata = metadata ? JSON.stringify(metadata) : null;
+  const id = executeWrite(database.transaction(() => {
+    database.prepare("INSERT OR REPLACE INTO summaries (session_id, content, metadata, created_at) VALUES (?, ?, ?, ?)").run(sessionId, content, serializedMetadata, now);
+    database.prepare("UPDATE sessions SET summary = ? WHERE id = ?").run(content.slice(0, 2000), sessionId);
+    return database.prepare("SELECT last_insert_rowid() as id").get().id;
+  }), `storeSummary(session=${sessionId})`);
+  debugLog(`storeSummary: wrote ${content.length} chars${metadata ? ` + ${JSON.stringify(metadata).length}B metadata` : ""} for session ${sessionId}`);
   return {
-    id: database.prepare("SELECT last_insert_rowid() as id").get().id,
+    id,
     session_id: sessionId,
     content,
+    metadata: metadata ?? null,
     created_at: now
   };
 }
@@ -1798,6 +1910,20 @@ function getObservationsForSession(sessionId) {
     tool_input: parseToolInput(obs.tool_input)
   }));
 }
+function getSessionSummary(sessionId) {
+  const database = getDb();
+  const row = database.prepare("SELECT * FROM summaries WHERE session_id = ?").get(sessionId);
+  if (!row)
+    return null;
+  return {
+    ...row,
+    metadata: row.metadata ? JSON.parse(row.metadata) : null
+  };
+}
+function getSessionByContentSessionId(contentSessionId) {
+  const database = getDb();
+  return database.prepare("SELECT * FROM sessions WHERE content_session_id = ?").get(contentSessionId) || null;
+}
 function getRecentObservations(directory, limit = 50) {
   const database = getDb();
   const rows = database.prepare(`SELECT o.*, s.project, s.content_session_id, s.created_at as session_created
@@ -1859,11 +1985,15 @@ function getContextForDirectory(directory, maxObservations = 20) {
       lines.push(`Output: ${preview}${observation.tool_response.length > 300 ? "..." : ""}`);
     }
   }
-  const summaries = getDb().prepare(`SELECT su.* FROM summaries su
+  const summaryRows = getDb().prepare(`SELECT su.* FROM summaries su
        JOIN sessions s ON su.session_id = s.id
        WHERE s.directory = ?
        ORDER BY su.created_at DESC
        LIMIT 3`).all(directory);
+  const summaries = summaryRows.map((r) => ({
+    ...r,
+    metadata: r.metadata ? JSON.parse(r.metadata) : null
+  }));
   if (summaries.length > 0) {
     lines.push(`
 ## Session Summaries`);
@@ -1871,12 +2001,20 @@ function getContextForDirectory(directory, maxObservations = 20) {
       const date = sum.created_at ? new Date(sum.created_at).toLocaleDateString() : "unknown";
       lines.push(`
 ### [${date}]`);
-      lines.push(sum.content.slice(0, 500));
+      lines.push(sum.content.slice(0, 2000));
     }
   }
   return lines.join(`
 `);
 }
+function getDbSettings() {
+  const database = getDb();
+  const journalMode = database.prepare("PRAGMA journal_mode").get().journal_mode;
+  const busyTimeout = database.prepare("PRAGMA busy_timeout").get().timeout;
+  const synchronous = database.prepare("PRAGMA synchronous").get().synchronous;
+  const walAutocheckpoint = database.prepare("PRAGMA wal_autocheckpoint").get().wal_autocheckpoint;
+  return { journal_mode: journalMode, busy_timeout: busyTimeout, synchronous, wal_autocheckpoint: walAutocheckpoint };
+}
 
 // src/tools/memory-search.ts
 var memorySearchTool = tool16({
@@ -1896,8 +2034,14 @@ var memorySearchTool = tool16({
         return JSON.stringify({ error: "Session not found", session_id: args.session_id });
       }
       const observations = getObservationsForSession(targetSession.id);
+      const summary = getSessionSummary(targetSession.id);
       return JSON.stringify({
         session: targetSession,
+        summary: summary ? {
+          content: summary.content,
+          metadata: summary.metadata,
+          created_at: summary.created_at
+        } : null,
         observations: observations.map((o) => ({
           tool_name: o.tool_name,
           tool_input: o.tool_input,
@@ -1944,69 +2088,57 @@ 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 existsSync17 } from "fs";
-import { join as join17 } from "path";
+import { existsSync as existsSync16 } from "fs";
+import { join as join16 } from "path";
 import { homedir as homedir2 } from "os";
-var DB_PATH2 = join17(homedir2(), ".flowdeck-memory", "memory.db");
+function resolveDbPath() {
+  return join16(process.env.FLOWDECK_MEMORY_DIR ?? join16(homedir2(), ".flowdeck-memory"), "memory.db");
+}
 var memoryStatusTool = tool17({
   description: "Check FlowDeck memory database status, statistics, and recent sessions",
   args: {},
-  async execute(_args, _context) {
+  async execute(_args, context) {
+    const directory = context?.directory ?? process.cwd();
+    const dbPath = resolveDbPath();
     try {
-      const exists = existsSync17(DB_PATH2);
-      const result = {
-        database_exists: exists,
-        path: DB_PATH2,
-        status: exists ? "ACTIVE" : "NOT_INITIALIZED",
-        statistics: null
-      };
-      if (exists) {
-        try {
-          const db2 = new Database2(DB_PATH2);
-          const sessions = db2.prepare("SELECT COUNT(*) as count FROM sessions").get();
-          const observations = db2.prepare("SELECT COUNT(*) as count FROM observations").get();
-          const summaries = db2.prepare("SELECT COUNT(*) as count FROM summaries").get();
-          const recentSessions = db2.prepare(`
-            SELECT 
-              id,
-              content_session_id,
-              project,
-              directory,
-              created_at,
-              last_active_at,
-              prompt_count
-            FROM sessions
-            ORDER BY last_active_at DESC
-            LIMIT 5
-          `).all();
-          result.statistics = {
-            sessions: sessions.count,
-            observations: observations.count,
-            summaries: summaries.count,
-            recent_sessions: recentSessions.map((s) => {
-              const obsCount = db2.prepare("SELECT COUNT(*) as count FROM observations WHERE session_id = ?").get(s.id);
-              return {
-                project: s.project,
-                directory: s.directory,
-                observations_in_session: obsCount.count,
-                last_active: s.last_active_at,
-                prompt_count: s.prompt_count
-              };
-            })
-          };
-          db2.close();
-        } catch (err) {
-          result.status = "ERROR";
-          result.statistics = { error: String(err) };
-        }
+      const exists = existsSync16(dbPath);
+      if (!exists) {
+        return JSON.stringify({
+          database_exists: false,
+          path: dbPath,
+          status: "NOT_INITIALIZED"
+        }, null, 2);
       }
-      return JSON.stringify(result, null, 2);
+      const settings = getDbSettings();
+      const recentSessions = getRecentSessions(directory, 5);
+      const sessionStats = recentSessions.map((s) => {
+        const observations = getObservationsForSession(s.id);
+        const summary = getSessionSummary(s.id);
+        return {
+          project: s.project,
+          directory: s.directory,
+          content_session_id: s.content_session_id,
+          observations_in_session: observations.length,
+          last_active: s.last_active_at,
+          prompt_count: s.prompt_count,
+          has_summary: !!summary,
+          summary_length: summary?.content.length ?? 0,
+          summary_preview: summary?.content.slice(0, 200) ?? null,
+          handoff_metadata: summary?.metadata ?? null
+        };
+      });
+      return JSON.stringify({
+        database_exists: true,
+        path: dbPath,
+        status: "ACTIVE",
+        pragma_settings: settings,
+        recent_sessions_in_directory: sessionStats
+      }, null, 2);
     } catch (err) {
       return JSON.stringify({
         status: "ERROR",
         error: String(err),
-        path: DB_PATH2
+        path: dbPath
       }, null, 2);
     }
   }
@@ -2014,7 +2146,7 @@ var memoryStatusTool = tool17({
 
 // src/hooks/memory-hook.ts
 var MAX_TOOL_RESPONSE = 1e4;
-var MAX_PROMPT_LENGTH = 2000;
+var MAX_SUMMARY_STORAGE = 50000;
 var activeSessions = new Map;
 function extractProjectFromDirectory(directory) {
   const parts = directory.split("/");
@@ -2025,6 +2157,59 @@ function truncate(str, max) {
     return str || "";
   return str.slice(0, max);
 }
+function buildHandoffMetadata(sessionId, directory, summaryText, observations) {
+  const fileTools = new Set(["edit", "create", "view", "read", "hash-edit", "str-replace-editor"]);
+  const importantFilesSet = new Set;
+  for (const obs of observations) {
+    if (fileTools.has(obs.tool_name) && obs.tool_input) {
+      const path = obs.tool_input.path;
+      if (path)
+        importantFilesSet.add(path);
+    }
+  }
+  const toolNamesUsed = [...new Set(observations.map((o) => o.tool_name).filter((t) => t !== "assistant_message"))];
+  function extractBullets(text) {
+    return text.split(`
+`).filter((l) => /^\s*[-*]/.test(l)).map((l) => l.replace(/^\s*[-*]\s+/, "").trim()).filter(Boolean);
+  }
+  const sections = {};
+  let currentSection = "";
+  const currentLines = [];
+  for (const line of summaryText.split(`
+`)) {
+    const header = line.match(/^##\s+\d+\.\s+(.+)/);
+    if (header) {
+      if (currentSection)
+        sections[currentSection] = currentLines.join(`
+`).trim();
+      currentSection = header[1].trim();
+      currentLines.length = 0;
+    } else {
+      currentLines.push(line);
+    }
+  }
+  if (currentSection)
+    sections[currentSection] = currentLines.join(`
+`).trim();
+  const completed = extractBullets(sections["Work Completed"] ?? "");
+  const pending = extractBullets(sections["Remaining Tasks"] ?? "");
+  return {
+    workflow_name: extractProjectFromDirectory(directory),
+    current_status: "compacted",
+    current_stage: null,
+    completed_stages: completed,
+    pending_stages: pending,
+    key_decisions: [],
+    blockers: [],
+    important_files: [...importantFilesSet].slice(0, 30),
+    approvals: [],
+    open_questions: [],
+    next_steps: pending.slice(0, 5),
+    tool_names_used: toolNamesUsed.slice(0, 20),
+    observation_count: observations.length,
+    updated_at: new Date().toISOString()
+  };
+}
 function onSessionCreated(directory, contentSessionId, prompt) {
   const project = extractProjectFromDirectory(directory);
   const session = initSession(contentSessionId, project, directory);
@@ -2049,7 +2234,11 @@ function onToolExecuted(contentSessionId, toolName, toolInput, toolResponse, dir
     };
     activeSessions.set(contentSessionId, ctx);
   }
-  storeObservation(ctx.sessionId, truncate(toolName, 200), toolInput, toolResponse ? truncate(toolResponse, MAX_TOOL_RESPONSE) : null, directory);
+  try {
+    storeObservation(ctx.sessionId, truncate(toolName, 200), toolInput, toolResponse ? truncate(toolResponse, MAX_TOOL_RESPONSE) : null, directory);
+  } catch (err) {
+    console.warn(`[FlowDeck Memory] Failed to store observation for tool "${toolName}":`, err);
+  }
 }
 function onMessageUpdated(contentSessionId, role, content, directory) {
   if (role !== "assistant")
@@ -2068,33 +2257,64 @@ function onMessageUpdated(contentSessionId, role, content, directory) {
     };
     activeSessions.set(contentSessionId, ctx);
   }
-  storeObservation(ctx.sessionId, "assistant_message", { role }, truncate(content, MAX_TOOL_RESPONSE), directory);
+  try {
+    storeObservation(ctx.sessionId, "assistant_message", { role }, truncate(content, MAX_TOOL_RESPONSE), directory);
+  } catch (err) {
+    console.warn("[FlowDeck Memory] Failed to store assistant message observation:", err);
+  }
 }
 function onSessionCompact(contentSessionId, summary) {
-  const ctx = activeSessions.get(contentSessionId);
-  if (!ctx)
-    return;
-  storeSummary(ctx.sessionId, truncate(summary, MAX_PROMPT_LENGTH));
+  let ctx = activeSessions.get(contentSessionId);
+  if (!ctx) {
+    const dbSession = getSessionByContentSessionId(contentSessionId);
+    if (!dbSession) {
+      console.warn(`[FlowDeck Memory] onSessionCompact: no session found for contentSessionId=${contentSessionId} — summary discarded`);
+      return;
+    }
+    ctx = {
+      sessionId: dbSession.id,
+      contentSessionId,
+      project: dbSession.project,
+      directory: dbSession.directory
+    };
+    activeSessions.set(contentSessionId, ctx);
+  }
+  const storedContent = truncate(summary, MAX_SUMMARY_STORAGE);
+  try {
+    const observations = getObservationsForSession(ctx.sessionId);
+    const metadata = buildHandoffMetadata(ctx.sessionId, ctx.directory, summary, observations);
+    storeSummary(ctx.sessionId, storedContent, metadata);
+  } catch (err) {
+    console.warn(`[FlowDeck Memory] Failed to store compaction summary for session ${ctx.sessionId}:`, err);
+  }
 }
 function onSessionEnd(contentSessionId, lastMessage) {
-  const ctx = activeSessions.get(contentSessionId);
-  if (!ctx)
-    return;
-  if (lastMessage && lastMessage.trim()) {
-    storeSummary(ctx.sessionId, truncate(lastMessage, MAX_PROMPT_LENGTH));
+  let ctx = activeSessions.get(contentSessionId);
+  if (!ctx) {
+    const dbSession = getSessionByContentSessionId(contentSessionId);
+    if (dbSession) {
+      ctx = {
+        sessionId: dbSession.id,
+        contentSessionId,
+        project: dbSession.project,
+        directory: dbSession.directory
+      };
+    }
+  }
+  if (ctx && lastMessage && lastMessage.trim()) {
+    try {
+      const observations = getObservationsForSession(ctx.sessionId);
+      const metadata = buildHandoffMetadata(ctx.sessionId, ctx.directory, lastMessage, observations);
+      storeSummary(ctx.sessionId, truncate(lastMessage, MAX_SUMMARY_STORAGE), metadata);
+    } catch (err) {
+      console.warn(`[FlowDeck Memory] Failed to store end-of-session summary for session ${ctx?.sessionId}:`, err);
+    }
   }
   activeSessions.delete(contentSessionId);
 }
 function getSessionContext(directory, contentSessionId) {
   const context = getContextForDirectory(directory, 30);
   const previousSessions = getRecentSessions(directory, 5);
-  if (previousSessions.length > 0 && activeSessions.has(contentSessionId)) {
-    const ctx = activeSessions.get(contentSessionId);
-    for (const prev of previousSessions) {
-      if (prev.content_session_id === contentSessionId)
-        continue;
-    }
-  }
   return { context, previousSessions };
 }
 function clearSession(contentSessionId) {
@@ -2113,6 +2333,49 @@ var memoryHook = {
 // src/hooks/guard-rails.ts
 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";
@@ -2198,6 +2461,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;
@@ -2220,6 +2487,31 @@ 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 (existsSync18(configPath)) {
     try {
@@ -2332,12 +2624,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;
@@ -3106,7 +3423,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
@@ -3308,11 +3627,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 |
@@ -3323,7 +3653,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 |
@@ -3336,12 +3665,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
@@ -3363,7 +3693,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.
 
@@ -3384,11 +3714,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: All code implementation tasks
-- **Delegate when:** Implementation work, following a plan`,
+- 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: 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
@@ -3460,11 +3805,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
@@ -3766,7 +4106,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
 
@@ -3876,11 +4216,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,
@@ -4027,6 +4418,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:**
@@ -4231,7 +4629,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
@@ -4351,7 +4749,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
 
@@ -4454,7 +4852,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 {
@@ -4802,7 +5200,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
@@ -4905,7 +5303,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 {
@@ -4932,7 +5330,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
 
@@ -4942,7 +5340,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]
@@ -4962,7 +5360,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
 
@@ -5002,7 +5400,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 |
@@ -5140,200 +5540,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 {
@@ -5358,18 +5564,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.
@@ -6016,11 +6210,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",
@@ -6034,13 +6298,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;
@@ -6060,8 +6324,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":
@@ -6088,8 +6356,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":
@@ -6102,6 +6368,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;
@@ -6139,42 +6407,16 @@ function getAgentConfigs(agentModels) {
   return configs;
 }
 
-// src/config/loader.ts
-import { existsSync as existsSync27, readFileSync as readFileSync23 } from "fs";
-import { join as join26 } from "path";
-import { homedir as homedir3 } from "os";
-var CONFIG_FILENAME = "flowdeck.json";
-function getGlobalConfigDir() {
-  return process.env.OPENCODE_CONFIG_DIR || (process.env.XDG_CONFIG_HOME ? join26(process.env.XDG_CONFIG_HOME, "opencode") : join26(homedir3(), ".config", "opencode"));
-}
-function loadFlowDeckConfig(directory) {
-  const candidates = [];
-  if (directory) {
-    candidates.push(join26(directory, ".opencode", CONFIG_FILENAME));
-  }
-  candidates.push(join26(getGlobalConfigDir(), CONFIG_FILENAME));
-  for (const configPath of candidates) {
-    if (existsSync27(configPath)) {
-      try {
-        const content = readFileSync23(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 = join27(__dir, "..", "src", "rules");
-  if (!existsSync28(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 = join27(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") {
@@ -6187,8 +6429,8 @@ function loadRulePaths() {
 }
 function loadCommands() {
   const __dir = dirname4(fileURLToPath2(import.meta.url));
-  const commandsDir = join27(__dir, "..", "src", "commands");
-  if (!existsSync28(commandsDir))
+  const commandsDir = join26(__dir, "..", "src", "commands");
+  if (!existsSync27(commandsDir))
     return {};
   const commands = {};
   try {
@@ -6196,7 +6438,7 @@ function loadCommands() {
       if (!file.endsWith(".md"))
         continue;
       const name = basename(file, ".md");
-      const raw = readFileSync24(join27(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]*)$/);
@@ -6237,12 +6479,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 };
@@ -6273,8 +6519,8 @@ var plugin = async (input, _options) => {
           }
         }
       }
-      const skillsDir = join27(dirname4(fileURLToPath2(import.meta.url)), "..", "src", "skills");
-      if (existsSync28(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: [] };
@@ -6351,7 +6597,7 @@ var plugin = async (input, _options) => {
           const delEvent = event?.event ?? event;
           const sessionId = delEvent?.sessionID ?? delEvent?.sessionId ?? "";
           if (sessionId) {
-            memoryHook.clearSession(sessionId);
+            memoryHook.onSessionEnd(sessionId);
           }
         }
       } catch (err) {