kandown 0.34.0 → 0.34.2

package/bin/kandown.js

@@ -5,9 +5,8 @@ if (typeof globalThis.require === 'undefined') {
 }
 
 // src/cli/cli.ts
-import { existsSync as existsSync8, readFileSync as readFileSync8, copyFileSync as copyFileSync3, mkdirSync as mkdirSync5, readdirSync as readdirSync4, statSync as statSync4 } from "fs";
-import { join as join8, resolve as resolve2, basename } from "path";
-import { spawn as spawn5, spawnSync } from "child_process";
+import { existsSync as existsSync11 } from "fs";
+import { join as join12 } from "path";
 
 // src/cli/lib/updater.ts
 import { existsSync, readFileSync, writeFileSync, unlinkSync, statSync, mkdirSync } from "fs";
@@ -16,7 +15,7 @@ import { spawn, execSync } from "child_process";
 import { homedir } from "os";
 
 // src/lib/version.ts
-var KANDOWN_VERSION = "0.34.0";
+var KANDOWN_VERSION = "0.34.2";
 
 // src/cli/lib/updater.ts
 import { fileURLToPath } from "url";
@@ -209,7 +208,7 @@ async function checkForUpdate(argv = process.argv) {
     }
   } catch {
   }
-  const latest = await new Promise((resolve3) => {
+  const latest = await new Promise((resolve5) => {
     const child2 = spawn("npm", ["view", "kandown", "version"], {
       timeout: 6e3,
       stdio: ["pipe", "pipe", "pipe"],
@@ -222,11 +221,11 @@ async function checkForUpdate(argv = process.argv) {
     });
     child2.stderr.on("data", () => {
     });
-    child2.on("error", () => resolve3(null));
+    child2.on("error", () => resolve5(null));
     child2.on("close", (code) => {
-      if (code !== 0) return resolve3(null);
+      if (code !== 0) return resolve5(null);
       const v = stdout.trim().replace(/^"|"$/g, "");
-      resolve3(v || null);
+      resolve5(v || null);
     });
   });
   if (!latest) return;
@@ -264,15 +263,192 @@ ${now}`, "utf8");
   process.exit(0);
 }
 
+// src/cli/lib/daemon.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, unlinkSync as unlinkSync2 } from "fs";
+import { dirname as dirname2, join as join2 } from "path";
+import { execFileSync, spawn as spawn2 } from "child_process";
+import { createConnection } from "net";
+function metadataPath(kandownDir) {
+  return join2(kandownDir, "daemon.json");
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function parseMetadata(value) {
+  if (!isRecord(value)) return null;
+  const { pid, port, url, kandownDir, startedAt, version, token } = value;
+  if (typeof pid !== "number" || !Number.isInteger(pid)) return null;
+  if (typeof port !== "number" || !Number.isInteger(port)) return null;
+  if (typeof url !== "string" || typeof kandownDir !== "string") return null;
+  if (typeof startedAt !== "string") return null;
+  if (version !== null && typeof version !== "string" && version !== void 0) return null;
+  if (token !== null && typeof token !== "string" && token !== void 0) return null;
+  return { pid, port, url, kandownDir, startedAt, version: version ?? null, token: typeof token === "string" ? token : null };
+}
+function readDaemonMetadata(kandownDir) {
+  const path = metadataPath(kandownDir);
+  if (!existsSync2(path)) return null;
+  try {
+    return parseMetadata(JSON.parse(readFileSync2(path, "utf8")));
+  } catch {
+    return null;
+  }
+}
+function removeDaemonMetadata(kandownDir) {
+  try {
+    const path = metadataPath(kandownDir);
+    if (existsSync2(path)) unlinkSync2(path);
+  } catch {
+  }
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function parseRemoteDaemonInfo(value) {
+  if (!isRecord(value)) return null;
+  const { ok, pid, kandownDir, version } = value;
+  if (ok !== true || typeof pid !== "number" || !Number.isInteger(pid) || typeof kandownDir !== "string") return null;
+  if (version !== null && typeof version !== "string" && version !== void 0) return null;
+  return { ok, pid, kandownDir, version: typeof version === "string" ? version : null };
+}
+async function fetchDaemonInfo(port) {
+  try {
+    const response = await fetch(`http://127.0.0.1:${port}/api/daemon`, {
+      signal: AbortSignal.timeout(700)
+    });
+    if (!response.ok) return null;
+    return parseRemoteDaemonInfo(await response.json());
+  } catch {
+    return null;
+  }
+}
+function isPortListening(port, timeoutMs = 400) {
+  return new Promise((resolve5) => {
+    const socket = createConnection({ port, host: "127.0.0.1" }, () => {
+      socket.destroy();
+      resolve5(true);
+    });
+    socket.on("error", () => resolve5(false));
+    socket.setTimeout(timeoutMs);
+    socket.on("timeout", () => {
+      socket.destroy();
+      resolve5(false);
+    });
+  });
+}
+async function getDaemonStatus(kandownDir) {
+  const metadata = readDaemonMetadata(kandownDir);
+  if (!metadata) return { running: false, metadata: null };
+  if (!isProcessAlive(metadata.pid)) {
+    removeDaemonMetadata(kandownDir);
+    return { running: false, metadata: null };
+  }
+  const remote = await fetchDaemonInfo(metadata.port);
+  if (!remote) {
+    return { running: false, metadata: null };
+  }
+  if (remote.pid !== metadata.pid || remote.kandownDir !== kandownDir) {
+    removeDaemonMetadata(kandownDir);
+    return { running: false, metadata: null };
+  }
+  return { running: true, metadata: { ...metadata, version: remote.version ?? metadata.version } };
+}
+async function waitForDaemon(kandownDir, timeoutMs = 8e3) {
+  const started = Date.now();
+  while (Date.now() - started < timeoutMs) {
+    const metadata = readDaemonMetadata(kandownDir);
+    if (metadata && isProcessAlive(metadata.pid) && await isPortListening(metadata.port)) {
+      return { running: true, metadata };
+    }
+    await new Promise((resolve5) => setTimeout(resolve5, 120));
+  }
+  return { running: false, metadata: null };
+}
+async function startProjectDaemon(kandownDir, preferredPort) {
+  const current = await getDaemonStatus(kandownDir);
+  if (current.running) {
+    if (current.metadata?.version === getCurrentVersion()) return current;
+    await stopProjectDaemon(kandownDir);
+  }
+  const cliPath = join2(PKG_ROOT, "bin", "kandown.js");
+  if (!existsSync2(cliPath)) throw new Error(`Cannot locate kandown CLI entrypoint at ${cliPath}`);
+  const args = [
+    cliPath,
+    "--no-update-check",
+    "daemon",
+    "run",
+    "--path",
+    kandownDir
+  ];
+  if (typeof preferredPort === "number" && Number.isInteger(preferredPort)) {
+    args.push("--port", String(preferredPort));
+  }
+  const child = spawn2(process.execPath, args, {
+    cwd: dirname2(kandownDir),
+    detached: true,
+    stdio: "ignore",
+    env: { ...process.env, KANDOWN_DAEMON: "1" }
+  });
+  child.unref();
+  return waitForDaemon(kandownDir);
+}
+async function isOwnedKandownDaemon(pid, port, kandownDir) {
+  const remote = await fetchDaemonInfo(port);
+  if (remote) return remote.pid === pid && remote.kandownDir === kandownDir;
+  try {
+    const cmd = execFileSync("ps", ["-p", String(pid), "-o", "command="], {
+      encoding: "utf8",
+      timeout: 2e3
+    }).trim();
+    return /kandown/.test(cmd) && cmd.includes(kandownDir);
+  } catch {
+    return false;
+  }
+}
+async function stopProjectDaemon(kandownDir) {
+  const metadata = readDaemonMetadata(kandownDir);
+  if (!metadata) return false;
+  const pid = metadata.pid;
+  if (!isProcessAlive(pid)) {
+    removeDaemonMetadata(kandownDir);
+    return false;
+  }
+  if (!await isOwnedKandownDaemon(pid, metadata.port, kandownDir)) {
+    removeDaemonMetadata(kandownDir);
+    return false;
+  }
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch {
+  }
+  const started = Date.now();
+  while (Date.now() - started < 2500 && isProcessAlive(pid)) {
+    await new Promise((resolve5) => setTimeout(resolve5, 100));
+  }
+  if (isProcessAlive(pid)) {
+    try {
+      process.kill(pid, "SIGKILL");
+    } catch {
+    }
+  }
+  removeDaemonMetadata(kandownDir);
+  return true;
+}
+
 // src/cli/lib/board-reader.ts
