@polderlabs/openkan 0.4.0

package/dist/commands/organize.md

@@ -0,0 +1,15 @@
+---
+description: Conservatively organize an OpenKan board using its local HTTP API.
+---
+
+Organize the OpenKan board at `http://127.0.0.1:7777/`.
+
+1. Read `/api/board`, `/api/tasks-index`, and relevant task details.
+2. Identify miscategorized, related, stale, or underspecified tasks.
+3. Preserve tasks in In Progress or Review unless they are clearly abandoned.
+4. Build the smallest useful batch of move, tag, priority, effort, area, archive,
+   or restore operations.
+5. Submit the operations to `POST /api/organize`.
+6. Re-read the board and report exactly what changed and what was skipped.
+
+Be conservative. Do not delete tasks. Do not alter active Bizar sessions.

package/dist/kanban/agent-profile.js

@@ -0,0 +1,8 @@
+import { readFileSync } from 'node:fs';
+import matter from 'gray-matter';
+export const OPENKAN_AGENT_ID = 'openkan';
+/** Provider-neutral prompt source; Claude's adapter maps it to a session agent. */
+export function openkanAgentDefinition() {
+    const { data, content } = matter(readFileSync(new URL('../agents/openkan.md', import.meta.url), 'utf8'));
+    return { description: String(data.description), prompt: content.trim(), model: 'inherit' };
+}

package/dist/kanban/archive.js

@@ -0,0 +1,49 @@
+// OpenKan — archive / restore helpers.
+import { withWrite, getBoard, nowIso } from "./board.js";
+import { writeTaskMdx } from "./mdx.js";
+import { recordEvent } from "./changelog.js";
+export async function archiveTask(task, kanbanDir, author) {
+    let updated;
+    await withWrite(async (board) => {
+        const t = board.tasks.find(x => x.id === task.id);
+        if (!t)
+            return;
+        t.archived = true;
+        t.updatedAt = nowIso();
+        updated = { ...t };
+    });
+    if (!updated)
+        return task;
+    // Write the task MDX so frontmatter reflects archived state
+    const board = await getBoard();
+    await writeTaskMdx(updated, kanbanDir, board);
+    recordEvent(kanbanDir, "task.archived", {
+        taskId: task.id,
+        author,
+        summary: `archived '${task.title}'`,
+        payload: {},
+    });
+    return updated;
+}
+export async function restoreTask(task, kanbanDir, author) {
+    let updated;
+    await withWrite(async (board) => {
+        const t = board.tasks.find(x => x.id === task.id);
+        if (!t)
+            return;
+        t.archived = false;
+        t.updatedAt = nowIso();
+        updated = { ...t };
+    });
+    if (!updated)
+        return task;
+    const board = await getBoard();
+    await writeTaskMdx(updated, kanbanDir, board);
+    recordEvent(kanbanDir, "task.restored", {
+        taskId: task.id,
+        author,
+        summary: `restored '${task.title}'`,
+        payload: {},
+    });
+    return updated;
+}

package/dist/kanban/bizar.js

