kanbango 3.8.0 → 5.1.0

package/plan.js

@@ -98,18 +98,11 @@ async function create(payload = {}) {
 }
 
 async function advance(payload = {}) {
-  const task = await kanban.getTask(payload.task_id);
-  const index = payload.index !== undefined ? Number(payload.index)
-    : task.subtasks.findIndex((subtask) => !subtask.done);
-  if (!Number.isInteger(index) || index < 0 || index >= task.subtasks.length) {
-    throw planError('INVALID_SUBTASK_INDEX', 'No valid plan step was provided',
-      'Provide the zero-based index of an incomplete subtask', { index, total_subtasks: task.subtasks.length });
-  }
-  const subtasks = task.subtasks.map((subtask, subtaskIndex) => ({
-    ...subtask,
-    done: subtaskIndex === index ? true : subtask.done
-  }));
-  const updated = await kanban.updateTask(task.id, { subtasks });
+  const hasIndex = payload.index !== undefined && payload.index !== null && payload.index !== '';
+  const patch = hasIndex
+    ? { mark_subtask_done: Number(payload.index) }
+    : { mark_subtask_done: null };
+  const updated = await kanban.updateTask(payload.task_id, patch);
   return result(updated, { current_step: updated.subtasks.findIndex((subtask) => !subtask.done) });
 }
 
@@ -125,19 +118,21 @@ async function evidence(payload = {}) {
     throw planError('VALIDATION_ERROR', 'exit_code must be an integer',
       'Use the process exit code from the test command, or omit exit_code', { field: 'exit_code' });
   }
-  const task = await kanban.getTask(payload.task_id);
-  const patch = { evidence: [...task.evidence, {
-    diff,
-    test_command: testCommand,
-    stdout: payload.stdout !== undefined ? String(payload.stdout) : '',
-    stderr: payload.stderr !== undefined ? String(payload.stderr) : '',
-    exit_code: Number.isInteger(payload.exit_code) ? payload.exit_code : null,
-    summary,
-    created: new Date().toISOString()
-  }] };
+  const patch = {
+    appendEvidence: {
+      diff,
+      test_command: testCommand,
+      stdout: payload.stdout !== undefined ? String(payload.stdout) : '',
+      stderr: payload.stderr !== undefined ? String(payload.stderr) : '',
+      exit_code: Number.isInteger(payload.exit_code) ? payload.exit_code : null,
+      summary,
+      created: new Date().toISOString()
+    }
+  };
   if (payload.files !== undefined) patch.files = payload.files;