-import { existsSync as existsSync3, readdirSync as readdirSync2, readFileSync as readFileSync3, mkdirSync as mkdirSync2, unlinkSync as unlinkSync3 } from "fs";
-import { dirname as dirname2, join as join3 } from "path";
+import { existsSync as existsSync4, readdirSync as readdirSync2, readFileSync as readFileSync4, mkdirSync as mkdirSync2, unlinkSync as unlinkSync4 } from "fs";
+import { dirname as dirname3, join as join4 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { homedir as homedir2 } from "os";
-import { execFileSync } from "child_process";
+import { execFileSync as execFileSync2 } from "child_process";
 
 // src/cli/lib/atomic-write.ts
-import { renameSync, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "fs";
+import { renameSync, unlinkSync as unlinkSync3, writeFileSync as writeFileSync2 } from "fs";
 function atomicWriteFileSync(path, content) {
   const tmp = `${path}.${process.pid}.tmp`;
   try {
@@ -280,7 +456,7 @@ function atomicWriteFileSync(path, content) {
     renameSync(tmp, path);
   } catch (e) {
     try {
-      unlinkSync2(tmp);
+      unlinkSync3(tmp);
     } catch {
     }
     throw e;
@@ -496,8 +672,8 @@ function serializeTaskFile(frontmatter, body) {
 }
 
 // src/cli/lib/config.ts
-import { readFileSync as readFileSync2, existsSync as existsSync2, readdirSync, statSync as statSync2 } from "fs";
-import { join as join2 } from "path";
+import { readFileSync as readFileSync3, existsSync as existsSync3, readdirSync, statSync as statSync2 } from "fs";
+import { join as join3 } from "path";
 var DEFAULT_CONFIG = {
   ui: { language: "en", theme: "auto", skin: "kandown", font: "inter" },
   agent: { suggestFollowUp: false, maxSuggestions: 3 },
@@ -526,11 +702,11 @@ var DEFAULT_CONFIG = {
   }
 };
 function loadConfig(kandownDir) {
-  const configPath = join2(kandownDir, "kandown.json");
-  if (!existsSync2(configPath)) return structuredClone(DEFAULT_CONFIG);
+  const configPath = join3(kandownDir, "kandown.json");
+  if (!existsSync3(configPath)) return structuredClone(DEFAULT_CONFIG);
   let raw;
   try {
-    raw = JSON.parse(readFileSync2(configPath, "utf8"));
+    raw = JSON.parse(readFileSync3(configPath, "utf8"));
   } catch (e) {
     const err2 = e;
     if (err2.code === "ENOENT") return structuredClone(DEFAULT_CONFIG);
@@ -561,22 +737,22 @@ function loadConfig(kandownDir) {
   return merged;
 }
 function saveConfig(kandownDir, config) {
-  const configPath = join2(kandownDir, "kandown.json");
+  const configPath = join3(kandownDir, "kandown.json");
   atomicWriteFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
 }
 
 // src/cli/lib/board-reader.ts
 function getProjectRoot(kandownDir) {
-  return dirname2(kandownDir);
+  return dirname3(kandownDir);
 }
 function getTasksDir(kandownDir) {
-  return join3(getProjectRoot(kandownDir), "tasks");
+  return join4(getProjectRoot(kandownDir), "tasks");
 }
 function listTaskIds(kandownDir) {
   const tasksDir = getTasksDir(kandownDir);
   const ids = /* @__PURE__ */ new Set();
-  for (const directory of [tasksDir, join3(tasksDir, "archive")]) {
-    if (!existsSync3(directory)) continue;
+  for (const directory of [tasksDir, join4(tasksDir, "archive")]) {
+    if (!existsSync4(directory)) continue;
     for (const name of readdirSync2(directory).filter((entry) => entry.endsWith(".md"))) {
       ids.add(name.slice(0, -3));
     }
@@ -586,10 +762,10 @@ function listTaskIds(kandownDir) {
 function findTaskPath(kandownDir, taskId) {
   if (!/^[a-zA-Z0-9_-]+$/.test(taskId)) return null;
   const tasksDir = getTasksDir(kandownDir);
-  const activePath = join3(tasksDir, `${taskId}.md`);
-  if (existsSync3(activePath)) return activePath;
-  const archivedPath = join3(tasksDir, "archive", `${taskId}.md`);
-  return existsSync3(archivedPath) ? archivedPath : null;
+  const activePath = join4(tasksDir, `${taskId}.md`);
+  if (existsSync4(activePath)) return activePath;
+  const archivedPath = join4(tasksDir, "archive", `${taskId}.md`);
+  return existsSync4(archivedPath) ? archivedPath : null;
 }
 function readBoard(kandownDir) {
   const config = loadConfig(kandownDir);
@@ -624,7 +800,7 @@ function readTask(kandownDir, taskId) {
       body: ""
     };
   }
-  const content = readFileSync3(taskPath2, "utf8");
+  const content = readFileSync4(taskPath2, "utf8");
   const parsed = parseTaskFile(content);
   return {
     ...parsed,
@@ -635,37 +811,37 @@ function readTask(kandownDir, taskId) {
     }
   };
 }
-var PKG_ROOT2 = dirname2(dirname2(fileURLToPath2(import.meta.url)));
+var PKG_ROOT2 = dirname3(dirname3(fileURLToPath2(import.meta.url)));
 function readAgentDoc(kandownDir) {
   const sections = [];
   try {
-    sections.push(readFileSync3(join3(PKG_ROOT2, "templates", "AGENT_KANDOWN.md"), "utf8").trim());
+    sections.push(readFileSync4(join4(PKG_ROOT2, "templates", "AGENT_KANDOWN.md"), "utf8").trim());
   } catch (e) {
     console.warn("[kandown] Could not read base agent rules:", e.message);
   }
-  const globalPath = join3(homedir2(), ".kandown", "instructions.md");
-  if (existsSync3(globalPath)) {
+  const globalPath = join4(homedir2(), ".kandown", "instructions.md");
+  if (existsSync4(globalPath)) {
     try {
       sections.push(`## Global instructions
 
-${readFileSync3(globalPath, "utf8").trim()}`);
+${readFileSync4(globalPath, "utf8").trim()}`);
     } catch (e) {
       console.warn(`[kandown] Could not read ${globalPath}:`, e.message);
     }
   }
-  const projectPath = join3(kandownDir, "instructions.md");
-  if (existsSync3(projectPath)) {
+  const projectPath = join4(kandownDir, "instructions.md");
+  if (existsSync4(projectPath)) {
     try {
       sections.push(`## Project-specific instructions
 
-${readFileSync3(projectPath, "utf8").trim()}`);
+${readFileSync4(projectPath, "utf8").trim()}`);
     } catch (e) {
       console.warn(`[kandown] Could not read ${projectPath}:`, e.message);
     }
   }
   try {
     const root = getProjectRoot(kandownDir);
-    const gitLog = execFileSync("git", ["log", "-n", "5", "--oneline", "--", "tasks/"], { cwd: root, encoding: "utf8" }).trim();
+    const gitLog = execFileSync2("git", ["log", "-n", "5", "--oneline", "--", "tasks/"], { cwd: root, encoding: "utf8" }).trim();
     if (gitLog) {
       sections.push(`## Recent Task Activity (Git History)
 
@@ -681,7 +857,7 @@ function moveTaskToColumn(kandownDir, taskId, targetColumn) {
   const taskPath2 = findTaskPath(kandownDir, taskId);
   if (!taskPath2) return false;
   try {
-    const prevContent = readFileSync3(taskPath2, "utf8");
+    const prevContent = readFileSync4(taskPath2, "utf8");
     const parsed = readTask(kandownDir, taskId);
     const newContent = serializeTaskFile({
       ...parsed.frontmatter,
@@ -705,13 +881,13 @@ function moveTaskToColumn(kandownDir, taskId, targetColumn) {
 }
 function pushUndo(kandownDir, record) {
   try {
-    const undoDir = join3(kandownDir, ".undo");
-    if (!existsSync3(undoDir)) mkdirSync2(undoDir, { recursive: true });
-    const logPath = join3(undoDir, "log.json");
+    const undoDir = join4(kandownDir, ".undo");
+    if (!existsSync4(undoDir)) mkdirSync2(undoDir, { recursive: true });
+    const logPath = join4(undoDir, "log.json");
     let list = [];
-    if (existsSync3(logPath)) {
+    if (existsSync4(logPath)) {
       try {
-        list = JSON.parse(readFileSync3(logPath, "utf8"));
+        list = JSON.parse(readFileSync4(logPath, "utf8"));
       } catch {
         list = [];
       }
@@ -724,7 +900,7 @@ function pushUndo(kandownDir, record) {
 }
 function createTaskInBoard(kandownDir, rawInput, status) {
   const tasksDir = getTasksDir(kandownDir);
-  if (!existsSync3(tasksDir)) mkdirSync2(tasksDir, { recursive: true });
+  if (!existsSync4(tasksDir)) mkdirSync2(tasksDir, { recursive: true });
   const ids = listTaskIds(kandownDir);
   let maxN = 0;
   for (const id of ids) {
@@ -776,7 +952,7 @@ function createTaskInBoard(kandownDir, rawInput, status) {
   if (due) fm.due = due;
   if (depends_on.length > 0) fm.depends_on = depends_on;
   const content = serializeTaskFile(fm, "");
-  const taskPath2 = join3(tasksDir, `${newId}.md`);
+  const taskPath2 = join4(tasksDir, `${newId}.md`);
   atomicWriteFileSync(taskPath2, content);
   pushUndo(kandownDir, {
     type: "create",
@@ -790,21 +966,21 @@ function createTaskInBoard(kandownDir, rawInput, status) {
 }
 function archiveTaskInBoard(kandownDir, taskId) {
   const tasksDir = getTasksDir(kandownDir);
-  const taskPath2 = join3(tasksDir, `${taskId}.md`);
-  if (!existsSync3(taskPath2)) return false;
+  const taskPath2 = join4(tasksDir, `${taskId}.md`);
+  if (!existsSync4(taskPath2)) return false;
   try {
-    const prevContent = readFileSync3(taskPath2, "utf8");
-    const archiveDir = join3(tasksDir, "archive");
-    if (!existsSync3(archiveDir)) mkdirSync2(archiveDir, { recursive: true });
+    const prevContent = readFileSync4(taskPath2, "utf8");
+    const archiveDir = join4(tasksDir, "archive");
+    if (!existsSync4(archiveDir)) mkdirSync2(archiveDir, { recursive: true });
     const parsed = readTask(kandownDir, taskId);
     const newContent = serializeTaskFile({
       ...parsed.frontmatter,
       id: taskId,
       archived: true
     }, parsed.body);
-    const destPath = join3(archiveDir, `${taskId}.md`);
+    const destPath = join4(archiveDir, `${taskId}.md`);
     atomicWriteFileSync(destPath, newContent);
-    unlinkSync3(taskPath2);
+    unlinkSync4(taskPath2);
     pushUndo(kandownDir, {
       type: "archive",
       taskId,
@@ -819,675 +995,48 @@ function archiveTaskInBoard(kandownDir, taskId) {
   }
 }
 
-// src/cli/lib/daemon.ts
-import { existsSync as existsSync4, readFileSync as readFileSync4, unlinkSync as unlinkSync4 } from "fs";
-import { dirname as dirname3, join as join4 } from "path";
-import { execFileSync as execFileSync2, spawn as spawn2 } from "child_process";
-import { createConnection } from "net";
-function metadataPath(kandownDir) {
-  return join4(kandownDir, "daemon.json");
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null;
-}
-function parseMetadata(value) {
-  if (!isRecord(value)) return null;
-  const { pid, port, url, kandownDir, startedAt, version, token } = value;
-  if (typeof pid !== "number" || !Number.isInteger(pid)) return null;
-  if (typeof port !== "number" || !Number.isInteger(port)) return null;
-  if (typeof url !== "string" || typeof kandownDir !== "string") return null;
-  if (typeof startedAt !== "string") return null;
-  if (version !== null && typeof version !== "string" && version !== void 0) return null;
-  if (token !== null && typeof token !== "string" && token !== void 0) return null;
-  return { pid, port, url, kandownDir, startedAt, version: version ?? null, token: typeof token === "string" ? token : null };
-}
-function readDaemonMetadata(kandownDir) {
-  const path = metadataPath(kandownDir);
-  if (!existsSync4(path)) return null;
-  try {
-    return parseMetadata(JSON.parse(readFileSync4(path, "utf8")));
-  } catch {
-    return null;
-  }
-}
-function removeDaemonMetadata(kandownDir) {
-  try {
-    const path = metadataPath(kandownDir);
-    if (existsSync4(path)) unlinkSync4(path);
-  } catch {
-  }
-}
-function isProcessAlive(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
+// src/cli/lib/mcp.ts
+import { existsSync as existsSync5 } from "fs";
+import { join as join5 } from "path";
+function startMcpServer(kandownDir) {
+  process.stdin.setEncoding("utf8");
+  let buffer = "";
+  process.stdin.on("data", (chunk) => {
+    buffer += chunk;
+    const lines = buffer.split("\n");
+    buffer = lines.pop() ?? "";
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      try {
+        const req = JSON.parse(trimmed);
+        handleJsonRpc(kandownDir, req);
+      } catch (e) {
+        sendResponse(null, { error: { code: -32700, message: "Parse error" } });
+      }
+    }
+  });
 }
-function parseRemoteDaemonInfo(value) {
-  if (!isRecord(value)) return null;
-  const { ok, pid, kandownDir, version } = value;
-  if (ok !== true || typeof pid !== "number" || !Number.isInteger(pid) || typeof kandownDir !== "string") return null;
-  if (version !== null && typeof version !== "string" && version !== void 0) return null;
-  return { ok, pid, kandownDir, version: typeof version === "string" ? version : null };
+function sendResponse(id, resultOrError) {
+  if (id === void 0) return;
+  const resp = {
+    jsonrpc: "2.0",
+    id,
+    ...resultOrError
+  };
+  process.stdout.write(JSON.stringify(resp) + "\n");
 }
-async function fetchDaemonInfo(port) {
-  try {
-    const response = await fetch(`http://127.0.0.1:${port}/api/daemon`, {
-      signal: AbortSignal.timeout(700)
+function handleJsonRpc(kandownDir, req) {
+  const { id, method, params } = req;
+  if (method === "initialize") {
+    sendResponse(id, {
+      result: {
+        protocolVersion: "2024-11-05",
+        capabilities: { tools: {} },
+        serverInfo: { name: "kandown", version: "0.20.0" }
+      }
     });
-    if (!response.ok) return null;
-    return parseRemoteDaemonInfo(await response.json());
-  } catch {
-    return null;
-  }
-}
-function isPortListening(port, timeoutMs = 400) {
-  return new Promise((resolve3) => {
-    const socket = createConnection({ port, host: "127.0.0.1" }, () => {
-      socket.destroy();
-      resolve3(true);
-    });
-    socket.on("error", () => resolve3(false));
-    socket.setTimeout(timeoutMs);
-    socket.on("timeout", () => {
-      socket.destroy();
-      resolve3(false);
-    });
-  });
-}
-async function getDaemonStatus(kandownDir) {
-  const metadata = readDaemonMetadata(kandownDir);
-  if (!metadata) return { running: false, metadata: null };
-  if (!isProcessAlive(metadata.pid)) {
-    removeDaemonMetadata(kandownDir);
-    return { running: false, metadata: null };
-  }
-  const remote = await fetchDaemonInfo(metadata.port);
-  if (!remote) {
-    return { running: false, metadata: null };
-  }
-  if (remote.pid !== metadata.pid || remote.kandownDir !== kandownDir) {
-    removeDaemonMetadata(kandownDir);
-    return { running: false, metadata: null };
-  }
-  return { running: true, metadata: { ...metadata, version: remote.version ?? metadata.version } };
-}
-async function waitForDaemon(kandownDir, timeoutMs = 8e3) {
-  const started = Date.now();
-  while (Date.now() - started < timeoutMs) {
-    const metadata = readDaemonMetadata(kandownDir);
-    if (metadata && isProcessAlive(metadata.pid) && await isPortListening(metadata.port)) {
-      return { running: true, metadata };
-    }
-    await new Promise((resolve3) => setTimeout(resolve3, 120));
-  }
-  return { running: false, metadata: null };
-}
-async function startProjectDaemon(kandownDir, preferredPort) {
-  const current = await getDaemonStatus(kandownDir);
-  if (current.running) {
-    if (current.metadata?.version === getCurrentVersion()) return current;
-    await stopProjectDaemon(kandownDir);
-  }
-  const cliPath = join4(PKG_ROOT, "bin", "kandown.js");
-  if (!existsSync4(cliPath)) throw new Error(`Cannot locate kandown CLI entrypoint at ${cliPath}`);
-  const args = [
-    cliPath,
-    "--no-update-check",
-    "daemon",
-    "run",
-    "--path",
-    kandownDir
-  ];
-  if (typeof preferredPort === "number" && Number.isInteger(preferredPort)) {
-    args.push("--port", String(preferredPort));
-  }
-  const child = spawn2(process.execPath, args, {
-    cwd: dirname3(kandownDir),
-    detached: true,
-    stdio: "ignore",
-    env: { ...process.env, KANDOWN_DAEMON: "1" }
-  });
-  child.unref();
-  return waitForDaemon(kandownDir);
-}
-async function isOwnedKandownDaemon(pid, port, kandownDir) {
-  const remote = await fetchDaemonInfo(port);
-  if (remote) return remote.pid === pid && remote.kandownDir === kandownDir;
-  try {
-    const cmd = execFileSync2("ps", ["-p", String(pid), "-o", "command="], {
-      encoding: "utf8",
-      timeout: 2e3
-    }).trim();
-    return /kandown/.test(cmd) && cmd.includes(kandownDir);
-  } catch {
-    return false;
-  }
-}
-async function stopProjectDaemon(kandownDir) {
-  const metadata = readDaemonMetadata(kandownDir);
-  if (!metadata) return false;
-  const pid = metadata.pid;
-  if (!isProcessAlive(pid)) {
-    removeDaemonMetadata(kandownDir);
-    return false;
-  }
-  if (!await isOwnedKandownDaemon(pid, metadata.port, kandownDir)) {
-    removeDaemonMetadata(kandownDir);
-    return false;
-  }
-  try {
-    process.kill(pid, "SIGTERM");
-  } catch {
-  }
-  const started = Date.now();
-  while (Date.now() - started < 2500 && isProcessAlive(pid)) {
-    await new Promise((resolve3) => setTimeout(resolve3, 100));
-  }
-  if (isProcessAlive(pid)) {
-    try {
-      process.kill(pid, "SIGKILL");
-    } catch {
-    }
-  }
-  removeDaemonMetadata(kandownDir);
-  return true;
-}
-
-// src/cli/lib/server.ts
-import { createServer } from "http";
-import { existsSync as existsSync5, readFileSync as readFileSync5, copyFileSync, unlinkSync as unlinkSync5, mkdirSync as mkdirSync3 } from "fs";
-import { join as join5 } from "path";
-import { spawn as spawn3 } from "child_process";
-var START_PORT_RANGE = 2050;
-var END_PORT_RANGE = 2099;
-var UNSAFE_PORTS = /* @__PURE__ */ new Set([2049, 4045, 6e3, 6665, 6666, 6667, 6668, 6669, 6697]);
-var sseClients = [];
-var nextClientId = 1;
-function broadcastSseEvent(data) {
-  const payload = `data: ${JSON.stringify(data)}
-
-`;
-  sseClients.forEach((c2) => c2.res.write(payload));
-}
-function handleCors(res) {
-  res.writeHead(204, {
-    "Access-Control-Allow-Origin": "*",
-    "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, OPTIONS",
-    "Access-Control-Allow-Headers": "Content-Type, X-Kandown-Token"
-  });
-  res.end();
-}
-function writeJson(res, status, data) {
-  res.writeHead(status, {
-    "Content-Type": "application/json",
-    "Access-Control-Allow-Origin": "*"
-  });
-  res.end(JSON.stringify(data));
-}
-function writeText(res, status, text) {
-  res.writeHead(status, {
-    "Content-Type": "text/plain; charset=utf-8",
-    "Access-Control-Allow-Origin": "*"
-  });
-  res.end(text);
-}
-function readRequestBody(req) {
-  return new Promise((resolveBody, rejectBody) => {
-    let body = "";
-    req.setEncoding("utf8");
-    req.on("data", (chunk) => {
-      body += chunk;
-    });
-    req.on("end", () => resolveBody(body));
-    req.on("error", rejectBody);
-  });
-}
-function syncProjectKandownHtml(kandownDir) {
-  try {
-    const projectHtml = join5(kandownDir, "kandown.html");
-    const distHtml = join5(PKG_ROOT, "dist", "index.html");
-    if (!existsSync5(distHtml)) return false;
-    if (!existsSync5(projectHtml)) {
-      copyFileSync(distHtml, projectHtml);
-      return true;
-    }
-    const currentContent = readFileSync5(projectHtml, "utf8");
-    const newContent = readFileSync5(distHtml, "utf8");
-    if (currentContent !== newContent) {
-      atomicWriteFileSync(projectHtml, newContent);
-      return true;
-    }
-  } catch {
-  }
-  return false;
-}
-function readDaemonPort(kandownDir) {
-  try {
-    const raw = JSON.parse(readFileSync5(join5(kandownDir, "daemon.json"), "utf8"));
-    return typeof raw.port === "number" && Number.isInteger(raw.port) ? raw.port : null;
-  } catch {
-    return null;
-  }
-}
-function restartDaemonAfterUpdateResponse(res, kandownDir) {
-  const cliPath = process.argv[1];
-  if (!cliPath) return;
-  const args = ["--no-update-check", "daemon", "run", "--path", kandownDir];
-  const port = readDaemonPort(kandownDir);
-  if (port !== null) args.push("--port", String(port));
-  const launcher = `
-const { spawn } = require('node:child_process');
-const [nodeBin, cliPath, ...cliArgs] = process.argv.slice(1);
-setTimeout(() => {
-  const child = spawn(nodeBin, [cliPath, ...cliArgs], {
-    detached: true,
-    stdio: 'ignore',
-    env: { ...process.env, KANDOWN_DAEMON: '1' },
-  });
-  child.unref();
-}, 350);
-`;
-  res.on("finish", () => {
-    const child = spawn3(process.execPath, ["-e", launcher, process.execPath, cliPath, ...args], {
-      detached: true,
-      stdio: "ignore",
-      env: { ...process.env, KANDOWN_DAEMON: "1" }
-    });
-    child.unref();
-    setTimeout(() => process.exit(0), 50).unref();
-  });
-}
-async function handleApi(req, res, url, kandownDir) {
-  const path = url.pathname;
-  const method = req.method || "GET";
-  if (path === "/api/daemon" && method === "GET") {
-    return writeJson(res, 200, {
-      ok: true,
-      pid: process.pid,
-      kandownDir,
-      version: getCurrentVersion(),
-      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      agentHook: process.env.KANDOWN_AGENT_HOOK_URL ? { enabled: true, label: process.env.KANDOWN_AGENT_HOOK_LABEL || "Send to Agent" } : null
-    });
-  }
-  if (path === "/api/version" && method === "GET") {
-    return writeJson(res, 200, {
-      version: getCurrentVersion()
-    });
-  }
-  if (path === "/api/update/check" && method === "GET") {
-    const current = getCurrentVersion();
-    const latest = await new Promise((resolve3) => {
-      const child = spawn3("npm", ["view", "kandown", "version"], {
-        timeout: 4e3,
-        stdio: ["pipe", "pipe", "pipe"],
-        env: { ...process.env },
-        detached: false
-      });
-      let stdout = "";
-      child.stdout.on("data", (d) => {
-        stdout += d;
-      });
-      child.stderr.on("data", () => {
-      });
-      child.on("error", () => resolve3(null));
-      child.on("close", (code) => {
-        if (code !== 0) return resolve3(null);
-        resolve3(stdout.trim().replace(/^"|"$/g, "") || null);
-      });
-    });
-    const updateAvailable = latest ? semverGt(latest, current) > 0 : false;
-    return writeJson(res, 200, {
-      current,
-      latest: latest || current,
-      updateAvailable
-    });
-  }
-  if (path === "/api/update/apply" && method === "POST") {
-    const current = getCurrentVersion();
-    const latest = await new Promise((resolve3) => {
-      const child = spawn3("npm", ["view", "kandown", "version"], {
-        timeout: 4e3,
-        stdio: ["pipe", "pipe", "pipe"],
-        env: { ...process.env },
-        detached: false
-      });
-      let stdout = "";
-      child.stdout.on("data", (d) => {
-        stdout += d;
-      });
-      child.on("error", () => resolve3(null));
-      child.on("close", (code) => resolve3(code === 0 ? stdout.trim() : null));
-    });
-    const targetVersion = latest || current;
-    const ok = await performGlobalPackageUpdate(`kandown@${targetVersion}`);
-    syncProjectKandownHtml(kandownDir);
-    if (ok) {
-      restartDaemonAfterUpdateResponse(res, kandownDir);
-      writeJson(res, 200, { ok: true, version: targetVersion, message: "Update installed successfully; daemon is restarting" });
-      broadcastSseEvent({ type: "update", version: targetVersion });
-    } else {
-      writeJson(res, 500, { ok: false, message: "Global package installation failed" });
-    }
-    return;
-  }
-  if (path === "/api/events" && method === "GET") {
-    res.writeHead(200, {
-      "Content-Type": "text/event-stream",
-      "Cache-Control": "no-cache",
-      "Connection": "keep-alive",
-      "Access-Control-Allow-Origin": "*"
-    });
-    res.write("retry: 2000\n\n");
-    const id = nextClientId++;
-    sseClients.push({ id, res });
-    req.on("close", () => {
-      sseClients = sseClients.filter((c2) => c2.id !== id);
-    });
-    return;
-  }
-  if (path === "/api/board") {
-    if (method === "GET") {
-      const tasksDir = getTasksDir(kandownDir);
-      const boardPath = join5(tasksDir, "board.md");
-      const text = existsSync5(boardPath) ? readFileSync5(boardPath, "utf8") : "";
-      return writeText(res, 200, text);
-    }
-    if (method === "PUT") {
-      let body = "";
-      req.on("data", (chunk) => {
-        body += chunk;
-      });
-      req.on("end", () => {
-        const tasksDir = getTasksDir(kandownDir);
-        if (!existsSync5(tasksDir)) mkdirSync3(tasksDir, { recursive: true });
-        atomicWriteFileSync(join5(tasksDir, "board.md"), body);
-        broadcastSseEvent({ type: "board" });
-        writeJson(res, 200, { ok: true });
-      });
-      return;
-    }
-  }
-  if (path === "/api/config") {
-    if (method === "GET") {
-      return writeJson(res, 200, loadConfig(kandownDir));
-    }
-    if (method === "PUT") {
-      let body = "";
-      req.on("data", (chunk) => {
-        body += chunk;
-      });
-      req.on("end", () => {
-        try {
-          const parsed = JSON.parse(body);
-          saveConfig(kandownDir, parsed);
-          broadcastSseEvent({ type: "config" });
-          writeJson(res, 200, { ok: true });
-        } catch (e) {
-          writeJson(res, 400, { error: e.message });
-        }
-      });
-      return;
-    }
-  }
-  if (path === "/api/tasks" && method === "GET") {
-    return writeJson(res, 200, listTaskIds(kandownDir));
-  }
-  if (path.startsWith("/api/tasks/")) {
-    const routeParts = path.slice("/api/tasks/".length).split("/").filter(Boolean);
-    let taskId;
-    try {
-      taskId = decodeURIComponent(routeParts[0] ?? "");
-    } catch {
-      return writeText(res, 400, "Invalid task id");
-    }
-    if (!/^[a-zA-Z0-9_-]+$/.test(taskId)) return writeText(res, 400, "Invalid task id");
-    const tasksDir = getTasksDir(kandownDir);
-    const archiveDir = join5(tasksDir, "archive");
-    const activePath = join5(tasksDir, `${taskId}.md`);
-    const archivedPath = join5(archiveDir, `${taskId}.md`);
-    const action = routeParts[1];
-    if (method === "POST" && (action === "archive" || action === "unarchive")) {
-      if (routeParts.length !== 2) return writeText(res, 400, "Invalid task route");
-      const archiving = action === "archive";
-      const source = archiving ? activePath : archivedPath;
-      const destination = archiving ? archivedPath : activePath;
-      if (!existsSync5(source) && !existsSync5(destination)) {
-        return writeText(res, 404, "Task not found");
-      }
-      try {
-        if (!existsSync5(tasksDir)) mkdirSync3(tasksDir, { recursive: true });
-        if (!existsSync5(archiveDir)) mkdirSync3(archiveDir, { recursive: true });
-        const body = await readRequestBody(req);
-        atomicWriteFileSync(destination, body);
-        if (source !== destination && existsSync5(source)) unlinkSync5(source);
-        broadcastSseEvent({ type: "task", id: taskId });
-        return writeJson(res, 200, { ok: true });
-      } catch (error) {
-        return writeJson(res, 500, {
-          error: `Failed to ${action} task: ${error instanceof Error ? error.message : String(error)}`
-        });
-      }
-    }
-    if (routeParts.length !== 1) return writeText(res, 404, "Route not found");
-    if (method === "GET") {
-      const taskPath2 = findTaskPath(kandownDir, taskId);
-      if (!taskPath2) return writeText(res, 404, "Task not found");
-      return writeText(res, 200, readFileSync5(taskPath2, "utf8"));
-    }
-    if (method === "PUT") {
-      try {
-        if (!existsSync5(tasksDir)) mkdirSync3(tasksDir, { recursive: true });
-        const taskPath2 = findTaskPath(kandownDir, taskId) ?? activePath;
-        const body = await readRequestBody(req);
-        atomicWriteFileSync(taskPath2, body);
-        broadcastSseEvent({ type: "task", id: taskId });
-        return writeJson(res, 200, { ok: true });
-      } catch (error) {
-        return writeJson(res, 500, {
-          error: `Failed to write task: ${error instanceof Error ? error.message : String(error)}`
-        });
-      }
-    }
-    if (method === "DELETE") {
-      try {
-        if (existsSync5(activePath)) unlinkSync5(activePath);
-        if (existsSync5(archivedPath)) unlinkSync5(archivedPath);
-        broadcastSseEvent({ type: "task_delete", id: taskId });
-        return writeJson(res, 200, { ok: true });
-      } catch (error) {
-        return writeJson(res, 500, {
-          error: `Failed to delete task: ${error instanceof Error ? error.message : String(error)}`
-        });
-      }
-    }
-  }
-  writeJson(res, 404, { error: "Route not found" });
-}
-function injectServerRoot(html, kandownDir) {
-  const marker = "</head>";
-  const markerIndex = html.toLowerCase().lastIndexOf(marker);
-  const safeRoot = JSON.stringify(kandownDir).replace(/</g, "\\u003c");
-  const script = `<script>window.__KANDOWN_ROOT__ = ${safeRoot};</script>
-`;
-  if (markerIndex === -1) return script + html;
-  return html.slice(0, markerIndex) + script + html.slice(markerIndex);
-}
-function serveApp(res, kandownDir) {
-  syncProjectKandownHtml(kandownDir);
-  const htmlPath = join5(kandownDir, "kandown.html");
-  if (existsSync5(htmlPath)) {
-    const html = readFileSync5(htmlPath, "utf8");
-    res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
-    res.end(injectServerRoot(html, kandownDir));
-  } else {
-    writeText(res, 404, "kandown.html not found");
-  }
-}
-function createServeServer(kandownDir) {
-  syncProjectKandownHtml(kandownDir);
-  return createServer((req, res) => {
-    const url = new URL(req.url || "/", "http://localhost");
-    if (req.method === "OPTIONS") return handleCors(res);
-    if (url.pathname === "/" || url.pathname === "/kandown.html" || !url.pathname.startsWith("/api/")) {
-      return serveApp(res, kandownDir);
-    }
-    if (url.pathname.startsWith("/api/")) {
-      return handleApi(req, res, url, kandownDir);
-    }
-    writeText(res, 404, "Not found");
-  });
-}
-function listen(server, port) {
-  return new Promise((resolveListen, rejectListen) => {
-    const onError = (e) => {
-      server.off("listening", onListening);
-      rejectListen(e);
-    };
-    const onListening = () => {
-      server.off("error", onError);
-      resolveListen();
-    };
-    server.once("error", onError);
-    server.once("listening", onListening);
-    server.listen(port, "127.0.0.1");
-  });
-}
-async function listenOnAvailablePort(kandownDir, preferredPort) {
-  const startPort = preferredPort ?? START_PORT_RANGE;
-  for (let p = startPort; p <= END_PORT_RANGE; p++) {
-    if (UNSAFE_PORTS.has(p)) continue;
-    const server = createServeServer(kandownDir);
-    try {
-      await listen(server, p);
-      return { server, port: p };
-    } catch (e) {
-      if (e.code !== "EADDRINUSE" && e.code !== "EACCES") throw e;
-    }
-  }
-  throw new Error(`No free port in range ${START_PORT_RANGE}-${END_PORT_RANGE}`);
-}
-
-// src/cli/lib/init.ts
-import { existsSync as existsSync6, readFileSync as readFileSync6, mkdirSync as mkdirSync4, copyFileSync as copyFileSync2, readdirSync as readdirSync3, statSync as statSync3 } from "fs";
-import { join as join6 } from "path";
-function copyRecursive(src, dest) {
-  const errors = [];
-  try {
-    if (!existsSync6(dest)) mkdirSync4(dest, { recursive: true });
-    const entries = readdirSync3(src);
-    for (const entry of entries) {
-      const srcPath = join6(src, entry);
-      const destPath = join6(dest, entry);
-      try {
-        if (statSync3(srcPath).isDirectory()) {
-          errors.push(...copyRecursive(srcPath, destPath));
-        } else if (!existsSync6(destPath)) {
-          copyFileSync2(srcPath, destPath);
-        }
-      } catch (error) {
-        errors.push(`${entry}: ${error instanceof Error ? error.message : String(error)}`);
-      }
-    }
-  } catch (error) {
-    errors.push(`${src}: ${error instanceof Error ? error.message : String(error)}`);
-  }
-  return errors;
-}
-function syncKandownAgentDoc(kandownDir) {
-  const source = join6(PKG_ROOT, "templates", "AGENT_KANDOWN.md");
-  const target = join6(kandownDir, "AGENT_KANDOWN.md");
-  if (!existsSync6(source)) return false;
-  try {
-    const expected = readFileSync6(source, "utf8");
-    const existing = existsSync6(target) ? readFileSync6(target, "utf8") : null;
-    if (existing === null || !existing.includes("# Kandown")) {
-      atomicWriteFileSync(target, expected.endsWith("\n") ? expected : `${expected}
-`);
-      return true;
-    }
-  } catch {
-  }
-  return false;
-}
-function doInit(kandownDir) {
-  try {
-    mkdirSync4(kandownDir, { recursive: true });
-    const htmlSrc = join6(PKG_ROOT, "dist", "index.html");
-    const htmlDest = join6(kandownDir, "kandown.html");
-    if (existsSync6(htmlSrc)) {
-      copyFileSync2(htmlSrc, htmlDest);
-    }
-    syncKandownAgentDoc(kandownDir);
-    const templatesDir = join6(PKG_ROOT, "templates");
-    if (existsSync6(templatesDir)) {
-      if (!existsSync6(join6(kandownDir, "README.md")) && existsSync6(join6(templatesDir, "README.md"))) {
-        copyFileSync2(join6(templatesDir, "README.md"), join6(kandownDir, "README.md"));
-      }
-      if (!existsSync6(join6(kandownDir, "AGENT.md")) && existsSync6(join6(templatesDir, "AGENT.md"))) {
-        copyFileSync2(join6(templatesDir, "AGENT.md"), join6(kandownDir, "AGENT.md"));
-      }
-      const tasksSrc = join6(templatesDir, "tasks");
-      const tasksDest = getTasksDir(kandownDir);
-      if (!existsSync6(tasksDest) && existsSync6(tasksSrc)) {
-        copyRecursive(tasksSrc, tasksDest);
-      }
-      if (!existsSync6(join6(kandownDir, "kandown.json")) && existsSync6(join6(templatesDir, "kandown.json"))) {
-        copyFileSync2(join6(templatesDir, "kandown.json"), join6(kandownDir, "kandown.json"));
-      }
-    }
-    return true;
-  } catch (error) {
-    console.error(`Init failed: ${error instanceof Error ? error.message : String(error)}`);
-    return false;
-  }
-}
-
-// src/cli/lib/mcp.ts
-import { existsSync as existsSync7 } from "fs";
-import { join as join7 } from "path";
-function startMcpServer(kandownDir) {
-  process.stdin.setEncoding("utf8");
-  let buffer = "";
-  process.stdin.on("data", (chunk) => {
-    buffer += chunk;
-    const lines = buffer.split("\n");
-    buffer = lines.pop() ?? "";
-    for (const line of lines) {
-      const trimmed = line.trim();
-      if (!trimmed) continue;
-      try {
-        const req = JSON.parse(trimmed);
-        handleJsonRpc(kandownDir, req);
-      } catch (e) {
-        sendResponse(null, { error: { code: -32700, message: "Parse error" } });
-      }
-    }
-  });
-}
-function sendResponse(id, resultOrError) {
-  if (id === void 0) return;
-  const resp = {
-    jsonrpc: "2.0",
-    id,
-    ...resultOrError
-  };
-  process.stdout.write(JSON.stringify(resp) + "\n");
-}
-function handleJsonRpc(kandownDir, req) {
-  const { id, method, params } = req;
-  if (method === "initialize") {
-    sendResponse(id, {
-      result: {
-        protocolVersion: "2024-11-05",
-        capabilities: { tools: {} },
-        serverInfo: { name: "kandown", version: "0.20.0" }
-      }
-    });
-    return;
+    return;
   }
   if (method === "notifications/initialized") {
     return;
@@ -1603,7 +1152,7 @@ function handleJsonRpc(kandownDir, req) {
           ...args.tags ? { tags: args.tags } : {}
         };
         const body = args.body ? (task.body + "\n\n" + args.body).trim() : task.body;
-        const taskPath2 = join7(getTasksDir(kandownDir), `${newId}.md`);
+        const taskPath2 = join5(getTasksDir(kandownDir), `${newId}.md`);
         atomicWriteFileSync(taskPath2, serializeTaskFile(fm, body));
       }
       sendResponse(id, { result: { content: [{ type: "text", text: `Created task ${newId}` }] } });
@@ -1615,8 +1164,8 @@ function handleJsonRpc(kandownDir, req) {
       return;
     }
     if (name === "add_report") {
-      const taskPath2 = join7(getTasksDir(kandownDir), `${args.id}.md`);
-      if (!existsSync7(taskPath2)) {
+      const taskPath2 = join5(getTasksDir(kandownDir), `${args.id}.md`);
+      if (!existsSync5(taskPath2)) {
         sendResponse(id, { error: { code: -32602, message: `Task ${args.id} not found` } });
         return;
       }
@@ -1640,23 +1189,103 @@ ${args.report.trim()}`) : task.body.trim() + reportSection;
       sendResponse(id, { result: { content: [{ type: "text", text: JSON.stringify(cols, null, 2) }] } });
       return;
     }
-    sendResponse(id, { error: { code: -32601, message: `Unknown tool: ${name}` } });
-    return;
+    sendResponse(id, { error: { code: -32601, message: `Unknown tool: ${name}` } });
+    return;
+  }
+  sendResponse(id, { error: { code: -32601, message: `Method not found: ${method}` } });
+}
+
+// src/cli/lib/browser.ts
+import { spawn as spawn3 } from "child_process";
+function openBrowser(target) {
+  const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+  try {
+    spawn3(cmd, [target], { detached: true, stdio: "ignore" }).unref();
+  } catch {
+  }
+}
+
+// src/cli/lib/cli-shared.ts
+import { existsSync as existsSync7, readFileSync as readFileSync7, readdirSync as readdirSync4, statSync as statSync4 } from "fs";
+import { join as join7, resolve as resolve2, basename } from "path";
+import { spawn as spawn4 } from "child_process";
+
+// src/cli/lib/init.ts
+import { existsSync as existsSync6, readFileSync as readFileSync6, mkdirSync as mkdirSync3, copyFileSync, readdirSync as readdirSync3, statSync as statSync3 } from "fs";
+import { join as join6 } from "path";
+function copyRecursive(src, dest) {
+  const errors = [];
+  try {
+    if (!existsSync6(dest)) mkdirSync3(dest, { recursive: true });
+    const entries = readdirSync3(src);
+    for (const entry of entries) {
+      const srcPath = join6(src, entry);
+      const destPath = join6(dest, entry);
+      try {
+        if (statSync3(srcPath).isDirectory()) {
+          errors.push(...copyRecursive(srcPath, destPath));
+        } else if (!existsSync6(destPath)) {
+          copyFileSync(srcPath, destPath);
+        }
+      } catch (error) {
+        errors.push(`${entry}: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+  } catch (error) {
+    errors.push(`${src}: ${error instanceof Error ? error.message : String(error)}`);
   }
-  sendResponse(id, { error: { code: -32601, message: `Method not found: ${method}` } });
+  return errors;
 }
-
-// src/cli/lib/browser.ts
-import { spawn as spawn4 } from "child_process";
-function openBrowser(target) {
-  const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+function syncKandownAgentDoc(kandownDir) {
+  const source = join6(PKG_ROOT, "templates", "AGENT_KANDOWN.md");
+  const target = join6(kandownDir, "AGENT_KANDOWN.md");
+  if (!existsSync6(source)) return false;
   try {
-    spawn4(cmd, [target], { detached: true, stdio: "ignore" }).unref();
+    const expected = readFileSync6(source, "utf8");
+    const existing = existsSync6(target) ? readFileSync6(target, "utf8") : null;
+    if (existing === null || !existing.includes("# Kandown")) {
+      atomicWriteFileSync(target, expected.endsWith("\n") ? expected : `${expected}
+`);
+      return true;
+    }
   } catch {
   }
+  return false;
+}
+function doInit(kandownDir) {
+  try {
+    mkdirSync3(kandownDir, { recursive: true });
+    const htmlSrc = join6(PKG_ROOT, "dist", "index.html");
+    const htmlDest = join6(kandownDir, "kandown.html");
+    if (existsSync6(htmlSrc)) {
+      copyFileSync(htmlSrc, htmlDest);
+    }
+    syncKandownAgentDoc(kandownDir);
+    const templatesDir = join6(PKG_ROOT, "templates");
+    if (existsSync6(templatesDir)) {
+      if (!existsSync6(join6(kandownDir, "README.md")) && existsSync6(join6(templatesDir, "README.md"))) {
+        copyFileSync(join6(templatesDir, "README.md"), join6(kandownDir, "README.md"));
+      }
+      if (!existsSync6(join6(kandownDir, "AGENT.md")) && existsSync6(join6(templatesDir, "AGENT.md"))) {
+        copyFileSync(join6(templatesDir, "AGENT.md"), join6(kandownDir, "AGENT.md"));
+      }
+      const tasksSrc = join6(templatesDir, "tasks");
+      const tasksDest = getTasksDir(kandownDir);
+      if (!existsSync6(tasksDest) && existsSync6(tasksSrc)) {
+        copyRecursive(tasksSrc, tasksDest);
+      }
+      if (!existsSync6(join6(kandownDir, "kandown.json")) && existsSync6(join6(templatesDir, "kandown.json"))) {
+        copyFileSync(join6(templatesDir, "kandown.json"), join6(kandownDir, "kandown.json"));
+      }
+    }
+    return true;
+  } catch (error) {
+    console.error(`Init failed: ${error instanceof Error ? error.message : String(error)}`);
+    return false;
+  }
 }
 
-// src/cli/cli.ts
+// src/cli/lib/cli-shared.ts
 var c = {
   reset: "\x1B[0m",
   bold: "\x1B[1m",
@@ -1754,7 +1383,7 @@ function stripFirstPositional(args, value) {
   return result;
 }
 function resolveKandownDir(pathArg = ".kandown", cwd = process.cwd()) {
-  if (basename(cwd) === ".kandown" || existsSync8(join8(cwd, "kandown.json"))) {
+  if (basename(cwd) === ".kandown" || existsSync7(join7(cwd, "kandown.json"))) {
     return cwd;
   }
   if (pathArg !== ".kandown") {
@@ -1768,7 +1397,7 @@ function resolveKandownDir(pathArg = ".kandown", cwd = process.cwd()) {
   }
   for (const name of entries) {
     if (name.startsWith(".") || name === "node_modules" || name === "tasks") continue;
-    const subPath = join8(cwd, name);
+    const subPath = join7(cwd, name);
     let stat;
     try {
       stat = statSync4(subPath);
@@ -1777,7 +1406,7 @@ function resolveKandownDir(pathArg = ".kandown", cwd = process.cwd()) {
     }
     if (!stat.isDirectory()) continue;
     const found = resolveKandownDir(pathArg, subPath);
-    if (existsSync8(found)) return found;
+    if (existsSync7(found)) return found;
   }
   return resolve2(cwd, pathArg);
 }
@@ -1785,7 +1414,7 @@ function ensureKandownDir(rawArgs) {
   const args = parseArgs(rawArgs);
   const cwd = process.cwd();
   const kandownDir = resolveKandownDir(args.path, cwd);
-  if (!existsSync8(kandownDir)) {
+  if (!existsSync7(kandownDir)) {
     info(`No .kandown/ found \u2014 auto-initializing ${c.bold}${kandownDir}${c.reset}`);
     if (!doInit(kandownDir)) {
       err(`Could not auto-initialize Kandown at ${c.bold}${kandownDir}${c.reset}`);
@@ -1830,105 +1459,6 @@ ${c.bold}OPTIONS:${c.reset}
   --help, -h          Show help screen
 `);
 }
-function cmdInit(rawArgs) {
-  const args = parseArgs(rawArgs);
-  const kandownDir = resolve2(process.cwd(), args.path);
-  const created = doInit(kandownDir);
-  if (!created) {
-    err("Failed to initialize Kandown.");
-    process.exit(1);
-  }
-  success(`Kandown initialized at ${kandownDir}`);
-}
-async function cmdUpdate(rawArgs) {
-  const current = getCurrentVersion();
-  log(`${c.bold}kandown update${c.reset} ${c.dim}\u2014 v${current}${c.reset}`);
-  const latest = await new Promise((resolve3) => {
-    const child = spawn5("npm", ["view", "kandown", "version"], {
-      timeout: 6e3,
-      stdio: ["pipe", "pipe", "pipe"],
-      env: { ...process.env },
-      detached: false
-    });
-    let stdout = "";
-    child.stdout.on("data", (d) => {
-      stdout += d;
-    });
-    child.stderr.on("data", () => {
-    });
-    child.on("error", () => resolve3(null));
-    child.on("close", (code) => {
-      if (code !== 0) return resolve3(null);
-      const v = stdout.trim().replace(/^"|"$/g, "");
-      resolve3(v || null);
-    });
-  });
-  if (latest && semverGt(latest, current) > 0) {
-    info(`Updating kandown package v${current} \u2192 v${latest}\u2026`);
-    const updateOk = await performGlobalPackageUpdate(`kandown@${latest}`);
-    if (updateOk) {
-      success(`Successfully upgraded kandown to v${latest}`);
-    } else {
-      err(`Global CLI update failed \u2014 try: pnpm add -g kandown@latest or npm install -g kandown@latest`);
-    }
-  } else {
-    info(`kandown CLI is already up to date (v${current}).`);
-  }
-  const args = parseArgs(rawArgs);
-  const cwd = process.cwd();
-  const kandownDir = resolve2(cwd, args.path);
-  const htmlDest = join8(kandownDir, "kandown.html");
-  if (existsSync8(htmlDest)) {
-    const htmlSrc = resolve2(PKG_ROOT, "dist", "index.html");
-    if (existsSync8(htmlSrc)) {
-      copyFileSync3(htmlSrc, htmlDest);
-      success(`Refreshed ${args.path}/kandown.html`);
-    }
-  }
-}
-async function cmdDoctor(rawArgs) {
-  const { kandownDir } = ensureKandownDir(rawArgs);
-  const currentVersion = getCurrentVersion();
-  log(`${c.bold}kandown doctor${c.reset} ${c.dim}\u2014 environment & board diagnostic${c.reset}
-`);
-  log(`  CLI Version: ${currentVersion}`);
-  const configPath = join8(kandownDir, "kandown.json");
-  if (existsSync8(configPath)) {
-    try {
-      JSON.parse(readFileSync8(configPath, "utf8"));
-      success("kandown.json valid");
-    } catch (e) {
-      err(`kandown.json invalid: ${e.message}`);
-    }
-  } else {
-    err("Missing kandown.json");
-  }
-  const daemonStatus = await getDaemonStatus(kandownDir);
-  if (daemonStatus.running && daemonStatus.metadata) {
-    success(`Daemon running on port ${daemonStatus.metadata.port} (PID ${daemonStatus.metadata.pid})`);
-  } else {
-    info("Daemon not running");
-  }
-  const taskIds = listTaskIds(kandownDir);
-  success(`Tasks: ${taskIds.length} active task files`);
-  log(`
-${c.green}\u2713 Everything looks good!${c.reset}
-`);
-}
-async function cmdWork(rawArgs) {
-  const { kandownDir } = ensureKandownDir(rawArgs);
-  const doc = readAgentDoc(kandownDir);
-  const board = readBoard(kandownDir);
-  log(doc);
-  log("\n---\n");
-  log(`## Current Board Digest
-`);
-  const allTasksCount = board.columns.reduce((sum, col) => sum + col.tasks.length, 0);
-  log(`Tasks total: ${allTasksCount}`);
-  for (const col of board.columns) {
-    log(`- **${col.name}** (${col.tasks.length}): ${col.tasks.map((t) => `${t.id} ${t.title}`).join(", ") || "empty"}`);
-  }
-}
 function addMultiFlag(flags, key, value) {
   const current = flags[key];
   if (Array.isArray(current)) current.push(value);
@@ -1985,19 +1515,19 @@ function resolveStatusArg(kandownDir, status) {
   return config.board.columns.find((col) => col.toLowerCase() === status.toLowerCase()) ?? null;
 }
 function taskPath(kandownDir, id, archived = false) {
-  return archived ? join8(getTasksDir(kandownDir), "archive", `${id}.md`) : join8(getTasksDir(kandownDir), `${id}.md`);
+  return archived ? join7(getTasksDir(kandownDir), "archive", `${id}.md`) : join7(getTasksDir(kandownDir), `${id}.md`);
 }
 function findTaskPath2(kandownDir, id) {
   const active = taskPath(kandownDir, id);
-  if (existsSync8(active)) return active;
+  if (existsSync7(active)) return active;
   const archived = taskPath(kandownDir, id, true);
-  if (existsSync8(archived)) return archived;
+  if (existsSync7(archived)) return archived;
   return null;
 }
 function nextTaskId(kandownDir) {
   const ids = new Set(listTaskIds(kandownDir));
-  const archiveDir = join8(getTasksDir(kandownDir), "archive");
-  if (existsSync8(archiveDir)) {
+  const archiveDir = join7(getTasksDir(kandownDir), "archive");
+  if (existsSync7(archiveDir)) {
     for (const file of readdirSync4(archiveDir)) {
       if (file.endsWith(".md")) ids.add(file.slice(0, -3));
     }
@@ -2009,17 +1539,156 @@ function nextTaskId(kandownDir) {
   }
   return `t${max + 1}`;
 }
-function readTaskFile(kandownDir, id) {
-  const path = findTaskPath2(kandownDir, id);
-  if (!path) return null;
-  const parsed = parseTaskFile(readFileSync8(path, "utf8"));
-  return {
-    path,
-    frontmatter: { ...parsed.frontmatter, id: parsed.frontmatter.id || id },
-    body: parsed.body,
-    archived: path.includes("/archive/")
-  };
+function readTaskFile(kandownDir, id) {
+  const path = findTaskPath2(kandownDir, id);
+  if (!path) return null;
+  const parsed = parseTaskFile(readFileSync7(path, "utf8"));
+  return {
+    path,
+    frontmatter: { ...parsed.frontmatter, id: parsed.frontmatter.id || id },
+    body: parsed.body,
+    archived: path.includes("/archive/")
+  };
+}
+function printTaskCommandsHelp() {
+  log(`
+${c.bold}Kandown task commands${c.reset}
+
+  kandown list [-s status] [-p P1] [-a user] [-t tag] [--archived] [--json]
+  kandown show <id>
+  kandown create "title" [-p P1] [-a user] [-t tag] [--to status] [--id id] [--json]
+  kandown move <id> <status|archived>
+  kandown assign <id> [user]
+  kandown commit [-m "message"]
+`);
+}
+async function launchTui(screen, kandownDir) {
+  if (!process.stdin.isTTY) {
+    info(`TUI skipped because stdin is not interactive. Use ${c.cyan}kandown daemon status${c.reset} to inspect the web daemon.`);
+    return;
+  }
+  const tuiPath = join7(PKG_ROOT, "bin", "tui.js");
+  if (!existsSync7(tuiPath)) {
+    err(`TUI binary not found at ${tuiPath}`);
+    process.exit(1);
+  }
+  await new Promise((resolveTui) => {
+    const child = spawn4(process.execPath, [tuiPath, screen, kandownDir, getCurrentVersion()], { stdio: "inherit" });
+    child.on("close", (code) => {
+      if (typeof code === "number" && code !== 0) process.exit(code);
+      resolveTui();
+    });
+  });
+}
+
+// src/cli/commands/project.ts
+import { existsSync as existsSync8, readFileSync as readFileSync8, copyFileSync as copyFileSync2 } from "fs";
+import { join as join8, resolve as resolve3 } from "path";
+import { spawn as spawn5 } from "child_process";
+function cmdInit(rawArgs) {
+  const args = parseArgs(rawArgs);
+  const kandownDir = resolve3(process.cwd(), args.path);
+  const created = doInit(kandownDir);
+  if (!created) {
+    err("Failed to initialize Kandown.");
+    process.exit(1);
+  }
+  success(`Kandown initialized at ${kandownDir}`);
+}
+async function cmdUpdate(rawArgs) {
+  const current = getCurrentVersion();
+  log(`${c.bold}kandown update${c.reset} ${c.dim}\u2014 v${current}${c.reset}`);
+  const latest = await new Promise((resolve5) => {
+    const child = spawn5("npm", ["view", "kandown", "version"], {
+      timeout: 6e3,
+      stdio: ["pipe", "pipe", "pipe"],
+      env: { ...process.env },
+      detached: false
+    });
+    let stdout = "";
+    child.stdout.on("data", (d) => {
+      stdout += d;
+    });
+    child.stderr.on("data", () => {
+    });
+    child.on("error", () => resolve5(null));
+    child.on("close", (code) => {
+      if (code !== 0) return resolve5(null);
+      const v = stdout.trim().replace(/^"|"$/g, "");
+      resolve5(v || null);
+    });
+  });
+  if (latest && semverGt(latest, current) > 0) {
+    info(`Updating kandown package v${current} \u2192 v${latest}\u2026`);
+    const updateOk = await performGlobalPackageUpdate(`kandown@${latest}`);
+    if (updateOk) {
+      success(`Successfully upgraded kandown to v${latest}`);
+    } else {
+      err(`Global CLI update failed \u2014 try: pnpm add -g kandown@latest or npm install -g kandown@latest`);
+    }
+  } else {
+    info(`kandown CLI is already up to date (v${current}).`);
+  }
+  const args = parseArgs(rawArgs);
+  const cwd = process.cwd();
+  const kandownDir = resolve3(cwd, args.path);
+  const htmlDest = join8(kandownDir, "kandown.html");
+  if (existsSync8(htmlDest)) {
+    const htmlSrc = resolve3(PKG_ROOT, "dist", "index.html");
+    if (existsSync8(htmlSrc)) {
+      copyFileSync2(htmlSrc, htmlDest);
+      success(`Refreshed ${args.path}/kandown.html`);
+    }
+  }
+}
+async function cmdDoctor(rawArgs) {
+  const { kandownDir } = ensureKandownDir(rawArgs);
+  const currentVersion = getCurrentVersion();
+  log(`${c.bold}kandown doctor${c.reset} ${c.dim}\u2014 environment & board diagnostic${c.reset}
+`);
+  log(`  CLI Version: ${currentVersion}`);
+  const configPath = join8(kandownDir, "kandown.json");
+  if (existsSync8(configPath)) {
+    try {
+      JSON.parse(readFileSync8(configPath, "utf8"));
+      success("kandown.json valid");
+    } catch (e) {
+      err(`kandown.json invalid: ${e.message}`);
+    }
+  } else {
+    err("Missing kandown.json");
+  }
+  const daemonStatus = await getDaemonStatus(kandownDir);
+  if (daemonStatus.running && daemonStatus.metadata) {
+    success(`Daemon running on port ${daemonStatus.metadata.port} (PID ${daemonStatus.metadata.pid})`);
+  } else {
+    info("Daemon not running");
+  }
+  const taskIds = listTaskIds(kandownDir);
+  success(`Tasks: ${taskIds.length} active task files`);
+  log(`
+${c.green}\u2713 Everything looks good!${c.reset}
+`);
+}
+async function cmdWork(rawArgs) {
+  const { kandownDir } = ensureKandownDir(rawArgs);
+  const doc = readAgentDoc(kandownDir);
+  const board = readBoard(kandownDir);
+  log(doc);
+  log("\n---\n");
+  log(`## Current Board Digest
+`);
+  const allTasksCount = board.columns.reduce((sum, col) => sum + col.tasks.length, 0);
+  log(`Tasks total: ${allTasksCount}`);
+  for (const col of board.columns) {
+    log(`- **${col.name}** (${col.tasks.length}): ${col.tasks.map((t) => `${t.id} ${t.title}`).join(", ") || "empty"}`);
+  }
 }
+
+// src/cli/commands/tasks.ts
+import { existsSync as existsSync9, readFileSync as readFileSync9, mkdirSync as mkdirSync4, readdirSync as readdirSync5 } from "fs";
+import { join as join9, resolve as resolve4 } from "path";
+import { spawnSync } from "child_process";
 function cmdList(rawArgs) {
   const { kandownDir } = ensureKandownDir(rawArgs);
   const args = taskParseArgs(rawArgs);
@@ -2042,11 +1711,11 @@ function cmdList(rawArgs) {
     });
   }
   if (includeArchived) {
-    const archiveDir = join8(getTasksDir(kandownDir), "archive");
-    if (existsSync8(archiveDir)) {
-      for (const file of readdirSync4(archiveDir).filter((name) => name.endsWith(".md"))) {
+    const archiveDir = join9(getTasksDir(kandownDir), "archive");
+    if (existsSync9(archiveDir)) {
+      for (const file of readdirSync5(archiveDir).filter((name) => name.endsWith(".md"))) {
         const id = file.slice(0, -3);
-        const parsed = parseTaskFile(readFileSync8(join8(archiveDir, file), "utf8"));
+        const parsed = parseTaskFile(readFileSync9(join9(archiveDir, file), "utf8"));
         rows.push({
           id,
           title: parsed.frontmatter.title || id,
@@ -2066,249 +1735,664 @@ function cmdList(rawArgs) {
     if (tagFilters.length > 0 && !tagFilters.every((tag) => row.tags.map((t) => t.toLowerCase()).includes(tag))) return false;
     return true;
   });
-  if (args.flags.json === true) {
-    process.stdout.write(JSON.stringify(filtered, null, 2) + "\n");
-    return;
-  }
-  const byStatus = /* @__PURE__ */ new Map();
-  for (const row of filtered) {
-    const list = byStatus.get(row.status) ?? [];
-    list.push(row);
-    byStatus.set(row.status, list);
-  }
-  for (const [status, tasks] of byStatus) {
-    log(`
-${c.bold}${status}${c.reset} (${tasks.length})`);
-    for (const task of tasks) {
-      const pri = task.priority || "P2";
-      const assignee = task.assignee ? ` @${task.assignee}` : "";
-      log(`  ${c.cyan}${task.id}${c.reset} [${pri}] ${task.title}${assignee}`);
+  if (args.flags.json === true) {
+    process.stdout.write(JSON.stringify(filtered, null, 2) + "\n");
+    return;
+  }
+  const byStatus = /* @__PURE__ */ new Map();
+  for (const row of filtered) {
+    const list = byStatus.get(row.status) ?? [];
+    list.push(row);
+    byStatus.set(row.status, list);
+  }
+  for (const [status, tasks] of byStatus) {
+    log(`
+${c.bold}${status}${c.reset} (${tasks.length})`);
+    for (const task of tasks) {
+      const pri = task.priority || "P2";
+      const assignee = task.assignee ? ` @${task.assignee}` : "";
+      log(`  ${c.cyan}${task.id}${c.reset} [${pri}] ${task.title}${assignee}`);
+    }
+  }
+  log("");
+}
+function cmdShow(rawArgs) {
+  const { kandownDir } = ensureKandownDir(rawArgs);
+  const args = taskParseArgs(rawArgs);
+  const id = args.positional[0];
+  if (!id) {
+    err("Usage: kandown show <task-id>");
+    process.exit(1);
+  }
+  const path = findTaskPath2(kandownDir, id);
+  if (!path) {
+    err(`Task not found: ${id}`);
+    process.exit(1);
+  }
+  process.stdout.write(readFileSync9(path, "utf8"));
+}
+function cmdCreate(rawArgs) {
+  const { kandownDir } = ensureKandownDir(rawArgs);
+  const args = taskParseArgs(rawArgs);
+  const title = args.positional.join(" ").trim();
+  if (!title) {
+    err('Usage: kandown create "title" [-p P1] [-a user] [-t tag] [--to status] [--id custom-id] [--json]');
+    process.exit(1);
+  }
+  const id = stringFlag(args.flags, "id") ?? nextTaskId(kandownDir);
+  if (!/^[a-zA-Z0-9_-]+$/.test(id)) {
+    err(`Invalid task id: ${id}`);
+    process.exit(1);
+  }
+  if (findTaskPath2(kandownDir, id)) {
+    err(`Task already exists: ${id}`);
+    process.exit(1);
+  }
+  const config = loadConfig(kandownDir);
+  const rawStatus = stringFlag(args.flags, "to", "status");
+  const status = rawStatus ? resolveStatusArg(kandownDir, rawStatus) : config.board.columns[0] || "Backlog";
+  if (!status) {
+    err(`Unknown status: ${rawStatus}`);
+    process.exit(1);
+  }
+  const fm = {
+    id,
+    title,
+    status,
+    created: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10)
+  };
+  const priority = stringFlag(args.flags, "priority")?.toUpperCase();
+  const assignee = stringFlag(args.flags, "assignee");
+  const tags = listFlag(args.flags, "tag");
+  if (priority) fm.priority = priority;
+  if (assignee) fm.assignee = assignee;
+  if (tags.length > 0) fm.tags = tags;
+  const tasksDir = getTasksDir(kandownDir);
+  if (!existsSync9(tasksDir)) mkdirSync4(tasksDir, { recursive: true });
+  const path = taskPath(kandownDir, id);
+  atomicWriteFileSync(path, serializeTaskFile(fm, ""));
+  process.stderr.write(`${c.green}\u2713${c.reset} Created ${c.bold}${id}${c.reset} \u2192 ${status}
+`);
+  process.stdout.write(args.flags.json === true ? JSON.stringify(fm, null, 2) + "\n" : `${id}
+`);
+}
+function cmdMove(rawArgs) {
+  const { kandownDir } = ensureKandownDir(rawArgs);
+  const args = taskParseArgs(rawArgs);
+  const id = args.positional[0];
+  const rawStatus = args.positional.slice(1).join(" ") || stringFlag(args.flags, "to", "status");
+  if (!id || !rawStatus) {
+    err("Usage: kandown move <task-id> <status>");
+    process.exit(1);
+  }
+  if (rawStatus.toLowerCase() === "archived") {
+    if (!archiveTaskInBoard(kandownDir, id)) {
+      err(`Archive failed: ${id}`);
+      process.exit(1);
+    }
+    success(`Archived ${id}`);
+    return;
+  }
+  const status = resolveStatusArg(kandownDir, rawStatus);
+  if (!status) {
+    err(`Unknown status: ${rawStatus}`);
+    process.exit(1);
+  }
+  if (!moveTaskToColumn(kandownDir, id, status)) {
+    err(`Move failed: ${id}`);
+    process.exit(1);
+  }
+  success(`Moved ${id} \u2192 "${status}"`);
+}
+function cmdAssign(rawArgs) {
+  const { kandownDir } = ensureKandownDir(rawArgs);
+  const args = taskParseArgs(rawArgs);
+  const [id, assignee] = args.positional;
+  if (!id) {
+    err("Usage: kandown assign <task-id> [assignee]");
+    process.exit(1);
+  }
+  const task = readTaskFile(kandownDir, id);
+  if (!task) {
+    err(`Task not found: ${id}`);
+    process.exit(1);
+  }
+  const frontmatter = { ...task.frontmatter, id };
+  if (assignee) frontmatter.assignee = assignee;
+  else delete frontmatter.assignee;
+  atomicWriteFileSync(task.path, serializeTaskFile(frontmatter, task.body));
+  success(assignee ? `Assigned ${id} \u2192 ${assignee}` : `Unassigned ${id}`);
+}
+function cmdCommit(rawArgs) {
+  ensureKandownDir(rawArgs);
+  const args = taskParseArgs(rawArgs);
+  const message = stringFlag(args.flags, "message") || "tasks: update kandown board";
+  const add = spawnSync("git", ["add", "tasks", ".kandown/kandown.json"], { stdio: "inherit" });
+  if (add.status !== 0) process.exit(add.status ?? 1);
+  const commit = spawnSync("git", ["commit", "-m", message], { stdio: "inherit" });
+  process.exit(commit.status ?? 1);
+}
+function cmdExport(rawArgs) {
+  const { kandownDir } = ensureKandownDir(rawArgs);
+  const board = readBoard(kandownDir);
+  process.stdout.write(JSON.stringify(board, null, 2) + "\n");
+}
+function cmdProjects(rawArgs) {
+  const { kandownDir } = ensureKandownDir(rawArgs);
+  const metadataPath2 = join9(kandownDir, "daemon.json");
+  if (!existsSync9(metadataPath2)) {
+    info("No daemon metadata for this project.");
+    return;
+  }
+  process.stdout.write(readFileSync9(metadataPath2, "utf8").trim() + "\n");
+}
+function cmdImport(rawArgs) {
+  const { kandownDir } = ensureKandownDir(rawArgs);
+  const args = taskParseArgs(rawArgs);
+  const file = args.positional[0];
+  if (!file) {
+    err("Usage: kandown import <file.json> [--overwrite]");
+    process.exit(1);
+  }
+  const importPath = resolve4(process.cwd(), file);
+  if (!existsSync9(importPath)) {
+    err(`Import file not found: ${file}`);
+    process.exit(1);
+  }
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync9(importPath, "utf8"));
+  } catch (error) {
+    err(`Import file must be JSON: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
+  const rows = [];
+  if (Array.isArray(raw)) {
+    rows.push(...raw.filter((value) => typeof value === "object" && value !== null));
+  } else if (typeof raw === "object" && raw !== null && Array.isArray(raw.columns)) {
+    for (const column of raw.columns) {
+      if (typeof column !== "object" || column === null) continue;
+      const col = column;
+      if (!Array.isArray(col.tasks)) continue;
+      for (const task of col.tasks) {
+        if (typeof task === "object" && task !== null) rows.push({ ...task, status: String(col.name || "Backlog") });
+      }
+    }
+  }
+  if (rows.length === 0) {
+    err("No tasks found to import. Expected a list JSON array or kandown export object.");
+    process.exit(1);
+  }
+  const tasksDir = getTasksDir(kandownDir);
+  if (!existsSync9(tasksDir)) mkdirSync4(tasksDir, { recursive: true });
+  let imported = 0;
+  for (const row of rows) {
+    const id = typeof row.id === "string" && /^[a-zA-Z0-9_-]+$/.test(row.id) ? row.id : nextTaskId(kandownDir);
+    const path = taskPath(kandownDir, id);
+    if (existsSync9(path) && args.flags.overwrite !== true) continue;
+    const fm = {
+      id,
+      title: typeof row.title === "string" && row.title ? row.title : id,
+      status: typeof row.status === "string" && row.status ? row.status.replace(/ \(archived\)$/i, "") : "Backlog"
+    };
+    if (typeof row.priority === "string") fm.priority = row.priority;
+    if (typeof row.assignee === "string") fm.assignee = row.assignee;
+    if (Array.isArray(row.tags)) fm.tags = row.tags.map(String);
+    atomicWriteFileSync(path, serializeTaskFile(fm, typeof row.body === "string" ? row.body : ""));
+    imported++;
+  }
+  success(`Imported ${imported} task${imported === 1 ? "" : "s"}`);
+}
+
+// src/cli/commands/daemon.ts
+import { join as join11 } from "path";
+
+// src/cli/lib/server.ts
+import { createServer } from "http";
+import { existsSync as existsSync10, readFileSync as readFileSync10, copyFileSync as copyFileSync3, unlinkSync as unlinkSync5, mkdirSync as mkdirSync5 } from "fs";
+import { join as join10 } from "path";
+import { spawn as spawn6 } from "child_process";
+var START_PORT_RANGE = 2050;
+var END_PORT_RANGE = 2099;
+var UNSAFE_PORTS = /* @__PURE__ */ new Set([2049, 4045, 6e3, 6665, 6666, 6667, 6668, 6669, 6697]);
+var sseClients = [];
+var nextClientId = 1;
+function broadcastSseEvent(data) {
+  const payload = `data: ${JSON.stringify(data)}
+
+`;
+  sseClients.forEach((c2) => c2.res.write(payload));
+}
+function handleCors(res) {
+  res.writeHead(204, {
+    "Access-Control-Allow-Origin": "*",
+    "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, OPTIONS",
+    "Access-Control-Allow-Headers": "Content-Type, X-Kandown-Token"
+  });
+  res.end();
+}
+function writeJson(res, status, data) {
+  res.writeHead(status, {
+    "Content-Type": "application/json",
+    "Access-Control-Allow-Origin": "*"
+  });
+  res.end(JSON.stringify(data));
+}
+function writeText(res, status, text) {
+  res.writeHead(status, {
+    "Content-Type": "text/plain; charset=utf-8",
+    "Access-Control-Allow-Origin": "*"
+  });
+  res.end(text);
+}
+function readRequestBody(req) {
+  return new Promise((resolveBody, rejectBody) => {
+    let body = "";
+    req.setEncoding("utf8");
+    req.on("data", (chunk) => {
+      body += chunk;
+    });
+    req.on("end", () => resolveBody(body));
+    req.on("error", rejectBody);
+  });
+}
+function syncProjectKandownHtml(kandownDir) {
+  try {
+    const projectHtml = join10(kandownDir, "kandown.html");
+    const distHtml = join10(PKG_ROOT, "dist", "index.html");
+    if (!existsSync10(distHtml)) return false;
+    if (!existsSync10(projectHtml)) {
+      copyFileSync3(distHtml, projectHtml);
+      return true;
+    }
+    const currentContent = readFileSync10(projectHtml, "utf8");
+    const newContent = readFileSync10(distHtml, "utf8");
+    if (currentContent !== newContent) {
+      atomicWriteFileSync(projectHtml, newContent);
+      return true;
     }
+  } catch {
   }
-  log("");
+  return false;
 }
-function cmdShow(rawArgs) {
-  const { kandownDir } = ensureKandownDir(rawArgs);
-  const args = taskParseArgs(rawArgs);
-  const id = args.positional[0];
-  if (!id) {
-    err("Usage: kandown show <task-id>");
-    process.exit(1);
-  }
-  const path = findTaskPath2(kandownDir, id);
-  if (!path) {
-    err(`Task not found: ${id}`);
-    process.exit(1);
+function readDaemonPort(kandownDir) {
+  try {
+    const raw = JSON.parse(readFileSync10(join10(kandownDir, "daemon.json"), "utf8"));
+    return typeof raw.port === "number" && Number.isInteger(raw.port) ? raw.port : null;
+  } catch {
+    return null;
   }
-  process.stdout.write(readFileSync8(path, "utf8"));
 }
-function cmdCreate(rawArgs) {
-  const { kandownDir } = ensureKandownDir(rawArgs);
-  const args = taskParseArgs(rawArgs);
-  const title = args.positional.join(" ").trim();
-  if (!title) {
-    err('Usage: kandown create "title" [-p P1] [-a user] [-t tag] [--to status] [--id custom-id] [--json]');
-    process.exit(1);
+function restartDaemonAfterUpdateResponse(res, kandownDir) {
+  const cliPath = process.argv[1];
+  if (!cliPath) return;
+  const args = ["--no-update-check", "daemon", "run", "--path", kandownDir];
+  const port = readDaemonPort(kandownDir);
+  if (port !== null) args.push("--port", String(port));
+  const launcher = `
+const { spawn } = require('node:child_process');
+const [nodeBin, cliPath, ...cliArgs] = process.argv.slice(1);
+setTimeout(() => {
+  const child = spawn(nodeBin, [cliPath, ...cliArgs], {
+    detached: true,
+    stdio: 'ignore',
+    env: { ...process.env, KANDOWN_DAEMON: '1' },
+  });
+  child.unref();
+}, 350);
+`;
+  res.on("finish", () => {
+    const child = spawn6(process.execPath, ["-e", launcher, process.execPath, cliPath, ...args], {
+      detached: true,
+      stdio: "ignore",
+      env: { ...process.env, KANDOWN_DAEMON: "1" }
+    });
+    child.unref();
+    setTimeout(() => process.exit(0), 50).unref();
+  });
+}
+async function handleApi(req, res, url, kandownDir) {
+  const path = url.pathname;
+  const method = req.method || "GET";
+  if (path === "/api/daemon" && method === "GET") {
+    return writeJson(res, 200, {
+      ok: true,
+      pid: process.pid,
+      kandownDir,
+      version: getCurrentVersion(),
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      agentHook: process.env.KANDOWN_AGENT_HOOK_URL ? { enabled: true, label: process.env.KANDOWN_AGENT_HOOK_LABEL || "Send to Agent" } : null
+    });
   }
-  const id = stringFlag(args.flags, "id") ?? nextTaskId(kandownDir);
-  if (!/^[a-zA-Z0-9_-]+$/.test(id)) {
-    err(`Invalid task id: ${id}`);
-    process.exit(1);
+  if (path === "/api/version" && method === "GET") {
+    return writeJson(res, 200, {
+      version: getCurrentVersion()
+    });
   }
-  if (findTaskPath2(kandownDir, id)) {
-    err(`Task already exists: ${id}`);
-    process.exit(1);
+  if (path === "/api/update/check" && method === "GET") {
+    const current = getCurrentVersion();
+    const latest = await new Promise((resolve5) => {
+      const child = spawn6("npm", ["view", "kandown", "version"], {
+        timeout: 4e3,
+        stdio: ["pipe", "pipe", "pipe"],
+        env: { ...process.env },
+        detached: false
+      });
+      let stdout = "";
+      child.stdout.on("data", (d) => {
+        stdout += d;
+      });
+      child.stderr.on("data", () => {
+      });
+      child.on("error", () => resolve5(null));
+      child.on("close", (code) => {
+        if (code !== 0) return resolve5(null);
+        resolve5(stdout.trim().replace(/^"|"$/g, "") || null);
+      });
+    });
+    const updateAvailable = latest ? semverGt(latest, current) > 0 : false;
+    return writeJson(res, 200, {
+      current,
+      latest: latest || current,
+      updateAvailable
+    });
   }
-  const config = loadConfig(kandownDir);
-  const rawStatus = stringFlag(args.flags, "to", "status");
-  const status = rawStatus ? resolveStatusArg(kandownDir, rawStatus) : config.board.columns[0] || "Backlog";
-  if (!status) {
-    err(`Unknown status: ${rawStatus}`);
-    process.exit(1);
+  if (path === "/api/update/apply" && method === "POST") {
+    const current = getCurrentVersion();
+    const latest = await new Promise((resolve5) => {
+      const child = spawn6("npm", ["view", "kandown", "version"], {
+        timeout: 4e3,
+        stdio: ["pipe", "pipe", "pipe"],
+        env: { ...process.env },
+        detached: false
+      });
+      let stdout = "";
+      child.stdout.on("data", (d) => {
+        stdout += d;
+      });
+      child.on("error", () => resolve5(null));
+      child.on("close", (code) => resolve5(code === 0 ? stdout.trim() : null));
+    });
+    const targetVersion = latest || current;
+    const ok = await performGlobalPackageUpdate(`kandown@${targetVersion}`);
+    syncProjectKandownHtml(kandownDir);
+    if (ok) {
+      restartDaemonAfterUpdateResponse(res, kandownDir);
+      writeJson(res, 200, { ok: true, version: targetVersion, message: "Update installed successfully; daemon is restarting" });
+      broadcastSseEvent({ type: "update", version: targetVersion });
+    } else {
+      writeJson(res, 500, { ok: false, message: "Global package installation failed" });
+    }
+    return;
   }
-  const fm = {
-    id,
-    title,
-    status,
-    created: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10)
-  };
-  const priority = stringFlag(args.flags, "priority")?.toUpperCase();
-  const assignee = stringFlag(args.flags, "assignee");
-  const tags = listFlag(args.flags, "tag");
-  if (priority) fm.priority = priority;
-  if (assignee) fm.assignee = assignee;
-  if (tags.length > 0) fm.tags = tags;
-  const tasksDir = getTasksDir(kandownDir);
-  if (!existsSync8(tasksDir)) mkdirSync5(tasksDir, { recursive: true });
-  const path = taskPath(kandownDir, id);
-  atomicWriteFileSync(path, serializeTaskFile(fm, ""));
-  process.stderr.write(`${c.green}\u2713${c.reset} Created ${c.bold}${id}${c.reset} \u2192 ${status}
-`);
-  process.stdout.write(args.flags.json === true ? JSON.stringify(fm, null, 2) + "\n" : `${id}
-`);
-}
-function cmdMove(rawArgs) {
-  const { kandownDir } = ensureKandownDir(rawArgs);
-  const args = taskParseArgs(rawArgs);
-  const id = args.positional[0];
-  const rawStatus = args.positional.slice(1).join(" ") || stringFlag(args.flags, "to", "status");
-  if (!id || !rawStatus) {
-    err("Usage: kandown move <task-id> <status>");
-    process.exit(1);
+  if (path === "/api/events" && method === "GET") {
+    res.writeHead(200, {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      "Connection": "keep-alive",
+      "Access-Control-Allow-Origin": "*"
+    });
+    res.write("retry: 2000\n\n");
+    const id = nextClientId++;
+    sseClients.push({ id, res });
+    req.on("close", () => {
+      sseClients = sseClients.filter((c2) => c2.id !== id);
+    });
+    return;
   }
-  if (rawStatus.toLowerCase() === "archived") {
-    if (!archiveTaskInBoard(kandownDir, id)) {
-      err(`Archive failed: ${id}`);
-      process.exit(1);
+  if (path === "/api/board") {
+    if (method === "GET") {
+      const tasksDir = getTasksDir(kandownDir);
+      const boardPath = join10(tasksDir, "board.md");
+      const text = existsSync10(boardPath) ? readFileSync10(boardPath, "utf8") : "";
+      return writeText(res, 200, text);
+    }
+    if (method === "PUT") {
+      let body = "";
+      req.on("data", (chunk) => {
+        body += chunk;
+      });
+      req.on("end", () => {
+        const tasksDir = getTasksDir(kandownDir);
+        if (!existsSync10(tasksDir)) mkdirSync5(tasksDir, { recursive: true });
+        atomicWriteFileSync(join10(tasksDir, "board.md"), body);
+        broadcastSseEvent({ type: "board" });
+        writeJson(res, 200, { ok: true });
+      });
+      return;
+    }
+  }
+  if (path === "/api/config") {
+    if (method === "GET") {
+      return writeJson(res, 200, loadConfig(kandownDir));
+    }
+    if (method === "PUT") {
+      let body = "";
+      req.on("data", (chunk) => {
+        body += chunk;
+      });
+      req.on("end", () => {
+        try {
+          const parsed = JSON.parse(body);
+          saveConfig(kandownDir, parsed);
+          broadcastSseEvent({ type: "config" });
+          writeJson(res, 200, { ok: true });
+        } catch (e) {
+          writeJson(res, 400, { error: e.message });
+        }
+      });
+      return;
     }
-    success(`Archived ${id}`);
-    return;
   }
-  const status = resolveStatusArg(kandownDir, rawStatus);
-  if (!status) {
-    err(`Unknown status: ${rawStatus}`);
-    process.exit(1);
+  if (path === "/api/tasks" && method === "GET") {
+    return writeJson(res, 200, listTaskIds(kandownDir));
   }
-  if (!moveTaskToColumn(kandownDir, id, status)) {
-    err(`Move failed: ${id}`);
-    process.exit(1);
+  if (path.startsWith("/api/tasks/")) {
+    const routeParts = path.slice("/api/tasks/".length).split("/").filter(Boolean);
+    let taskId;
+    try {
+      taskId = decodeURIComponent(routeParts[0] ?? "");
+    } catch {
+      return writeText(res, 400, "Invalid task id");
+    }
+    if (!/^[a-zA-Z0-9_-]+$/.test(taskId)) return writeText(res, 400, "Invalid task id");
+    const tasksDir = getTasksDir(kandownDir);
+    const archiveDir = join10(tasksDir, "archive");
+    const activePath = join10(tasksDir, `${taskId}.md`);
+    const archivedPath = join10(archiveDir, `${taskId}.md`);
+    const action = routeParts[1];
+    if (method === "POST" && (action === "archive" || action === "unarchive")) {
+      if (routeParts.length !== 2) return writeText(res, 400, "Invalid task route");
+      const archiving = action === "archive";
+      const source = archiving ? activePath : archivedPath;
+      const destination = archiving ? archivedPath : activePath;
+      if (!existsSync10(source) && !existsSync10(destination)) {
+        return writeText(res, 404, "Task not found");
+      }
+      try {
+        if (!existsSync10(tasksDir)) mkdirSync5(tasksDir, { recursive: true });
+        if (!existsSync10(archiveDir)) mkdirSync5(archiveDir, { recursive: true });
+        const body = await readRequestBody(req);
+        atomicWriteFileSync(destination, body);
+        if (source !== destination && existsSync10(source)) unlinkSync5(source);
+        broadcastSseEvent({ type: "task", id: taskId });
+        return writeJson(res, 200, { ok: true });
+      } catch (error) {
+        return writeJson(res, 500, {
+          error: `Failed to ${action} task: ${error instanceof Error ? error.message : String(error)}`
+        });
+      }
+    }
+    if (routeParts.length !== 1) return writeText(res, 404, "Route not found");
+    if (method === "GET") {
+      const taskPath2 = findTaskPath(kandownDir, taskId);
+      if (!taskPath2) return writeText(res, 404, "Task not found");
+      return writeText(res, 200, readFileSync10(taskPath2, "utf8"));
+    }
+    if (method === "PUT") {
+      try {
+        if (!existsSync10(tasksDir)) mkdirSync5(tasksDir, { recursive: true });
+        const taskPath2 = findTaskPath(kandownDir, taskId) ?? activePath;
+        const body = await readRequestBody(req);
+        atomicWriteFileSync(taskPath2, body);
+        broadcastSseEvent({ type: "task", id: taskId });
+        return writeJson(res, 200, { ok: true });
+      } catch (error) {
+        return writeJson(res, 500, {
+          error: `Failed to write task: ${error instanceof Error ? error.message : String(error)}`
+        });
+      }
+    }
+    if (method === "DELETE") {
+      try {
+        if (existsSync10(activePath)) unlinkSync5(activePath);
+        if (existsSync10(archivedPath)) unlinkSync5(archivedPath);
+        broadcastSseEvent({ type: "task_delete", id: taskId });
+        return writeJson(res, 200, { ok: true });
+      } catch (error) {
+        return writeJson(res, 500, {
+          error: `Failed to delete task: ${error instanceof Error ? error.message : String(error)}`
+        });
+      }
+    }
   }
-  success(`Moved ${id} \u2192 "${status}"`);
+  writeJson(res, 404, { error: "Route not found" });
 }
-function cmdAssign(rawArgs) {
-  const { kandownDir } = ensureKandownDir(rawArgs);
-  const args = taskParseArgs(rawArgs);
-  const [id, assignee] = args.positional;
-  if (!id) {
-    err("Usage: kandown assign <task-id> [assignee]");
-    process.exit(1);
-  }
-  const task = readTaskFile(kandownDir, id);
-  if (!task) {
-    err(`Task not found: ${id}`);
-    process.exit(1);
+function injectServerRoot(html, kandownDir) {
+  const marker = "</head>";
+  const markerIndex = html.toLowerCase().lastIndexOf(marker);
+  const safeRoot = JSON.stringify(kandownDir).replace(/</g, "\\u003c");
+  const script = `<script>window.__KANDOWN_ROOT__ = ${safeRoot};</script>
+`;
+  if (markerIndex === -1) return script + html;
+  return html.slice(0, markerIndex) + script + html.slice(markerIndex);
+}
+function serveApp(res, kandownDir) {
+  syncProjectKandownHtml(kandownDir);
+  const htmlPath = join10(kandownDir, "kandown.html");
+  if (existsSync10(htmlPath)) {
+    const html = readFileSync10(htmlPath, "utf8");
+    res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+    res.end(injectServerRoot(html, kandownDir));
+  } else {
+    writeText(res, 404, "kandown.html not found");
   }
-  const frontmatter = { ...task.frontmatter, id };
-  if (assignee) frontmatter.assignee = assignee;
-  else delete frontmatter.assignee;
-  atomicWriteFileSync(task.path, serializeTaskFile(frontmatter, task.body));
-  success(assignee ? `Assigned ${id} \u2192 ${assignee}` : `Unassigned ${id}`);
 }
-function cmdCommit(rawArgs) {
-  ensureKandownDir(rawArgs);
-  const args = taskParseArgs(rawArgs);
-  const message = stringFlag(args.flags, "message") || "tasks: update kandown board";
-  const add = spawnSync("git", ["add", "tasks", ".kandown/kandown.json"], { stdio: "inherit" });
-  if (add.status !== 0) process.exit(add.status ?? 1);
-  const commit = spawnSync("git", ["commit", "-m", message], { stdio: "inherit" });
-  process.exit(commit.status ?? 1);
+function createServeServer(kandownDir) {
+  syncProjectKandownHtml(kandownDir);
+  return createServer((req, res) => {
+    const url = new URL(req.url || "/", "http://localhost");
+    if (req.method === "OPTIONS") return handleCors(res);
+    if (url.pathname === "/" || url.pathname === "/kandown.html" || !url.pathname.startsWith("/api/")) {
+      return serveApp(res, kandownDir);
+    }
+    if (url.pathname.startsWith("/api/")) {
+      return handleApi(req, res, url, kandownDir);
+    }
+    writeText(res, 404, "Not found");
+  });
 }
-function printTaskCommandsHelp() {
-  log(`
-${c.bold}Kandown task commands${c.reset}
-
-  kandown list [-s status] [-p P1] [-a user] [-t tag] [--archived] [--json]
-  kandown show <id>
-  kandown create "title" [-p P1] [-a user] [-t tag] [--to status] [--id id] [--json]
-  kandown move <id> <status|archived>
-  kandown assign <id> [user]
-  kandown commit [-m "message"]
-`);
+function listen(server, port) {
+  return new Promise((resolveListen, rejectListen) => {
+    const onError = (e) => {
+      server.off("listening", onListening);
+      rejectListen(e);
+    };
+    const onListening = () => {
+      server.off("error", onError);
+      resolveListen();
+    };
+    server.once("error", onError);
+    server.once("listening", onListening);
+    server.listen(port, "127.0.0.1");
+  });
 }
-async function launchTui(screen, kandownDir) {
-  if (!process.stdin.isTTY) {
-    info(`TUI skipped because stdin is not interactive. Use ${c.cyan}kandown daemon status${c.reset} to inspect the web daemon.`);
-    return;
+async function listenOnAvailablePort(kandownDir, preferredPort) {
+  const startPort = preferredPort ?? START_PORT_RANGE;
+  for (let p = startPort; p <= END_PORT_RANGE; p++) {
+    if (UNSAFE_PORTS.has(p)) continue;
+    const server = createServeServer(kandownDir);
+    try {
+      await listen(server, p);
+      return { server, port: p };
+    } catch (e) {
+      if (e.code !== "EADDRINUSE" && e.code !== "EACCES") throw e;
+    }
   }
-  const tuiPath = join8(PKG_ROOT, "bin", "tui.js");
-  if (!existsSync8(tuiPath)) {
-    err(`TUI binary not found at ${tuiPath}`);
+  throw new Error(`No free port in range ${START_PORT_RANGE}-${END_PORT_RANGE}`);
+}
+
+// src/cli/commands/daemon.ts
+async function cmdDaemon(rest) {
+  const parsedDaemonArgs = parseArgs(rest);
+  const subcommand = parsedDaemonArgs.positional[0] || "status";
+  const daemonArgs = subcommand ? stripFirstPositional(rest, subcommand) : rest;
+  const { kandownDir } = ensureKandownDir(daemonArgs);
+  if (subcommand === "run") {
+    const daemonOptions = parseArgs(daemonArgs);
+    const preferredPort = typeof daemonOptions.flags.port === "string" ? Number(daemonOptions.flags.port) : null;
+    const { port } = await listenOnAvailablePort(kandownDir, Number.isInteger(preferredPort) ? preferredPort : null);
+    const url = `http://localhost:${port}`;
+    const metadataPath2 = join11(kandownDir, "daemon.json");
+    atomicWriteFileSync(metadataPath2, JSON.stringify({
+      pid: process.pid,
+      port,
+      url,
+      kandownDir,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      version: getCurrentVersion(),
+      token: null
+    }, null, 2));
+    info(`Kandown daemon running on port ${port} (PID ${process.pid})`);
+    await new Promise(() => {
+    });
+  } else if (subcommand === "start") {
+    const daemonOptions = parseArgs(daemonArgs);
+    const preferredPort = typeof daemonOptions.flags.port === "string" ? Number(daemonOptions.flags.port) : null;
+    const status = await startProjectDaemon(kandownDir, Number.isInteger(preferredPort) ? preferredPort : null);
+    if (status.running && status.metadata) success(`Daemon running on port ${status.metadata.port} (PID ${status.metadata.pid})`);
+    else {
+      err("Daemon failed to start");
+      process.exit(1);
+    }
+  } else if (subcommand === "restart") {
+    await stopProjectDaemon(kandownDir);
+    const status = await startProjectDaemon(kandownDir);
+    if (status.running && status.metadata) success(`Daemon restarted on port ${status.metadata.port} (PID ${status.metadata.pid})`);
+    else {
+      err("Daemon failed to restart");
+      process.exit(1);
+    }
+  } else if (subcommand === "stop") {
+    const stopped = await stopProjectDaemon(kandownDir);
+    if (stopped) success("Daemon stopped");
+    else info("Daemon not running");
+  } else if (subcommand === "status") {
+    const status = await getDaemonStatus(kandownDir);
+    if (status.running && status.metadata) {
+      success(`Daemon running on port ${status.metadata.port} (PID ${status.metadata.pid})`);
+    } else {
+      info("Daemon not running");
+    }
+  } else if (subcommand === "refresh-all") {
+    const status = await getDaemonStatus(kandownDir);
+    if (status.running) await stopProjectDaemon(kandownDir);
+    const restarted = await startProjectDaemon(kandownDir);
+    if (restarted.running && restarted.metadata) success(`Refreshed current project daemon on port ${restarted.metadata.port}`);
+    else info("No running daemon refreshed");
+  } else {
+    err(`Unknown daemon command: ${subcommand}`);
+    log(`  Use ${c.cyan}kandown daemon start|stop|restart|status|refresh-all${c.reset}`);
     process.exit(1);
   }
-  await new Promise((resolveTui) => {
-    const child = spawn5(process.execPath, [tuiPath, screen, kandownDir, getCurrentVersion()], { stdio: "inherit" });
-    child.on("close", (code) => {
-      if (typeof code === "number" && code !== 0) process.exit(code);
-      resolveTui();
-    });
-  });
 }
+
+// src/cli/cli.ts
 async function cmdTui(screen, rawArgs) {
   const args = parseArgs(rawArgs);
   const kandownDir = resolveKandownDir(args.path, process.cwd());
   await launchTui(screen, kandownDir);
 }
-function cmdExport(rawArgs) {
-  const { kandownDir } = ensureKandownDir(rawArgs);
-  const board = readBoard(kandownDir);
-  process.stdout.write(JSON.stringify(board, null, 2) + "\n");
-}
-function cmdProjects(rawArgs) {
-  const { kandownDir } = ensureKandownDir(rawArgs);
-  const metadataPath2 = join8(kandownDir, "daemon.json");
-  if (!existsSync8(metadataPath2)) {
-    info("No daemon metadata for this project.");
-    return;
-  }
-  process.stdout.write(readFileSync8(metadataPath2, "utf8").trim() + "\n");
-}
-function cmdImport(rawArgs) {
-  const { kandownDir } = ensureKandownDir(rawArgs);
-  const args = taskParseArgs(rawArgs);
-  const file = args.positional[0];
-  if (!file) {
-    err("Usage: kandown import <file.json> [--overwrite]");
-    process.exit(1);
-  }
-  const importPath = resolve2(process.cwd(), file);
-  if (!existsSync8(importPath)) {
-    err(`Import file not found: ${file}`);
-    process.exit(1);
-  }
-  let raw;
-  try {
-    raw = JSON.parse(readFileSync8(importPath, "utf8"));
-  } catch (error) {
-    err(`Import file must be JSON: ${error instanceof Error ? error.message : String(error)}`);
-    process.exit(1);
-  }
-  const rows = [];
-  if (Array.isArray(raw)) {
-    rows.push(...raw.filter((value) => typeof value === "object" && value !== null));
-  } else if (typeof raw === "object" && raw !== null && Array.isArray(raw.columns)) {
-    for (const column of raw.columns) {
-      if (typeof column !== "object" || column === null) continue;
-      const col = column;
-      if (!Array.isArray(col.tasks)) continue;
-      for (const task of col.tasks) {
-        if (typeof task === "object" && task !== null) rows.push({ ...task, status: String(col.name || "Backlog") });
-      }
-    }
-  }
-  if (rows.length === 0) {
-    err("No tasks found to import. Expected a list JSON array or kandown export object.");
-    process.exit(1);
-  }
-  const tasksDir = getTasksDir(kandownDir);
-  if (!existsSync8(tasksDir)) mkdirSync5(tasksDir, { recursive: true });
-  let imported = 0;
-  for (const row of rows) {
-    const id = typeof row.id === "string" && /^[a-zA-Z0-9_-]+$/.test(row.id) ? row.id : nextTaskId(kandownDir);
-    const path = taskPath(kandownDir, id);
-    if (existsSync8(path) && args.flags.overwrite !== true) continue;
-    const fm = {
-      id,
-      title: typeof row.title === "string" && row.title ? row.title : id,
-      status: typeof row.status === "string" && row.status ? row.status.replace(/ \(archived\)$/i, "") : "Backlog"
-    };
-    if (typeof row.priority === "string") fm.priority = row.priority;
-    if (typeof row.assignee === "string") fm.assignee = row.assignee;
-    if (Array.isArray(row.tags)) fm.tags = row.tags.map(String);
-    atomicWriteFileSync(path, serializeTaskFile(fm, typeof row.body === "string" ? row.body : ""));
-    imported++;
-  }
-  success(`Imported ${imported} task${imported === 1 ? "" : "s"}`);
-}
 async function main() {
   const rawArgs = process.argv.slice(2);
   if (rawArgs.length === 1 && (rawArgs[0] === "--version" || rawArgs[0] === "version")) {
@@ -2382,80 +2466,19 @@ async function main() {
     case "-h":
       help();
       break;
-    case "daemon": {
-      const parsedDaemonArgs = parseArgs(rest);
-      const subcommand = parsedDaemonArgs.positional[0] || "status";
-      const daemonArgs = subcommand ? stripFirstPositional(rest, subcommand) : rest;
-      const { kandownDir } = ensureKandownDir(daemonArgs);
-      if (subcommand === "run") {
-        const daemonOptions = parseArgs(daemonArgs);
-        const preferredPort = typeof daemonOptions.flags.port === "string" ? Number(daemonOptions.flags.port) : null;
-        const { port } = await listenOnAvailablePort(kandownDir, Number.isInteger(preferredPort) ? preferredPort : null);
-        const url = `http://localhost:${port}`;
-        const metadataPath2 = join8(kandownDir, "daemon.json");
-        atomicWriteFileSync(metadataPath2, JSON.stringify({
-          pid: process.pid,
-          port,
-          url,
-          kandownDir,
-          startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-          version: getCurrentVersion(),
-          token: null
-        }, null, 2));
-        info(`Kandown daemon running on port ${port} (PID ${process.pid})`);
-        await new Promise(() => {
-        });
-      } else if (subcommand === "start") {
-        const daemonOptions = parseArgs(daemonArgs);
-        const preferredPort = typeof daemonOptions.flags.port === "string" ? Number(daemonOptions.flags.port) : null;
-        const status = await startProjectDaemon(kandownDir, Number.isInteger(preferredPort) ? preferredPort : null);
-        if (status.running && status.metadata) success(`Daemon running on port ${status.metadata.port} (PID ${status.metadata.pid})`);
-        else {
-          err("Daemon failed to start");
-          process.exit(1);
-        }
-      } else if (subcommand === "restart") {
-        await stopProjectDaemon(kandownDir);
-        const status = await startProjectDaemon(kandownDir);
-        if (status.running && status.metadata) success(`Daemon restarted on port ${status.metadata.port} (PID ${status.metadata.pid})`);
-        else {
-          err("Daemon failed to restart");
-          process.exit(1);
-        }
-      } else if (subcommand === "stop") {
-        const stopped = await stopProjectDaemon(kandownDir);
-        if (stopped) success("Daemon stopped");
-        else info("Daemon not running");
-      } else if (subcommand === "status") {
-        const status = await getDaemonStatus(kandownDir);
-        if (status.running && status.metadata) {
-          success(`Daemon running on port ${status.metadata.port} (PID ${status.metadata.pid})`);
-        } else {
-          info("Daemon not running");
-        }
-      } else if (subcommand === "refresh-all") {
-        const status = await getDaemonStatus(kandownDir);
-        if (status.running) await stopProjectDaemon(kandownDir);
-        const restarted = await startProjectDaemon(kandownDir);
-        if (restarted.running && restarted.metadata) success(`Refreshed current project daemon on port ${restarted.metadata.port}`);
-        else info("No running daemon refreshed");
-      } else {
-        err(`Unknown daemon command: ${subcommand}`);
-        log(`  Use ${c.cyan}kandown daemon start|stop|restart|status|refresh-all${c.reset}`);
-        process.exit(1);
-      }
+    case "daemon":
+      await cmdDaemon(rest);
       break;
-    }
     case void 0: {
       const parsed = parseArgs(rest);
       const kandownDir = resolveKandownDir(parsed.path, process.cwd());
-      if (existsSync8(kandownDir)) {
+      if (existsSync11(kandownDir)) {
         let status = await getDaemonStatus(kandownDir);
         if (!status.running) {
           status = await startProjectDaemon(kandownDir);
         }
         if (!parsed.flags["no-open"]) {
-          const urlToOpen = status.metadata?.url || join8(kandownDir, "kandown.html");
+          const urlToOpen = status.metadata?.url || join12(kandownDir, "kandown.html");
           openBrowser(urlToOpen);
         }
       } else if (!process.stdin.isTTY) {