kandown 0.33.5 → 0.34.0

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## 0.34.0 — 2026-07-24 — "Quick-Wins Collection"
+
+- **Added**: **Quick archive button on every card** — task cards in the board and list views now expose a one-click **archive** action next to the existing guarded delete button. Archiving is reversible from the archive view and reuses the existing store `archiveTask` action so files, watchers, and broadcasts stay consistent.
+- **Added**: **Terminal-column bulk actions** — the column whose name matches the configured terminal status now shows a dedicated **Manage tasks** menu with **Archive all** and **Delete all** entries. Both confirm the exact task count and column name before mutating anything; deletions are permanent, archive operations can be undone from the archive view.
+- **Added**: **Robust bulk task actions** — `bulkArchiveTasks(ids)` and `bulkDeleteTasks(ids?)` use `Promise.allSettled` over strict task reads so a single failed file cannot abort the batch. An in-flight guard prevents two destructive runs from racing each other. `nextTaskId` now considers archived ids so new tasks cannot reuse a number that already lives in `tasks/archive/`.
+- **Added**: **Subtask editor in the task drawer and workspace** — both surfaces re-mount the original checklist editor (toggle, edit, enter-to-insert, backspace-to-remove, expand description/report) that was previously removed. `SubtaskEditor` owns the section UI while the drawer/workspace persists edits through the existing `saveDrawer` autosave path.
+- **Fixed**: **Subtask markdown round-trip preserves hand-written prose** — `extractSubtasks` and `injectSubtasks` now preserve unrelated lines that share the `## Subtasks` section, support multi-line `[DESC]`/`[REPORT]` markers, and treat `- [ ]` (empty text) as a valid checklist row so a fresh row can be created without immediately supplying text.
+- **Fixed**: **Subtask editor stays above hooks** — the SubtaskEditor handler is defined before the desktop/media-query guard in both `Drawer` and `TaskWorkspace`, restoring the React rules-of-hooks order and eliminating a mobile-drawer crash.
+- **Fixed**: **Server-mode archive round-trip** — the production daemon's `/api/tasks/:id` routes now read from and write to the `tasks/archive/` directory, accept `POST /api/tasks/:id/archive` and `…/unarchive`, validate task ids, and remove both the active and archived files on `DELETE`. The dev middleware in `vite.config.ts` resolves tasks at the project-root `tasks/` directory (the canonical location since v0.12) and exposes the same archive routes.
+- **Fixed**: **SPA fallback for deep links** — the daemon now serves the single-file app for any non-API path, so refreshing on a deep task URL (e.g. `/2?p=project`) keeps the client routing intact.
+- **Changed**: **File watcher covers the archive directory** — the CLI content-hash watcher also tracks `tasks/archive/*.md`, so archived task updates still trigger board reloads and notifications.
+- **Changed**: **Card action group and a11y** — the card's right-corner actions now live in a flex group that reveals both archive and delete on hover or keyboard focus, with `aria-label` and `aria-haspopup` attributes on the new menu, and a `Card isMountedRef` reset so React StrictMode double-mount doesn't disable the buttons.
+- **Changed**: **i18n strings** — English and French locales gain new keys for archive/delete-all prompts, subtask a11y labels, and progress messages. English remains the source of truth; untranslated keys fall back automatically.
+
+## 0.33.6 — 2026-07-24 — "Subdirectory Project Discovery"
+
+- **Fixed**: **Auto-detect `.kandown/` in sub-directories from parent folder** — when running `kandown` from a parent directory that contains a sub-directory with a `.kandown/` folder, the CLI now recursively searches sub-directories (skipping `node_modules`, hidden dirs, and `tasks/`) to find it automatically. This restores the expected behaviour where `kandown` opens the child project without requiring an explicit `--path` argument.
+
 ## 0.33.5 — 2026-07-24 — "Sidebar Task Switch Fix"
 
 - **Fixed**: **BlockNote Editor Not Refreshing on Sidebar Task Switch** — the BlockNote markdown editor now properly reloads when switching between tasks via the sidebar explorer. Previously, the editor body kept showing the previous task's content because the `useEffect` only ran once on mount. The fix compares the editor's current markdown (normalized) against the incoming `value` prop and only calls `replaceBlocks` when they differ. This makes the editor reactive to external value changes (task switch) while preserving cursor/focus during the user's own typing sessions.

