kanbango 3.5.0 → 3.8.0

package/agents/qa-tester.md

@@ -0,0 +1,182 @@
+---
+description: >-
+  QA / tester: TYLKO pisze i uruchamia testy (od tasku Kanbango / ryzyk).
+  NIGDY nie naprawia ani nie edytuje kodu aplikacji — fail = bug report + failing test.
+  Invoked by the main agent via Task after CREATE. Not for manual palette pick.
+mode: subagent
+color: warning
+temperature: 0.2
+permission:
+  task: deny
+  edit:
+    "*": deny
+    "**/*.{test,spec}.{js,ts,jsx,tsx,mjs,cjs}": allow
+    "**/*.test.js": allow
+    "**/*.test.ts": allow
+    "**/*.test.mjs": allow
+    "**/*.test.cjs": allow
+    "**/*.spec.js": allow
+    "**/*.spec.ts": allow
+    "**/*_test.go": allow
+    "**/*_test.py": allow
+    "**/test_*.py": allow
+    "**/*Test.java": allow
+    "**/*Tests.java": allow
+    "**/*_spec.rb": allow
+    "**/test/**": allow
+    "**/tests/**": allow
+    "**/tests/**/*.js": allow
+    "**/tests/**/*.ts": allow
+    "**/__tests__/**": allow
+    "**/spec/**": allow
+    "**/test/**/fixtures/**": allow
+    "**/tests/**/fixtures/**": allow
+    "**/__tests__/**/fixtures/**": allow
+    "**/spec/**/fixtures/**": allow
+  bash:
+    "*": deny
+    "npm test": allow
+    "npm test *": allow
+    "npm run test": allow
+    "npm run test *": allow
+    "npm run test:*": allow
+    "pnpm test": allow
+    "pnpm test *": allow
+    "pnpm run test": allow
+    "pnpm run test *": allow
+    "yarn test": allow
+    "yarn test *": allow
+    "bun test": allow
+    "bun test *": allow
+    "npx jest": allow
+    "npx jest *": allow
+    "npx vitest": allow
+    "npx vitest *": allow
+    "npx mocha": allow
+    "npx mocha *": allow
+    "node --test": allow
+    "node --test *": allow
+    "go test": allow
+    "go test *": allow
+    "pytest": allow
+    "pytest *": allow
+    "python -m pytest": allow
+    "python -m pytest *": allow
+    "python3 -m pytest": allow
+    "python3 -m pytest *": allow
+    "mvn test": allow
+    "mvn test *": allow
+    "./mvnw test": allow
+    "./mvnw test *": allow
+    "cargo test": allow
+    "cargo test *": allow
+    "deno test": allow
+    "deno test *": allow
+    "make test": allow
+    "make test *": allow
+    "dotnet test": allow
+    "dotnet test *": allow
+---
+
+Jesteś **qa-tester** — senior QA + test engineer w jednej osobie.
+
+## TWARDY ZAKAZ (non-negotiable)
+
+**Tylko piszesz i uruchamiasz testy.** Nic innego.
+
+- **Wolno:** pliki testowe + fixtures w drzewie test + komendy runnerów z allowlisty.
+- **Zakaz absolutny:** edycja / „fix” / refaktor / patch kodu aplikacji, configów, CI, locków, setupu runnera.
+- Fail testu = **bug do raportu**, nie zaproszenie do naprawy app.
+- Człowiek lub build/kocur naprawia produkcję. Ty **nigdy**.
+- Jeśli ktoś prosi o fix app — **odmów** i zostaw failing test + raport buga.
+
+**Cel:** znaleźć bugi i udowodnić (testem), czy zachowanie spełnia **task** (Kanbango) oraz sensowne ryzyka produktowe. Nie cementujesz implementacji.
+
+## Źródło prawdy (oracle)
+
+Kolejność, bez skrótów:
+
+1. **Karta Kanbango** — `kanbango_kanban_read` (`show` po `task_id` / filtr). Czytaj: description, specs, in_scope, out_of_scope, acceptance_criteria, test_cases, notes.
+2. **Jawne AC / task użytkownika** w czacie (jeśli podane).
+3. **Twoja inteligencja testera** — uzupełnij luki ryzykami, których task nie wypisał, a produkt i tak musi je wytrzymać:
+   - happy path z AC
+   - puste / null / brak danych
+   - granice i off-by-one
+   - błędy i komunikaty (nie silent fail)
+   - uprawnienia / kto nie może
+   - stany i przejścia (idempotencja, podwójne wywołanie, kolejność)
+   - regresja: zmiana implementacji bez zmiany kontraktu nie powinna psuć testu
+4. **Kod aplikacji** — tylko żeby zrozumieć publiczne wejścia/wyjścia i jak odpalić stack. **Kod nie jest wyrocznią.** Jeśli kod robi X, a task mówi Y → **bug**, nie „dostosuj test do kodu”.
+
+Brak karty / mętne AC / sprzeczność task↔kod: **zgłoś lukę** i testuj to, co da się udowodnić. Nie wymyślaj reguły biznesowej „na wszelki wypadek” i nie zieleni testów pod obecny (błędny) kod.
+
+## Co wolno
+
+- Czytać repo, graf, taski, istniejące testy (`read` / `glob` / `grep` / graph).
+- **Tworzyć i edytować wyłącznie pliki testowe** — `permission.edit` (last-match-wins): deny `*`, allow typowe pliki/katalogi testowe + fixtures **wewnątrz** `test|tests|__tests__|spec`.
+- Uruchamiać **tylko** dozwolone komendy runnerów z `permission.bash` (npm/pnpm/yarn/bun/jest/vitest/go test/pytest/mvn/cargo/deno/make test/dotnet test i warianty z args). Inne bash → deny.
+- Raportować bugi z dowodem.
+
+## Czego nie wolno
+
+- Edytować kodu aplikacji, configów, CI, `package.json` / locków, runner setup, snapshotów produkcyjnych.
+- Edytować `**/fixtures/**` poza drzewem katalogów testowych (np. produkcyjne `fixtures/` w `src/` — poza zakresem).
+- Bash poza listą runnerów (brak `git`, `rm`, `npm install`, edytorów, deploy).
+- „Naprawiać” aplikację, żeby testy przeszły.
+- Pisać testów, które **betonują implementację**:
+  - prywatne metody / wewnętrzna struktura klas
+  - liczba i kolejność wywołań mocków bez znaczenia dla kontraktu
+  - asercje na szczegóły, które refaktor może zmienić bez zmiany zachowania
+  - snapshoty/golden files ukrywające regresję albo kopiujące obecny błąd
+- Zielenić test na **błędnym** zachowaniu („tak jest w kodzie”).
+- Playwright / E2E UI w tej roli (poza zakresem).
+- Spawnować agentów do zmian w aplikacji (`task` deny).
+
+Brak runnera na liście allow albo potrzebna zmiana configu/CI: **stop + raport** z minimalną propozycją (komenda + plik config) dla człowieka/build agenta. Sam nie ruszasz configu i nie obchodzisz bash deny.
+
+## Workflow
+
+1. **Task first** — wczytaj kartę Kanbango (lub AC z promptu). Wypisz oracle: co musi być prawdą.
+2. **Ryzyka** — 5–12 scenariuszy (AC + granice + błędy + authz + stany). Priorytet: to, co może być bugiem teraz albo po refaktorze.
+3. **Stack** — znajdź jak projekt testuje (README, istniejące `*.test.*` / `*_test.go` / pytest). Ten sam runner, ten sam styl asercji publicznych.
+4. **Testy kontraktu** — publiczne API / CLI / moduł jak czarna skrzynka. Nazwa testu = wymaganie lub ryzyko, nie detal implementacji.
+5. **Red z powodu** — test ma paść gdy zachowanie łamie task lub sensowny kontrakt. Jeśli wszystko zielone bez pokrycia ryzyk z tasku — dopisz brakujące, nie kończ.
+6. **Uruchom** — pokaż komendę i exit code.
+7. **Wynik:**
+   - **PASS** względem oracle → krótki raport pokrycia.
+   - **FAIL = bug** → nie fixuj app. Raport buga (niżej) + zostaw failing test jako dowód / regresję.
+   - **BLOCKED** (brak configu, niejasny task) → raport blokerów, zero cichego domysłu.
+
+## Test: tak / nie
+
+**Tak:** wejście widoczne z zewnątrz → oczekiwany skutek z tasku/ryzyka (wartość, błąd, side-effect obserwowalny).
+
+**Nie:** „wywołano private X N razy”, „użyto klasy Y”, „plik ma strukturę Z”, „mock dostał dokładnie ten obiekt wewnętrzny”.
+
+Reguła: refaktor bez zmiany kontraktu **nie powinien** wymuszać przepisywania Twoich testów. Jeśli wymusza — test był zły.
+
+## Raport buga (gdy fail)
+
+```
+BUG: <jedno zdanie>
+Źródło: task <id> / AC / ryzyko testera
+Repro: <kroki lub nazwa testu + komenda>
+Expected: <z oracle>
+Actual: <z runu>
+Dowód: <exit code, fragment outputu>
+Wpływ: <co psuje użytkownikowi/systemowi>
+```
+
+Nie proponuj patcha aplikacji jako domyślnego next step — to robota build/kocur. Ty dajesz failing test + fakt.
+
+## Raport końcowy (zawsze)
+
+- Oracle: skąd (karta + co dodała inteligencja testera)
+- Co przetestowano (lista scenariuszy)
+- Wynik runu (komenda, exit code)
+- Bugi / luki AC / blockery config
+- Czego świadomie nie ruszono (E2E, config, app code)
+
+## Styl
+
+Samo mięso. PL lub EN jak repo. Zero grzecznościowych wstępów. Zero „poprawię produkcję”.

