create-claude-kanban 1.0.0

package/templates/kanban.cjs

@@ -0,0 +1,1837 @@
+#!/usr/bin/env node
+/**
+ * claude-kanban — Real-time agent kanban dashboard
+ * Run: claude-kanban or node bin/server.cjs
+ *
+ * ~/.claude/tasks/ watch → SSE browser auto-update
+ * Server-side CRUD — POST/PUT/DELETE /api/tasks
+ * Manual tasks → ~/.claude/tasks/kanban/
+ */
+
+// ── Config Loading ──
+// Load kanban.config.json from project root, fallback to env vars
+var config;
+var _configPath = require("path").join(__dirname, "..", "kanban.config.json");
+try {
+  var _rawConfig = require("fs").readFileSync(_configPath, "utf-8");
+  var _fileConfig = JSON.parse(_rawConfig);
+  try { require("dotenv").config({ path: require("path").join(__dirname, "..", ".env") }); } catch {}
+  config = {
+    port: parseInt(process.env.PORT) || _fileConfig.port || 4040,
+    projectName: _fileConfig.projectName || "Project",
+    slack: {
+      webhookUrl: process.env.SLACK_AGENT_WEBHOOK || "",
+      botToken: process.env.SLACK_BOT_TOKEN || "",
+      appToken: process.env.SLACK_APP_TOKEN || "",
+      channelId: process.env.SLACK_CHANNEL_ID || "",
+      adminUsers: (process.env.SLACK_ADMIN_USERS || "").split(",").filter(Boolean),
+      command: process.env.SLACK_COMMAND || (_fileConfig.slack && _fileConfig.slack.command) || "/kanban",
+    },
+    agents: _fileConfig.agents || {},
+    paths: _fileConfig.paths || { agents: ".claude/agents", tasks: ".claude/tasks", logs: ".claude/logs" },
+  };
+} catch {
+  try { require("dotenv").config({ path: require("path").join(__dirname, "..", ".env") }); } catch {}
+  config = {
+    port: parseInt(process.env.PORT) || 4040,
+    projectName: "Project",
+    slack: {
+      webhookUrl: process.env.SLACK_AGENT_WEBHOOK || "",
+      botToken: process.env.SLACK_BOT_TOKEN || "",
+      appToken: process.env.SLACK_APP_TOKEN || "",
+      channelId: process.env.SLACK_CHANNEL_ID || "",
+      adminUsers: (process.env.SLACK_ADMIN_USERS || "").split(",").filter(Boolean),
+      command: process.env.SLACK_COMMAND || "/kanban",
+    },
+    agents: {},
+    paths: { agents: ".claude/agents", tasks: ".claude/tasks", logs: ".claude/logs" },
+  };
+}
+
+const http = require("http");
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const { execSync, spawn } = require("child_process");
+
+const PORT = config.port;
+const PROJECT_NAME = config.projectName;
+const TASKS_DIR = path.join(os.homedir(), ".claude", "tasks");
+const KANBAN_DIR = path.join(TASKS_DIR, "kanban");
+const ACTIVITY_FILE = path.join(TASKS_DIR, "activity.jsonl");
+
+if (!fs.existsSync(KANBAN_DIR)) {
+  fs.mkdirSync(KANBAN_DIR, { recursive: true });
+}
+
+const SLACK_WEBHOOK = config.slack.webhookUrl;
+const SLACK_BOT_TOKEN = config.slack.botToken;
+const SLACK_APP_TOKEN = config.slack.appToken;
+const SLACK_CHANNEL_ID = config.slack.channelId;
+const SLACK_ADMIN_USERS = config.slack.adminUsers;
+const SLACK_COMMAND = config.slack.command;
+let slackApp = null;
+let slackAskActive = false;
+
+// ── Slack Thread Management ──
+const threadMap = new Map(); // taskId → slackThreadTs
+
+function loadThreadMap() {
+  // Load slackThreadTs from all existing task JSON files
+  var tasks = [];
+  try {
+    if (fs.existsSync(TASKS_DIR)) {
+      var sessions = fs.readdirSync(TASKS_DIR, { withFileTypes: true });
+      for (var s = 0; s < sessions.length; s++) {
+        if (!sessions[s].isDirectory()) continue;
+        var sp = path.join(TASKS_DIR, sessions[s].name);
+        var files = fs.readdirSync(sp).filter(function (f) { return f.endsWith(".json"); });
+        for (var fi = 0; fi < files.length; fi++) {
+          try {
+            var raw = fs.readFileSync(path.join(sp, files[fi]), "utf-8");
+            var t = JSON.parse(raw);
+            if (t.id && t.slackThreadTs) {
+              threadMap.set(String(t.id), t.slackThreadTs);
+            }
+          } catch {}
+        }
+      }
+    }
+  } catch {}
+  if (threadMap.size > 0) {
+    console.log("  Slack threads: loaded " + threadMap.size + " thread mappings");
+  }
+}
+
+function setThreadTs(taskId, ts) {
+  if (!ts) return;
+  threadMap.set(String(taskId), ts);
+  // Persist to task JSON
+  var filePath = findTaskFile(String(taskId));
+  if (filePath) {
+    try {
+      var task = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+      task.slackThreadTs = ts;
+      fs.writeFileSync(filePath, JSON.stringify(task, null, 2));
+    } catch {}
+  }
+}
+
+function getThreadTs(taskId) {
+  return threadMap.get(String(taskId)) || null;
+}
+
+// ── Chat Session ──
+let chatSessionId = null;
+let chatSessionModel = null;
+
+// ── Orchestrator Prompt System ──
+const ORCHESTRATOR_FILE = path.join(os.homedir(), ".claude", "orchestrator.md");
+const ORCHESTRATOR_LOG = path.join(os.homedir(), ".claude", "orchestrator-history.jsonl");
+
+function readOrchestratorPrompt() {
+  try { return fs.readFileSync(ORCHESTRATOR_FILE, "utf-8"); } catch { return ""; }
+}
+
+function readOrchestratorHistory(limit) {
+  if (!fs.existsSync(ORCHESTRATOR_LOG)) return "";
+  try {
+    var lines = fs.readFileSync(ORCHESTRATOR_LOG, "utf-8").trim().split("\n").filter(Boolean);
+    var recent = lines.slice(-1 * (limit || 10));
+    return recent.map(function (line) {
+      try {
+        var e = JSON.parse(line);
+        return "[" + e.ts + "] " + (e.role || "system") + ": " + e.content;
+      } catch { return ""; }
+    }).filter(Boolean).join("\n");
+  } catch { return ""; }
+}
+
+function appendOrchestratorHistory(role, content) {
+  var entry = { ts: new Date().toISOString(), role: role, content: content.slice(0, 500) };
+  try { fs.appendFileSync(ORCHESTRATOR_LOG, JSON.stringify(entry) + "\n"); } catch {}
+  // Trim to 500 entries
+  try {
+    var lines = fs.readFileSync(ORCHESTRATOR_LOG, "utf-8").trim().split("\n");
+    if (lines.length > 600) {
+      fs.writeFileSync(ORCHESTRATOR_LOG, lines.slice(-500).join("\n") + "\n");
+    }
+  } catch {}
+}
+
+function extractAndSaveLearnings(text) {
+  var regex = /<!--\s*LEARN:\s*(.*?)\s*-->/g;
+  var match;
+  var learnings = [];
+  while ((match = regex.exec(text)) !== null) {
+    learnings.push(match[1].trim());
+  }
+  if (learnings.length === 0) return;
+  try {
+    var content = fs.readFileSync(ORCHESTRATOR_FILE, "utf-8");
+    var marker = "## Learnings";
+    var idx = content.indexOf(marker);
+    if (idx >= 0) {
+      var ts = new Date().toISOString().slice(0, 10);
+      var additions = learnings.map(function (l) { return "- [" + ts + "] " + l; }).join("\n");
+      var insertPos = content.indexOf("\n", idx + marker.length);
+      if (insertPos < 0) insertPos = content.length;
+      // Find end of the comment line after marker
+      var afterMarker = content.indexOf("\n", insertPos + 1);
+      if (afterMarker < 0) afterMarker = content.length;
+      content = content.slice(0, afterMarker) + "\n" + additions + content.slice(afterMarker);
+      fs.writeFileSync(ORCHESTRATOR_FILE, content);
+    }
+  } catch {}
+}
+
+// ── Action Block Parser ──
+function parseActionBlocks(text) {
+  var actions = [];
+  var cleaned = text.replace(/:::action\n([\s\S]*?)\n:::/g, function (match, json) {
+    try {
+      actions.push(JSON.parse(json.trim()));
+    } catch (e) {
+      return match; // malformed — leave as-is
+    }
+    return "";
+  });
+  return { cleaned: cleaned.trim(), actions: actions };
+}
+
+function executeAction(action) {
+  var results = [];
+  switch (action.type) {
+    case "task_create": {
+      var task = createTask(action.data || {});
+      results.push({ action: "task_create", ok: true, task: { id: task.id, subject: task.subject } });
+      break;
+    }
+    case "task_update": {
+      var task = updateTask(String(action.id), action.data || {});
+      results.push({ action: "task_update", ok: !!task, task: task ? { id: task.id, subject: task.subject } : null });
+      break;
+    }
+    case "task_delete": {
+      var ok = deleteTask(String(action.id));
+      results.push({ action: "task_delete", ok: ok, id: String(action.id) });
+      break;
+    }
+    case "task_execute": {
+      var t = readAllTasks().find(function (t) { return String(t.id) === String(action.id); });
+      if (t) {
+        if (t.status === "pending") updateTask(String(action.id), { status: "in_progress" });
+        else enqueueExec(t);
+        results.push({ action: "task_execute", ok: true, id: String(action.id) });
+      } else {
+        results.push({ action: "task_execute", ok: false, id: String(action.id) });
+      }
+      break;
+    }
+    case "task_execute_batch": {
+      var ids = action.ids || [];
+      for (var i = 0; i < ids.length; i++) {
+        var bt = readAllTasks().find(function (t) { return String(t.id) === String(ids[i]); });
+        if (bt) {
+          if (bt.status === "pending") updateTask(String(ids[i]), { status: "in_progress" });
+          else enqueueExec(bt);
+        }
+      }
+      results.push({ action: "task_execute_batch", ok: true, ids: ids });
+      break;
+    }
+  }
+  return results;
+}
+
+function buildChatSystemPrompt(tasks, projectName) {
+  var orchestratorPrompt = readOrchestratorPrompt();
+  var history = readOrchestratorHistory(5);
+  var taskDetail = tasks.map(function (t) {
+    var line = "#" + t.id + " [" + t.status + "] " + t.subject;
+    if (t.agent) line += " (agent:" + t.agent + ")";
+    if (t.owner) line += " (owner:" + t.owner + ")";
+    if (t.priority === "high" || t.priority === "critical") line += " [" + t.priority.toUpperCase() + "]";
+    if (t.blockedBy && t.blockedBy.length) line += " blocked-by:" + t.blockedBy.join(",");
+    if (t.activeForm) line += " — " + t.activeForm;
+    return line;
+  }).join("\n");
+
+  var prompt = "";
+  if (orchestratorPrompt) {
+    prompt += orchestratorPrompt + "\n\n";
+  } else {
+    prompt += "You are the Orchestrator for the " + projectName + " Kanban board.\n\n";
+  }
+  prompt += "## Current Board State\n";
+  prompt += "Project: " + projectName + "\n";
+  prompt += "Working directory: " + path.join(__dirname, "..") + "\n\n";
+  prompt += (taskDetail || "(보드 비어있음)") + "\n\n";
+  if (history) {
+    prompt += "## Recent Orchestrator Decisions\n" + history + "\n\n";
+  }
+
+  // Action block instructions
+  prompt += "## Task Actions\n";
+  prompt += "You can create, update, delete, and execute tasks directly using action blocks.\n";
+  prompt += "Include action blocks in your response to manipulate the board:\n\n";
+  prompt += "Create task:\n:::action\n";
+  prompt += '{"type":"task_create","data":{"subject":"제목","description":"상세 설명","priority":"medium","agent":"frontend"}}\n';
+  prompt += ":::\n\n";
+  prompt += "Update task:\n:::action\n";
+  prompt += '{"type":"task_update","id":"15","data":{"status":"in_progress","activeForm":"진행 중 메시지"}}\n';
+  prompt += ":::\n\n";
+  prompt += "Delete task:\n:::action\n";
+  prompt += '{"type":"task_delete","id":"15"}\n';
+  prompt += ":::\n\n";
+  prompt += "Execute task (starts agent):\n:::action\n";
+  prompt += '{"type":"task_execute","id":"15"}\n';
+  prompt += ":::\n\n";
+  prompt += "Batch execute:\n:::action\n";
+  prompt += '{"type":"task_execute_batch","ids":["15","16","17"]}\n';
+  prompt += ":::\n\n";
+  prompt += "After each action block, write a natural language confirmation.\n";
+  prompt += "When the user says '실행해', '시작해', 'execute' — create tasks and execute immediately.\n";
+  prompt += "For broad/ambiguous requests, present a plan and wait for confirmation.\n\n";
+
+  prompt += "## Agent Roles & Models\n";
+  prompt += "| Agent | Model |\n";
+  prompt += "|-------|-------|\n";
+  if (config.agents) {
+    Object.keys(config.agents).forEach(function (name) {
+      prompt += "| " + name + " | " + (config.agents[name].model || "sonnet") + " |\n";
+    });
+  }
+  prompt += "\n";
+
+  prompt += "## Chat Formatting Rules\n";
+  prompt += "- Do NOT wrap plain words in backticks. Only use backticks for actual code snippets or CLI commands.\n";
+  prompt += "- Keep responses concise. Use plain text for normal conversation.\n";
+  prompt += "- Tables are OK for structured data. Avoid excessive bold/headers.\n\n";
+  return prompt;
+}
+
+function boardSummary(tasks) {
+  const pending = tasks.filter(t => t.status === "pending");
+  const inProgress = tasks.filter(t => t.status === "in_progress");
+  const completed = tasks.filter(t => t.status === "completed");
+  const total = tasks.length;
+  const pct = total ? Math.round((completed.length / total) * 100) : 0;
+  let summary = `📊 Board: ${completed.length}✅ ${inProgress.length}🔄 ${pending.length}⏳ (${pct}% done)`;
+  if (inProgress.length > 0) {
+    summary += "\n🔄 *In progress:* " + inProgress.map(t => `#${t.id} ${t.subject}${t.activeForm ? " — _" + t.activeForm + "_" : ""}`).join(", ");
+  }
+  if (pending.length > 0 && pending.length <= 5) {
+    summary += "\n⏳ *Up next:* " + pending.map(t => `#${t.id} ${t.subject}`).join(", ");
+  } else if (pending.length > 5) {
+    summary += "\n⏳ *Up next:* " + pending.slice(0, 3).map(t => `#${t.id} ${t.subject}`).join(", ") + ` +${pending.length - 3} more`;
+  }
+  return summary;
+}
+
+async function slackPost(text, threadTs) {
+  // Prefer Slack Bot API (supports threads)
+  if (slackApp && SLACK_CHANNEL_ID) {
+    try {
+      var opts = { channel: SLACK_CHANNEL_ID, text: text };
+      if (threadTs) opts.thread_ts = threadTs;
+      var result = await slackApp.client.chat.postMessage(opts);
+      if (result.ts) console.log("  [slack-thread] posted ts=" + result.ts + (threadTs ? " (reply to " + threadTs + ")" : " (parent)"));
+      return result.ts || null;
+    } catch (e) {
+      // Auto-join channel on not_in_channel error
+      var errCode = (e.data && e.data.error) || "";
+      if (errCode === "not_in_channel") {
+        try {
+          await slackApp.client.conversations.join({ channel: SLACK_CHANNEL_ID });
+          console.log("  [slack-thread] joined channel " + SLACK_CHANNEL_ID);
+          var opts2 = { channel: SLACK_CHANNEL_ID, text: text };
+          if (threadTs) opts2.thread_ts = threadTs;
+          var result2 = await slackApp.client.chat.postMessage(opts2);
+          if (result2.ts) console.log("  [slack-thread] posted ts=" + result2.ts + (threadTs ? " (reply to " + threadTs + ")" : " (parent)"));
+          return result2.ts || null;
+        } catch (e2) {
+          console.log("  [slack-thread] join failed, trying invite hint: " + e2.message);
+          console.log("  [slack-thread] Please invite the bot to the channel: /invite @bot-name");
+        }
+      }
+      console.log("  [slack-thread] Bot API error: " + (errCode || e.message) + " — falling back to webhook");
+      // Fall through to webhook fallback below
+    }
+  }
+  // Fallback to webhook (no thread support)
+  if (!SLACK_WEBHOOK) return null;
+  const payload = JSON.stringify({ text: text });
+  const url = new URL(SLACK_WEBHOOK);
+  const options = {
+    hostname: url.hostname,
+    path: url.pathname,
+    method: "POST",
+    headers: { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(payload) },
+  };
+  const req = require("https").request(options);
+  req.on("error", () => {});
+  req.write(payload);
+  req.end();
+  return null;
+}
+
+// Legacy sync wrapper for places that don't need thread support
+function slackNotify(text) {
+  slackPost(text, null);
+}
+
+// ── Activity Log ──
+function logActivity(evt) {
+  const ts = new Date().toISOString();
+  const record = { ts, ...evt };
+
+  // 1. Append to JSONL
+  try {
+    fs.appendFileSync(ACTIVITY_FILE, JSON.stringify(record) + "\n");
+  } catch {
+    try { fs.mkdirSync(path.dirname(ACTIVITY_FILE), { recursive: true }); } catch {}
+    try { fs.appendFileSync(ACTIVITY_FILE, JSON.stringify(record) + "\n"); } catch {}
+  }
+
+  // 2. Trim to 1000 lines
+  try {
+    const content = fs.readFileSync(ACTIVITY_FILE, "utf-8");
+    const lines = content.trim().split("\n");
+    if (lines.length > 1200) {
+      fs.writeFileSync(ACTIVITY_FILE, lines.slice(lines.length - 1000).join("\n") + "\n");
+    }
+  } catch {}
+
+  // 3. SSE broadcast (activity event — no dedup)
+  const msg = "data: " + JSON.stringify({ type: "activity", event: record }) + "\n\n";
+  for (const res of sseClients) {
+    try { res.write(msg); } catch { sseClients.delete(res); }
+  }
+
+  // 4. Slack notification (threaded)
+  if (evt._skipSlack) return; // Skip if already sent by agent report API
+
+  const allTasks = readAllTasks();
+  let slackMsg = "";
+  let isParent = false; // true = new parent message (created), false = thread reply
+  if (evt.type === "created") {
+    isParent = true;
+    const summary = boardSummary(allTasks);
+    slackMsg = `🆕 *New Task #${evt.taskId}*: ${evt.subject}`;
+    if (evt.description) slackMsg += "\n> " + evt.description.split("\n")[0].slice(0, 120);
+    if (evt.priority === "high") slackMsg += "\n🔴 Priority: HIGH";
+    if (evt.owner) slackMsg += "\n👤 Assigned: " + evt.owner;
+    if (evt.parentId) slackMsg += "\n↳ Subtask of #" + evt.parentId;
+    slackMsg += "\n" + summary;
+  } else if (evt.type === "started") {
+    slackMsg = `▶️ *Task #${evt.taskId} Started*: ${evt.subject}`;
+    if (evt.owner) slackMsg += "\n👤 " + evt.owner;
+    if (evt.activeForm) slackMsg += "\n💬 _" + evt.activeForm + "_";
+    if (evt.description) slackMsg += "\n> " + evt.description.split("\n")[0].slice(0, 120);
+  } else if (evt.type === "completed") {
+    slackMsg = `✅ *Task #${evt.taskId} Done*: ${evt.subject}`;
+    if (evt.reportSummary) slackMsg += "\n> " + evt.reportSummary.split("\n")[0].slice(0, 200);
+    if (evt.reportPath) slackMsg += "\n📄 Report: \`" + evt.reportPath + "\`";
+    if (evt.parentId) slackMsg += "\n↳ Subtask of #" + evt.parentId;
+  } else if (evt.type === "deleted") {
+    slackMsg = `🗑️ *Task #${evt.taskId} Deleted*: ${evt.subject}`;
+  } else if (evt.type === "updated") {
+    slackMsg = `📝 *Task #${evt.taskId} Updated*: ${evt.subject}`;
+    if (evt.detail) slackMsg += "\n> " + evt.detail;
+  }
+  if (slackMsg) {
+    if (isParent) {
+      // New parent message — save thread ts
+      slackPost(slackMsg, null).then(function (ts) {
+        if (ts && evt.taskId) setThreadTs(evt.taskId, ts);
+      });
+    } else {
+      // Thread reply
+      var threadTs = evt.taskId ? getThreadTs(evt.taskId) : null;
+      if (threadTs) {
+        slackPost(slackMsg, threadTs);
+      } else {
+        // Legacy task without thread — create parent, save ts
+        slackPost(slackMsg, null).then(function (ts) {
+          if (ts && evt.taskId) setThreadTs(evt.taskId, ts);
+        });
+      }
+    }
+  }
+}
+
+function readActivity(since, limit) {
+  if (!fs.existsSync(ACTIVITY_FILE)) return [];
+  try {
+    const lines = fs.readFileSync(ACTIVITY_FILE, "utf-8").trim().split("\n").filter(Boolean);
+    let events = lines.map(line => {
+      try { return JSON.parse(line); } catch { return null; }
+    }).filter(Boolean);
+    if (since) {
+      events = events.filter(e => e.ts > since);
+    }
+    events.reverse();
+    if (limit) events = events.slice(0, limit);
+    return events;
+  } catch { return []; }
+}
+
+// ── Task 파일 읽기 ──
+function readAllTasks() {
+  const tasks = [];
+  if (!fs.existsSync(TASKS_DIR)) return tasks;
+  try {
+    const sessions = fs.readdirSync(TASKS_DIR, { withFileTypes: true });
+    for (const session of sessions) {
+      if (!session.isDirectory()) continue;
+      const sessionPath = path.join(TASKS_DIR, session.name);
+      const files = fs.readdirSync(sessionPath).filter(
+        (f) => f.endsWith(".json") && f !== ".lock"
+      );
+      for (const file of files) {
+        try {
+          const filePath = path.join(sessionPath, file);
+          const raw = fs.readFileSync(filePath, "utf-8");
+          const task = JSON.parse(raw);
+          task._session = session.name;
+          task._file = file;
+          task._mtime = fs.statSync(filePath).mtimeMs;
+          task._editable = session.name === "kanban";
+          tasks.push(task);
+        } catch {}
+      }
+    }
+  } catch {}
+  return tasks.sort((a, b) => (a.id || 0) - (b.id || 0));
+}
+
+// ── Kanban 태스크 CRUD ──
+function getNextId() {
+  const files = fs.existsSync(KANBAN_DIR)
+    ? fs.readdirSync(KANBAN_DIR).filter((f) => f.endsWith(".json"))
+    : [];
+  let max = 0;
+  for (const f of files) {
+    const n = parseInt(f.replace(".json", ""), 10);
+    if (n > max) max = n;
+  }
+  return max + 1;
+}
+
+function createTask(data) {
+  const id = getNextId();
+  const now = new Date().toISOString();
+  const task = {
+    id: String(id),
+    subject: data.subject || "Untitled",
+    description: data.description || "",
+    status: data.status || "pending",
+    priority: data.priority || "medium",
+    agent: data.agent || "",
+    owner: data.owner || "",
+    activeForm: data.activeForm || "",
+    blockedBy: data.blockedBy || [],
+    blocks: data.blocks || [],
+    parentId: data.parentId || null,
+    reportPath: data.reportPath || null,
+    reportSummary: data.reportSummary || null,
+    slackThreadTs: null,
+    createdAt: now,
+    updatedAt: now,
+  };
+  const filePath = path.join(KANBAN_DIR, id + ".json");
+  fs.writeFileSync(filePath, JSON.stringify(task, null, 2));
+  // Update snapshot so file watcher won't double-notify
+  taskSnapshot.set(String(id), { status: task.status, subject: task.subject, owner: task.owner || "", reportSummary: "" });
+  logActivity({
+    type: "created", taskId: String(id), subject: task.subject,
+    agent: task.agent || task.owner || "", detail: task.priority === "high" ? "Priority: high" : "",
+    description: task.description, priority: task.priority, owner: task.owner, parentId: task.parentId,
+  });
+  return task;
+}
+
+function findTaskFile(id) {
+  // Search kanban dir first, then all session dirs
+  const kanbanPath = path.join(KANBAN_DIR, id + ".json");
+  if (fs.existsSync(kanbanPath)) return kanbanPath;
+  try {
+    const sessions = fs.readdirSync(TASKS_DIR, { withFileTypes: true });
+    for (const session of sessions) {
+      if (!session.isDirectory()) continue;
+      const fp = path.join(TASKS_DIR, session.name, id + ".json");
+      if (fs.existsSync(fp)) return fp;
+    }
+  } catch {}
+  return null;
+}
+
+function updateTask(id, data) {
+  const filePath = findTaskFile(id);
+  if (!filePath) return null;
+  const task = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+  const now = new Date().toISOString();
+  var prevStatus = task.status;
+  var statusChanged = false;
+  if (data.status !== undefined && data.status !== task.status) {
+    statusChanged = true;
+    task.status = data.status;
+    if (data.status === "in_progress" && !task.startedAt) task.startedAt = now;
+    if (data.status === "completed") task.completedAt = now;
+  }
+  if (data.subject !== undefined) task.subject = data.subject;
+  if (data.description !== undefined) task.description = data.description;
+  if (data.priority !== undefined) task.priority = data.priority;
+  if (data.agent !== undefined) task.agent = data.agent;
+  if (data.owner !== undefined) task.owner = data.owner;
+  if (data.activeForm !== undefined) task.activeForm = data.activeForm;
+  if (data.blockedBy !== undefined) task.blockedBy = data.blockedBy;
+  if (data.blocks !== undefined) task.blocks = data.blocks;
+  if (data.reportPath !== undefined) task.reportPath = data.reportPath;
+  if (data.reportSummary !== undefined) task.reportSummary = data.reportSummary;
+  if (data.parentId !== undefined) task.parentId = data.parentId;
+  task.updatedAt = now;
+  fs.writeFileSync(filePath, JSON.stringify(task, null, 2));
+
+  // Update snapshot so file watcher won't double-notify
+  taskSnapshot.set(String(id), { status: task.status, subject: task.subject, owner: task.owner || "", reportSummary: task.reportSummary || "" });
+
+  // Activity log (replaces direct Slack calls)
+  if (statusChanged) {
+    if (data.status === "in_progress" && prevStatus === "pending") {
+      logActivity({
+        type: "started", taskId: String(id), subject: task.subject,
+        agent: task.agent || task.owner || "", detail: task.activeForm || "",
+        owner: task.owner, activeForm: task.activeForm, description: task.description,
+      });
+    } else if (data.status === "completed") {
+      logActivity({
+        type: "completed", taskId: String(id), subject: task.subject,
+        agent: task.agent || task.owner || "", detail: task.reportSummary || "",
+        reportSummary: task.reportSummary, reportPath: task.reportPath, parentId: task.parentId,
+      });
+    } else {
+      logActivity({
+        type: "updated", taskId: String(id), subject: task.subject,
+        agent: task.agent || task.owner || "", detail: prevStatus + " → " + data.status,
+      });
+    }
+  } else if (data.subject !== undefined || data.description !== undefined || data.owner !== undefined) {
+    logActivity({
+      type: "updated", taskId: String(id), subject: task.subject,
+      agent: task.agent || task.owner || "", detail: "Fields updated",
+    });
+  }
+
+  // Auto-execute: pending → in_progress with description
+  if (statusChanged && data.status === "in_progress" && prevStatus === "pending" && task.description && cliAvailable) {
+    setTimeout(function () { enqueueExec(task); }, 100);
+  }
+
+  return task;
+}
+
+function deleteTask(id) {
+  const filePath = findTaskFile(id);
+  if (!filePath) return false;
+  // Read task data before deletion for logging
+  let taskData = {};
+  try { taskData = JSON.parse(fs.readFileSync(filePath, "utf-8")); } catch {}
+  fs.unlinkSync(filePath);
+  taskSnapshot.delete(String(id));
+  logActivity({
+    type: "deleted", taskId: String(id), subject: taskData.subject || "Unknown",
+    agent: taskData.agent || taskData.owner || "", detail: "",
+  });
+  return true;
+}
+
+// ── SSE ──
+const sseClients = new Set();
+let lastHash = "";
+
+function broadcast(data) {
+  const hash = JSON.stringify(
+    data.tasks?.map((t) => t.status + t.id + (t.updatedAt || ""))
+  );
+  if (hash === lastHash) return;
+  lastHash = hash;
+  const msg = "data: " + JSON.stringify(data) + "\n\n";
+  for (const res of sseClients) {
+    try { res.write(msg); } catch { sseClients.delete(res); }
+  }
+}
+
+// ── Raw broadcast (no dedup, for streaming events) ──
+function broadcastRaw(data) {
+  const msg = "data: " + JSON.stringify(data) + "\n\n";
+  for (const res of sseClients) {
+    try { res.write(msg); } catch { sseClients.delete(res); }
+  }
+}
+
+// ── Claude CLI Detection ──
+let cliAvailable = false;
+
+function checkClaudeCLI() {
+  if (process.env.CLAUDECODE) {
+    console.log("  CLI: unavailable (nested session)");
+    return;
+  }
+  try {
+    execSync("which claude", { encoding: "utf-8", timeout: 5000 });
+    cliAvailable = true;
+  } catch {
+    cliAvailable = false;
+  }
+}
+
+// ── Task Executor (Queue-based) ──
+let activeExec = null; // { process, taskId, output }
+let execQueue = [];
+const EXEC_QUEUE_MAX = 5;
+
+function enqueueExec(task) {
+  if (!cliAvailable) return;
+  var id = String(task.id);
+  if (activeExec && activeExec.taskId === id) return;
+  if (execQueue.some(function (t) { return String(t.id) === id; })) return;
+  if (execQueue.length >= EXEC_QUEUE_MAX) return;
+  execQueue.push(task);
+  broadcastExecQueue();
+  if (!activeExec) drainExecQueue();
+}
+
+function drainExecQueue() {
+  if (activeExec || execQueue.length === 0) return;
+  var next = execQueue.shift();
+  broadcastExecQueue();
+  spawnExecutor(next);
+}
+
+function broadcastExecQueue() {
+  broadcastRaw({
+    type: "exec_queue",
+    active: activeExec ? { taskId: activeExec.taskId } : null,
+    queued: execQueue.map(function (t) { return { id: t.id, subject: t.subject }; }),
+  });
+}
+
+// ── Agent Prompt & Model Loading ──
+
+// Build agent model map from config (fallback to sensible defaults)
+var AGENT_MODEL_MAP = {};
+if (config.agents) {
+  Object.keys(config.agents).forEach(function (name) {
+    if (config.agents[name].model) AGENT_MODEL_MAP[name] = config.agents[name].model;
+  });
+}
+
+function getModelForAgent(agent) {
+  if (!agent) return "sonnet";
+  return AGENT_MODEL_MAP[agent] || "sonnet";
+}
+
+// Build agent aliases from config + common patterns
+var AGENT_ALIASES = {};
+if (config.agents) {
+  Object.keys(config.agents).forEach(function (name) {
+    var aliases = (config.agents[name].aliases || []);
+    aliases.forEach(function (a) { AGENT_ALIASES[a] = name; });
+    // Auto-generate common alias patterns for hyphenated names
+    if (name.indexOf("-") >= 0) {
+      AGENT_ALIASES[name.replace(/-/g, "")] = name;
+      AGENT_ALIASES[name.replace(/-/g, "_")] = name;
+    }
+  });
+}
+
+function resolveAgentName(agent) {
+  if (!agent) return null;
+  return AGENT_ALIASES[agent] || agent;
+}
+
+function loadAgentPrompt(agent) {
+  if (!agent) return "";
+  var resolved = resolveAgentName(agent);
+  var filePath = path.join(__dirname, "..", ".claude", "agents", resolved + ".md");
+  try {
+    if (fs.existsSync(filePath)) return fs.readFileSync(filePath, "utf8");
+  } catch (e) {}
+  // Try original name if alias didn't match
+  if (resolved !== agent) {
+    var fallback = path.join(__dirname, "..", ".claude", "agents", agent + ".md");
+    try {
+      if (fs.existsSync(fallback)) return fs.readFileSync(fallback, "utf8");
+    } catch (e) {}
+  }
+  return "";
+}
+
+function loadProjectContext() {
+  var contextPath = path.join(__dirname, "..", ".claude", "agents", "_project-context.md");
+  try {
+    if (fs.existsSync(contextPath)) return fs.readFileSync(contextPath, "utf8");
+  } catch (e) {}
+  return "";
+}
+
+function buildExecutorPrompt(task) {
+  var parts = [];
+  var projectContext = loadProjectContext();
+  var agentPrompt = loadAgentPrompt(task.agent);
+
+  if (projectContext) parts.push(projectContext);
+  if (agentPrompt) parts.push(agentPrompt);
+
+  parts.push("## 태스크\n\n- **Task ID**: " + task.id + "\n- **Subject**: " + task.subject + "\n\n" + (task.description || "(설명 없음)"));
+  parts.push("작업 디렉토리: " + path.join(__dirname, ".."));
+  parts.push("## Slack Progress Reporting\n\n진행 상황을 Slack에 보고할 때 반드시 아래 API를 사용한다:\n\n```bash\ncurl -s -X POST http://localhost:4040/api/tasks/" + task.id + "/slack \\\n  -H \"Content-Type: application/json\" \\\n  -d '{\"text\":\"progress message\"}'\n```\n\n`$SLACK_AGENT_WEBHOOK` 직접 사용 금지. 반드시 위 API를 통해 보고.");
+
+  return parts.join("\n\n---\n\n");
+}
+
+function spawnExecutor(task) {
+  if (!cliAvailable || activeExec) { enqueueExec(task); return; }
+  const taskId = String(task.id);
+  const prompt = buildExecutorPrompt(task);
+  const model = getModelForAgent(resolveAgentName(task.agent));
+
+  var execEnv = Object.assign({}, process.env);
+  delete execEnv.ANTHROPIC_API_KEY; // Max 구독 OAuth 사용
+  const proc = spawn("claude", ["-p", "--verbose", "--output-format", "stream-json", "--model", model, "--no-session-persistence", "--dangerously-skip-permissions"], {
+    cwd: path.join(__dirname, ".."),
+    env: execEnv,
+    stdio: ["pipe", "pipe", "pipe"],
+  });
+
+  activeExec = { process: proc, taskId: taskId, output: "" };
+  broadcastRaw({ type: "exec_start", taskId: taskId, subject: task.subject, agent: task.agent || "", model: model });
+  logActivity({ type: "started", taskId: taskId, subject: task.subject, detail: "Agent: " + (task.agent || "none") + " | Model: " + model });
+
+  proc.stdin.write(prompt);
+  proc.stdin.end();
+
+  let buffer = "";
+  proc.stdout.on("data", function (data) {
+    buffer += data.toString();
+    var lines = buffer.split("\n");
+    buffer = lines.pop();
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      try {
+        var json = JSON.parse(line);
+        var text = "";
+        if (json.type === "assistant" && json.subtype === "text") text = json.text || "";
+        else if (json.type === "assistant" && json.message && json.message.content) {
+          json.message.content.forEach(function (c) { if (c.type === "text") text += c.text; });
+        }
+        else if (json.type === "content_block_delta" && json.delta) text = json.delta.text || "";
+        if (text && activeExec) {
+          activeExec.output += text;
+          broadcastRaw({ type: "exec", taskId: taskId, chunk: text });
+        }
+      } catch (e) {}
+    }
+  });
+
+  proc.stderr.on("data", function (data) {
+    broadcastRaw({ type: "exec_error", taskId: taskId, chunk: data.toString() });
+  });
+
+  proc.on("close", function (code) {
+    var output = activeExec ? activeExec.output : "";
+    activeExec = null;
+    if (code === 0) {
+      updateTask(taskId, { status: "in_review", reportSummary: output.slice(0, 500) });
+      broadcastRaw({ type: "exec_done", taskId: taskId, exitCode: 0 });
+    } else {
+      updateTask(taskId, { status: "pending" });
+      broadcastRaw({ type: "exec_done", taskId: taskId, exitCode: code });
+      logActivity({ type: "updated", taskId: taskId, subject: task.subject || "", detail: "Exec failed (exit " + code + ")" });
+    }
+    broadcastExecQueue();
+    drainExecQueue();
+  });
+}
+
+function stopExec() {
+  if (!activeExec) return null;
+  var taskId = activeExec.taskId;
+  try { activeExec.process.kill(); } catch (e) {}
+  activeExec = null;
+  updateTask(taskId, { status: "pending" });
+  broadcastRaw({ type: "exec_done", taskId: taskId, exitCode: -1, stopped: true });
+  logActivity({ type: "updated", taskId: taskId, subject: "", detail: "Execution stopped by user" });
+  broadcastExecQueue();
+  drainExecQueue();
+  return taskId;
+}
+
+// ── Slack Bot (Socket Mode) ──
+
+async function initSlackBot() {
+  if (!SLACK_BOT_TOKEN || !SLACK_APP_TOKEN) {
+    console.log("  Slack Bot: disabled (no tokens)");
+    return;
+  }
+  try {
+    const { App } = require("@slack/bolt");
+    slackApp = new App({
+      token: SLACK_BOT_TOKEN,
+      appToken: SLACK_APP_TOKEN,
+      socketMode: true,
+    });
+
+    // slash command
+    slackApp.command(SLACK_COMMAND, async ({ command, ack, respond, client }) => {
+      await ack();
+      const args = (command.text || "").trim();
+      const parts = args.split(/\s+/);
+      const sub = (parts[0] || "").toLowerCase();
+      const restText = parts.slice(1).join(" ");
+
+      switch (sub) {
+        case "board":
+        case "": {
+          const tasks = readAllTasks();
+          const blocks = buildBoardBlocks(tasks);
+          await respond({ blocks, text: PROJECT_NAME + " Kanban", response_type: "ephemeral" });
+          break;
+        }
+        case "list": {
+          const tasks = readAllTasks();
+          const blocks = buildTaskListBlocks(tasks);
+          await respond({ blocks, response_type: "ephemeral" });
+          break;
+        }
+        case "add": {
+          if (!restText) {
+            await client.views.open({
+              trigger_id: command.trigger_id,
+              view: buildAddTaskModal(),
+            });
+          } else {
+            const task = createTask({ subject: restText });
+            await respond({ text: `Task #${task.id} created: ${task.subject}`, response_type: "in_channel" });
+          }
+          break;
+        }
+        case "ask": {
+          if (!restText) {
+            await respond({ text: "Usage: `" + SLACK_COMMAND + " ask <question>`", response_type: "ephemeral" });
+            break;
+          }
+          if (slackAskActive) {
+            await respond({ text: "Another ask is in progress. Please wait.", response_type: "ephemeral" });
+            break;
+          }
+          if (!cliAvailable) {
+            await respond({ text: "Claude CLI not available.", response_type: "ephemeral" });
+            break;
+          }
+          await respond({ text: `Asking Claude: _${restText}_`, response_type: "ephemeral" });
+          handleSlackAsk(restText, command.channel_id, client);
+          break;
+        }
+        case "exec": {
+          if (SLACK_ADMIN_USERS.length > 0 && !SLACK_ADMIN_USERS.includes(command.user_id)) {
+            await respond({ text: "Permission denied. You are not in SLACK_ADMIN_USERS.", response_type: "ephemeral" });
+            break;
+          }
+          const execId = restText.replace("#", "");
+          if (!execId) {
+            await respond({ text: "Usage: `" + SLACK_COMMAND + " exec <task_id>`", response_type: "ephemeral" });
+            break;
+          }
+          if (!cliAvailable) {
+            await respond({ text: "Claude CLI not available.", response_type: "ephemeral" });
+            break;
+          }
+          if (activeExec) {
+            await respond({ text: "Already executing task #" + activeExec.taskId + ". Use `" + SLACK_COMMAND + " stop` first.", response_type: "ephemeral" });
+            break;
+          }
+          const taskToExec = readAllTasks().find(function (t) { return String(t.id) === execId; });
+          if (!taskToExec) {
+            await respond({ text: `Task #${execId} not found.`, response_type: "ephemeral" });
+            break;
+          }
+          if (taskToExec.status === "pending") {
+            updateTask(execId, { status: "in_progress" });
+          }
+          if (!activeExec) {
+            spawnExecutor(taskToExec);
+          }
+          await respond({ text: `Executing task #${execId}: ${taskToExec.subject}`, response_type: "in_channel" });
+          break;
+        }
+        case "stop": {
+          const stoppedId = stopExec();
+          if (stoppedId) {
+            await respond({ text: `Stopped execution of task #${stoppedId}.`, response_type: "in_channel" });
+          } else {
+            await respond({ text: "No active execution.", response_type: "ephemeral" });
+          }
+          break;
+        }
+        default:
+          await respond({
+            text: "Unknown: `" + sub + "`\nAvailable: `board` `list` `add` `ask` `exec` `stop`",
+            response_type: "ephemeral",
+          });
+      }
+    });
+
+    // Interactive button handlers
+    slackApp.action(/^task_(start|complete|delete)_/, async ({ action, ack, respond, body }) => {
+      await ack();
+      const match = action.action_id.match(/^task_(start|complete|delete)_(.+)$/);
+      if (!match) return;
+      const actionType = match[1];
+      const taskId = match[2];
+      const userName = (body.user && body.user.name) || (body.user && body.user.id) || "someone";
+
+      switch (actionType) {
+        case "start": {
+          const task = updateTask(taskId, { status: "in_progress" });
+          if (task) {
+            await respond({ text: "▶️ Task #" + taskId + " started by " + userName + ": " + task.subject, response_type: "in_channel", replace_original: false });
+          } else {
+            await respond({ text: "Task #" + taskId + " not found.", response_type: "ephemeral" });
+          }
+          break;
+        }
+        case "complete": {
+          const task = updateTask(taskId, { status: "completed" });
+          if (task) {
+            await respond({ text: "✅ Task #" + taskId + " completed by " + userName + ": " + task.subject, response_type: "in_channel", replace_original: false });
+          } else {
+            await respond({ text: "Task #" + taskId + " not found.", response_type: "ephemeral" });
+          }
+          break;
+        }
+        case "delete": {
+          const tasks = readAllTasks();
+          const task = tasks.find(function (t) { return String(t.id) === taskId; });
+          const ok = deleteTask(taskId);
+          if (ok) {
+            await respond({ text: "🗑️ Task #" + taskId + " deleted by " + userName + (task ? ": " + task.subject : ""), response_type: "in_channel", replace_original: false });
+          } else {
+            await respond({ text: "Task #" + taskId + " not found.", response_type: "ephemeral" });
+          }
+          break;
+        }
+      }
+    });
+
+    // Modal submission for add command
+    slackApp.view("add_task_modal", async ({ ack, view }) => {
+      await ack();
+      const vals = view.state.values;
+      const subject = vals.subject_block.subject_input.value || "";
+      const description = (vals.desc_block && vals.desc_block.desc_input && vals.desc_block.desc_input.value) || "";
+      const priority = (vals.priority_block && vals.priority_block.priority_select && vals.priority_block.priority_select.selected_option && vals.priority_block.priority_select.selected_option.value) || "medium";
+      if (subject) {
+        createTask({ subject, description, priority });
+        // slackPost는 createTask → logActivity에서 자동 호출 (스레드 부모 메시지)
+      }
+    });
+
+    await slackApp.start();
+    console.log("  Slack Bot: connected (Socket Mode)");
+  } catch (e) {
+    console.log("  Slack Bot: failed — " + e.message);
+    slackApp = null;
+  }
+}
+
+function buildBoardBlocks(tasks) {
+  var pending = tasks.filter(function (t) { return t.status === "pending"; });
+  var inProgress = tasks.filter(function (t) { return t.status === "in_progress"; });
+  var completed = tasks.filter(function (t) { return t.status === "completed"; });
+  var total = tasks.length;
+  var pct = total ? Math.round((completed.length / total) * 100) : 0;
+
+  // Progress bar: 20 chars
+  var filled = Math.round(pct / 5);
+  var bar = "";
+  for (var i = 0; i < 20; i++) bar += (i < filled ? "\u2588" : "\u2591");
+
+  var blocks = [
+    { type: "header", text: { type: "plain_text", text: PROJECT_NAME + " Kanban" } },
+    { type: "section", text: { type: "mrkdwn", text:
+      "*" + completed.length + "* done  \u00b7  *" + inProgress.length + "* in progress  \u00b7  *" + pending.length + "* pending  \u00b7  *" + total + "* total\n`" + bar + "` " + pct + "%"
+    }},
+  ];
+
+  // In Progress
+  if (inProgress.length > 0) {
+    blocks.push({ type: "divider" });
+    blocks.push({ type: "section", text: { type: "mrkdwn", text: ":arrows_counterclockwise:  *In Progress* (" + inProgress.length + ")" } });
+    for (var ip = 0; ip < inProgress.length; ip++) {
+      var t = inProgress[ip];
+      var line = "> *#" + t.id + "*  " + t.subject;
+      if (t.owner) line += "  \u2014  " + t.owner;
+      if (t.activeForm) line += "\n>       _" + t.activeForm + "_";
+      blocks.push({ type: "section", text: { type: "mrkdwn", text: line } });
+    }
+  }
+
+  // Pending
+  if (pending.length > 0) {
+    blocks.push({ type: "divider" });
+    blocks.push({ type: "section", text: { type: "mrkdwn", text: ":hourglass_flowing_sand:  *Pending* (" + pending.length + ")" } });
+    var showPending = pending.length > 8 ? pending.slice(0, 6) : pending;
+    var lines = [];
+    for (var pp = 0; pp < showPending.length; pp++) {
+      var p = showPending[pp];
+      var pl = "*#" + p.id + "*  " + p.subject;
+      if (p.priority === "high") pl += "  :red_circle:";
+      if (p.owner) pl += "  \u2014  " + p.owner;
+      lines.push(pl);
+    }
+    blocks.push({ type: "section", text: { type: "mrkdwn", text: lines.join("\n") } });
+    if (pending.length > 8) {
+      blocks.push({ type: "context", elements: [{ type: "mrkdwn", text: "+" + (pending.length - 6) + " more \u2014 use `" + SLACK_COMMAND + " list` to see all with actions" }] });
+    }
+  }
+
+  // Recently completed
+  var recentDone = completed.slice(-3);
+  if (recentDone.length > 0) {
+    blocks.push({ type: "divider" });
+    blocks.push({ type: "section", text: { type: "mrkdwn", text: ":white_check_mark:  *Recently Done*" } });
+    var doneLines = [];
+    for (var dd = 0; dd < recentDone.length; dd++) {
+      var d = recentDone[dd];
+      doneLines.push("~#" + d.id + "  " + d.subject + "~");
+    }
+    blocks.push({ type: "context", elements: [{ type: "mrkdwn", text: doneLines.join("\n") }] });
+  }
+
+  // Footer
+  blocks.push({ type: "divider" });
+  blocks.push({ type: "context", elements: [{ type: "mrkdwn", text: ":keyboard:  `" + SLACK_COMMAND + " list` \u2014 interactive  \u00b7  `" + SLACK_COMMAND + " add` \u2014 new task  \u00b7  `" + SLACK_COMMAND + " ask` \u2014 Claude" }] });
+
+  return blocks;
+}
+
+function buildTaskListBlocks(tasks) {
+  var blocks = [
+    { type: "header", text: { type: "plain_text", text: PROJECT_NAME + " Kanban" } },
+  ];
+  var groups = [
+    { key: "in_progress", label: "🔄 In Progress" },
+    { key: "pending", label: "⏳ Pending" },
+    { key: "completed", label: "✅ Completed (recent)" },
+  ];
+  for (var gi = 0; gi < groups.length; gi++) {
+    var g = groups[gi];
+    var items = tasks.filter(function (t) { return t.status === g.key; });
+    if (g.key === "completed") items = items.slice(-5);
+    if (items.length === 0) continue;
+
+    blocks.push({ type: "divider" });
+    blocks.push({ type: "section", text: { type: "mrkdwn", text: "*" + g.label + "* (" + items.length + ")" } });
+
+    for (var ti = 0; ti < items.length; ti++) {
+      var t = items[ti];
+      var desc = "*#" + t.id + "* " + t.subject;
+      if (t.owner) desc += "  👤 " + t.owner;
+      if (t.activeForm) desc += "\n_" + t.activeForm + "_";
+      blocks.push({ type: "section", text: { type: "mrkdwn", text: desc } });
+
+      var buttons = [];
+      if (t.status === "pending") {
+        buttons.push({ type: "button", text: { type: "plain_text", text: "Start" }, action_id: "task_start_" + t.id, style: "primary" });
+      }
+      if (t.status === "in_progress") {
+        buttons.push({ type: "button", text: { type: "plain_text", text: "Complete" }, action_id: "task_complete_" + t.id, style: "primary" });
+      }
+      if (t.status !== "completed") {
+        buttons.push({ type: "button", text: { type: "plain_text", text: "Delete" }, action_id: "task_delete_" + t.id, style: "danger" });
+      }
+      if (buttons.length > 0) {
+        blocks.push({ type: "actions", elements: buttons });
+      }
+    }
+  }
+  if (blocks.length <= 1) {
+    blocks.push({ type: "section", text: { type: "mrkdwn", text: "_No tasks found._" } });
+  }
+  return blocks;
+}
+
+function buildAddTaskModal() {
+  return {
+    type: "modal",
+    callback_id: "add_task_modal",
+    title: { type: "plain_text", text: "New Task" },
+    submit: { type: "plain_text", text: "Create" },
+    blocks: [
+      {
+        type: "input",
+        block_id: "subject_block",
+        element: { type: "plain_text_input", action_id: "subject_input", placeholder: { type: "plain_text", text: "Task title" } },
+        label: { type: "plain_text", text: "Subject" },
+      },
+      {
+        type: "input",
+        block_id: "desc_block",
+        optional: true,
+        element: { type: "plain_text_input", action_id: "desc_input", multiline: true, placeholder: { type: "plain_text", text: "Task description" } },
+        label: { type: "plain_text", text: "Description" },
+      },
+      {
+        type: "input",
+        block_id: "priority_block",
+        optional: true,
+        element: {
+          type: "static_select",
+          action_id: "priority_select",
+          initial_option: { text: { type: "plain_text", text: "Medium" }, value: "medium" },
+          options: [
+            { text: { type: "plain_text", text: "Low" }, value: "low" },
+            { text: { type: "plain_text", text: "Medium" }, value: "medium" },
+            { text: { type: "plain_text", text: "High" }, value: "high" },
+          ],
+        },
+        label: { type: "plain_text", text: "Priority" },
+      },
+    ],
+  };
+}
+
+function handleSlackAsk(question, channelId, client) {
+  slackAskActive = true;
+  var tasks = readAllTasks();
+  var prompt = buildChatSystemPrompt(tasks, PROJECT_NAME);
+  prompt += "\n\n[User via Slack]: " + question;
+  appendOrchestratorHistory("user-slack", question);
+
+  var askEnv = Object.assign({}, process.env);
+  delete askEnv.ANTHROPIC_API_KEY;
+  var proc = spawn("claude", ["-p", "--output-format", "text", "--model", "sonnet", "--no-session-persistence", "--dangerously-skip-permissions"], {
+    cwd: path.join(__dirname, ".."),
+    env: askEnv,
+    stdio: ["pipe", "pipe", "pipe"],
+  });
+
+  proc.stdin.write(prompt);
+  proc.stdin.end();
+
+  var output = "";
+  proc.stdout.on("data", function (data) { output += data.toString(); });
+  proc.stderr.on("data", function () {});
+
+  proc.on("close", function (code) {
+    slackAskActive = false;
+    var targetChannel = channelId || SLACK_CHANNEL_ID;
+    if (!targetChannel || !client) return;
+    var text = (code === 0 && output.trim())
+      ? output.trim().slice(0, 3000)
+      : "(Claude returned exit code " + code + ")";
+    appendOrchestratorHistory("orchestrator", text);
+    extractAndSaveLearnings(output);
+    client.chat.postMessage({
+      channel: targetChannel,
+      text: "💬 *Claude says:*\n" + text,
+    }).catch(function () {});
+  });
+}
+
+// ── 파일 감시 + Slack diff ──
+const taskSnapshot = new Map(); // id → {status, subject, owner}
+
+function snapshotTasks(tasks) {
+  for (const t of tasks) {
+    taskSnapshot.set(String(t.id), { status: t.status, subject: t.subject, owner: t.owner || "", reportSummary: t.reportSummary || "" });
+  }
+}
+
+function detectAndNotifyChanges(tasks) {
+  for (const t of tasks) {
+    const id = String(t.id);
+    const prev = taskSnapshot.get(id);
+    if (!prev) {
+      logActivity({
+        type: "created", taskId: id, subject: t.subject,
+        agent: t.agent || t.owner || "", detail: t.priority === "high" ? "Priority: high" : "",
+        description: t.description, priority: t.priority, owner: t.owner, parentId: t.parentId,
+      });
+    } else if (prev.status !== t.status) {
+      if (t.status === "in_progress" && prev.status === "pending") {
+        logActivity({
+          type: "started", taskId: id, subject: t.subject,
+          agent: t.agent || t.owner || "", detail: t.activeForm || "",
+          owner: t.owner, activeForm: t.activeForm, description: t.description,
+        });
+      } else if (t.status === "completed") {
+        logActivity({
+          type: "completed", taskId: id, subject: t.subject,
+          agent: t.agent || t.owner || "", detail: t.reportSummary || "",
+          reportSummary: t.reportSummary, reportPath: t.reportPath, parentId: t.parentId,
+        });
+      } else {
+        logActivity({
+          type: "updated", taskId: id, subject: t.subject,
+          agent: t.agent || t.owner || "", detail: prev.status + " → " + t.status,
+        });
+      }
+    }
+  }
+  // Detect deleted tasks (in snapshot but not in current tasks)
+  const currentIds = new Set(tasks.map(t => String(t.id)));
+  for (const [id, prev] of taskSnapshot) {
+    if (!currentIds.has(id)) {
+      logActivity({
+        type: "deleted", taskId: id, subject: prev.subject || "Unknown",
+        agent: "", detail: "",
+      });
+    }
+  }
+  snapshotTasks(tasks);
+}
+
+function watchTasks() {
+  if (!fs.existsSync(TASKS_DIR)) fs.mkdirSync(TASKS_DIR, { recursive: true });
+  const watched = new Set();
+
+  // 초기 스냅샷 (서버 시작 시 현재 상태 기록 → 기존 태스크에 대해 알림 안 보냄)
+  snapshotTasks(readAllTasks());
+
+  function onFileChange() {
+    const tasks = readAllTasks();
+    detectAndNotifyChanges(tasks);
+    broadcast({ type: "update", tasks });
+  }
+
+  function scanAndWatch() {
+    if (!fs.existsSync(TASKS_DIR)) return;
+    try {
+      const sessions = fs.readdirSync(TASKS_DIR, { withFileTypes: true });
+      for (const session of sessions) {
+        if (!session.isDirectory()) continue;
+        const sp = path.join(TASKS_DIR, session.name);
+        if (!watched.has(sp)) {
+          watched.add(sp);
+          try {
+            fs.watch(sp, { persistent: false }, () => onFileChange());
+          } catch {}
+        }
+      }
+    } catch {}
+  }
+  try {
+    fs.watch(TASKS_DIR, { persistent: false }, () => {
+      scanAndWatch();
+      onFileChange();
+    });
+  } catch {}
+  scanAndWatch();
+  setInterval(() => broadcast({ type: "update", tasks: readAllTasks() }), 2000);
+}
+
+// ── Request body parser ──
+function parseBody(req) {
+  return new Promise((resolve, reject) => {
+    let body = "";
+    req.on("data", (chunk) => (body += chunk));
+    req.on("end", () => {
+      try { resolve(JSON.parse(body)); }
+      catch { reject(new Error("Invalid JSON")); }
+    });
+  });
+}
+
+// ── HTML (loaded from separate file) ──
+const HTML_PATH = fs.existsSync(path.join(__dirname, "kanban.html"))
+  ? path.join(__dirname, "kanban.html")
+  : path.join(__dirname, "..", "assets", "kanban.html");
+function getHTML() {
+  return fs.readFileSync(HTML_PATH, "utf-8")
+    .replace(/\{\{PORT\}\}/g, String(PORT))
+    .replace(/\{\{PROJECT_NAME\}\}/g, PROJECT_NAME);
+}
+
+// ── Server ──
+const server = http.createServer(async (req, res) => {
+  res.setHeader("Access-Control-Allow-Origin", "*");
+  res.setHeader("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");
+  res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+
+  if (req.method === "OPTIONS") { res.writeHead(204); res.end(); return; }
+
+  // SSE
+  if (req.url === "/events") {
+    res.writeHead(200, {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive",
+    });
+    sseClients.add(res);
+    res.write("data: " + JSON.stringify({ type: "update", tasks: readAllTasks() }) + "\n\n");
+    req.on("close", () => sseClients.delete(res));
+    return;
+  }
+
+  // GET /api/tasks
+  if (req.url === "/api/tasks" && req.method === "GET") {
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(readAllTasks()));
+    return;
+  }
+
+  // POST /api/tasks
+  if (req.url === "/api/tasks" && req.method === "POST") {
+    try {
+      const data = await parseBody(req);
+      const task = createTask(data);
+      res.writeHead(201, { "Content-Type": "application/json" });
+      res.end(JSON.stringify(task));
+    } catch (e) {
+      res.writeHead(400, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: e.message }));
+    }
+    return;
+  }
+
+  // PUT /api/tasks/:id
+  const putMatch = req.url.match(/^\/api\/tasks\/([\w.-]+)$/);
+  if (putMatch && req.method === "PUT") {
+    try {
+      const data = await parseBody(req);
+      const task = updateTask(putMatch[1], data);
+      if (!task) { res.writeHead(404); res.end('{"error":"Not found"}'); return; }
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify(task));
+    } catch (e) {
+      res.writeHead(400, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: e.message }));
+    }
+    return;
+  }
+
+  // GET /api/activity
+  if (req.url.startsWith("/api/activity") && req.method === "GET") {
+    const params = new URL(req.url, "http://localhost").searchParams;
+    const since = params.get("since") || null;
+    const limit = parseInt(params.get("limit")) || 200;
+    const events = readActivity(since, limit);
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(events));
+    return;
+  }
+
+  // GET /api/report?path=<filepath>
+  if (req.url.startsWith("/api/report?") && req.method === "GET") {
+    const params = new URL(req.url, "http://localhost").searchParams;
+    const filePath = params.get("path");
+    if (!filePath || !fs.existsSync(filePath)) {
+      res.writeHead(404, { "Content-Type": "application/json" });
+      res.end('{"error":"File not found"}');
+      return;
+    }
+    // Security: only allow reading from .claude/logs/ or project docs
+    const allowed = [
+      path.join(os.homedir(), ".claude"),
+      path.join(__dirname, ".."),
+    ];
+    const resolved = path.resolve(filePath);
+    if (!allowed.some((a) => resolved.startsWith(a))) {
+      res.writeHead(403, { "Content-Type": "application/json" });
+      res.end('{"error":"Access denied"}');
+      return;
+    }
+    try {
+      const content = fs.readFileSync(resolved, "utf-8");
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ path: resolved, content: content }));
+    } catch (e) {
+      res.writeHead(500, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: e.message }));
+    }
+    return;
+  }
+
+  // POST /api/tasks/:id/slack — Agent progress reporting via thread
+  const slackMatch = req.url.match(/^\/api\/tasks\/([\w.-]+)\/slack$/);
+  if (slackMatch && req.method === "POST") {
+    try {
+      const taskId = slackMatch[1];
+      const allTasks = readAllTasks();
+      const task = allTasks.find(function (t) { return String(t.id) === taskId; });
+      if (!task) {
+        res.writeHead(404, { "Content-Type": "application/json" });
+        res.end('{"error":"Task not found"}');
+        return;
+      }
+      const body = await parseBody(req);
+      const text = body.text || "";
+      if (!text) {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end('{"error":"text is required"}');
+        return;
+      }
+      const formatted = `[${task.agent || "agent"}] #${taskId}: ${text}`;
+      const threadTs = getThreadTs(taskId);
+      const msgTs = await slackPost(formatted, threadTs);
+      // If legacy task (no thread), save the returned ts as parent
+      if (!threadTs && msgTs) {
+        setThreadTs(taskId, msgTs);
+      }
+      // Log to activity (skip Slack to avoid duplicate)
+      logActivity({
+        type: "updated", taskId: taskId, subject: task.subject,
+        agent: task.agent || "", detail: "Agent report: " + text.slice(0, 100),
+        _skipSlack: true,
+      });
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ ok: true, threadTs: threadTs || msgTs }));
+    } catch (e) {
+      res.writeHead(400, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: e.message }));
+    }
+    return;
+  }
+
+  // DELETE /api/tasks/:id
+  const delMatch = req.url.match(/^\/api\/tasks\/([\w.-]+)$/);
+  if (delMatch && req.method === "DELETE") {
+    const ok = deleteTask(delMatch[1]);
+    res.writeHead(ok ? 204 : 404);
+    res.end();
+    return;
+  }
+
+  // GET /api/cli-status
+  if (req.url === "/api/cli-status" && req.method === "GET") {
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({
+      available: cliAvailable,
+      executing: activeExec ? activeExec.taskId : null,
+      nested: !!process.env.CLAUDECODE,
+      queue: execQueue.map(function (t) { return { id: t.id, subject: t.subject }; }),
+    }));
+    return;
+  }
+
+  // GET /api/chat/session
+  if (req.url === "/api/chat/session" && req.method === "GET") {
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ sessionId: chatSessionId, model: chatSessionModel, hasSession: !!chatSessionId }));
+    return;
+  }
+
+  // DELETE /api/chat/session
+  if (req.url === "/api/chat/session" && req.method === "DELETE") {
+    chatSessionId = null;
+    chatSessionModel = null;
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end('{"ok":true}');
+    return;
+  }
+
+  // GET /api/agents — list all agents with prompts
+  if (req.url === "/api/agents" && req.method === "GET") {
+    var agentsDir = path.join(__dirname, "..", ".claude", "agents");
+    var agentList = [];
+    try {
+      var files = fs.readdirSync(agentsDir).filter(function (f) { return f.endsWith(".md") && !f.startsWith("_"); });
+      files.forEach(function (f) {
+        var name = f.replace(".md", "");
+        var content = "";
+        try { content = fs.readFileSync(path.join(agentsDir, f), "utf8"); } catch (e) {}
+        var model = getModelForAgent(resolveAgentName(name) || name);
+        agentList.push({ name: name, model: model, prompt: content });
+      });
+    } catch (e) {}
+    // Also include project context
+    var projectCtx = loadProjectContext();
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ agents: agentList, projectContext: projectCtx }));
+    return;
+  }
+
+  // GET /api/agents/:name — single agent prompt
+  if (req.url.startsWith("/api/agents/") && req.method === "GET") {
+    var agentName = decodeURIComponent(req.url.split("/api/agents/")[1]);
+    var prompt = loadAgentPrompt(agentName);
+    var model = getModelForAgent(resolveAgentName(agentName) || agentName);
+    var ctx = loadProjectContext();
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ name: agentName, model: model, prompt: prompt, projectContext: ctx }));
+    return;
+  }
+
+  // GET /api/exec/queue
+  if (req.url === "/api/exec/queue" && req.method === "GET") {
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({
+      active: activeExec ? { taskId: activeExec.taskId } : null,
+      queue: execQueue.map(function (t) { return { id: t.id, subject: t.subject }; }),
+    }));
+    return;
+  }
+
+  // GET /api/chat/history
+  var CHAT_FILE = path.join(KANBAN_DIR, "chat-history.json");
+  if (req.url === "/api/chat/history" && req.method === "GET") {
+    try {
+      var hist = fs.existsSync(CHAT_FILE) ? JSON.parse(fs.readFileSync(CHAT_FILE, "utf-8")) : [];
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify(hist));
+    } catch (e) {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end("[]");
+    }
+    return;
+  }
+
+  // PUT /api/chat/history
+  if (req.url === "/api/chat/history" && req.method === "PUT") {
+    try {
+      var body = await parseBody(req);
+      fs.writeFileSync(CHAT_FILE, JSON.stringify(body.messages || [], null, 2));
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end('{"ok":true}');
+    } catch (e) {
+      res.writeHead(400, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: e.message }));
+    }
+    return;
+  }
+
+  // DELETE /api/chat/history
+  if (req.url === "/api/chat/history" && req.method === "DELETE") {
+    try { fs.unlinkSync(CHAT_FILE); } catch (e) {}
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end('{"ok":true}');
+    return;
+  }
+
+  // GET /api/orchestrator
+  if (req.url === "/api/orchestrator" && req.method === "GET") {
+    var orchPrompt = readOrchestratorPrompt();
+    var orchHistory = readOrchestratorHistory(20);
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ prompt: orchPrompt, history: orchHistory, path: ORCHESTRATOR_FILE }));
+    return;
+  }
+
+  // PUT /api/orchestrator
+  if (req.url === "/api/orchestrator" && req.method === "PUT") {
+    try {
+      var orchBody = await parseBody(req);
+      if (orchBody.prompt) {
+        fs.writeFileSync(ORCHESTRATOR_FILE, orchBody.prompt);
+      }
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end('{"ok":true}');
+    } catch (e) {
+      res.writeHead(400, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: e.message }));
+    }
+    return;
+  }
+
+  // POST /api/chat — enhanced with tool_use capture + action execution + session
+  if (req.url === "/api/chat" && req.method === "POST") {
+    if (!cliAvailable) {
+      res.writeHead(503, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Claude CLI not available" }));
+      return;
+    }
+    try {
+      var chatBody = await parseBody(req);
+      var chatMessage = chatBody.message || "";
+      var chatModel = chatBody.model || "sonnet";
+
+      var tasks = readAllTasks();
+      var chatPrompt = buildChatSystemPrompt(tasks, PROJECT_NAME);
+
+      // Build CLI args
+      var chatArgs = ["-p", "--verbose", "--output-format", "stream-json",
+        "--model", chatModel, "--dangerously-skip-permissions"];
+
+      // Session continuity: resume if same model
+      if (chatSessionId && chatSessionModel === chatModel) {
+        chatArgs.push("--resume", chatSessionId);
+      } else {
+        chatArgs.push("--no-session-persistence");
+        chatSessionId = null;
+        chatSessionModel = chatModel;
+      }
+
+      // Build input — include system context only for new sessions
+      var chatInput = "";
+      if (!chatSessionId) {
+        chatInput = chatPrompt + "\n\n[User]: " + chatMessage;
+      } else {
+        chatInput = chatMessage;
+      }
+
+      res.writeHead(200, {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        "Connection": "keep-alive",
+      });
+
+      var chatEnv = Object.assign({}, process.env);
+      delete chatEnv.ANTHROPIC_API_KEY; // Max 구독 OAuth 사용
+      var chatProc = spawn("claude", chatArgs, {
+        cwd: path.join(__dirname, ".."),
+        env: chatEnv,
+        stdio: ["pipe", "pipe", "pipe"],
+      });
+
+      chatProc.stdin.write(chatInput);
+      chatProc.stdin.end();
+
+      var chatBuf = "";
+      var rawOut = "";
+      var fullResponse = "";
+      appendOrchestratorHistory("user", chatMessage);
+
+      chatProc.stdout.on("data", function (data) {
+        var chunk = data.toString();
+        rawOut += chunk;
+        chatBuf += chunk;
+        var lines = chatBuf.split("\n");
+        chatBuf = lines.pop();
+        for (var li = 0; li < lines.length; li++) {
+          var ln = lines[li];
+          if (!ln.trim()) continue;
+          try {
+            var json = JSON.parse(ln);
+
+            // Capture session ID from init event
+            if (json.type === "system" && json.session_id) {
+              chatSessionId = json.session_id;
+              chatSessionModel = chatModel;
+              res.write("data: " + JSON.stringify({ type: "chat_session", sessionId: chatSessionId }) + "\n\n");
+            }
+
+            // Text content
+            var text = "";
+            if (json.type === "assistant" && json.subtype === "text") {
+              text = json.text || "";
+            } else if (json.type === "assistant" && json.message && json.message.content) {
+              json.message.content.forEach(function (c) { if (c.type === "text") text += c.text; });
+            } else if (json.type === "content_block_delta" && json.delta && json.delta.text) {
+              text = json.delta.text;
+            }
+            if (text) {
+              fullResponse += text;
+              res.write("data: " + JSON.stringify({ type: "chat", chunk: text }) + "\n\n");
+            }
+
+            // Tool use start
+            if (json.type === "assistant" && json.subtype === "tool_use") {
+              var toolName = json.tool || json.name || "Tool";
+              var toolInput = "";
+              if (json.input) {
+                if (typeof json.input === "string") toolInput = json.input;
+                else if (json.input.command) toolInput = json.input.command;
+                else if (json.input.file_path) toolInput = json.input.file_path;
+                else if (json.input.pattern) toolInput = json.input.pattern;
+                else if (json.input.query) toolInput = json.input.query;
+                else toolInput = JSON.stringify(json.input).slice(0, 200);
+              }
+              res.write("data: " + JSON.stringify({ type: "chat_tool_use", tool: toolName, input: toolInput }) + "\n\n");
+            }
+
+            // Tool result
+            if (json.type === "tool_result" || (json.type === "tool" && json.subtype === "result")) {
+              var output = json.output || json.text || json.content || "";
+              if (typeof output !== "string") output = JSON.stringify(output).slice(0, 2000);
+              res.write("data: " + JSON.stringify({ type: "chat_tool_result", output: String(output).slice(0, 2000) }) + "\n\n");
+            }
+
+          } catch (e) {}
+        }
+      });
+
+      var chatErr = "";
+      chatProc.stderr.on("data", function (data) { chatErr += data.toString(); });
+
+      chatProc.on("close", function (code) {
+        try {
+          // Debug info if no output
+          if (!rawOut.trim() || code !== 0) {
+            res.write("data: " + JSON.stringify({ type: "chat_debug", rawOut: rawOut.slice(0, 2000), stderr: chatErr.slice(0, 2000), exitCode: code }) + "\n\n");
+          }
+          if (chatErr && code !== 0) {
+            res.write("data: " + JSON.stringify({ type: "chat_error", error: chatErr.trim(), exitCode: code }) + "\n\n");
+          }
+
+          // Parse and execute action blocks
+          var parsed = parseActionBlocks(fullResponse);
+          if (parsed.actions.length > 0) {
+            var actionResults = [];
+            for (var ai = 0; ai < parsed.actions.length; ai++) {
+              var results = executeAction(parsed.actions[ai]);
+              actionResults = actionResults.concat(results);
+            }
+            res.write("data: " + JSON.stringify({ type: "chat_actions", results: actionResults }) + "\n\n");
+          }
+
+          res.write("data: " + JSON.stringify({ type: "chat_done" }) + "\n\n");
+          res.end();
+
+          // Save orchestrator history
+          if (parsed.cleaned || fullResponse) {
+            appendOrchestratorHistory("orchestrator", (parsed.cleaned || fullResponse));
+            extractAndSaveLearnings(fullResponse);
+          }
+        } catch (e) {}
+      });
+
+      req.on("close", function () {
+        try { chatProc.kill(); } catch (e) {}
+      });
+    } catch (e) {
+      if (!res.headersSent) {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: e.message }));
+      }
+    }
+    return;
+  }
+
+  // POST /api/exec/stop
+  if (req.url === "/api/exec/stop" && req.method === "POST") {
+    var stoppedId = stopExec();
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ stopped: !!stoppedId, taskId: stoppedId }));
+    return;
+  }
+
+  // HTML
+  res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+  res.end(getHTML());
+});
+
+checkClaudeCLI();
+loadThreadMap();
+watchTasks();
+server.listen(PORT, () => {
+  console.log("");
+  console.log("  " + PROJECT_NAME + " Control Center");
+  console.log("  ─────────────────────────");
+  console.log("  http://localhost:" + PORT);
+  console.log("  " + TASKS_DIR);
+  console.log("  Manual tasks: " + KANBAN_DIR);
+  console.log("  CLI: " + (cliAvailable ? "ready" : process.env.CLAUDECODE ? "unavailable (nested session)" : "not found"));
+  console.log("");
+  console.log("  N            : new task");
+  console.log("  C            : chat panel");
+  console.log("  A            : activity panel");
+  console.log("  Drag         : move between columns");
+  console.log("  Ctrl+Shift+K : stop execution");
+  console.log("  Ctrl+C       : quit");
+  console.log("");
+  initSlackBot();
+});