kanbango 3.6.2 → 5.1.0

package/bin/kanban.js

@@ -3,6 +3,7 @@
 const kanban = require('../kanban.js');
 const plan = require('../plan.js');
 const guiRegistry = require('../gui-registry.js');
+const configWizard = require('../config-wizard.js');
 const http = require('http');
 const fs = require('fs');
 const path = require('path');
@@ -10,6 +11,8 @@ const crypto = require('crypto');
 
 const BACKLOG = path.join(process.cwd(), 'backlog');
 const AGENT_MANIFEST = '.kanbango-agents.json';
+const PLUGIN_MANIFEST = '.kanbango-plugins.json';
+const OPENCODE_PLUGIN_FILES = ['tui-kanban.tsx', 'tui-kanban-controller.js'];
 
 function shortId(taskId) {
   const match = taskId.match(/^(?:[A-Z]+-)?(\d+)/);
@@ -89,7 +92,7 @@ function sendError(res, error) {
   });
 }
 
-async function cliInit() {
+async function cliInit(options = {}) {
   await kanban.ensureBacklogDir();
   const readme = path.join(BACKLOG, 'README.md');
 
@@ -101,36 +104,66 @@ async function cliInit() {
         + '- `active/`  — w trakcie (max 1-2)\n'
         + '- `planned/` — zaplanowane\n'
         + '- `icebox/`  — zamrozone / nice-to-have\n'
-        + '- `testing/` — bramka QA (async agent)\n'
-        + '- `review/`  — bramka review / Temida (async agent)\n'
+        + '- `testing/` — bramka QA (async agent; optional via kanbango.json)\n'
+        + '- `review/`  — bramka review / Temida (optional via kanbango.json)\n'
         + '- `done/`    — ukonczone\n'
-        + '- `epics/`   — first-class epic containers (context for initiatives)\n',
+        + '- `epics/`   — first-class epic containers (context for initiatives)\n'
+        + '- `kanbango.json` — optional project config (columns + workflow agents)\n',
       'utf-8'
     );
   }
 
   console.log(`✓ Backlog w: ${BACKLOG}`);
+  if (options.opencode) {
+    const cwd = process.cwd();
+    await copyOpenCodeAgents(cwd, options.force);
+    await copyOpenCodePlugins(cwd, options.force);
+  }
+  await configWizard.maybeCreateConfigOnInit({ cwd: process.cwd() });
+}
+
+function exitConfigError(error) {
+  console.error(`✗ ${error.message}`);
+  if (error.hint) console.error(`  ${error.hint}`);
+  process.exit(1);
+}
+
+async function cliConfig() {
+  try {
+    await kanban.ensureBacklogDir();
+    await configWizard.runConfigCommand({ cwd: process.cwd() });
+  } catch (error) {
+    if (error && (error.code === 'NOT_TTY' || error.code === 'CONFIG_INVALID')) {
+      exitConfigError(error);
+    }
+    throw error;
+  }
 }
 
 function sha256Hex(content) {
   return crypto.createHash('sha256').update(content).digest('hex');
 }
 