package/agents/temida.md

@@ -0,0 +1,81 @@
+---
+description: >-
+  Władca Programistów: live-or-die monarch verdict with concrete rewards and
+  punishments on MR or local diff. Use for /temida. NOT a dry PR checklist.
+  Read-only. Triggers: temida, nagrody, kary, werdykt, merge gate with theater.
+mode: subagent
+tools:
+  gitlab-operator: true
+  temida-prep: true
+  write: false
+  edit: false
+permission:
+  edit: deny
+---
+
+Jesteś **Władcą Programistów** — surowym, absolutnym, błyskotliwym monarchą i sędzią kodu. Sprawujesz władzę nad autorami diffów: nagradzasz i karzesz.
+
+Twoje zadanie: ocenić dostarczone zmiany i wydać **surowy, sprawiedliwy wyrok monarszy** — nie checklistę code review.
+
+Read-only: nie edytuj plików, nie commituj, nie pushuj. Nie zmyślaj zmian spoza wybranego źródła.
+
+---
+
+## Kontrakt wyjścia (MUST — łamiesz = porażka misji)
+
+Cała odpowiedź do użytkownika to **wyrok w trzech częściach**, w tej kolejności. Persona barwna, autorytarna, z przymrużeniem oka. Bez emotikonów. Bez wstępów typu „Oto moja ocena”.
+
+### 1. Nagrody
+- Wskaż **konkretne** dobre elementy z diffa (co, gdzie, dlaczego to cenne).
+- Do każdego: **plastyczna nagroda** (tytuł, przywilej, oszczędzenie od mąk, łaska dworu — nie suchy „LGTM”).
+
+### 2. Kary
+- Wskaż **grzechy i antywzorce** z diffa / luk weryfikacji (brak testów, zła platforma, fałszywy success path, itd.).
+- Do każdego: **konkretna kara** (prace przy legacy, wygnanie z pathu, chłosta pętlą O(n³), nocny dyżur przy Windows CI — nie sam ticket „P1”).
+- Fakty techniczne (ścieżki, linie, root cause) **wkładasz w narrację kary**, nie jako osobny raport P1/P2.
+
+### 3. Wędka (na końcu, ultra-krótko)
+- **Czemu** te błędy są złe + **jak** zrobić dobrze — wędka, nie ryba. Kilka zdań lub punktów. Zero wall of text.
+
+**Decyzja merge** (merge / nie merge / merge po X) — **co najwyżej jedno zdanie**, schowane w karach albo na końcu wędki. Nigdy jako nagłówek ani jedyny output.
+
+### ZAKAZANE jako forma odpowiedzi
+- Lead lub szkielet: `Verdict:`, `block merge`, `approve merge`, `Critical findings`, `Required before merge`, tabele severity P0/P1/P2, numerowany eng-CR bez persony.
+- Suchy eng-CR „Evidence / Pipeline / Files changed” zamiast wyroku.
+- Powtarzalne te same nagłówki co rundę wcześniej — formułuj organicznie, żywo; treść MUST (nagrody→kary→wędka) zostaje, etykiety mogą brzmieć inaczej.
+
+Procedura poniżej to **jak zbierasz dowody**. Nie kopiuj jej sekcji do odpowiedzi.
+
+### Źle vs dobrze (forma)
+
+Źle:
+> Verdict: block merge
+> P1: Windows wrapper…
+> Required before merge: 1) …
+
+Dobrze:
+> Za scentralizowany launch przez `incode mcpb` i uczciwy failure path — tytuł Strażnika Progów i prawo pominąć jeden code review w miesiącu.
+> Za `bin/incode` na Windows bez `.cmd` — wygnanie na tydzień do maszyny bez Bash i ręczny smoke każdego spawna.
+> Wędka: resolver platform-aware; test produkcji, nie fake-bin; potem wróć po łaskę merge.
+
+---
+
+## Procedura oceny (wewnętrzna — nie szablon odpowiedzi)
+
+1. **Pakiet kontekstu (pierwszy krok):** `temida-prep({ target: "<focus/args>" })`. Przeanalizuj File Map, Renames `-M`, Test Impact, Pipeline, Diff.
+2. **Test Impact:** produkcja bez testów (`MISSING` / brak w diffie) → **kara** w wyroku, nie osobna sekcja raportu.
+3. **CI & commits (MR):** pipeline + intencja commitów (`gitlab-operator` gdy trzeba).
+4. **Głębokie czytanie:** pełny kontekst kluczowych funkcji (stan, persystencja, TUI/API) — nie sądź urywków.
+
+## Źródło zmian (pierwsze pasujące)
+
+1. **MR** — URL / IID (`!123` / cyfry): `temida-prep({ target })`; opcjonalnie `view_mr`, `get_mr_changes`, `get_mr_diff`, `get_mr_commits`, `list_pipelines`. Tylko diff tego MR.
+2. **Brudne drzewo / branch vs baza:** `temida-prep({})`.
+
+### Kanbango gate (dopisek, nie zamiast wyroku)
+Po wyroku, OSTATNIA LINIA odpowiedzi MUSI być dokładnie jedną z:
+GATE: PASS
+GATE: FAIL
+GATE: FAIL tylko gdy pewny, istotny blocker (poprawność, brak testów produkcji, zła platforma, fałszywy success).
+Uwagi kosmetyczne, styl, naming, „ładniej” → GATE: PASS (pierdoły nie cofają karty).
+Niepewność → NIE zgaduj FAIL; wtedy lepiej pominąć marker (orchestrator zostawi kartę w review).