package/README.md

@@ -178,6 +178,7 @@ Interactive runs of `kandown` check npm for updates at most once every 24 hours
 | Command palette | `⌘K` / `Ctrl+K` for quick actions |
 | Custom columns | Add, rename, delete columns freely |
 | Guarded deletion | Double-click to delete — no accidents |
+| Terminal bulk actions | Archive or permanently delete every task in the terminal column with confirmation |
 
 ### Task Management
 
@@ -185,6 +186,7 @@ Interactive runs of `kandown` check npm for updates at most once every 24 hours
 |---|---|
 | Rich task drawer | WYSIWYG markdown editor for title, metadata, subtasks, body |
 | Subtasks | Full checklist with progress tracking on cards |
+| Subtask editor | Add, reorder-by-keyboard, check off, remove, and edit per-step descriptions and reports |
 | Metadata fields | Priority, assignee, tags, due date, owner type |
 | Owner filtering | Filter human vs AI-agent tasks separately |
 | External-change detection | Warns when files are modified outside the app |

package/bin/kandown.js

@@ -5,9 +5,9 @@ if (typeof globalThis.require === 'undefined') {
 }
 
 // src/cli/cli.ts
-import { existsSync as existsSync8, readFileSync as readFileSync8, copyFileSync as copyFileSync3, mkdirSync as mkdirSync5, readdirSync as readdirSync3 } from "fs";
+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 spawn4, spawnSync } from "child_process";
+import { spawn as spawn5, spawnSync } from "child_process";
 
 // src/cli/lib/updater.ts
 import { existsSync, readFileSync, writeFileSync, unlinkSync, statSync, mkdirSync } from "fs";
@@ -16,7 +16,7 @@ import { spawn, execSync } from "child_process";
 import { homedir } from "os";
 
 // src/lib/version.ts
-var KANDOWN_VERSION = "0.33.5";
+var KANDOWN_VERSION = "0.34.0";
 
 // src/cli/lib/updater.ts
 import { fileURLToPath } from "url";