-async function readAgentManifest(destDir) {
-  const manifestPath = path.join(destDir, AGENT_MANIFEST);
+function emptyCopyStats() {
+  return { written: 0, updated: 0, unchanged: 0, skipped: 0, conflict: 0 };
+}
+
+function hashesFromManifest(parsed, hashesKey) {
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return {};
+  const nested = parsed[hashesKey];
+  const hashes = nested && typeof nested === 'object' && !Array.isArray(nested) ? nested : parsed;
+  const out = {};
+  for (const [name, value] of Object.entries(hashes)) {
+    if (typeof value === 'string' && value) out[name] = value;
+    else if (value && typeof value.hash === 'string' && value.hash) out[name] = value.hash;
+  }
+  return out;
+}
+
+async function readTrackedManifest(destDir, manifestName, hashesKey) {
+  const manifestPath = path.join(destDir, manifestName);
   try {
-    const raw = await fs.promises.readFile(manifestPath, 'utf-8');
-    const parsed = JSON.parse(raw);
-    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return {};
-    const agents = parsed.agents && typeof parsed.agents === 'object' && !Array.isArray(parsed.agents)
-      ? parsed.agents
-      : parsed;
-    const out = {};
-    for (const [name, value] of Object.entries(agents)) {
-      if (typeof value === 'string' && value) out[name] = value;
-      else if (value && typeof value.hash === 'string' && value.hash) out[name] = value.hash;
-    }
-    return out;
+    return hashesFromManifest(JSON.parse(await fs.promises.readFile(manifestPath, 'utf-8')), hashesKey);
   } catch (error) {
     if (error.code === 'ENOENT') return {};
     if (error instanceof SyntaxError) return {};
@@ -138,16 +171,79 @@ async function readAgentManifest(destDir) {
   }
 }
 
-async function writeAgentManifest(destDir, hashes) {
-  const manifestPath = path.join(destDir, AGENT_MANIFEST);
+async function writeTrackedManifest(destDir, manifestName, hashesKey, hashes) {
+  const manifestPath = path.join(destDir, manifestName);
   const payload = {
     version: 1,
     updated: new Date().toISOString(),
-    agents: hashes
+    [hashesKey]: hashes
   };
   await fs.promises.writeFile(manifestPath, JSON.stringify(payload, null, 2) + '\n', 'utf-8');
 }
 
+function logTrackedSkip(logPrefix, name, recorded, destHash) {
+  if (recorded && destHash !== recorded) {
+    console.log(`• Konflikt ${logPrefix}/${name} (lokalna edycja; użyj --force aby nadpisać)`);
+    return;
+  }
+  console.log(`• Pominięto ${logPrefix}/${name} (lokalna kopia różni się od paczki; użyj --force)`);
+}
+
+async function syncTrackedFile({ srcPath, destPath, name, force, logPrefix, recorded }) {
+  const srcContent = await fs.promises.readFile(srcPath, 'utf-8');
+  const srcHash = sha256Hex(srcContent);
+  if (!fs.existsSync(destPath)) {
+    await fs.promises.writeFile(destPath, srcContent, 'utf-8');
+    console.log(`✓ Skopiowano ${logPrefix}/${name}`);
+    return { kind: 'written', hash: srcHash };
+  }
+  const destHash = sha256Hex(await fs.promises.readFile(destPath, 'utf-8'));
+  if (destHash === srcHash) {
+    console.log(`• Bez zmian ${logPrefix}/${name}`);
+    return { kind: 'unchanged', hash: srcHash };
+  }
+  if (force || (recorded && destHash === recorded)) {
+    const reason = force ? '(--force)' : '(nowa wersja w paczce)';
+    await fs.promises.writeFile(destPath, srcContent, 'utf-8');
+    console.log(`✓ Zaktualizowano ${logPrefix}/${name} ${reason}`);
+    return { kind: 'updated', hash: srcHash };
+  }
+  logTrackedSkip(logPrefix, name, recorded, destHash);
+  return { kind: 'conflict', hash: null };
+}
+
+async function copyTrackedFiles(options) {
+  const { srcDir, destDir, names, force, logPrefix, manifestName, hashesKey } = options;
+  const stats = emptyCopyStats();
+  if (!names || names.length === 0) return stats;
+
+  await fs.promises.mkdir(destDir, { recursive: true });
+  const prevHashes = await readTrackedManifest(destDir, manifestName, hashesKey);
+  const nextHashes = { ...prevHashes };
+
+  for (const name of names) {
+    const result = await syncTrackedFile({
+      srcPath: path.join(srcDir, name),
+      destPath: path.join(destDir, name),
+      name,
+      force,
+      logPrefix,
+      recorded: prevHashes[name] || null
+    });
+    if (result.hash) nextHashes[name] = result.hash;
+    if (result.kind === 'written') stats.written += 1;
+    else if (result.kind === 'updated') stats.updated += 1;
+    else if (result.kind === 'unchanged') stats.unchanged += 1;
+    else {
+      stats.conflict += 1;
+      stats.skipped += 1;
+    }
+  }
+
+  await writeTrackedManifest(destDir, manifestName, hashesKey, nextHashes);
+  return stats;
+}
+
 async function copyOpenCodeAgents(cwd, force) {
   const srcDir = path.join(__dirname, '..', 'agents');
   const destDir = path.join(cwd, '.opencode', 'agent');
@@ -155,84 +251,37 @@ async function copyOpenCodeAgents(cwd, force) {
   try {
     names = (await fs.promises.readdir(srcDir)).filter((f) => f.endsWith('.md'));
   } catch (error) {
-    if (error.code === 'ENOENT') return { written: 0, updated: 0, unchanged: 0, skipped: 0, conflict: 0 };
+    if (error.code === 'ENOENT') return emptyCopyStats();
     throw error;
   }
-  await fs.promises.mkdir(destDir, { recursive: true });
-  const prevHashes = await readAgentManifest(destDir);
-  const nextHashes = { ...prevHashes };
-  let written = 0;
-  let updated = 0;
-  let unchanged = 0;
-  let skipped = 0;
-  let conflict = 0;
-
-  for (const name of names) {
-    const srcPath = path.join(srcDir, name);
-    const destPath = path.join(destDir, name);
-    const srcContent = await fs.promises.readFile(srcPath, 'utf-8');
-    const srcHash = sha256Hex(srcContent);
-    const destExists = fs.existsSync(destPath);
-
-    if (!destExists) {
-      await fs.promises.writeFile(destPath, srcContent, 'utf-8');
-      nextHashes[name] = srcHash;
-      written += 1;
-      console.log(`✓ Skopiowano .opencode/agent/${name}`);
-      continue;
-    }
-
-    const destContent = await fs.promises.readFile(destPath, 'utf-8');
-    const destHash = sha256Hex(destContent);
-    const recorded = prevHashes[name] || null;
-
-    if (force) {
-      if (destHash === srcHash) {
-        nextHashes[name] = srcHash;
-        unchanged += 1;
-        console.log(`• Bez zmian .opencode/agent/${name}`);
-      } else {
-        await fs.promises.writeFile(destPath, srcContent, 'utf-8');
-        nextHashes[name] = srcHash;
-        updated += 1;
-        console.log(`✓ Zaktualizowano .opencode/agent/${name} (--force)`);
-      }
-      continue;
-    }
-
-    // Local copy already matches package source.
-    if (destHash === srcHash) {
-      nextHashes[name] = srcHash;
-      unchanged += 1;
-      console.log(`• Bez zmian .opencode/agent/${name}`);
-      continue;
-    }
-
-    // Clean packaged copy from an older version → safe auto-update.
-    if (recorded && destHash === recorded && recorded !== srcHash) {
-      await fs.promises.writeFile(destPath, srcContent, 'utf-8');
-      nextHashes[name] = srcHash;
-      updated += 1;
-      console.log(`✓ Zaktualizowano .opencode/agent/${name} (nowa wersja w paczce)`);
-      continue;
-    }
+  return copyTrackedFiles({
+    srcDir,
+    destDir,
+    names,
+    force,
+    logPrefix: '.opencode/agent',
+    manifestName: AGENT_MANIFEST,
+    hashesKey: 'agents'
+  });
+}
 
-    // Local edit (or legacy copy without matching manifest) → do not overwrite.
-    conflict += 1;
-    skipped += 1;
-    if (recorded && destHash !== recorded) {
-      console.log(
-        `• Konflikt .opencode/agent/${name} (lokalna edycja; użyj --force aby nadpisać)`
-      );
-    } else {
-      console.log(
-        `• Pominięto .opencode/agent/${name} (lokalna kopia różni się od paczki; użyj --force)`
-      );
-    }
+async function copyOpenCodePlugins(cwd, force) {
+  const srcDir = path.join(__dirname, '..', 'plugins');
+  const destDir = path.join(cwd, '.opencode', 'plugins');
+  const names = [];
+  for (const name of OPENCODE_PLUGIN_FILES) {
+    if (fs.existsSync(path.join(srcDir, name))) names.push(name);
   }
-
-  await writeAgentManifest(destDir, nextHashes);
-  return { written, updated, unchanged, skipped, conflict };
+  if (names.length === 0) return emptyCopyStats();
+  return copyTrackedFiles({
+    srcDir,
+    destDir,
+    names,
+    force,
+    logPrefix: '.opencode/plugins',
+    manifestName: PLUGIN_MANIFEST,
+    hashesKey: 'plugins'
+  });
 }
 
 async function cliMcpInit(options) {
@@ -267,17 +316,34 @@ async function cliMcpInit(options) {
     }
   }
 
-  // OpenCode agents ship with the package; Claude path does not get them.
+  // OpenCode agents and TUI plugin ship with the package; Claude path does not get them.
   if (!onlyClaude) {
     await copyOpenCodeAgents(cwd, force);
+    await copyOpenCodePlugins(cwd, force);
   }
 
   if (!force) {
     console.log('  (użyj --force, aby nadpisać istniejące pliki)');
   }
+
+  await kanban.ensureBacklogDir();
+  await configWizard.maybeCreateConfigOnInit({ cwd });
+}
+
+async function ensureProjectConfig() {
+  try {
+    await require('../workflow.js').ensureBoardConfig();
+  } catch (error) {
+    if (error && error.code === 'CONFIG_INVALID') {
+      console.error(`✗ ${error.message}`);
+      process.exit(1);
+    }
+    throw error;
+  }
 }
 
 async function cliList(colFilter, epicFilter, asJson, listOptions = {}) {
+  await ensureProjectConfig();
   await kanban.migrateEpicGroups();
   const epics = await kanban.listEpicEntities();
   let tasks = await kanban.allTasks();
@@ -288,7 +354,7 @@ async function cliList(colFilter, epicFilter, asJson, listOptions = {}) {
   if (epicFilter) {
     tasks = tasks.filter((task) => kanban.taskMatchesEpicFilter(task, epicFilter));
   } else {
-    tasks = kanban.filterTasksForList(tasks, epics, listOptions);
+    tasks = kanban.filterTasksForList(tasks, epics, { ...listOptions, col: colFilter });
   }
 
   if (asJson) {
@@ -316,6 +382,7 @@ async function cliList(colFilter, epicFilter, asJson, listOptions = {}) {
 
 async function cliShow(taskId) {
   try {
+    await ensureProjectConfig();
     const task = await kanban.getTask(taskId);
     console.log(`ID:      ${shortId(task.id)}`);
     console.log(`Plik:    ${taskFilePath(task)}`);
@@ -343,6 +410,7 @@ async function cliShow(taskId) {
 }
 
 async function cliEpicList(asJson, listOptions = {}) {
+  await ensureProjectConfig();
   await kanban.migrateEpicGroups();
   const tasks = await kanban.allTasks();
   const epics = await kanban.listEpicEntities();
@@ -437,17 +505,19 @@ async function cliDelete(taskId) {
 }
 
 async function cliMove(taskId, column) {
-  const success = await kanban.doMove(taskId, column);
-  if (success) {
+  try {
+    await ensureProjectConfig();
+    await kanban.updateTask(taskId, { column });
     console.log(`✓ ${shortId(taskId)} → ${column}`);
-  } else {
-    console.error(`✗ Nie znaleziono: ${taskId}`);
+  } catch (error) {
+    console.error(`✗ ${error.message}`);
     process.exit(1);
   }
 }
 
 async function cliAdd(title, column, epicGroup) {
   try {
+    await ensureProjectConfig();
     const task = await kanban.doCreate(title, column, epicGroup);
     console.log(`✓ Utworzono ${shortId(task.id)} w ${column}  [${task.epic_group}]`);
     console.log(`  Plik: ${taskFilePath(task)}`);
@@ -508,215 +578,232 @@ function logGuiPortCleanupError(err) {
   }
 }
 
-async function serveWeb(port) {
-  const htmlTemplate = fs.readFileSync(path.join(__dirname, '..', 'index.html'), 'utf-8');
-  const project = guiRegistry.projectLabel();
-  const html = injectProjectIntoHtml(htmlTemplate, project);
+function taskCreateExtra(body) {
+  return {
+    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,
+    adr: body.adr,
+    evidence: body.evidence,
+    depends_on: body.depends_on,
+    files: body.files
+  };
+}
 
-  const server = http.createServer(async (req, res) => {
-    const url = new URL(req.url, `http://localhost:${port}`);
-    const requestPath = decodeURIComponent(url.pathname);
+function taskCreateRef(body) {
+  return body.epic_id || body.epic || body.epic_group || '—';
+}
 
-    try {
-      if (requestPath === '/' || requestPath === '/index.html') {
-        res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
-        res.end(html);
-        return;
-      }
+function taskPatchFromBody(body) {
+  const patch = body.patch ? { ...body.patch } : {};
+  const keys = [
+    'title', 'description', 'specs', 'in_scope', 'out_of_scope',
+    'acceptance_criteria', 'test_cases', 'subtasks', 'notes', 'adr', 'evidence'
+  ];
+  for (const key of keys) {
+    if (body[key] !== undefined) patch[key] = body[key];
+  }
+  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;
+  return patch;
+}
 
-      if (req.method === 'GET' && sendVendorFile(res, requestPath)) {
-        return;
-      }
+async function handleGuiGet(req, res, url, requestPath, html) {
+  if (requestPath === '/' || requestPath === '/index.html') {
+    res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+    res.end(html);
+    return true;
+  }
+  if (sendVendorFile(res, requestPath)) return true;
 
-      if (requestPath === '/api/board') {
-        await kanban.migrateEpicGroups();
-        const includeArchived = url.searchParams.get('include_archived') === 'true';
-        const epics = await kanban.listEpicEntities();
-        // GUI: show done-epic tasks; only hide archived unless toggled
-        const tasks = kanban.filterTasksForList(await kanban.allTasks(), epics, {
-          live_only: false,
-          include_archived: includeArchived
-        });
-        sendJson(res, 200, tasks);
-        return;
-      }
+  if (requestPath === '/api/config') {
+    const workflow = require('../workflow.js');
+    const config = await workflow.ensureBoardConfig();
+    sendJson(res, 200, workflow.shapePublicConfig(config));
+    return true;
+  }
 
-      if (requestPath === '/api/epics' && req.method === 'GET') {
-        await kanban.migrateEpicGroups();
-        const tasks = await kanban.allTasks();
-        const epics = await kanban.listEpicEntities();
-        const shaped = epics.map((epic) => kanban.shapeEpic(epic, tasks, { view: 'full' }));
-        const includeArchived = url.searchParams.get('include_archived') === 'true';
-        const includeDone = url.searchParams.get('include_done') === 'true';
-        const status = url.searchParams.get('status') || undefined;
-        // GUI default: all non-archived (live + done). Agents use MCP live-only.
-        const liveOnly = url.searchParams.get('live_only') === 'true';
-        const filtered = kanban.filterShapedEpics(shaped, liveOnly
-          ? { include_archived: includeArchived, include_done: includeDone, status }
-          : { live_only: false, include_archived: includeArchived, status });
-        sendJson(res, 200, filtered);
-        return;
-      }
+  if (requestPath === '/api/board') {
+    await require('../workflow.js').ensureBoardConfig();
+    await kanban.migrateEpicGroups();
+    const includeArchived = url.searchParams.get('include_archived') === 'true';
+    const epics = await kanban.listEpicEntities();
+    const allBoardTasks = await kanban.allTasks();
+    const tasks = kanban.filterTasksForList(allBoardTasks, epics, {
+      live_only: false,
+      include_archived: includeArchived
+    });
+    const boardFields = ['id'].concat(kanban.VIEW_FIELDS.full);
+    sendJson(res, 200, tasks.map((task) => kanban.shapeTask(task, {
+      fields: boardFields,
+      allTasks: allBoardTasks
+    })));
+    return true;
+  }
 
-      if (requestPath === '/api/epics' && req.method === 'POST') {
-        const body = await readBody(req);
-        // 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,
-            adr: body.adr,
-            evidence: body.evidence
-          }
-        );
-        sendJson(res, 201, task);
-        return;
-      }
+  if (requestPath === '/api/context') {
+    await require('../workflow.js').ensureBoardConfig();
+    await kanban.migrateEpicGroups();
+    sendJson(res, 200, await kanban.getContextPayload());
+    return true;
+  }
 
-      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,
-            adr: body.adr,
-            evidence: body.evidence
-          }
-        );
-        sendJson(res, 201, task);
-        return;
-      }
+  if (requestPath === '/api/epics') {
+    await require('../workflow.js').ensureBoardConfig();
+    await kanban.migrateEpicGroups();
+    const tasks = await kanban.allTasks();
+    const epics = await kanban.listEpicEntities();
+    const shaped = epics.map((epic) => kanban.shapeEpic(epic, tasks, { view: 'full' }));
+    const includeArchived = url.searchParams.get('include_archived') === 'true';
+    const includeDone = url.searchParams.get('include_done') === 'true';
+    const status = url.searchParams.get('status') || undefined;
+    const liveOnly = url.searchParams.get('live_only') === 'true';
+    const filtered = kanban.filterShapedEpics(shaped, liveOnly
+      ? { include_archived: includeArchived, include_done: includeDone, status }
+      : { live_only: false, include_archived: includeArchived, status });
+    sendJson(res, 200, filtered);
+    return true;
+  }
 
-      if (req.method === 'DELETE') {
-        const epicDeleteMatch = requestPath.match(/^\/api\/epic-entities\/([^/]+)$/);
-        if (epicDeleteMatch) {
-          const result = await kanban.deleteEpic(epicDeleteMatch[1]);
-          sendJson(res, 200, result);
-          return;
-        }
-
-        const taskDeleteMatch = requestPath.match(/^\/api\/(?:epics|tasks)\/([^/]+)$/);
-        if (taskDeleteMatch) {
-          const result = await kanban.deleteTask(taskDeleteMatch[1]);
-          sendJson(res, 200, result);
-          return;
-        }
-      }
+  return false;
+}
 
-      if (req.method === 'POST') {
-        const epicArchiveMatch = requestPath.match(/^\/api\/epic-entities\/([^/]+)\/(archive|unarchive)$/);
-        if (epicArchiveMatch) {
-          const epic = epicArchiveMatch[2] === 'archive'
-            ? await kanban.archiveEpic(epicArchiveMatch[1])
-            : await kanban.unarchiveEpic(epicArchiveMatch[1]);
-          sendJson(res, 200, kanban.shapeEpic(epic, await kanban.allTasks(), { view: 'full' }));
-          return;
-        }
-      }
+async function createTaskFromBody(body) {
+  return kanban.doCreate(
+    body.title || '',
+    body.column || 'planned',
+    taskCreateRef(body),
+    taskCreateExtra(body)
+  );
+}
 
-      if (req.method === 'PATCH') {
-        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);
-          const task = await kanban.updateTask(taskId, { column: body.column || '' });
-          sendJson(res, 200, task);
-          return;
-        }
-
-        const toggleMatch = requestPath.match(/^\/api\/(?:epics|tasks)\/([^/]+)\/tasks\/(\d+)$/);
-        if (toggleMatch) {
-          const taskId = toggleMatch[1];
-          const idx = parseInt(toggleMatch[2], 10);
-          const current = await kanban.getTask(taskId);
-          if (idx < 0 || idx >= current.subtasks.length) {
-            throw kanban.createKanbanError(
-              'INVALID_SUBTASK_INDEX',
-              `Subtask index ${idx} is not valid for task ${taskId}`,
-              'Read the task first and use an index between 0 and subtasks.length - 1',
-              { task_id: taskId, idx, total_subtasks: current.subtasks.length },
-              false,
-              400
-            );
-          }
-
-          const subtasks = current.subtasks.map((subtask, subtaskIdx) => ({
-            ...subtask,
-            done: subtaskIdx === idx ? !subtask.done : subtask.done
-          }));
-          const task = await kanban.updateTask(taskId, { subtasks });
-          sendJson(res, 200, task);
-          return;
-        }
-
-        const updateMatch = requestPath.match(/^\/api\/(?:epics|tasks)\/([^/]+)$/);
-        if (updateMatch) {
-          const taskId = updateMatch[1];
-          const body = await readBody(req);
-          const patch = body.patch ? { ...body.patch } : {};
-
-          if (body.title !== undefined) patch.title = body.title;
-          if (body.description !== undefined) patch.description = body.description;
-          if (body.specs !== undefined) patch.specs = body.specs;
-          if (body.in_scope !== undefined) patch.in_scope = body.in_scope;
-          if (body.out_of_scope !== undefined) patch.out_of_scope = body.out_of_scope;
-          if (body.acceptance_criteria !== undefined) patch.acceptance_criteria = body.acceptance_criteria;
-          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.adr !== undefined) patch.adr = body.adr;
-          if (body.evidence !== undefined) patch.evidence = body.evidence;
-          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);
-          return;
-        }
-      }
+async function handleGuiPost(req, res, requestPath) {
+  if (requestPath === '/api/epics') {
+    await require('../workflow.js').ensureBoardConfig();
+    const body = await readBody(req);
+    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 true;
+    }
+    sendJson(res, 201, await createTaskFromBody(body));
+    return true;
+  }
 
-      sendJson(res, 404, { error: { code: 'NOT_FOUND', message: 'Route not found' } });
+  if (requestPath === '/api/tasks') {
+    await require('../workflow.js').ensureBoardConfig();
+    sendJson(res, 201, await createTaskFromBody(await readBody(req)));
+    return true;
+  }
+
+  const epicArchiveMatch = requestPath.match(/^\/api\/epic-entities\/([^/]+)\/(archive|unarchive)$/);
+  if (epicArchiveMatch) {
+    const epic = epicArchiveMatch[2] === 'archive'
+      ? await kanban.archiveEpic(epicArchiveMatch[1])
+      : await kanban.unarchiveEpic(epicArchiveMatch[1]);
+    sendJson(res, 200, kanban.shapeEpic(epic, await kanban.allTasks(), { view: 'full' }));
+    return true;
+  }
+
+  return false;
+}
+
+async function handleGuiDelete(res, requestPath) {
+  const epicDeleteMatch = requestPath.match(/^\/api\/epic-entities\/([^/]+)$/);
+  if (epicDeleteMatch) {
+    sendJson(res, 200, await kanban.deleteEpic(epicDeleteMatch[1]));
+    return true;
+  }
+  const taskDeleteMatch = requestPath.match(/^\/api\/(?:epics|tasks)\/([^/]+)$/);
+  if (taskDeleteMatch) {
+    sendJson(res, 200, await kanban.deleteTask(taskDeleteMatch[1]));
+    return true;
+  }
+  return false;
+}
+
+async function handleGuiPatch(req, res, requestPath) {
+  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 true;
+  }
+
+  const moveMatch = requestPath.match(/^\/api\/(?:epics|tasks)\/([^/]+)\/move$/);
+  if (moveMatch) {
+    await require('../workflow.js').ensureBoardConfig();
+    const body = await readBody(req);
+    sendJson(res, 200, await kanban.updateTask(moveMatch[1], { column: body.column || '' }));
+    return true;
+  }
+
+  const toggleMatch = requestPath.match(/^\/api\/(?:epics|tasks)\/([^/]+)\/tasks\/(\d+)$/);
+  if (toggleMatch) {
+    const taskId = toggleMatch[1];
+    const idx = parseInt(toggleMatch[2], 10);
+    const current = await kanban.getTask(taskId);
+    if (idx < 0 || idx >= current.subtasks.length) {
+      throw kanban.createKanbanError(
+        'INVALID_SUBTASK_INDEX',
+        `Subtask index ${idx} is not valid for task ${taskId}`,
+        'Read the task first and use an index between 0 and subtasks.length - 1',
+        { task_id: taskId, idx, total_subtasks: current.subtasks.length },
+        false,
+        400
+      );
+    }
+    const subtasks = current.subtasks.map((subtask, subtaskIdx) => ({
+      ...subtask,
+      done: subtaskIdx === idx ? !subtask.done : subtask.done
+    }));
+    sendJson(res, 200, await kanban.updateTask(taskId, { subtasks }));
+    return true;
+  }
+
+  const updateMatch = requestPath.match(/^\/api\/(?:epics|tasks)\/([^/]+)$/);
+  if (updateMatch) {
+    const body = await readBody(req);
+    sendJson(res, 200, await kanban.updateTask(updateMatch[1], taskPatchFromBody(body)));
+    return true;
+  }
+
+  return false;
+}
+
+async function handleGuiRequest(req, res, url, requestPath, html) {
+  if (req.method === 'GET' && await handleGuiGet(req, res, url, requestPath, html)) return;
+  if (req.method === 'POST' && await handleGuiPost(req, res, requestPath)) return;
+  if (req.method === 'DELETE' && await handleGuiDelete(res, requestPath)) return;
+  if (req.method === 'PATCH' && await handleGuiPatch(req, res, requestPath)) return;
+  sendJson(res, 404, { error: { code: 'NOT_FOUND', message: 'Route not found' } });
+}
+
+async function serveWeb(port) {
+  const htmlTemplate = fs.readFileSync(path.join(__dirname, '..', 'index.html'), 'utf-8');
+  const project = guiRegistry.projectLabel();
+  const html = injectProjectIntoHtml(htmlTemplate, project);
+
+  const server = http.createServer(async (req, res) => {
+    const url = new URL(req.url, `http://localhost:${port}`);
+    const requestPath = decodeURIComponent(url.pathname);
+    try {
+      await handleGuiRequest(req, res, url, requestPath, html);
     } catch (error) {
       sendError(res, error);
     }
@@ -862,7 +949,15 @@ async function main() {
     const port = guiRegistry.resolvePreferredGuiPort(args[1]);
     await serveWeb(port);
   } else if (cmd === 'init') {
-    await cliInit();
+    let initOpenCode = false;
+    let initForce = false;
+    for (let i = 1; i < args.length; i++) {
+      if (args[i] === '--opencode') initOpenCode = true;
+      else if (args[i] === '--force') initForce = true;
+    }
+    await cliInit({ opencode: initOpenCode, force: initForce });
+  } else if (cmd === 'config') {
+    await cliConfig();
   } else if (cmd === 'mcp-init') {
     let useNpx = false;
     let onlyClaude = false;