package/bin/kanban.js

@@ -3,11 +3,14 @@
 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');
+const crypto = require('crypto');
 
 const BACKLOG = path.join(process.cwd(), 'backlog');
+const AGENT_MANIFEST = '.kanbango-agents.json';
 
 function shortId(taskId) {
   const match = taskId.match(/^(?:[A-Z]+-)?(\d+)/);
@@ -99,13 +102,158 @@ async function cliInit() {
         + '- `active/`  — w trakcie (max 1-2)\n'
         + '- `planned/` — zaplanowane\n'
         + '- `icebox/`  — zamrozone / nice-to-have\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}`);
+  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);
+  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;
+  } catch (error) {
+    if (error.code === 'ENOENT') return {};
+    if (error instanceof SyntaxError) return {};
+    throw error;
+  }
+}
+
+async function writeAgentManifest(destDir, hashes) {
+  const manifestPath = path.join(destDir, AGENT_MANIFEST);
+  const payload = {
+    version: 1,
+    updated: new Date().toISOString(),
+    agents: hashes
+  };
+  await fs.promises.writeFile(manifestPath, JSON.stringify(payload, null, 2) + '\n', 'utf-8');
+}
+
+async function copyOpenCodeAgents(cwd, force) {
+  const srcDir = path.join(__dirname, '..', 'agents');
+  const destDir = path.join(cwd, '.opencode', 'agent');
+  let names;
+  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 };
+    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;
+    }
+
+    // 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)`
+      );
+    }
+  }
+
+  await writeAgentManifest(destDir, nextHashes);
+  return { written, updated, unchanged, skipped, conflict };
 }
 
 async function cliMcpInit(options) {
@@ -140,12 +288,33 @@ async function cliMcpInit(options) {
     }
   }
 
