kanbango 3.6.2 → 5.1.0

package/workflow.js

@@ -7,11 +7,25 @@ const BACKLOG = path.join(process.cwd(), 'backlog');
 const CONFIG_PATH = path.join(BACKLOG, 'kanbango.json');
 const JOBS_DIR = path.join(BACKLOG, '.workflow');
 
+const GATE_COLUMNS = ['testing', 'review'];
+const DEFAULT_LABELS = {
+  icebox: 'Icebox',
+  planned: 'Planned',
+  active: 'NOW',
+  testing: 'Testing',
+  review: 'Review',
+  done: 'Done'
+};
+
 /** PIDs spawned by this process — only these may be SIGTERM'd on timeout. */
 const ownedPids = new Set();
 /** In-flight run_ids to prevent double-spawn within this process. */
 const runningLocal = new Set();
 
+let cachedConfig = null;
+let cacheCwd = null;
+let ensureTail = Promise.resolve();
+
 function workflowError(code, message, hint, details = {}) {
   return kanban.createKanbanError(code, message, hint, details, false, 400);
 }
@@ -20,6 +34,85 @@ function isNonEmptyString(value) {
   return typeof value === 'string' && value.trim().length > 0;
 }
 
+function parseAgentField(value, fieldName, defaultName) {
+  if (value === undefined) {
+    return { enabled: true, name: defaultName };
+  }
+  if (typeof value === 'string') {
+    if (!isNonEmptyString(value)) {
+      throw workflowError(
+        'CONFIG_INVALID',
+        `workflow.${fieldName} must be a non-empty string when set`,
+        `Fix workflow.${fieldName} in backlog/kanbango.json`,
+        { field: `workflow.${fieldName}` }
+      );
+    }
+    return { enabled: true, name: value.trim() };
+  }
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    throw workflowError(
+      'CONFIG_INVALID',
+      `workflow.${fieldName} must be a string or { enabled, name }`,
+      `Use a name string or object with optional enabled/name`,
+      { field: `workflow.${fieldName}` }
+    );
+  }
+  if (value.enabled !== undefined && typeof value.enabled !== 'boolean') {
+    throw workflowError(
+      'CONFIG_INVALID',
+      `workflow.${fieldName}.enabled must be a boolean`,
+      'Use true or false',
+      { field: `workflow.${fieldName}.enabled` }
+    );
+  }
+  if (value.name !== undefined && !isNonEmptyString(value.name)) {
+    throw workflowError(
+      'CONFIG_INVALID',
+      `workflow.${fieldName}.name must be a non-empty string when set`,
+      `Fix workflow.${fieldName}.name in backlog/kanbango.json`,
+      { field: `workflow.${fieldName}.name` }
+    );
+  }
+  return {
+    enabled: value.enabled === undefined ? true : value.enabled,
+    name: isNonEmptyString(value.name) ? value.name.trim() : defaultName
+  };
+}
+
+function parseGateColumn(value, columnId) {
+  if (value === undefined) {
+    return { enabled: true, label: DEFAULT_LABELS[columnId] };
+  }
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    throw workflowError(
+      'CONFIG_INVALID',
+      `columns.${columnId} must be an object`,
+      `Use { "enabled": true, "label": "${DEFAULT_LABELS[columnId]}" }`,
+      { field: `columns.${columnId}` }
+    );
+  }
+  if (value.enabled !== undefined && typeof value.enabled !== 'boolean') {
+    throw workflowError(
+      'CONFIG_INVALID',
+      `columns.${columnId}.enabled must be a boolean`,
+      'Use true or false',
+      { field: `columns.${columnId}.enabled` }
+    );
+  }
+  if (value.label !== undefined && !isNonEmptyString(value.label)) {
+    throw workflowError(
+      'CONFIG_INVALID',
+      `columns.${columnId}.label must be a non-empty string when set`,
+      `Fix columns.${columnId}.label in backlog/kanbango.json`,
+      { field: `columns.${columnId}.label` }
+    );
+  }
+  return {
+    enabled: value.enabled === undefined ? true : value.enabled,
+    label: isNonEmptyString(value.label) ? value.label.trim() : DEFAULT_LABELS[columnId]
+  };
+}
+
 function assertWorkflowShape(workflow) {
   if (!workflow || typeof workflow !== 'object' || Array.isArray(workflow)) {
     throw workflowError(
@@ -37,14 +130,23 @@ function assertWorkflowShape(workflow) {
       { field: 'workflow.enabled' }
     );
   }
-  const stringFields = ['command', 'testing_agent', 'e2e_agent', 'review_agent'];
-  for (const field of stringFields) {
-    if (workflow[field] !== undefined && !isNonEmptyString(workflow[field])) {
+  if (workflow.command !== undefined && !isNonEmptyString(workflow.command)) {
+    throw workflowError(
+      'CONFIG_INVALID',
+      'workflow.command must be a non-empty string when set',
+      'Fix workflow.command in backlog/kanbango.json',
+      { field: 'workflow.command' }
+    );
+  }
+  if (workflow.e2e_agent !== undefined && !isNonEmptyString(workflow.e2e_agent)
+    && !(workflow.e2e_agent && typeof workflow.e2e_agent === 'object')) {
+    // Keep legacy string validation; object form not used for spawn yet.
+    if (typeof workflow.e2e_agent === 'string' && !isNonEmptyString(workflow.e2e_agent)) {
       throw workflowError(
         'CONFIG_INVALID',
-        `workflow.${field} must be a non-empty string when set`,
-        `Fix workflow.${field} in backlog/kanbango.json`,
-        { field: `workflow.${field}` }
+        'workflow.e2e_agent must be a non-empty string when set',
+        'Fix workflow.e2e_agent in backlog/kanbango.json',
+        { field: 'workflow.e2e_agent' }
       );
     }
   }
@@ -58,6 +160,130 @@ function assertWorkflowShape(workflow) {
       );
     }
   }
+  // Validate agent fields early (parseAgentField throws CONFIG_INVALID).
+  parseAgentField(workflow.testing_agent, 'testing_agent', 'qa-tester');
+  parseAgentField(workflow.review_agent, 'review_agent', 'temida');
+  if (workflow.e2e_agent !== undefined && typeof workflow.e2e_agent === 'string') {
+    parseAgentField(workflow.e2e_agent, 'e2e_agent', 'qa-e2e-tester');
+  }
+}
+
+function assertColumnsShape(columns) {
+  if (columns === undefined) return;
+  if (!columns || typeof columns !== 'object' || Array.isArray(columns)) {
+    throw workflowError(
+      'CONFIG_INVALID',
+      'columns config must be an object',
+      'Use { "testing": { "enabled": true, "label": "Testing" }, "review": { ... } }',
+      { field: 'columns' }
+    );
+  }
+  for (const key of Object.keys(columns)) {
+    if (!GATE_COLUMNS.includes(key)) {
+      throw workflowError(
+        'CONFIG_INVALID',
+        `columns.${key} is not configurable`,
+        'Only testing and review may be set under columns',
+        { field: `columns.${key}`, allowed: GATE_COLUMNS }
+      );
+    }
+  }
+  parseGateColumn(columns.testing, 'testing');
+  parseGateColumn(columns.review, 'review');
+}
+
+function buildTransitions(testingOn, reviewOn) {
+  const afterActive = testingOn ? 'testing' : (reviewOn ? 'review' : 'done');
+  const afterTesting = reviewOn ? 'review' : 'done';
+
+  const transitions = {
+    icebox: ['planned'],
+    planned: ['active', 'icebox', afterActive],
+    active: ['planned', afterActive, 'icebox'],
+    done: ['active']
+  };
+
+  // Dedupe while preserving order
+  for (const key of Object.keys(transitions)) {
+    transitions[key] = [...new Set(transitions[key])];
+  }
+
+  if (testingOn) {
+    transitions.testing = ['active', afterTesting];
+  }
+  if (reviewOn) {
+    transitions.review = ['active', 'done'];
+  }
+
+  return transitions;
+}
+
+function buildActiveCols(testingOn, reviewOn) {
+  const cols = ['active', 'planned', 'icebox'];
+  if (testingOn) cols.push('testing');
+  if (reviewOn) cols.push('review');
+  cols.push('done');
+  return cols;
+}
+
+function planDoneTarget(testingOn, reviewOn) {
+  if (testingOn) return 'testing';
+  if (reviewOn) return 'review';
+  return 'done';
+}
+
+function defaultConfig() {
+  const testingOn = false;
+  const reviewOn = false;
+  return {
+    missing: true,
+    enabled: false,
+    command: 'opencode',
+    testing_agent: { enabled: false, name: 'qa-tester' },
+    e2e_agent: { enabled: false, name: 'qa-e2e-tester' },
+    review_agent: { enabled: false, name: 'temida' },
+    timeout_ms: 600000,
+    columns: {
+      icebox: { enabled: true, label: DEFAULT_LABELS.icebox },
+      planned: { enabled: true, label: DEFAULT_LABELS.planned },
+      active: { enabled: true, label: DEFAULT_LABELS.active },
+      testing: { enabled: false, label: DEFAULT_LABELS.testing },
+      review: { enabled: false, label: DEFAULT_LABELS.review },
+      done: { enabled: true, label: DEFAULT_LABELS.done }
+    },
+    active_cols: buildActiveCols(testingOn, reviewOn),
+    workflow_stages: [],
+    transitions: buildTransitions(testingOn, reviewOn),
+    plan_done_column: planDoneTarget(testingOn, reviewOn),
+    move_order: ['icebox', 'planned', 'active', 'done'],
+    board_columns: [
+      { id: 'icebox', label: DEFAULT_LABELS.icebox },
+      { id: 'planned', label: DEFAULT_LABELS.planned },
+      { id: 'done', label: DEFAULT_LABELS.done }
+    ]
+  };
+}
+
+function shapePublicConfig(config) {
+  return {
+    columns: config.columns,
+    active_cols: config.active_cols.slice(),
+    workflow_stages: config.workflow_stages.slice(),
+    transitions: Object.fromEntries(
+      Object.entries(config.transitions).map(([k, v]) => [k, v.slice()])
+    ),
+    plan_done_column: config.plan_done_column,
+    move_order: config.move_order.slice(),
+    board_columns: config.board_columns.map((c) => ({ id: c.id, label: c.label })),
+    workflow: {
+      enabled: config.enabled,
+      command: config.command,
+      testing_agent: { ...config.testing_agent },
+      e2e_agent: { ...config.e2e_agent },
+      review_agent: { ...config.review_agent },
+      timeout_ms: config.timeout_ms
+    }
+  };
 }
 
 async function loadConfig() {
@@ -66,7 +292,7 @@ async function loadConfig() {
     raw = await fs.readFile(CONFIG_PATH, 'utf-8');
   } catch (error) {
     if (error.code === 'ENOENT') {
-      return { enabled: false, missing: true };
+      return defaultConfig();
     }
     throw error;
   }
@@ -87,26 +313,121 @@ async function loadConfig() {
     throw workflowError(
       'CONFIG_INVALID',
       'kanbango.json root must be an object',
-      'Use { "workflow": { ... } }',
+      'Use { "workflow": { ... }, "columns": { ... } }',
       { field: 'root' }
     );
   }
 
-  assertWorkflowShape(parsed.workflow);
-  const w = parsed.workflow;
+  assertColumnsShape(parsed.columns);
+
+  // workflow optional when only columns are configured
+  let w = parsed.workflow;
+  if (w === undefined) {
+    w = { enabled: false };
+  }
+  assertWorkflowShape(w);
+
+  const testingCol = parseGateColumn(parsed.columns && parsed.columns.testing, 'testing');
+  const reviewCol = parseGateColumn(parsed.columns && parsed.columns.review, 'review');
+  const testingOn = testingCol.enabled;
+  const reviewOn = reviewCol.enabled;
+
+  const testingAgent = parseAgentField(w.testing_agent, 'testing_agent', 'qa-tester');
+  const reviewAgent = parseAgentField(w.review_agent, 'review_agent', 'temida');
+  let e2eAgent = { enabled: true, name: 'qa-e2e-tester' };
+  if (w.e2e_agent !== undefined) {
+    if (typeof w.e2e_agent === 'string') {
+      e2eAgent = parseAgentField(w.e2e_agent, 'e2e_agent', 'qa-e2e-tester');
+    } else {
+      e2eAgent = parseAgentField(w.e2e_agent, 'e2e_agent', 'qa-e2e-tester');
+    }
+  }
+
   const envRunner = String(process.env.KANBANGO_WORKFLOW_RUNNER || '').trim();
+  const activeCols = buildActiveCols(testingOn, reviewOn);
+  const workflowStages = GATE_COLUMNS.filter((col) => (col === 'testing' ? testingOn : reviewOn));
+  const moveOrder = ['icebox', 'planned', 'active']
+    .concat(testingOn ? ['testing'] : [])
+    .concat(reviewOn ? ['review'] : [])
+    .concat(['done']);
+
+  const boardColumns = [
+    { id: 'icebox', label: DEFAULT_LABELS.icebox },
+    { id: 'planned', label: DEFAULT_LABELS.planned }
+  ];
+  if (testingOn) boardColumns.push({ id: 'testing', label: testingCol.label });
+  if (reviewOn) boardColumns.push({ id: 'review', label: reviewCol.label });
+  boardColumns.push({ id: 'done', label: DEFAULT_LABELS.done });
 
   return {
-    enabled: w.enabled,
     missing: false,
+    enabled: w.enabled,
     command: envRunner || (isNonEmptyString(w.command) ? w.command.trim() : 'opencode'),
-    testing_agent: isNonEmptyString(w.testing_agent) ? w.testing_agent.trim() : 'qa-tester',
-    e2e_agent: isNonEmptyString(w.e2e_agent) ? w.e2e_agent.trim() : 'qa-e2e-tester',
-    review_agent: isNonEmptyString(w.review_agent) ? w.review_agent.trim() : 'temida',
-    timeout_ms: Number.isInteger(w.timeout_ms) && w.timeout_ms > 0 ? w.timeout_ms : 600000
+    testing_agent: testingAgent,
+    e2e_agent: e2eAgent,
+    review_agent: reviewAgent,
+    timeout_ms: Number.isInteger(w.timeout_ms) && w.timeout_ms > 0 ? w.timeout_ms : 600000,
+    columns: {
+      icebox: { enabled: true, label: DEFAULT_LABELS.icebox },
+      planned: { enabled: true, label: DEFAULT_LABELS.planned },
+      active: { enabled: true, label: DEFAULT_LABELS.active },
+      testing: testingCol,
+      review: reviewCol,
+      done: { enabled: true, label: DEFAULT_LABELS.done }
+    },
+    active_cols: activeCols,
+    workflow_stages: workflowStages,
+    transitions: buildTransitions(testingOn, reviewOn),
+    plan_done_column: planDoneTarget(testingOn, reviewOn),
+    move_order: moveOrder,
+    board_columns: boardColumns
   };
 }
 
+async function migrateDisabledGateCards(config) {
+  const migrated = [];
+  for (const col of GATE_COLUMNS) {
+    if (config.columns[col].enabled) continue;
+    const tasks = await kanban.listTasksInKnownColumn(col);
+    for (const task of tasks) {
+      await kanban.relocateTask(task.id, 'planned');
+      migrated.push({ id: task.id, from: col, to: 'planned' });
+    }
+  }
+  return migrated;
+}
+
+/**
+ * Load board config, apply layout to kanban, migrate cards out of disabled gates.
+ * Always re-reads backlog/kanbango.json (file is small) so enable/disable changes apply.
+ * Migration is idempotent: second call finds no cards in disabled columns.
+ */
+async function ensureBoardConfig({ force = false } = {}) {
+  const run = ensureTail.then(async () => {
+    const cwd = process.cwd();
+    // force kept for API/tests; always reload from disk so config edits are live.
+    void force;
+    const config = await loadConfig();
+    kanban.applyBoardLayout({
+      cols: config.active_cols,
+      transitions: config.transitions,
+      workflowStages: config.workflow_stages
+    });
+    await migrateDisabledGateCards(config);
+
+    cachedConfig = config;
+    cacheCwd = cwd;
+    return config;
+  });
+  ensureTail = run.then(() => undefined, () => undefined);
+  return run;
+}
+
+function clearConfigCache() {
+  cachedConfig = null;
+  cacheCwd = null;
+}
+
 function newRunId() {
   return `run-${Date.now().toString(16)}-${Math.random().toString(16).slice(2, 10)}`;
 }
@@ -139,9 +460,12 @@ function truncate(text, max = 2000) {
 
 function parseTestingVerdict(stdout, stderr, exitCode) {
   const text = `${stdout}\n${stderr}`;
-  if (/\bBLOCKED\b/i.test(text)) return 'blocked';
-  if (/\bPASS\b/i.test(text) && !/\bFAIL\b/i.test(text)) return 'pass';
-  if (/\bFAIL\b/i.test(text)) return 'fail';
+  // Last standalone PASS|FAIL|BLOCKED wins — prompt text itself contains all three.
+  const matches = text.match(/(?:^|[^A-Za-z])(PASS|FAIL|BLOCKED)(?:[^A-Za-z]|$)/gi) || [];
+  const last = matches.length ? matches[matches.length - 1].replace(/[^A-Za-z]/g, '').toLowerCase() : '';
+  if (last === 'pass') return 'pass';
+  if (last === 'blocked') return 'blocked';
+  if (last === 'fail') return 'fail';
   if (exitCode !== 0) return 'fail';
   return 'fail';
 }
@@ -265,9 +589,11 @@ function outcomeForResult(stage, result) {
   if (stage === 'testing') {
     const verdict = parseTestingVerdict(result.stdout, result.stderr, result.exitCode);
     if (verdict === 'pass') {
+      const config = cachedConfig || defaultConfig();
+      const nextColumn = config.columns.review.enabled ? 'review' : 'done';
       return {
         verdict: 'pass',
-        nextColumn: 'review',
+        nextColumn,
         workflowStatus: 'pass',
         summary: truncate(result.stdout || 'PASS', 500)
       };
@@ -356,7 +682,8 @@ async function finishRun(taskId, stage, agent, runId, result) {
 }
 
 async function startRun(task, stage, config) {
-  const agent = agentForStage(config, stage);
+  const agentField = agentForStage(config, stage);
+  const agent = agentField.name;
   const runId = newRunId();
   const startedAt = new Date().toISOString();
 
@@ -411,11 +738,20 @@ async function maybeEnqueueOnColumnEnter(task, previousColumn) {
     return { enqueued: false, reason: 'same_column' };
   }
 
-  const config = await loadConfig();
+  const config = await ensureBoardConfig();
   if (config.missing || !config.enabled) {
     return { enqueued: false, reason: config.missing ? 'no_config' : 'disabled' };
   }
 
+  if (!config.columns[task.column] || !config.columns[task.column].enabled) {
+    return { enqueued: false, reason: 'column_disabled' };
+  }
+
+  const agentField = agentForStage(config, task.column);
+  if (!agentField.enabled) {
+    return { enqueued: false, reason: 'agent_disabled' };
+  }
+
   // Dedup: already running this stage
   const wf = task.workflow;
   if (wf && wf.status === 'running' && wf.stage === task.column) {
@@ -449,12 +785,23 @@ async function waitForIdle(taskId, timeoutMs = 15000) {
   throw new Error(`waitForIdle timeout for task ${taskId}`);
 }
 
+async function planDoneColumn() {
+  const config = await ensureBoardConfig();
+  return config.plan_done_column;
+}
+
 module.exports = {
   loadConfig,
+  ensureBoardConfig,
+  clearConfigCache,
+  shapePublicConfig,
   maybeEnqueueOnColumnEnter,
   parseTestingVerdict,
   parseReviewGate,
   waitForIdle,
+  planDoneColumn,
+  buildTransitions,
+  DEFAULT_LABELS,
   JOBS_DIR,
   CONFIG_PATH
 };

package/.ai/lessons.jsonl

@@ -1,9 +0,0 @@
-{"id":"260729-3h4","ts":"2026-07-29","scope":"proj","tags":["tests","mcp","cli","review"],"rule":"DO Add automated tests for every new public CLI/MCP workflow before shipping","when":"api-review","sev":2,"hits":1}
-{"id":"260729-1ur","ts":"2026-07-29","scope":"proj","tags":["javascript","objects"],"rule":"DON'T Use empty object fallbacks in spreads like `...(obj || {})` since spreading falsy is safe","when":"object spread","sev":2,"hits":1}
-{"id":"260729-5eo","ts":"2026-07-29","scope":"proj","tags":["processes","mcp","ownership"],"rule":"DO Track process ownership before stopping or cleaning up discovered services","when":"gui-process management","sev":2,"hits":1}
-{"id":"260729-1ch","ts":"2026-07-29","scope":"proj","tags":["gui","process","mcp"],"rule":"DO GUI/MCP stop must only SIGTERM processes spawned by the current process; treat port-file PIDs as external_running","when":"gui-process management","sev":2,"hits":1}
-{"id":"260731-o6g","ts":"2026-07-31","scope":"proj","tags":["kanban","epics","mcp"],"rule":"DO Default list/list_epics hide done+archived; hard-delete cascades epic children; archive is reversible flag","when":"kanban cleanup context","sev":2,"hits":1}
-{"id":"260803-b27","ts":"2026-08-03","scope":"proj","tags":["tests","race","fs"],"rule":"DO Serialize board file mutations with an in-process lock and atomic write (temp+rename/link); race tests should assert…","when":"kanban concurrent IO","sev":2,"hits":1}
-{"id":"260813-9t0","ts":"2026-08-13","scope":"proj","tags":["mcp","errors","dx"],"rule":"DO MCP missing-field errors: put Valid list + Example JSON + sent keys in message so the agent can retry without guessi…","when":"MCP tool validation / agent-facing erro…","sev":2,"hits":1}
-{"id":"260819-ztl","ts":"2026-08-19","scope":"proj","tags":["config","kanban","validation"],"rule":"DO Field-policy config: skip only ENOENT; invalid JSON/shape must throw CONFIG_INVALID, never silently fall back to def…","when":"config load / required fields","sev":2,"hits":1}
-{"id":"260825-d68","ts":"2026-08-25","scope":"proj","tags":["http","adr"],"rule":"DO HTTP POST/PATCH must forward adr and evidence the same way MCP update does — doCreate already persisted evidence, on…","when":"http adr evidence","sev":2,"hits":1}

package/.ai/retro/close.json

@@ -1 +0,0 @@
-{"goal":"push do npm","done":["session had mutations"],"next":[],"block":[],"lessons":[],"files":["/Users/mkorbas/projects/personal/markdown-kanban/mcp-server.js","/Users/mkorbas/projects/personal/markdown-kanban/kanban.js","/Users/mkorbas/projects/personal/markdown-kanban/tests/mcp-server.test.js","/Users/mkorbas/projects/personal/markdown-kanban/plan.js","/Users/mkorbas/projects/personal/markdown-kanban/CHANGELOG.md","/Users/mkorbas/projects/personal/markdown-kanban/bin/kanban.js","/Users/mkorbas/projects/personal/markdown-kanban/tests/update-tasks.test.js"],"verify":""}

package/.ai/retro/last-run.json

@@ -1 +0,0 @@
-{"ts":"2026-08-25T07:24:47.875Z","sessionID":"ses_fcd476c1effeADbTA3UAQxjKMA","added":["260825-d68"],"bumped":[]}

package/.ait-quality.yml

@@ -1,25 +0,0 @@
-# kanbango quality policy
-# CLI/GUI entrypoints use console.log as user-facing output (not debug leftovers).
-version: 1
-include: []
-exclude:
-  - node_modules/**
-  - backlog/**
-  - examples/**
-languages:
-  - javascript
-  - markdown
-rules:
-  enabled: true
-  debug-leftover: off
-  swallowed-exception: error
-  hidden-fallback: error
-  unsafe-pattern: error
-  placeholder-todo: warning
-  dead-code: warning
-  cognitive-complexity: warning
-  function-length: warning
-  nesting-depth: warning
-  duplicate-blocks: warning
-gate:
-  fail_on: error

package/bin/kanban-cmd.js

@@ -1,40 +0,0 @@
-#!/usr/bin/env node
-const { spawn } = require('child_process');
-const path = require('path');
-const os = require('os');
-
-// Find Python executable
-function findPython() {
-  const pyCommands = os.platform() === 'win32' ? ['python', 'py'] : ['python3', 'python'];
-  
-  for (const cmd of pyCommands) {
-    try {
-      const result = require('child_process').spawnSync(cmd, ['--version'], { stdio: 'ignore' });
-      if (result.status === 0) {
-        return cmd;
-      }
-    } catch {
-      continue;
-    }
-  }
-  throw new Error('Python not found. Please install Python 3.7+');
-}
-
-// Main execution
-const python = findPython();
-const scriptPath = path.join(__dirname, '..', 'kanban-cmd.py');
-const args = process.argv.slice(2);
-
-const child = spawn(python, [scriptPath, ...args], {
-  stdio: 'inherit',
-  env: { ...process.env }
-});
-
-child.on('exit', (code) => {
-  process.exit(code || 0);
-});
-
-child.on('error', (err) => {
-  console.error('Error running kanban-cmd.py:', err.message);
-  process.exit(1);
-});

package/kan2.md

@@ -1,76 +0,0 @@
-# Plan kan2: Kanbango Plan Workflow
-
-## Cel
-
-Rozszerzyć Kanbango o niezależny workflow planów, który może być używany przez
-OpenCode, inne agenty i CLI. Kanbango pozostaje osobnym repozytorium.
-
-## Zasada architektoniczna
-
-Kanbango nie zna API OpenCode ani hooków pluginu. Udostępnia stabilne operacje
-na planie i evidence. Plugin OpenCode jest tylko klientem oraz strażnikiem sesji.
-
-## Funkcjonalność
-
-Dodać bibliotekę domenową oraz odpowiednie operacje CLI/MCP:
-
-- utworzenie taska z zaakceptowanym planem,
-- zapis kroków planu jako subtasks,
-- oznaczenie bieżącego kroku jako zakończonego,
-- zapis evidence: diff, komenda testowa, stdout, stderr i exit code,
-- zakończenie workflow i przeniesienie taska do `done`,
-- odczyt pełnego statusu planu w stabilnym formacie JSON.
-
-## Domyślne kroki
-
-Każdy zaakceptowany plan dostaje kolejno:
-
-1. `Write tests`
-2. `Run tests and confirm red`
-3. Kroki implementacyjne dostarczone przez advisora
-4. `Run tests and confirm green`
-
-## Test runner
-
-Autodetekcja musi działać per projekt, bez założenia Node:
-
-- Rust: `cargo test` przy `Cargo.toml`,
-- Go: `go test ./...` przy `go.mod`,
-- Python: `python -m pytest` przy `pyproject.toml` lub `pytest.ini`,
-- JavaScript/TypeScript: `npm test`, `pnpm test`, `yarn test` albo `bun test`
-  zgodnie z lockfilem i skryptem `test` w `package.json`,
-- jawny override przez `OPENCODE_TEST_COMMAND`.
-
-Autodetekcja ma zwracać także powód wyboru komendy i czytelny błąd, gdy nie
-znaleziono testów.
-
-## Interfejs
-
-Preferowany jest wspólny moduł JS oraz JSON CLI/MCP, zamiast parsowania tekstu:
-
-- `plan create --json <payload>`,
-- `plan advance --json <payload>`,
-- `plan evidence --json <payload>`,
-- `plan done --json <payload>`,
-- odpowiadające operacje w `kanban_manage` lub osobnym narzędziu MCP.
-
-CLI musi zwracać stabilny JSON z `ok`, `task_id`, `subtasks` i `error`.
-
-## Testy TDD
-
-- autodetekcja runnera dla Rust, Go, Python i Node,
-- utworzenie planu z czterema grupami kroków,
-- aktualizacja kroku bez kasowania pozostałych subtasks,
-- zapis evidence bez silent fail,
-- zakończenie planu i przejście do `done`,
-- błędna komenda testowa i brak testów,
-- wywołanie przez CLI i MCP z tym samym rezultatem.
-
-## Kolejność implementacji
-
-1. Model planu i runner detection.
-2. Operacje biblioteki Kanbango.
-3. CLI i JSON output.
-4. MCP adapter.
-5. Integracja pluginu OpenCode z tym kontraktem.
-6. Test end-to-end w przykładowym projekcie.