-  const updated = await kanban.updateTask(task.id, patch);
-  return result(updated, { evidence: patch.evidence[patch.evidence.length - 1] });
+  const updated = await kanban.updateTask(payload.task_id, patch);
+  const evidenceList = updated.evidence || [];
+  return result(updated, { evidence: evidenceList[evidenceList.length - 1] });
 }
 
 async function done(payload = {}) {

package/plugins/tui-kanban-controller.js

@@ -0,0 +1,117 @@
+const path = require('path');
+
+const LIST_COLUMNS = ['active', 'planned', 'icebox'];
+
+const kanbanPalette = {
+  commandName: 'kanban.open',
+  title: 'Kanban',
+  desc: 'Browse board and paste a start prompt',
+  category: 'Kanban',
+  slashName: 'kanban',
+  shortcut: 'ctrl+alt+k'
+};
+
+function defaultKanban() {
+  return require(path.join(__dirname, '..', 'kanban.js'));
+}
+
+function formatEpicLabel(epic) {
+  if (!epic || !epic.id) return '—';
+  const title = typeof epic.title === 'string' ? epic.title.trim() : '';
+  return title ? `${epic.id}/${title}` : String(epic.id);
+}
+
+function formatStartPrompt(task, epic) {
+  const id = task && task.id != null ? String(task.id) : '';
+  const title = task && task.title != null ? String(task.title) : '';
+  return `Zacznij implementować zadanie #${id}: ${title} z epiku ${formatEpicLabel(epic)}.`;
+}
+
+function epicLookup(epics) {
+  const byId = new Map();
+  for (const epic of epics || []) {
+    if (epic && epic.id) byId.set(epic.id, epic);
+  }
+  return byId;
+}
+
+function shapeRow(task, epicsById, allTasks, unmetDependencies) {
+  const unmet = unmetDependencies(task, allTasks) || [];
+  const epic = task.epic_id ? epicsById.get(task.epic_id) : null;
+  return {
+    id: task.id,
+    title: task.title || '',
+    column: task.column,
+    epic_id: task.epic_id || '',
+    epicTitle: epic && epic.title ? epic.title : '',
+    epicLabel: formatEpicLabel(epic || (task.epic_id ? { id: task.epic_id } : null)),
+    blocked: unmet.length > 0,
+    unmet_dependencies: unmet,
+    description: task.description || '',
+    acceptance_criteria: Array.isArray(task.acceptance_criteria) ? task.acceptance_criteria : [],
+    depends_on: Array.isArray(task.depends_on) ? task.depends_on : []
+  };
+}
+
+function toBoardRows(tasks, epics, helpers = {}) {
+  const filterTasksForList = helpers.filterTasksForList || ((list) => list);
+  const unmetDependencies = helpers.unmetDependencies || (() => []);
+  const filtered = filterTasksForList(tasks || [], epics || [], {});
+  const epicsById = epicLookup(epics);
+  const byColumn = new Map(LIST_COLUMNS.map((column) => [column, []]));
+  for (const task of filtered) {
+    if (!task || !byColumn.has(task.column)) continue;
+    byColumn.get(task.column).push(shapeRow(task, epicsById, tasks, unmetDependencies));
+  }
+  return LIST_COLUMNS.flatMap((column) => byColumn.get(column));
+}
+
+async function loadBoard(options = {}) {
+  const kanban = options.kanban || defaultKanban();
+  const cwd = options.cwd;
+  const previous = process.cwd();
+  let changed = false;
+  try {
+    if (cwd && cwd !== previous) {
+      process.chdir(cwd);
+      changed = true;
+    }
+    const tasks = await kanban.allTasks();
+    const epics = await kanban.listEpicEntities();
+    return {
+      rows: toBoardRows(tasks, epics, {
+        filterTasksForList: kanban.filterTasksForList,
+        unmetDependencies: kanban.unmetDependencies
+      }),
+      tasks,
+      epics
+    };
+  } finally {
+    if (changed) process.chdir(previous);
+  }
+}
+
+function moveSelection(index, delta, length) {
+  if (!length || length <= 0) return 0;
+  const next = Number(index || 0) + Number(delta || 0);
+  if (next < 0) return 0;
+  if (next >= length) return length - 1;
+  return next;
+}
+
+function selectedRow(rows, index) {
+  if (!Array.isArray(rows) || rows.length === 0) return null;
+  if (index < 0 || index >= rows.length) return null;
+  return rows[index];
+}
+
+module.exports = {
+  LIST_COLUMNS,
+  kanbanPalette,
+  formatEpicLabel,
+  formatStartPrompt,
+  toBoardRows,
+  loadBoard,
+  moveSelection,
+  selectedRow
+};

package/plugins/tui-kanban.tsx

@@ -0,0 +1,314 @@
+/** @jsxImportSource @opentui/solid */
+import { createRequire } from 'node:module';
+import type { TuiPlugin, TuiPluginApi, TuiPluginModule, TuiThemeCurrent } from '@opencode-ai/plugin/tui';
+import { createSignal, For, Show, type Accessor } from 'solid-js';
+
+type BoardRow = {
+  id: string;
+  title: string;
+  column: string;
+  epic_id: string;
+  epicTitle: string;
+  epicLabel: string;
+  blocked: boolean;
+  unmet_dependencies: Array<{ id: string }>;
+  description: string;
+  acceptance_criteria: string[];
+  depends_on: string[];
+};
+
+const requireController = createRequire(import.meta.url);
+const controller = requireController('./tui-kanban-controller.js') as {
+  kanbanPalette: {
+    commandName: string;
+    title: string;
+    desc: string;
+    category: string;
+    slashName: string;
+    shortcut: string;
+  };
+  formatStartPrompt: (
+    task: { id: string; title: string },
+    epic: { id?: string; title?: string } | null
+  ) => string;
+  loadBoard: (options?: { cwd?: string }) => Promise<{ rows: BoardRow[] }>;
+  moveSelection: (index: number, delta: number, length: number) => number;
+  selectedRow: (rows: BoardRow[], index: number) => BoardRow | null;
+};
+
+const id = 'kanbango.tui';
+type TuiApi = TuiPluginApi;
+type Theme = TuiThemeCurrent;
+
+type View =
+  | { status: 'loading' }
+  | { status: 'error'; message: string }
+  | { status: 'ready'; rows: BoardRow[]; selected: number };
+
+type DialogCtrl = {
+  view: Accessor<View>;
+  reload: () => Promise<void>;
+  move: (delta: number) => void;
+  confirm: () => Promise<void>;
+};
+
+let dialogOpen = false;
+let dialogCtrl: DialogCtrl | null = null;
+
+function closeKanbanDialog(api: TuiApi) {
+  dialogOpen = false;
+  dialogCtrl = null;
+  api.ui.dialog.clear();
+}
+
+function createDialogController(api: TuiApi): DialogCtrl {
+  const [view, setView] = createSignal<View>({ status: 'loading' });
+
+  const reload = async () => {
+    setView({ status: 'loading' });
+    try {
+      const board = await controller.loadBoard({ cwd: api.state.path.directory });
+      setView({
+        status: 'ready',
+        rows: board.rows,
+        selected: controller.moveSelection(0, 0, board.rows.length)
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      setView({ status: 'error', message });
+    }
+  };
+
+  const move = (delta: number) => {
+    setView((current) => {
+      if (current.status !== 'ready') return current;
+      return {
+        ...current,
+        selected: controller.moveSelection(current.selected, delta, current.rows.length)
+      };
+    });
+  };
+
+  const confirm = async () => {
+    const current = view();
+    if (current.status !== 'ready') return;
+    const row = controller.selectedRow(current.rows, current.selected);
+    if (!row) return;
+    const epic = row.epic_id ? { id: row.epic_id, title: row.epicTitle } : null;
+    const text = controller.formatStartPrompt(row, epic);
+    await api.client.tui.appendPrompt({ text });
+    closeKanbanDialog(api);
+  };
+
+  return { view, reload, move, confirm };
+}
+
+export function openKanbanDialog(api: TuiApi) {
+  const ctrl = createDialogController(api);
+  dialogCtrl = ctrl;
+  dialogOpen = true;
+  api.ui.dialog.setSize('large');
+  api.ui.dialog.replace(
+    () => <KanbanDialog api={api} ctrl={ctrl} />,
+    () => {
+      dialogOpen = false;
+      if (dialogCtrl === ctrl) dialogCtrl = null;
+    }
+  );
+  void ctrl.reload();
+}
+
+function registerPalette(api: TuiApi) {
+  api.keymap.registerLayer({
+    commands: [
+      {
+        name: controller.kanbanPalette.commandName,
+        title: controller.kanbanPalette.title,
+        desc: controller.kanbanPalette.desc,
+        category: controller.kanbanPalette.category,
+        namespace: 'palette',
+        slashName: controller.kanbanPalette.slashName,
+        run() {
+          openKanbanDialog(api);
+        }
+      }
+    ]
+  });
+}
+
+function registerShortcut(api: TuiApi) {
+  api.keymap.registerLayer({
+    enabled: () => !dialogOpen,
+    bindings: [
+      {
+        key: controller.kanbanPalette.shortcut,
+        cmd: () => openKanbanDialog(api),
+        desc: controller.kanbanPalette.title
+      }
+    ]
+  });
+}
+
+function registerDialogKeys(api: TuiApi) {
+  api.keymap.registerLayer({
+    enabled: () => dialogOpen && api.ui.dialog.open,
+    bindings: [
+      { key: 'up', cmd: () => dialogCtrl?.move(-1), desc: 'Previous task' },
+      { key: 'down', cmd: () => dialogCtrl?.move(1), desc: 'Next task' },
+      { key: 'k', cmd: () => dialogCtrl?.move(-1), desc: 'Previous task' },
+      { key: 'j', cmd: () => dialogCtrl?.move(1), desc: 'Next task' },
+      { key: 'return', cmd: () => void dialogCtrl?.confirm(), desc: 'Paste start prompt' },
+      { key: 'escape', cmd: () => closeKanbanDialog(api), desc: 'Close' }
+    ]
+  });
+}
+
+const tui: TuiPlugin = async (api) => {
+  registerPalette(api);
+  registerShortcut(api);
+  registerDialogKeys(api);
+};
+
+function KanbanDialog(props: { api: TuiApi; ctrl: DialogCtrl }) {
+  const theme = () => props.api.theme.current as Theme;
+  const state = () => props.ctrl.view();
+  const selected = () => {
+    const current = state();
+    if (current.status !== 'ready') return null;
+    return controller.selectedRow(current.rows, current.selected);
+  };
+
+  return (
+    <box flexDirection="column" width="100%" height="100%" padding={1} gap={1}>
+      <text>
+        <span style={{ fg: theme().primary, bold: true }}>Kanban</span>
+        <span style={{ fg: theme().textMuted }}>  · Enter paste start  · Esc close</span>
+      </text>
+      <Show when={state().status === 'loading'}>
+        <text fg={theme().textMuted}>Loading board…</text>
+      </Show>
+      <Show when={state().status === 'error'}>
+        <text fg={theme().error}>{(state() as { message: string }).message}</text>
+      </Show>
+      <Show when={state().status === 'ready'}>
+        <box flexDirection="row" width="100%" height="100%" gap={1} flexGrow={1}>
+          <TaskList
+            rows={(state() as Extract<View, { status: 'ready' }>).rows}
+            selected={(state() as Extract<View, { status: 'ready' }>).selected}
+            theme={theme()}
+          />
+          <DetailPanel row={selected()} theme={theme()} />
+        </box>
+      </Show>
+    </box>
+  );
+}
+
+function groupedRows(rows: BoardRow[]) {
+  const groups: Array<{ column: string; items: Array<{ row: BoardRow; index: number }> }> = [];
+  for (let index = 0; index < rows.length; index++) {
+    const row = rows[index];
+    const last = groups[groups.length - 1];
+    if (!last || last.column !== row.column) {
+      groups.push({ column: row.column, items: [{ row, index }] });
+    } else {
+      last.items.push({ row, index });
+    }
+  }
+  return groups;
+}
+
+function TaskList(props: { rows: BoardRow[]; selected: number; theme: Theme }) {
+  const groups = () => groupedRows(props.rows);
+  return (
+    <box
+      flexDirection="column"
+      flexGrow={1}
+      width="50%"
+      height="100%"
+      border={true}
+      borderColor={props.theme.border}
+      padding={1}
+      title=" tasks "
+      titleAlignment="left"
+    >
+      <Show when={props.rows.length > 0} fallback={<text fg={props.theme.textMuted}>No open tasks</text>}>
+        <For each={groups()}>
+          {(group) => (
+            <box flexDirection="column" gap={0}>
+              <text>
+                <span style={{ fg: props.theme.accent ?? props.theme.primary, bold: true }}>
+                  {group.column}
+                </span>
+              </text>
+              <For each={group.items}>
+                {(item) => (
+                  <TaskRow row={item.row} selected={item.index === props.selected} theme={props.theme} />
+                )}
+              </For>
+            </box>
+          )}
+        </For>
+      </Show>
+    </box>
+  );
+}
+
+function TaskRow(props: { row: BoardRow; selected: boolean; theme: Theme }) {
+  const mark = props.row.blocked ? '!' : ' ';
+  return (
+    <text>
+      <span style={{ fg: props.theme.primary }}>{props.selected ? '❯ ' : '  '}</span>
+      <span style={{ fg: props.row.blocked ? props.theme.error : props.theme.textMuted }}>{mark}</span>
+      <span style={{ fg: props.selected ? props.theme.primary : props.theme.textMuted }}>
+        {` ${props.row.id} `}
+      </span>
+      <span style={{ fg: props.selected ? props.theme.text : props.theme.textMuted }}>
+        {props.row.title}
+      </span>
+      <span style={{ fg: props.theme.textMuted }}>{`  ${props.row.epicLabel}`}</span>
+    </text>
+  );
+}
+
+function DetailPanel(props: { row: BoardRow | null; theme: Theme }) {
+  const row = () => props.row;
+  const ac = () => row()?.acceptance_criteria ?? [];
+  const unmet = () => (row()?.unmet_dependencies ?? []).map((item) => item.id).join(', ');
+  return (
+    <box
+      flexDirection="column"
+      flexGrow={1}
+      width="50%"
+      height="100%"
+      border={true}
+      borderColor={props.theme.borderActive ?? props.theme.primary}
+      padding={1}
+      title=" detail "
+      titleAlignment="left"
+      gap={0}
+    >
+      <Show when={row()} fallback={<text fg={props.theme.textMuted}>Select a task</text>}>
+        <text>
+          <span style={{ fg: props.theme.primary, bold: true }}>{row()!.id}</span>
+          <span style={{ fg: props.theme.text }}>{`  ${row()!.title}`}</span>
+        </text>
+        <text fg={props.theme.textMuted}>{`epic  ${row()!.epicLabel}`}</text>
+        <Show when={row()!.blocked}>
+          <text fg={props.theme.error}>{`blocked  ${unmet() || 'yes'}`}</text>
+        </Show>
+        <text fg={props.theme.textMuted}>
+          {`depends_on  ${row()!.depends_on.length ? row()!.depends_on.join(', ') : '—'}`}
+        </text>
+        <text fg={props.theme.text}>{row()!.description || '(no description)'}</text>
+        <text fg={props.theme.textMuted}>acceptance criteria</text>
+        <Show when={ac().length > 0} fallback={<text fg={props.theme.textMuted}>—</text>}>
+          <For each={ac()}>{(line) => <text fg={props.theme.text}>{`- ${line}`}</text>}</For>
+        </Show>
+      </Show>
+    </box>
+  );
+}
+
+const plugin: TuiPluginModule & { id: string } = { id, tui };
+export default plugin;

package/workflow.js

@@ -233,34 +233,32 @@ function planDoneTarget(testingOn, reviewOn) {
 }
 
 function defaultConfig() {
-  const testingOn = true;
-  const reviewOn = true;
+  const testingOn = false;
+  const reviewOn = false;
   return {
     missing: true,
     enabled: false,
     command: 'opencode',
-    testing_agent: { enabled: true, name: 'qa-tester' },
-    e2e_agent: { enabled: true, name: 'qa-e2e-tester' },
-    review_agent: { enabled: true, name: 'temida' },
+    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: true, label: DEFAULT_LABELS.testing },
-      review: { enabled: true, label: DEFAULT_LABELS.review },
+      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: GATE_COLUMNS.slice(),
+    workflow_stages: [],
     transitions: buildTransitions(testingOn, reviewOn),
     plan_done_column: planDoneTarget(testingOn, reviewOn),
-    move_order: ['icebox', 'planned', 'active', 'testing', 'review', 'done'],
+    move_order: ['icebox', 'planned', 'active', 'done'],
     board_columns: [
       { id: 'icebox', label: DEFAULT_LABELS.icebox },
       { id: 'planned', label: DEFAULT_LABELS.planned },
-      { id: 'testing', label: DEFAULT_LABELS.testing },
-      { id: 'review', label: DEFAULT_LABELS.review },
       { id: 'done', label: DEFAULT_LABELS.done }
     ]
   };
@@ -462,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';
 }

package/.ai/lessons.jsonl

@@ -1,14 +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}
-{"id":"260826-bvz","ts":"2026-08-26","scope":"proj","tags":["gui","testing","config"],"rule":"DO Test dynamic GUI columns through runtime config, not static HTML IDs.","when":"config-driven GUI","sev":2,"hits":1}
-{"id":"260827-mmv","ts":"2026-08-27","scope":"proj","tags":["plan","mcp","qa"],"rule":"DO When create maps steps→subtasks, assert subtasks win if both sent; evidence accepts any of diff|summary|test_command…","when":"plan_create / MCP create steps","sev":2,"hits":1}
-{"id":"260827-m2q","ts":"2026-08-27","scope":"proj","tags":["plan","mcp","evidence"],"rule":"DO When create maps steps→subtasks, assert subtasks win if both sent; evidence accepts any of diff|summary|test_command","when":"plan_create / MCP create steps","sev":2,"hits":1}
-{"id":"260916-9im","ts":"2026-09-16","scope":"proj","tags":["kanban","mcp","context","depends-on"],"rule":"DO Agent wake: one kanban_read operation=context instead of list+show; store depends_on and files on the task so gates …","when":"kanban MCP agent context","sev":2,"hits":1}
-{"id":"260916-guc","ts":"2026-09-16","scope":"proj","tags":["kanban","mcp","depends-on","dag"],"rule":"DO On depends_on writes detect cycles immediately (CIRCULAR_DEPENDENCY with details.cycle); expose blocked/blocks on li…","when":"kanban DAG depends_on","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-09-16T10:23:54.497Z","sessionID":"ses_f5682fb36ffeOu9sf2lXfIUCGB","added":["260916-guc"],"bumped":[]}

package/.ait-quality.yml

@@ -1,26 +0,0 @@
-# kanbango quality policy
-# CLI/GUI entrypoints use console.log as user-facing output (not debug leftovers).
-# This file is local policy only — kanbango does not depend on or invoke ait-quality.
-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);
-});