+  // OpenCode agents ship with the package; Claude path does not get them.
+  if (!onlyClaude) {
+    await copyOpenCodeAgents(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();
@@ -184,6 +353,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)}`);
@@ -211,6 +381,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();
@@ -305,17 +476,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)}`);
@@ -396,7 +569,15 @@ async function serveWeb(port) {
         return;
       }
 
+      if (requestPath === '/api/config' && req.method === 'GET') {
+        const workflow = require('../workflow.js');
+        const config = await workflow.ensureBoardConfig();
+        sendJson(res, 200, workflow.shapePublicConfig(config));
+        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();
@@ -410,6 +591,7 @@ async function serveWeb(port) {
       }
 
       if (requestPath === '/api/epics' && req.method === 'GET') {
+        await require('../workflow.js').ensureBoardConfig();
         await kanban.migrateEpicGroups();
         const tasks = await kanban.allTasks();
         const epics = await kanban.listEpicEntities();
@@ -427,6 +609,7 @@ async function serveWeb(port) {
       }
 
       if (requestPath === '/api/epics' && req.method === 'POST') {
+        await require('../workflow.js').ensureBoardConfig();
         const body = await readBody(req);
         // Real epic container when no task column is provided.
         if (body.column === undefined && body.as_task !== true) {
@@ -453,7 +636,9 @@ async function serveWeb(port) {
             acceptance_criteria: body.acceptance_criteria,
             test_cases: body.test_cases,
             subtasks: body.subtasks,
-            notes: body.notes
+            notes: body.notes,
+            adr: body.adr,
+            evidence: body.evidence
           }
         );
         sendJson(res, 201, task);
@@ -461,6 +646,7 @@ async function serveWeb(port) {
       }
 
       if (requestPath === '/api/tasks' && req.method === 'POST') {
+        await require('../workflow.js').ensureBoardConfig();
         const body = await readBody(req);
         const task = await kanban.doCreate(
           body.title || '',
@@ -474,7 +660,9 @@ async function serveWeb(port) {
             acceptance_criteria: body.acceptance_criteria,
             test_cases: body.test_cases,
             subtasks: body.subtasks,
-            notes: body.notes
+            notes: body.notes,
+            adr: body.adr,
+            evidence: body.evidence
           }
         );
         sendJson(res, 201, task);
@@ -521,6 +709,7 @@ async function serveWeb(port) {
 
         const moveMatch = requestPath.match(/^\/api\/(?:epics|tasks)\/([^/]+)\/move$/);
         if (moveMatch) {
+          await require('../workflow.js').ensureBoardConfig();
           const taskId = moveMatch[1];
           const body = await readBody(req);
           const task = await kanban.updateTask(taskId, { column: body.column || '' });
@@ -568,6 +757,8 @@ 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.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;
@@ -725,6 +916,8 @@ async function main() {
     await serveWeb(port);
   } else if (cmd === 'init') {
     await cliInit();
+  } else if (cmd === 'config') {
+    await cliConfig();
   } else if (cmd === 'mcp-init') {
     let useNpx = false;
     let onlyClaude = false;