@@ -0,0 +1,242 @@
+import { existsSync, readFileSync, } from "node:fs";
+import { resolve, join, isAbsolute } from "node:path";
+import { randomUUID } from "node:crypto";
+import { WebSocketServer, WebSocket } from "ws";
+import { readSnapshot as readClaudeSnapshot } from "./claude-state.js";
+export class BizarBridgeError extends Error {
+    status;
+    details;
+    constructor(message, status = 500, details) {
+        super(message);
+        this.name = "BizarBridgeError";
+        this.status = status;
+        this.details = details;
+    }
+}
+function loadOpenKanConfig(openkanProjectRoot) {
+    const path = join(openkanProjectRoot, ".ok", "openkan.json");
+    try {
+        return JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch {
+        return {};
+    }
+}
+function resolveConfiguredPath(base, value) {
+    return isAbsolute(value) ? resolve(value) : resolve(base, value);
+}
+export function resolveBizarConfig(openkanProjectRoot) {
+    const root = resolve(openkanProjectRoot);
+    const config = loadOpenKanConfig(root);
+    const raw = (config.bizar && typeof config.bizar === "object"
+        ? config.bizar
+        : {});
+    const configuredRoot = process.env.OPENKAN_BIZAR_PROJECT_ROOT
+        || raw.projectRoot
+        || root;
+    const projectRoot = resolveConfiguredPath(root, configuredRoot);
+    const command = process.env.OPENKAN_BIZAR_COMMAND
+        || raw.command
+        || (existsSync(join(projectRoot, "cli", "bin.mjs"))
+            ? join(projectRoot, "cli", "bin.mjs")
+            : "bizar");
+    return {
+        enabled: raw.enabled !== false,
+        projectRoot,
+        command: isAbsolute(command) || command.includes("/")
+            ? resolveConfiguredPath(root, command)
+            : command,
+    };
+}
+/**
+ * Legacy snapshot endpoint. The Bizar CLI bridge has been removed; the
+ * legacy `/api/bizar/*` URL namespace now sources its data directly from the
+ * native Claude Code readers in `claude-state.ts`. New integrations should
+ * prefer `/api/claude/*`.
+ */
+export async function getBizarSnapshot(openkanProjectRoot) {
+    const snapshot = await readClaudeSnapshot(openkanProjectRoot);
+    return {
+        version: 1,
+        projectRoot: openkanProjectRoot,
+        agents: snapshot.agents ?? [],
+        tasks: [],
+        sessions: [],
+        messages: [],
+    };
+}
+/**
+ * Legacy session/message/task command shim. With the Bizar CLI removed, this
+ * no longer spawns external processes. Callers receive back a local session
+ * identifier that the UI can display alongside the task; nothing actually
+ * runs off-host. Mutations (claim/heartbeat/complete/cancel) return
+ * `{deprecated:true, status:410}` so existing clients can detect the change.
+ * For new integrations use `/api/claude/*` POST handlers and the
+ * `/api/claude/events` SSE stream.
+ */
+export function executeBizarCommand(_openkanProjectRoot, command, payload) {
+    if (command === "start-session") {
+        const sessionId = `ses-local-${randomUUID()}`;
+        return { session: { sessionId }, deprecated: true, successor: "/api/claude/*" };
+    }
+    if (command === "stop-session" || command === "send-session" || command === "send-message") {
+        return { ok: true, deprecated: true, successor: "/api/claude/*" };
+    }
+    if (command === "create-task" ||
+        command === "claim-task" ||
+        command === "heartbeat-task" ||
+        command === "complete-task" ||
+        command === "cancel-task") {
+        return { ok: true, deprecated: true, status: 410, successor: "/api/claude/*" };
+    }
+    throw new BizarBridgeError(`Unknown Bizar command: ${command}`, 404);
+}
+function response(value, status = 200) {
+    return new Response(JSON.stringify(value), {
+        status,
+        headers: { "content-type": "application/json; charset=utf-8" },
+    });
+}
+function errorResponse(error) {
+    const bridge = error instanceof BizarBridgeError
+        ? error
+        : new BizarBridgeError(error?.message || String(error));
+    return response({
+        error: bridge.message,
+        ...(bridge.details ? { details: bridge.details } : {}),
+    }, bridge.status);
+}
+function gone(message) {
+    return response({
+        error: message,
+        deprecated: true,
+        successor: "/api/claude/*",
+    }, 410);
+}
+const GONE = "Bizar CLI integration removed; use /api/claude/*";
+export async function handleBizarRequest(openkanProjectRoot, req, path) {
+    try {
+        if (req.method === "GET") {
+            const snapshot = await getBizarSnapshot(openkanProjectRoot);
+            if (path === "/api/bizar/snapshot")
+                return response(snapshot);
+            if (path === "/api/bizar/agents")
+                return response({ agents: snapshot.agents || [] });
+            if (path === "/api/bizar/tasks")
+                return response({ tasks: snapshot.tasks || [] });
+            if (path === "/api/bizar/sessions")
+                return response({ sessions: snapshot.sessions || [] });
+            if (path === "/api/bizar/messages")
+                return response({ messages: snapshot.messages || [] });
+        }
+        if (req.method !== "POST")
+            return response({ error: "Not found" }, 404);
+        return gone(GONE);
+    }
+    catch (error) {
+        return errorResponse(error);
+    }
+}
+function isLoopback(req) {
+    const address = req.socket.remoteAddress || "";
+    return address === "127.0.0.1" || address === "::1" || address === "::ffff:127.0.0.1";
+}
+export function attachBizarWebSocket(server, projectRoot) {
+    const wss = new WebSocketServer({ noServer: true });
+    function send(socket, value) {
+        if (socket.readyState === WebSocket.OPEN)
+            socket.send(JSON.stringify(value));
+    }
+    async function snapshot(socket) {
+        try {
+            const event = { type: "snapshot", data: await getBizarSnapshot(projectRoot()) };
+            if (socket)
+                send(socket, event);
+            else
+                for (const client of wss.clients)
+                    send(client, event);
+        }
+        catch (error) {
+            const event = {
+                type: "error",
+                error: error?.message || String(error),
+            };
+            if (socket)
+                send(socket, event);
+            else
+                for (const client of wss.clients)
+                    send(client, event);
+        }
+    }
+    const upgrade = (req, socket, head) => {
+        let pathname = "";
+        try {
+            pathname = new URL(req.url || "/", "http://localhost").pathname;
+        }
+        catch { /* invalid */ }
+        if (pathname !== "/api/bizar/ws")
+            return;
+        if (!isLoopback(req)) {
+            socket.write("HTTP/1.1 403 Forbidden\r\n\r\n");
+            socket.destroy();
+            return;
+        }
+        wss.handleUpgrade(req, socket, head, (client) => wss.emit("connection", client, req));
+    };
+    server.on("upgrade", upgrade);
+    wss.on("connection", (socket) => {
+        snapshot(socket);
+        socket.on("message", (raw) => {
+            let message;
+            try {
+                message = JSON.parse(raw.toString());
+            }
+            catch {
+                send(socket, { type: "error", error: "Invalid JSON" });
+                return;
+            }
+            if (message.type === "refresh") {
+                snapshot(socket);
+                return;
+            }
+            if (message.type !== "command") {
+                send(socket, { type: "error", requestId: message.requestId, error: "Unknown message type" });
+                return;
+            }
+            try {
+                // The legacy WS command channel has been superseded by the native
+                // /api/claude/events SSE stream and the /api/claude/* POST endpoints.
+                // Acknowledging receipt with a 410-styled result keeps existing clients
+                // log-parsable while signalling that no work will be performed.
+                send(socket, {
+                    type: "result",
+                    requestId: message.requestId,
+                    data: { deprecated: true, status: 410, error: GONE, successor: "/api/claude/*" },
+                });
+                snapshot();
+            }
+            catch (error) {
+                send(socket, {
+                    type: "error",
+                    requestId: message.requestId,
+                    error: error?.message || String(error),
+                });
+            }
+        });
+    });
+    const interval = setInterval(() => {
+        if (wss.clients.size > 0)
+            snapshot();
+    }, 5_000);
+    interval.unref?.();
+    return {
+        broadcastSnapshot: () => snapshot(),
+        close() {
+            clearInterval(interval);
+            server.off("upgrade", upgrade);
+            for (const client of wss.clients)
+                client.close();
+            wss.close();
+        },
+    };
+}

package/dist/kanban/board.js

@@ -0,0 +1,367 @@
+import { nanoid } from "nanoid";
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { writeFileAtomic, ensureDir, cleanupStaleTmp } from "./io.js";
+import { writeTask, readTask as readOkTask, writeConfig, paths as okPaths, rebuildIndex } from "../ok/storage.js";
+import { nowIso as okNowIso } from "../ok/ids.js";
+// ─── Task getter / setter helpers ─────────────────────────────────────────────
+/** Return artifact paths for a task, under .ok/. */
+export function taskArtifacts(taskId) {
+    return {
+        mdxPath: `tasks/${taskId}/task.mdx`,
+        commentsPath: `tasks/${taskId}/comments.json`,
+        inputsPath: `tasks/${taskId}/inputs.json`,
+        statePath: `tasks/${taskId}/state.json`,
+    };
+}
+// ─── Constants ───────────────────────────────────────────────────────────────
+export const DEFAULT_COLUMNS = [
+    { id: "backlog", title: "Backlog" },
+    { id: "todo", title: "To Do" },
+    { id: "doing", title: "In Progress" },
+    { id: "review", title: "Review" },
+    { id: "done", title: "Done" },
+];
+export let KANBAN_DIR = ""; // set by initBoard or setKanbanDir
+export const BOARD_FILE = "board.json";
+export const BOARD_MDX = "board.mdx";
+export const TASKS_INDEX_FILE = "tasks.json";
+// ─── Project root (set by the CLI/server before project operations) ─────────
+let _projectRoot = null;
+export function setProjectRoot(dir) { _projectRoot = dir; }
+export function getProjectRoot() {
+    if (!_projectRoot)
+        throw new Error("Project root not initialised — call setProjectRoot first");
+    return _projectRoot;
+}
+/** Allow server.ts to override KANBAN_DIR when the active project changes at runtime. */
+export function setKanbanDir(dir) {
+    KANBAN_DIR = dir;
+}
+let _board = null;
+// `KANBAN_DIR` names the persistence directory, but a running server also
+// needs to know which root populated its in-memory board. Keeping this
+// separately prevents a project switch from merely changing output paths
+// while continuing to serve the previous project's cached tasks.
+let _loadedProjectRoot = "";
+let _writeQueue = Promise.resolve();
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+export function newId(prefix) {
+    return `${prefix}-${nanoid(8)}`;
+}
+export function nowIso() {
+    return new Date().toISOString();
+}
+export function renormalizeOrder(tasks) {
+    // Active tasks get renumbered; archived tasks retain their last order so they
+    // reappear in the right position when restored.
+    const active = tasks.filter(t => !t.archived);
+    const archived = tasks.filter(t => t.archived);
+    const sortedActive = [...active]
+        .sort((a, b) => a.order - b.order || a.id.localeCompare(b.id))
+        .map((t, i) => ({ ...t, order: i }));
+    return [...sortedActive, ...archived];
+}
+// ─── Init ─────────────────────────────────────────────────────────────────────
+/** One-time idempotent migration: flat tasks/<id>.mdx → tasks/<id>/task.mdx */
+async function migrateLegacyTaskArtifacts(board) {
+    for (const task of board.tasks) {
+        const flatMdxPath = join(KANBAN_DIR, "tasks", `${task.id}.mdx`);
+        if (existsSync(flatMdxPath)) {
+            const taskDir = join(KANBAN_DIR, "tasks", task.id);
+            ensureDir(taskDir);
+            const newMdxPath = join(taskDir, "task.mdx");
+            // Read legacy file, write to new location
+            const content = readFileSync(flatMdxPath, "utf-8");
+            writeFileAtomic(newMdxPath, content);
+            // Update task.artifact to new layout
+            task.artifact = `tasks/${task.id}/task.mdx`;
+            task.artifacts = taskArtifacts(task.id);
+            try {
+                // Remove old flat file
+                const { unlinkSync } = await import("node:fs");
+                unlinkSync(flatMdxPath);
+            }
+            catch {
+                // ignore
+            }
+        }
+        else if (!task.artifacts) {
+            // Back-compat: ensure artifacts field exists for old tasks loaded from board.json
+            task.artifacts = taskArtifacts(task.id);
+        }
+        // Ensure state field exists for old tasks
+        if (!task.state) {
+            task.state = task.status ?? "idle";
+        }
+        if (!task.pendingInputs) {
+            task.pendingInputs = [];
+        }
+        // New fields: apply defaults for legacy tasks
+        if (!task.tags)
+            task.tags = [];
+        if (!task.category)
+            task.category = "task";
+        if (!task.priority)
+            task.priority = "normal";
+        if (task.effort === undefined)
+            task.effort = null;
+        if (task.archived === undefined)
+            task.archived = false;
+        if (!task.assignees)
+            task.assignees = [];
+        if (!task.images)
+            task.images = [];
+        if (task.parentId === undefined)
+            task.parentId = null;
+        if (!task.subtaskIds)
+            task.subtaskIds = [];
+    }
+}
+export async function initBoard(ctx) {
+    // Finish writes against the current board before replacing its cache. This
+    // makes project activation an atomic boundary for callers sharing a server.
+    await _writeQueue.catch(() => undefined);
+    const dir = join(ctx.directory, ".ok");
+    KANBAN_DIR = dir;
+    ensureDir(dir);
+    cleanupStaleTmp(dir);
+    // Write tasks.json from board.tasks if tasks.json doesn't exist (migration helper)
+    const tasksIndexPath = join(dir, TASKS_INDEX_FILE);
+    if (!existsSync(tasksIndexPath)) {
+        // Will be written after board is loaded
+    }
+    const boardPath = join(dir, BOARD_FILE);
+    if (existsSync(boardPath)) {
+        const raw = readFileSync(boardPath, "utf-8");
+        _board = JSON.parse(raw);
+        // Apply migrations
+        await migrateLegacyTaskArtifacts(_board);
+        await persist(_board);
+    }
+    else {
+        _board = {
+            version: 1,
+            columns: [...DEFAULT_COLUMNS],
+            tasks: [],
+            sessions: {},
+        };
+        await persist(_board);
+    }
+    _loadedProjectRoot = ctx.directory;
+    return { board: _board, dir };
+}
+/**
+ * Load the board for `ctx.directory` when the active project changed.
+ * Unlike `setKanbanDir`, this refreshes the in-memory board as well as its
+ * destination path, which is required for a long-lived multi-project server.
+ */
+export async function ensureBoardForProject(ctx) {
+    if (_board && _loadedProjectRoot === ctx.directory) {
+        return { board: _board, dir: KANBAN_DIR };
+    }
+    return initBoard(ctx);
+}
+export async function getBoard() {
+    if (!_board)
+        throw new Error("Board not initialised — call initBoard first");
+    return _board;
+}
+// ─── Write queue ─────────────────────────────────────────────────────────────
+export async function withWrite(fn) {
+    const operation = _writeQueue.catch(() => undefined).then(async () => {
+        if (!_board)
+            throw new Error("Board not initialised");
+        const result = await fn(_board);
+        await persist(_board);
+        return result;
+    });
+    _writeQueue = operation.then(() => undefined, () => undefined);
+    return operation;
+}
+// ─── Persist ─────────────────────────────────────────────────────────────────
+/**
+ * Map an OpenKan engine `Task` onto the planning-system `ok.task.v1`
+ * shape. Column placement (`backlog|todo|doing|review|done`) maps onto
+ * the planning status enum (`pending|in_progress|review|done|cancelled`)
+ * so a single field is the canonical lifecycle indicator.
+ */
+function toPlanningTask(task) {
+    const status = mapColumnToStatus(task.column, task.state, task.archived);
+    const ok = {
+        schema: "ok.task.v1",
+        id: task.id.startsWith("tsk-") ? task.id : `tsk-${task.id}`,
+        title: task.title || "untitled",
+        status,
+        createdAt: task.createdAt,
+        updatedAt: task.updatedAt,
+    };
+    if (task.agent)
+        ok.owner = task.agent;
+    if (task.description && task.description.trim().length > 0)
+        ok.description = task.description;
+    if (task.tags && task.tags.length > 0)
+        ok.scopes = task.tags;
+    return ok;
+}
+function mapColumnToStatus(column, state, archived) {
+    if (archived)
+        return "cancelled";
+    if (state === "done")
+        return "done";
+    if (state === "cancelled" || state === "failed")
+        return "cancelled";
+    if (state === "running" || state === "waiting-for-input")
+        return "in_progress";
+    if (column === "review")
+        return "review";
+    if (column === "doing")
+        return "in_progress";
+    if (column === "done")
+        return "done";
+    return "pending";
+}
+let _okMirrorWritesDisabled = false;
+/** Disable the side-effect per-task mirror writes (used by tests). */
+export function setOkMirrorWritesDisabled(v) { _okMirrorWritesDisabled = v; }
+/**
+ * Mirror the engine board into the planning-system store. Idempotent:
+ * existing per-task JSONs are overwritten with the latest engine view.
+ * `config.json` is created on first call so the planning system sees the
+ * project as initialised.
+ */
+async function mirrorToOkStore(board) {
+    if (_okMirrorWritesDisabled)
+        return;
+    if (!KANBAN_DIR)
+        return;
+    // KANBAN_DIR = <root>/.ok/. The planning layout is exactly that.
+    // We resolve the project root as the parent of KANBAN_DIR.
+    const projectRoot = join(KANBAN_DIR, "..");
+    const p = okPaths(projectRoot);
+    ensureDir(p.tasksDir);
+    ensureDir(p.plansDir);
+    ensureDir(p.prdsDir);
+    ensureDir(p.sessionsDir);
+    ensureDir(p.locksDir);
+    // Ensure config.json exists
+    if (!existsSync(p.configFile)) {
+        const now = okNowIso();
+        await writeConfig(p, { schema: "ok.config.v1", version: 1, createdAt: now, updatedAt: now });
+    }
+    // Write one JSON per task, plus idempotent tasks.json index.
+    const seen = new Set();
+    const indexEntries = [];
+    for (const t of board.tasks) {
+        const okTask = toPlanningTask(t);
+        await writeTask(p, okTask);
+        seen.add(okTask.id);
+        indexEntries.push({ id: okTask.id, status: okTask.status, title: okTask.title, updatedAt: okTask.updatedAt });
+    }
+    // Best-effort index rebuild (non-fatal if it fails).
+    try {
+        await rebuildIndex(p);
+    }
+    catch { /* swallow */ }
+}
+/**
+ * Map a planning-system `ok.task.v1` entry onto the engine Task schema.
+ * Used when the source of truth for a task lives in `.ok/tasks/<id>.json`
+ * (e.g. an agent invoked `ok task add` directly). The reverse direction
+ * is `toPlanningTask` above; together they keep both stores coherent.
+ */
+function fromPlanningTask(ok) {
+    if (!ok.id || !/^tsk-[A-Za-z0-9_-]+$/.test(ok.id))
+        return null;
+    const column = ok.status === "done" ? "done" :
+        ok.status === "review" ? "review" :
+            ok.status === "in_progress" ? "doing" :
+                ok.status === "cancelled" ? "backlog" :
+                    ok.status === "pending" ? "todo" :
+                        "todo";
+    const state = ok.status === "done" ? "done" :
+        ok.status === "cancelled" ? "cancelled" :
+            ok.status === "in_progress" ? "running" :
+                "idle";
+    const arts = taskArtifacts(ok.id);
+    return {
+        id: ok.id,
+        title: ok.title ?? "untitled",
+        description: ok.description ?? "",
+        column,
+        order: 0,
+        sessionId: null,
+        agent: ok.owner ?? "",
+        model: null,
+        status: state,
+        state,
+        lastError: null,
+        createdAt: ok.createdAt,
+        updatedAt: ok.updatedAt,
+        artifact: arts.mdxPath,
+        sessionArtifact: null,
+        pendingInputs: [],
+        artifacts: arts,
+        tags: ok.scopes ? [...ok.scopes] : [],
+        category: "task",
+        priority: (ok.priority ?? "p3"),
+        effort: null,
+        archived: ok.status === "cancelled",
+        assignees: ok.owner ? [ok.owner] : [],
+        images: [],
+        parentId: null,
+        subtaskIds: [],
+    };
+}
+/**
+ * Reconcile a single `.ok/tasks/<id>.json` entry into the engine board.
+ * Called by the SSE watcher when an agent (e.g. via `ok task add`) writes
+ * a planning task while a dashboard server is running. No-op when the
+ * board already has the task (subsequent edits flow through the existing
+ * HTTP PATCH path); returns the inserted task for broadcasting.
+ *
+ * The function intentionally mirrors the `apiCreateTask` shape so the
+ * dashboard's broadcast and write-quote semantics stay consistent.
+ */
+export async function reconcileOkTask(taskId, kanbanDir = KANBAN_DIR) {
+    if (!/^tsk-[A-Za-z0-9_-]+$/.test(taskId))
+        return null;
+    if (!kanbanDir)
+        return null;
+    const projectRoot = join(kanbanDir, "..");
+    const p = okPaths(projectRoot);
+    const ok = await readOkTask(p, taskId);
+    if (!ok)
+        return null;
+    // Skip if the board already has this id — the HTTP path owns updates.
+    if (_board && _board.tasks.some(t => t.id === ok.id))
+        return null;
+    const task = fromPlanningTask(ok);
+    if (!task)
+        return null;
+    let inserted;
+    await withWrite(async (board) => {
+        // Re-check after queueing; another reconcile could have won.
+        if (board.tasks.some(t => t.id === task.id)) {
+            inserted = board.tasks.find(t => t.id === task.id);
+            return;
+        }
+        const colTasks = board.tasks.filter(t => t.column === task.column);
+        task.order = colTasks.length;
+        board.tasks.push(task);
+        inserted = task;
+    });
+    return inserted ?? null;
+}
+export async function persist(board) {
+    if (!KANBAN_DIR)
+        return;
+    const dest = join(KANBAN_DIR, BOARD_FILE);
+    writeFileAtomic(dest, JSON.stringify(board, null, 2));
+    // Mirror into the planning-system store. Side effect only; failure does
+    // not abort the engine write.
+    try {
+        await mirrorToOkStore(board);
+    }
+    catch { /* swallow */ }
+}