@@ -265,7 +265,7 @@ ${now}`, "utf8");
 }
 
 // src/cli/lib/board-reader.ts
-import { existsSync as existsSync3, readdirSync, readFileSync as readFileSync3, mkdirSync as mkdirSync2, unlinkSync as unlinkSync3 } from "fs";
+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 { fileURLToPath as fileURLToPath2 } from "url";
 import { homedir as homedir2 } from "os";
@@ -428,30 +428,42 @@ function extractSubtasks(body) {
       kept.push(line);
       continue;
     }
-    const m = line.match(/^\s*-\s+\[([ xX])\]\s+(.+)$/);
+    const m = line.match(/^\s*-\s+\[([ xX])\]\s*(.*)$/);
     if (m && inSubtaskSection) {
       const text = m[2]?.trim() ?? "";
       subtasks.push({ done: (m[1]?.toLowerCase() ?? "") === "x", text });
       continue;
     }
-    const descMatch = line.match(/^\s*\[DESC\]\s*(.*)$/);
+    const descMatch = line.match(/^\s*\[DESC\]\s?(.*)$/);
     if (descMatch && subtasks.length > 0) {
-      subtasks[subtasks.length - 1].description = descMatch[1];
+      const subtask = subtasks[subtasks.length - 1];
+      const nextLine = descMatch[1] ?? "";
+      subtask.description = subtask.description === void 0 ? nextLine : `${subtask.description}
+${nextLine}`;
       continue;
     }
-    const reportMatch = line.match(/^\s*\[REPORT\]\s*(.*)$/);
+    const reportMatch = line.match(/^\s*\[REPORT\]\s?(.*)$/);
     if (reportMatch && subtasks.length > 0) {
-      subtasks[subtasks.length - 1].report = reportMatch[1];
+      const subtask = subtasks[subtasks.length - 1];
+      const nextLine = reportMatch[1] ?? "";
+      subtask.report = subtask.report === void 0 ? nextLine : `${subtask.report}
+${nextLine}`;
       continue;
     }
     const legacyDescMatch = line.match(/^\s+description:\s*(.+)$/);
     if (legacyDescMatch && inSubtaskSection && subtasks.length > 0) {
-      subtasks[subtasks.length - 1].description = legacyDescMatch[1].trim();
+      const subtask = subtasks[subtasks.length - 1];
+      const nextLine = legacyDescMatch[1].trim();
+      subtask.description = subtask.description ? `${subtask.description}
+${nextLine}` : nextLine;
       continue;
     }
     const legacyReportMatch = line.match(/^\s+report:\s*(.+)$/);
     if (legacyReportMatch && inSubtaskSection && subtasks.length > 0) {
-      subtasks[subtasks.length - 1].report = legacyReportMatch[1].trim();
+      const subtask = subtasks[subtasks.length - 1];
+      const nextLine = legacyReportMatch[1].trim();
+      subtask.report = subtask.report ? `${subtask.report}
+${nextLine}` : nextLine;
       continue;
     }
     kept.push(line);
@@ -484,7 +496,7 @@ function serializeTaskFile(frontmatter, body) {
 }
 
 // src/cli/lib/config.ts
-import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
+import { readFileSync as readFileSync2, existsSync as existsSync2, readdirSync, statSync as statSync2 } from "fs";
 import { join as join2 } from "path";
 var DEFAULT_CONFIG = {
   ui: { language: "en", theme: "auto", skin: "kandown", font: "inter" },
@@ -562,8 +574,22 @@ function getTasksDir(kandownDir) {
 }
 function listTaskIds(kandownDir) {
   const tasksDir = getTasksDir(kandownDir);
-  if (!existsSync3(tasksDir)) return [];
-  return readdirSync(tasksDir).filter((name) => name.endsWith(".md")).map((name) => name.slice(0, -3)).sort((a, b) => a.localeCompare(b, void 0, { numeric: true }));
+  const ids = /* @__PURE__ */ new Set();
+  for (const directory of [tasksDir, join3(tasksDir, "archive")]) {
+    if (!existsSync3(directory)) continue;
+    for (const name of readdirSync2(directory).filter((entry) => entry.endsWith(".md"))) {
+      ids.add(name.slice(0, -3));
+    }
+  }
+  return [...ids].sort((a, b) => a.localeCompare(b, void 0, { numeric: true }));
+}
+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;
 }
 function readBoard(kandownDir) {
   const config = loadConfig(kandownDir);
@@ -591,8 +617,8 @@ function readBoard(kandownDir) {
   };
 }
 function readTask(kandownDir, taskId) {
-  const taskPath2 = join3(getTasksDir(kandownDir), `${taskId}.md`);
-  if (!existsSync3(taskPath2)) {
+  const taskPath2 = findTaskPath(kandownDir, taskId);
+  if (!taskPath2) {
     return {
       frontmatter: { id: taskId, title: `Task ${taskId}`, status: "Backlog" },
       body: ""
@@ -652,8 +678,8 @@ ${gitLog}
   return sections.filter(Boolean).join("\n\n---\n\n");
 }
 function moveTaskToColumn(kandownDir, taskId, targetColumn) {
-  const taskPath2 = join3(getTasksDir(kandownDir), `${taskId}.md`);
-  if (!existsSync3(taskPath2)) return false;
+  const taskPath2 = findTaskPath(kandownDir, taskId);
+  if (!taskPath2) return false;
   try {
     const prevContent = readFileSync3(taskPath2, "utf8");
     const parsed = readTask(kandownDir, taskId);
@@ -905,8 +931,8 @@ async function startProjectDaemon(kandownDir, preferredPort) {
     if (current.metadata?.version === getCurrentVersion()) return current;
     await stopProjectDaemon(kandownDir);
   }
-  const cliPath = process.argv[1];
-  if (!cliPath) throw new Error("Cannot locate kandown CLI entrypoint");
+  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",
@@ -1008,6 +1034,17 @@ function writeText(res, status, text) {
   });
   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");
@@ -1200,40 +1237,92 @@ async function handleApi(req, res, url, kandownDir) {
     return writeJson(res, 200, listTaskIds(kandownDir));
   }
   if (path.startsWith("/api/tasks/")) {
-    const taskId = decodeURIComponent(path.slice("/api/tasks/".length));
+    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 taskPath2 = join5(tasksDir, `${taskId}.md`);
+    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") {
-      if (!existsSync5(taskPath2)) return writeText(res, 404, "Task not found");
+      const taskPath2 = findTaskPath(kandownDir, taskId);
+      if (!taskPath2) return writeText(res, 404, "Task not found");
       return writeText(res, 200, readFileSync5(taskPath2, "utf8"));
     }
     if (method === "PUT") {
-      let body = "";
-      req.on("data", (chunk) => {
-        body += chunk;
-      });
-      req.on("end", () => {
+      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 });
-        writeJson(res, 200, { ok: true });
-      });
-      return;
+        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") {
-      if (existsSync5(taskPath2)) unlinkSync5(taskPath2);
-      broadcastSseEvent({ type: "task_delete", id: taskId });
-      return writeJson(res, 200, { ok: true });
+      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(readFileSync5(htmlPath, "utf8"));
+    res.end(injectServerRoot(html, kandownDir));
   } else {
     writeText(res, 404, "kandown.html not found");
   }
@@ -1243,7 +1332,7 @@ function createServeServer(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") {
+    if (url.pathname === "/" || url.pathname === "/kandown.html" || !url.pathname.startsWith("/api/")) {
       return serveApp(res, kandownDir);
     }
     if (url.pathname.startsWith("/api/")) {
@@ -1283,18 +1372,18 @@ async function listenOnAvailablePort(kandownDir, preferredPort) {
 }
 
 // src/cli/lib/init.ts
-import { existsSync as existsSync6, readFileSync as readFileSync6, mkdirSync as mkdirSync4, copyFileSync as copyFileSync2, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
+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 = readdirSync2(src);
+    const entries = readdirSync3(src);
     for (const entry of entries) {
       const srcPath = join6(src, entry);
       const destPath = join6(dest, entry);
       try {
-        if (statSync2(srcPath).isDirectory()) {
+        if (statSync3(srcPath).isDirectory()) {
           errors.push(...copyRecursive(srcPath, destPath));
         } else if (!existsSync6(destPath)) {
           copyFileSync2(srcPath, destPath);
@@ -1557,6 +1646,16 @@ ${args.report.trim()}`) : task.body.trim() + reportSection;
   sendResponse(id, { error: { code: -32601, message: `Method not found: ${method}` } });
 }
 
