kanbango 2.5.0 → 3.1.0

package/bin/kanban.js

@@ -2,12 +2,12 @@
 
 const kanban = require('../kanban.js');
 const plan = require('../plan.js');
+const guiRegistry = require('../gui-registry.js');
 const http = require('http');
 const fs = require('fs');
 const path = require('path');
 
 const BACKLOG = path.join(process.cwd(), 'backlog');
-const COLS = kanban.COLS;
 
 function shortId(taskId) {
   const match = taskId.match(/^(?:[A-Z]+-)?(\d+)/);
@@ -99,7 +99,8 @@ async function cliInit() {
         + '- `active/`  — w trakcie (max 1-2)\n'
         + '- `planned/` — zaplanowane\n'
         + '- `icebox/`  — zamrozone / nice-to-have\n'
-        + '- `done/`    — ukonczone\n',
+        + '- `done/`    — ukonczone\n'
+        + '- `epics/`   — first-class epic containers (context for initiatives)\n',
       'utf-8'
     );
   }
@@ -145,13 +146,14 @@ async function cliMcpInit(options) {
 }
 
 async function cliList(colFilter, epicFilter, asJson) {
-  let tasks = await kanban.allEpics();
+  await kanban.migrateEpicGroups();
+  let tasks = await kanban.allTasks();
 
   if (colFilter) {
     tasks = tasks.filter((task) => task.column === colFilter);
   }
   if (epicFilter) {
-    tasks = tasks.filter((task) => task.epic_group === epicFilter);
+    tasks = tasks.filter((task) => kanban.taskMatchesEpicFilter(task, epicFilter));
   }
 
   if (asJson) {
@@ -168,8 +170,11 @@ async function cliList(colFilter, epicFilter, asJson) {
     const progress = kanban.getProgress(task);
     const prog = progress.total ? `${progress.done}/${progress.total}` : '—';
     const title = displayTitle(task).substring(0, 42);
+    const epicLabel = task.epic_id
+      ? `${task.epic_id}:${task.epic_group}`
+      : task.epic_group;
     console.log(
-      `  ${task.column.padEnd(8)}  ${shortId(task.id).padEnd(8)}  ${title.padEnd(43)}  ${prog.padStart(5)}  [${task.epic_group}]`
+      `  ${task.column.padEnd(8)}  ${shortId(task.id).padEnd(8)}  ${title.padEnd(43)}  ${prog.padStart(5)}  [${epicLabel}]`
     );
   }
 }
@@ -181,7 +186,7 @@ async function cliShow(taskId) {
     console.log(`Plik:    ${taskFilePath(task)}`);
     console.log(`Tytuł:   ${displayTitle(task)}`);
     console.log(`Kolumna: ${task.column}`);
-    console.log(`Epik:    ${task.epic_group}`);
+    console.log(`Epik:    ${task.epic_id ? `${task.epic_id} (${task.epic_group})` : task.epic_group}`);
     console.log(`Worzono: ${task.created || '—'}`);
 
     if (task.description) {
@@ -202,6 +207,64 @@ async function cliShow(taskId) {
   }
 }
 
+async function cliEpicList(asJson) {
+  await kanban.migrateEpicGroups();
+  const tasks = await kanban.allTasks();
+  const epics = await kanban.listEpicEntities();
+  const shaped = epics.map((epic) => kanban.shapeEpic(epic, tasks, { view: 'summary' }));
+
+  if (asJson) {
+    console.log(JSON.stringify(shaped, null, 2));
+    return;
+  }
+
+  if (shaped.length === 0) {
+    console.log('(brak epików)');
+    return;
+  }
+
+  for (const epic of shaped) {
+    const p = epic.progress || {};
+    console.log(
+      `  ${epic.id.padEnd(6)}  ${epic.status.padEnd(8)}  ${String(epic.title).substring(0, 40).padEnd(40)}  ${p.tasks_done || 0}/${p.tasks_total || 0} tasks`
+    );
+  }
+}
+
+async function cliEpicShow(epicId) {
+  try {
+    await kanban.migrateEpicGroups();
+    const link = await kanban.resolveEpicRef(epicId, { createIfMissing: false });
+    const epic = await kanban.getEpicEntity(link.epic_id);
+    const tasks = await kanban.allTasks();
+    const shaped = kanban.shapeEpic(epic, tasks, { view: 'full' });
+    console.log(JSON.stringify(shaped, null, 2));
+  } catch (error) {
+    console.error(`✗ ${error.message}`);
+    process.exit(1);
+  }
+}
+
+async function cliEpicAdd(title, options = {}) {
+  try {
+    const epic = await kanban.doCreateEpic(title, options);
+    console.log(`✓ Epic ${epic.id}: ${epic.title}`);
+  } catch (error) {
+    console.error(`✗ ${error.message}`);
+    process.exit(1);
+  }
+}
+
+async function cliEpicUpdate(epicId, patch) {
+  try {
+    const epic = await kanban.updateEpicEntity(epicId, patch);
+    console.log(`✓ Epic ${epic.id} updated`);
+  } catch (error) {
+    console.error(`✗ ${error.message}`);
+    process.exit(1);
+  }
+}
+
 async function cliMove(taskId, column) {
   const success = await kanban.doMove(taskId, column);
   if (success) {
@@ -238,29 +301,87 @@ async function serveWeb(port) {
       }
 
       if (requestPath === '/api/board') {
-        const tasks = await kanban.allEpics();
+        await kanban.migrateEpicGroups();
+        const tasks = await kanban.allTasks();
         sendJson(res, 200, tasks);
         return;
       }
 
+      if (requestPath === '/api/epics' && req.method === 'GET') {
+        await kanban.migrateEpicGroups();
+        const tasks = await kanban.allTasks();
+        const epics = await kanban.listEpicEntities();
+        sendJson(res, 200, epics.map((epic) => kanban.shapeEpic(epic, tasks, { view: 'full' })));
+        return;
+      }
+
       if (requestPath === '/api/epics' && req.method === 'POST') {
         const body = await readBody(req);
-        const task = await kanban.doCreate(body.title || '', body.column || 'planned', body.epic_group || '—', {
-          description: body.description,
-          specs: body.specs,
-          in_scope: body.in_scope,
-          out_of_scope: body.out_of_scope,
-          acceptance_criteria: body.acceptance_criteria,
-          test_cases: body.test_cases,
-          subtasks: body.subtasks,
-          notes: body.notes
-        });
+        // Real epic container when no task column is provided.
+        if (body.column === undefined && body.as_task !== true) {
+          const epic = await kanban.doCreateEpic(body.title || '', {
+            description: body.description,
+            goals: body.goals,
+            in_scope: body.in_scope,
+            out_of_scope: body.out_of_scope,
+            notes: body.notes
+          });
+          sendJson(res, 201, kanban.shapeEpic(epic, [], { view: 'full' }));
+          return;
+        }
+
+        const task = await kanban.doCreate(
+          body.title || '',
+          body.column || 'planned',
+          body.epic_id || body.epic || body.epic_group || '—',
+          {
+            description: body.description,
+            specs: body.specs,
+            in_scope: body.in_scope,
+            out_of_scope: body.out_of_scope,
+            acceptance_criteria: body.acceptance_criteria,
+            test_cases: body.test_cases,
+            subtasks: body.subtasks,
+            notes: body.notes
+          }
+        );
+        sendJson(res, 201, task);
+        return;
+      }
+
+      if (requestPath === '/api/tasks' && req.method === 'POST') {
+        const body = await readBody(req);
+        const task = await kanban.doCreate(
+          body.title || '',
+          body.column || 'planned',
+          body.epic_id || body.epic || body.epic_group || '—',
+          {
+            description: body.description,
+            specs: body.specs,
+            in_scope: body.in_scope,
+            out_of_scope: body.out_of_scope,
+            acceptance_criteria: body.acceptance_criteria,
+            test_cases: body.test_cases,
+            subtasks: body.subtasks,
+            notes: body.notes
+          }
+        );
         sendJson(res, 201, task);
         return;
       }
 
       if (req.method === 'PATCH') {
-        const moveMatch = requestPath.match(/^\/api\/epics\/([^/]+)\/move$/);
+        const epicUpdateMatch = requestPath.match(/^\/api\/epic-entities\/([^/]+)$/);
+        if (epicUpdateMatch) {
+          const body = await readBody(req);
+          const patch = body.patch ? { ...body.patch } : { ...body };
+          delete patch.patch;
+          const epic = await kanban.updateEpicEntity(epicUpdateMatch[1], patch);
+          sendJson(res, 200, kanban.shapeEpic(epic, await kanban.allTasks(), { view: 'full' }));
+          return;
+        }
+
+        const moveMatch = requestPath.match(/^\/api\/(?:epics|tasks)\/([^/]+)\/move$/);
         if (moveMatch) {
           const taskId = moveMatch[1];
           const body = await readBody(req);
@@ -269,7 +390,7 @@ async function serveWeb(port) {
           return;
         }
 
-        const toggleMatch = requestPath.match(/^\/api\/epics\/([^/]+)\/tasks\/(\d+)$/);
+        const toggleMatch = requestPath.match(/^\/api\/(?:epics|tasks)\/([^/]+)\/tasks\/(\d+)$/);
         if (toggleMatch) {
           const taskId = toggleMatch[1];
           const idx = parseInt(toggleMatch[2], 10);
@@ -294,7 +415,7 @@ async function serveWeb(port) {
           return;
         }
 
-        const updateMatch = requestPath.match(/^\/api\/epics\/([^/]+)$/);
+        const updateMatch = requestPath.match(/^\/api\/(?:epics|tasks)\/([^/]+)$/);
         if (updateMatch) {
           const taskId = updateMatch[1];
           const body = await readBody(req);
@@ -309,7 +430,9 @@ async function serveWeb(port) {
           if (body.test_cases !== undefined) patch.test_cases = body.test_cases;
           if (body.subtasks !== undefined) patch.subtasks = body.subtasks;
           if (body.notes !== undefined) patch.notes = body.notes;
-          if (body.epic_group !== undefined) patch.epic_group = body.epic_group;
+          if (body.epic_id !== undefined) patch.epic_id = body.epic_id;
+          else if (body.epic !== undefined) patch.epic = body.epic;
+          else if (body.epic_group !== undefined) patch.epic_group = body.epic_group;
 
           const task = await kanban.updateTask(taskId, patch);
           sendJson(res, 200, task);
@@ -357,11 +480,11 @@ async function serveWeb(port) {
   }
 
   const actualPort = server.address().port;
-  const portInfo = await kanban.writeGuiPortFile({ port: actualPort, pid: process.pid });
+  const portInfo = await guiRegistry.writeGuiPortFile({ port: actualPort, pid: process.pid });
 
   async function cleanupGuiPortFile() {
     try {
-      await kanban.clearGuiPortFile({ pid: process.pid });
+      await guiRegistry.clearGuiPortFile({ pid: process.pid });
     } catch {
       // best-effort cleanup
     }
@@ -458,9 +581,9 @@ async function main() {
   const args = process.argv.slice(2);
   const cmd = args[0];
 
-if (!cmd || cmd === 'serve') {
-  const port = kanban.resolvePreferredGuiPort(args[1]);
-  await serveWeb(port);
+  if (!cmd || cmd === 'serve') {
+    const port = guiRegistry.resolvePreferredGuiPort(args[1]);
+    await serveWeb(port);
   } else if (cmd === 'init') {
     await cliInit();
   } else if (cmd === 'mcp-init') {
@@ -506,6 +629,26 @@ if (!cmd || cmd === 'serve') {
     }
 
     await cliList(colFilter, epicFilter, asJson);
+  } else if (cmd === 'epic') {
+    const sub = args[1];
+    if (sub === 'list') {
+      await cliEpicList(args.includes('--json'));
+    } else if (sub === 'show' && args[2]) {
+      await cliEpicShow(args[2]);
+    } else if (sub === 'add' && args[2]) {
+      let description = '';
+      let goals = '';
+      for (let i = 3; i < args.length; i++) {
+        if (args[i] === '--description' && args[i + 1]) description = args[++i];
+        else if (args[i] === '--goals' && args[i + 1]) goals = args[++i];
+      }
+      await cliEpicAdd(args[2], { description, goals });
+    } else if (sub === 'update' && args[2] && args[3]) {
+      await cliEpicUpdate(args[2], parseJsonPayload(args[3]));
+    } else {
+      console.error('Usage: kanban epic list|show|add|update ...');
+      process.exit(1);
+    }
   } else if (cmd === 'show' && args[1]) {
     await cliShow(args[1]);
   } else if (cmd === 'move' && args[1] && args[2]) {

package/gui-registry.js

@@ -0,0 +1,148 @@
+const fs = require('fs').promises;
+const path = require('path');
+
+const BACKLOG = path.join(process.cwd(), 'backlog');
+const GUI_PORT_FILE = '.kanbango-gui.json';
+const GUI_PORT_MIN = 5510;
+const GUI_PORT_MAX = 5999;
+const GUI_PORT_SPAN = GUI_PORT_MAX - GUI_PORT_MIN + 1;
+
+function createGuiError(code, message, hint, details = {}, retryable = false, status = 400) {
+  const error = new Error(message);
+  error.code = code;
+  error.hint = hint;
+  error.details = details;
+  error.retryable = retryable;
+  error.status = status;
+  return error;
+}
+
+function guiPortFilePath() {
+  return path.join(BACKLOG, GUI_PORT_FILE);
+}
+
+function hashCwdToPort(cwd = process.cwd()) {
+  let hash = 0;
+  const input = String(cwd);
+  for (let i = 0; i < input.length; i++) {
+    hash = ((hash << 5) - hash + input.charCodeAt(i)) | 0;
+  }
+  return GUI_PORT_MIN + (Math.abs(hash) % GUI_PORT_SPAN);
+}
+
+function normalizeGuiPort(value) {
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed) || parsed < 1 || parsed > 65535) {
+    return null;
+  }
+  return parsed;
+}
+
+function resolvePreferredGuiPort(explicitPort) {
+  if (explicitPort !== undefined && explicitPort !== null && explicitPort !== '') {
+    const fromArg = normalizeGuiPort(explicitPort);
+    if (fromArg) return fromArg;
+  }
+
+  const fromEnv = normalizeGuiPort(process.env.KANBANGO_GUI_PORT);
+  if (fromEnv) return fromEnv;
+
+  return hashCwdToPort(process.cwd());
+}
+
+function isPidAlive(pid) {
+  const n = Number.parseInt(pid, 10);
+  if (!Number.isFinite(n) || n <= 0) return false;
+  try {
+    process.kill(n, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function ensureBacklogDir() {
+  await fs.mkdir(BACKLOG, { recursive: true });
+}
+
+async function writeGuiPortFile({ port, pid = process.pid } = {}) {
+  const normalizedPort = normalizeGuiPort(port);
+  if (!normalizedPort) {
+    throw createGuiError(
+      'VALIDATION_ERROR',
+      'Invalid GUI port',
+      'Use an integer between 1 and 65535',
+      { port },
+      false,
+      400
+    );
+  }
+
+  await ensureBacklogDir();
+  const data = {
+    port: normalizedPort,
+    pid,
+    url: `http://localhost:${normalizedPort}`,
+    cwd: process.cwd(),
+    started_at: new Date().toISOString()
+  };
+  await fs.writeFile(guiPortFilePath(), JSON.stringify(data, null, 2), 'utf-8');
+  return data;
+}
+
+async function readGuiPortFile() {
+  try {
+    const raw = await fs.readFile(guiPortFilePath(), 'utf-8');
+    const data = JSON.parse(raw);
+    if (!data || !normalizeGuiPort(data.port)) return null;
+    return data;
+  } catch (error) {
+    if (error.code === 'ENOENT') return null;
+    return null;
+  }
+}
+
+async function clearGuiPortFile({ pid, force = false } = {}) {
+  const info = await readGuiPortFile();
+  if (!info) return false;
+  if (!force && pid !== undefined && info.pid !== pid) return false;
+  if (!force && pid === undefined && info.pid !== process.pid) return false;
+
+  try {
+    await fs.unlink(guiPortFilePath());
+    return true;
+  } catch (error) {
+    if (error.code === 'ENOENT') return false;
+    throw error;
+  }
+}
+
+async function discoverRunningGui() {
+  const info = await readGuiPortFile();
+  if (!info || !isPidAlive(info.pid)) {
+    if (info) await clearGuiPortFile({ force: true });
+    return null;
+  }
+  return {
+    status: 'running',
+    port: info.port,
+    pid: info.pid,
+    url: info.url || `http://localhost:${info.port}`,
+    cwd: info.cwd,
+    started_at: info.started_at
+  };
+}
+
+module.exports = {
+  hashCwdToPort,
+  normalizeGuiPort,
+  resolvePreferredGuiPort,
+  isPidAlive,
+  writeGuiPortFile,
+  readGuiPortFile,
+  clearGuiPortFile,
+  discoverRunningGui,
+  guiPortFilePath,
+  GUI_PORT_MIN,
+  GUI_PORT_MAX
+};

package/index.html

@@ -529,29 +529,34 @@ const COL_DEFS = [
   { id: "done",    label: "✅ Done",    icon: "✅" },
 ];
 
-let allEpics   = [];
+let allTasks   = [];
+let allEpicEntities = [];
 let colCounts  = {};
 let collapsed  = new Set();
 let expanded   = new Set();
 let editingId  = null;
-let dirtyEdits = {}; // epicId -> editable task draft
+let dirtyEdits = {}; // taskId -> editable task draft
 
 // ── Load & render ─────────────────────────────────────────────────────────────
 
 async function load() {
-  const res = await fetch("/api/board");
-  allEpics = await res.json();
+  const [boardRes, epicsRes] = await Promise.all([
+    fetch("/api/board"),
+    fetch("/api/epics")
+  ]);
+  allTasks = await boardRes.json();
+  allEpicEntities = epicsRes.ok ? await epicsRes.json() : [];
   render();
 }
 
 function render() {
   colCounts = {};
   COL_DEFS.forEach(c => (colCounts[c.id] = 0));
-  allEpics.forEach(e => { if (colCounts[e.column] !== undefined) colCounts[e.column]++; });
+  allTasks.forEach(e => { if (colCounts[e.column] !== undefined) colCounts[e.column]++; });
 
   // Header stats
-  const total = allEpics.length;
-  const done  = allEpics.filter(e => e.column === "done").length;
+  const total = allTasks.length;
+  const done  = allTasks.filter(e => e.column === "done").length;
   document.getElementById("hstats").textContent = `${done}/${total} done`;
 
   // Col headers
@@ -567,59 +572,82 @@ function render() {
   // Swimlanes
   const sl = document.getElementById("swimlanes");
   sl.innerHTML = "";
-  groupEpics(allEpics).forEach(g => sl.appendChild(renderSwimlane(g)));
+  groupTasks(allTasks).forEach(g => sl.appendChild(renderSwimlane(g)));
 }
 
-function groupEpics(epics) {
+function groupTasks(tasks) {
   const map = new Map();
-  epics.forEach(e => {
-    const g = e.epic_group || "—";
-    if (!map.has(g)) map.set(g, []);
-    map.get(g).push(e);
+  tasks.forEach(t => {
+    const key = t.epic_id || "—";
+    if (!map.has(key)) map.set(key, []);
+    map.get(key).push(t);
   });
-  // Sort: known phases first, "—" last
   return [...map.entries()]
     .sort(([a], [b]) => a === "—" ? 1 : b === "—" ? -1 : a.localeCompare(b, "pl"))
-    .map(([name, epics]) => ({ name, epics }));
+    .map(([key, laneTasks]) => {
+      const entity = allEpicEntities.find(e => e.id === key);
+      const name = key === "—"
+        ? "—"
+        : (entity ? entity.title : (laneTasks[0] && laneTasks[0].epic_group) || key);
+      return {
+        key,
+        name,
+        epicId: key === "—" ? null : key,
+        status: entity ? entity.status : null,
+        description: entity ? entity.description : "",
+        goals: entity ? entity.goals : "",
+        tasks: laneTasks
+      };
+    });
 }
 
 // ── Swimlane ──────────────────────────────────────────────────────────────────
 
-function renderSwimlane({ name, epics }) {
-  const isCollapsed = collapsed.has(name);
+function renderSwimlane({ key, name, epicId, status, description, goals, tasks }) {
+  const isCollapsed = collapsed.has(key);
 
   const wrap = el("div", "swimlane");
 
   // Header
   const hdr = el("div", `sl-header${isCollapsed ? " collapsed" : ""}`);
-  const totalTasks = epics.reduce((s, e) => s + e.subtasks.length, 0);
-  const doneTasks  = epics.reduce((s, e) => s + e.subtasks.filter(t => t.done).length, 0);
+  const totalTasks = tasks.reduce((s, e) => s + (e.subtasks || []).length, 0);
+  const doneTasks  = tasks.reduce((s, e) => s + (e.subtasks || []).filter(t => t.done).length, 0);
   const pct = totalTasks > 0 ? Math.round(doneTasks / totalTasks * 100) : null;
+  const cardsDone = tasks.filter(t => t.column === "done").length;
+  const statusBadge = status ? `<span class="sl-cnt" title="derived status">${escHtml(status)}</span>` : "";
 
   hdr.innerHTML = `
     <span class="sl-arrow">▼</span>
-    <span class="sl-name">${escHtml(name === "—" ? "Uncategorized (no epic)" : name)}</span>
-    <span class="sl-cnt">${epics.length}</span>
-    ${pct !== null ? `<span class="sl-progress" style="margin-left:auto">${pct}% tasks done</span>` : ""}
+    <span class="sl-name">${escHtml(name === "—" ? "Uncategorized (no epic)" : name)}${epicId ? ` <small style="opacity:.6">${escHtml(epicId)}</small>` : ""}</span>
+    <span class="sl-cnt">${tasks.length} cards · ${cardsDone} done</span>
+    ${statusBadge}
+    ${pct !== null ? `<span class="sl-progress" style="margin-left:auto">${pct}% subtasks</span>` : ""}
   `;
   hdr.onclick = () => {
-    if (collapsed.has(name)) collapsed.delete(name);
-    else collapsed.add(name);
+    if (collapsed.has(key)) collapsed.delete(key);
+    else collapsed.add(key);
     render();
   };
   wrap.appendChild(hdr);
 
+  if (!isCollapsed && (description || goals)) {
+    const meta = el("div", "sl-body");
+    meta.style.cssText = "display:block;padding:6px 12px 0;font-size:12px;opacity:.85";
+    meta.innerHTML = `${goals ? `<div><strong>Goals:</strong> ${escHtml(goals)}</div>` : ""}${description ? `<div>${escHtml(description)}</div>` : ""}`;
+    wrap.appendChild(meta);
+  }
+
   // Body
   const body = el("div", `sl-body${isCollapsed ? " hidden" : ""}`);
   COL_DEFS.forEach(col => {
     const lane = el("div", `lane col-${col.id}`);
-    epics.filter(e => e.column === col.id).forEach(e => lane.appendChild(renderCard(e, col.id)));
+    tasks.filter(e => e.column === col.id).forEach(e => lane.appendChild(renderCard(e, col.id)));
     // Add button only in non-done columns
     if (col.id !== "done") {
       const addBtn = document.createElement("button");
       addBtn.className = "lane-add";
       addBtn.textContent = "+ Add here";
-      addBtn.onclick = e => { e.stopPropagation(); showLaneAdd(lane, col.id, name, addBtn); };
+      addBtn.onclick = e => { e.stopPropagation(); showLaneAdd(lane, col.id, epicId || name, addBtn); };
       lane.appendChild(addBtn);
     }
     body.appendChild(lane);
@@ -931,7 +959,7 @@ async function saveEdit(epicId) {
   if (!dirty) { editingId = null; render(); return; }
 
   const body = {};
-  const epic = allEpics.find(e => e.id === epicId);
+  const epic = allTasks.find(e => e.id === epicId);
   if (epic) {
     const origTitle = epic.title.replace(/^[\w.-]+:\s*/, "");
     if (dirty.title !== origTitle) body.title = dirty.title;
@@ -1007,13 +1035,15 @@ function showLaneAdd(lane, colId, groupName, addBtn) {
     if (!title) return;
     inp.disabled = true;
     description.disabled = true;
-    const res = await fetch("/api/epics", {
+    const epicRef = groupName === "—" ? "" : groupName;
+    const res = await fetch("/api/tasks", {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({
         title,
         column: colId,
-        epic_group: groupName === "—" ? "" : groupName,
+        epic: epicRef,
+        epic_id: epicRef && /^E\d+/i.test(epicRef) ? epicRef : undefined,
         description: description.value.trim()
       }),
     });
@@ -1058,10 +1088,10 @@ async function submitNew() {
   const group = document.getElementById("ne-group").value.trim();
   if (!title) { document.getElementById("ne-title").focus(); return; }
 
-  const res = await fetch("/api/epics", {
+  const res = await fetch("/api/tasks", {
     method: "POST",
     headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ title, column: col, epic_group: group || "—" }),
+    body: JSON.stringify({ title, column: col, epic: group || "—" }),
   });
   if (res.ok) {
     toast("Task added ✓");

package/index.js

@@ -10,8 +10,12 @@
 
 const kanban = require('./kanban.js');
 const plan = require('./plan.js');
+const guiRegistry = require('./gui-registry.js');
+const playbook = require('./agent-playbook.js');
 
 module.exports = {
   kanban,
   plan,
+  guiRegistry,
+  playbook,
 };