+// 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";
+  try {
+    spawn4(cmd, [target], { detached: true, stdio: "ignore" }).unref();
+  } catch {
+  }
+}
+
 // src/cli/cli.ts
 var c = {
   reset: "\x1B[0m",
@@ -1580,13 +1679,6 @@ function success(msg) {
 function err(msg) {
   console.error(`${c.red}\u2717${c.reset}  ${msg}`);
 }
-function openBrowser(target) {
-  const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
-  try {
-    spawn4(cmd, [target], { detached: true, stdio: "ignore" }).unref();
-  } catch {
-  }
-}
 function parseArgs(args) {
   const flags = {};
   const positional = [];
@@ -1665,6 +1757,28 @@ function resolveKandownDir(pathArg = ".kandown", cwd = process.cwd()) {
   if (basename(cwd) === ".kandown" || existsSync8(join8(cwd, "kandown.json"))) {
     return cwd;
   }
+  if (pathArg !== ".kandown") {
+    return resolve2(cwd, pathArg);
+  }
+  let entries;
+  try {
+    entries = readdirSync4(cwd);
+  } catch {
+    return resolve2(cwd, pathArg);
+  }
+  for (const name of entries) {
+    if (name.startsWith(".") || name === "node_modules" || name === "tasks") continue;
+    const subPath = join8(cwd, name);
+    let stat;
+    try {
+      stat = statSync4(subPath);
+    } catch {
+      continue;
+    }
+    if (!stat.isDirectory()) continue;
+    const found = resolveKandownDir(pathArg, subPath);
+    if (existsSync8(found)) return found;
+  }
   return resolve2(cwd, pathArg);
 }
 function ensureKandownDir(rawArgs) {
@@ -1730,7 +1844,7 @@ 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 = spawn4("npm", ["view", "kandown", "version"], {
+    const child = spawn5("npm", ["view", "kandown", "version"], {
       timeout: 6e3,
       stdio: ["pipe", "pipe", "pipe"],
       env: { ...process.env },
@@ -1873,7 +1987,7 @@ function resolveStatusArg(kandownDir, status) {
 function taskPath(kandownDir, id, archived = false) {
   return archived ? join8(getTasksDir(kandownDir), "archive", `${id}.md`) : join8(getTasksDir(kandownDir), `${id}.md`);
 }
-function findTaskPath(kandownDir, id) {
+function findTaskPath2(kandownDir, id) {
   const active = taskPath(kandownDir, id);
   if (existsSync8(active)) return active;
   const archived = taskPath(kandownDir, id, true);
@@ -1884,7 +1998,7 @@ function nextTaskId(kandownDir) {
   const ids = new Set(listTaskIds(kandownDir));
   const archiveDir = join8(getTasksDir(kandownDir), "archive");
   if (existsSync8(archiveDir)) {
-    for (const file of readdirSync3(archiveDir)) {
+    for (const file of readdirSync4(archiveDir)) {
       if (file.endsWith(".md")) ids.add(file.slice(0, -3));
     }
   }
@@ -1896,7 +2010,7 @@ function nextTaskId(kandownDir) {
   return `t${max + 1}`;
 }
 function readTaskFile(kandownDir, id) {
-  const path = findTaskPath(kandownDir, id);
+  const path = findTaskPath2(kandownDir, id);
   if (!path) return null;
   const parsed = parseTaskFile(readFileSync8(path, "utf8"));
   return {
@@ -1930,7 +2044,7 @@ function cmdList(rawArgs) {
   if (includeArchived) {
     const archiveDir = join8(getTasksDir(kandownDir), "archive");
     if (existsSync8(archiveDir)) {
-      for (const file of readdirSync3(archiveDir).filter((name) => name.endsWith(".md"))) {
+      for (const file of readdirSync4(archiveDir).filter((name) => name.endsWith(".md"))) {
         const id = file.slice(0, -3);
         const parsed = parseTaskFile(readFileSync8(join8(archiveDir, file), "utf8"));
         rows.push({
@@ -1981,7 +2095,7 @@ function cmdShow(rawArgs) {
     err("Usage: kandown show <task-id>");
     process.exit(1);
   }
-  const path = findTaskPath(kandownDir, id);
+  const path = findTaskPath2(kandownDir, id);
   if (!path) {
     err(`Task not found: ${id}`);
     process.exit(1);
@@ -2001,7 +2115,7 @@ function cmdCreate(rawArgs) {
     err(`Invalid task id: ${id}`);
     process.exit(1);
   }
-  if (findTaskPath(kandownDir, id)) {
+  if (findTaskPath2(kandownDir, id)) {
     err(`Task already exists: ${id}`);
     process.exit(1);
   }
@@ -2112,7 +2226,7 @@ async function launchTui(screen, kandownDir) {
     process.exit(1);
   }
   await new Promise((resolveTui) => {
-    const child = spawn4(process.execPath, [tuiPath, screen, kandownDir, getCurrentVersion()], { stdio: "inherit" });
+    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();
@@ -2120,7 +2234,8 @@ async function launchTui(screen, kandownDir) {
   });
 }
 async function cmdTui(screen, rawArgs) {
-  const { kandownDir } = ensureKandownDir(rawArgs);
+  const args = parseArgs(rawArgs);
+  const kandownDir = resolveKandownDir(args.path, process.cwd());
   await launchTui(screen, kandownDir);
 }
 function cmdExport(rawArgs) {
@@ -2333,14 +2448,19 @@ async function main() {
     }
     case void 0: {
       const parsed = parseArgs(rest);
-      const { kandownDir } = ensureKandownDir(rest);
-      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");
-        openBrowser(urlToOpen);
+      const kandownDir = resolveKandownDir(parsed.path, process.cwd());
+      if (existsSync8(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");
+          openBrowser(urlToOpen);
+        }
+      } else if (!process.stdin.isTTY) {
+        err(`No kandown project found at ${c.bold}${kandownDir}${c.reset} \u2014 run ${c.cyan}kandown init${c.reset} first.`);
+        process.exit(1);
       }
       await launchTui("board", kandownDir);
       break;