@polderlabs/openkan 0.4.0

package/dist/kanban/images.js

@@ -0,0 +1,140 @@
+// OpenKan — image storage helpers.
+import { existsSync, readFileSync, writeFileSync, unlinkSync, openSync, fsyncSync, closeSync, renameSync } from "node:fs";
+import { join } from "node:path";
+import { nanoid } from "nanoid";
+import { ensureDir } from "./io.js";
+// ─── Constants ────────────────────────────────────────────────────────────────
+const ALLOWED_EXTENSIONS = new Set(["png", "jpg", "jpeg", "gif", "webp", "svg"]);
+const MAX_SIZE_BYTES = 10 * 1024 * 1024; // 10 MB
+const CONTENT_TYPE_MAP = {
+    png: "image/png",
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    gif: "image/gif",
+    webp: "image/webp",
+    svg: "image/svg+xml",
+};
+const STORE_FILE = "images.json";
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+function imagesStorePath(taskDir) {
+    return join(taskDir, STORE_FILE);
+}
+function loadStore(taskDir) {
+    const p = imagesStorePath(taskDir);
+    if (!existsSync(p))
+        return { images: [] };
+    try {
+        return JSON.parse(readFileSync(p, "utf-8"));
+    }
+    catch {
+        return { images: [] };
+    }
+}
+function saveStore(taskDir, store) {
+    ensureDir(taskDir);
+    writeFileSync(imagesStorePath(taskDir), JSON.stringify(store, null, 2), "utf-8");
+}
+function validateExtension(ext) {
+    const lower = ext.toLowerCase().replace(/^\./, "");
+    if (!ALLOWED_EXTENSIONS.has(lower))
+        return null;
+    return lower;
+}
+// ─── Public API ───────────────────────────────────────────────────────────────
+/** Return the path to the images directory for a task. */
+export function imagesDir(taskId, kanbanDir) {
+    return join(kanbanDir, "tasks", taskId, "images");
+}
+/** Ensure the images directory for a task exists and return its path. */
+export function ensureImagesDir(taskId, kanbanDir) {
+    const dir = imagesDir(taskId, kanbanDir);
+    ensureDir(dir);
+    return dir;
+}
+/**
+ * Save an image buffer to a task's images directory.
+ * v1 accepts JSON with base64-encoded data.
+ *
+ * @returns ImageMeta for the saved file.
+ * @throws Error if extension is not allowed or size exceeds 10 MB.
+ */
+export function saveImage(taskId, kanbanDir, buffer, ext, contentType, author) {
+    const validExt = validateExtension(ext);
+    if (!validExt) {
+        throw new Error(`Invalid file extension: ${ext}. Allowed: ${[...ALLOWED_EXTENSIONS].join(", ")}`);
+    }
+    if (buffer.length > MAX_SIZE_BYTES) {
+        throw new Error(`File too large: ${buffer.length} bytes. Maximum allowed: ${MAX_SIZE_BYTES} bytes.`);
+    }
+    const dir = ensureImagesDir(taskId, kanbanDir);
+    const name = `img-${nanoid(8)}.${validExt}`;
+    const filePath = join(dir, name);
+    // Write atomically
+    const tmp = `${filePath}.tmp`;
+    writeFileSync(tmp, buffer);
+    try {
+        const fd = openSync(tmp, "r");
+        fsyncSync(fd);
+        closeSync(fd);
+    }
+    catch (_) { /* atomic write best-effort on this filesystem */ }
+    renameSync(tmp, filePath);
+    const meta = {
+        name,
+        taskId,
+        size: buffer.length,
+        contentType: contentType ?? CONTENT_TYPE_MAP[validExt] ?? "application/octet-stream",
+        uploadedAt: new Date().toISOString(),
+        uploadedBy: author,
+    };
+    // Record in images.json
+    const taskDir = join(kanbanDir, "tasks", taskId);
+    const store = loadStore(taskDir);
+    store.images.push(meta);
+    saveStore(taskDir, store);
+    return meta;
+}
+/** List all images for a task. */
+export function listImages(taskId, kanbanDir) {
+    const taskDir = join(kanbanDir, "tasks", taskId);
+    const { images } = loadStore(taskDir);
+    return images.filter(img => img.taskId === taskId);
+}
+/** Delete a named image from a task. Returns true if deleted, false if not found. */
+export function deleteImage(taskId, kanbanDir, name) {
+    const taskDir = join(kanbanDir, "tasks", taskId);
+    const dir = imagesDir(taskId, kanbanDir);
+    const filePath = join(dir, name);
+    const store = loadStore(taskDir);
+    const before = store.images.length;
+    store.images = store.images.filter(img => !(img.name === name && img.taskId === taskId));
+    if (store.images.length === before)
+        return false;
+    // Remove file
+    try {
+        if (existsSync(filePath))
+            unlinkSync(filePath);
+    }
+    catch { /* ignore */ }
+    saveStore(taskDir, store);
+    return true;
+}
+/**
+ * Read an image file for serving via HTTP.
+ * Returns { buffer, contentType } or null if not found.
+ */
+export function readImage(taskId, kanbanDir, name) {
+    const dir = imagesDir(taskId, kanbanDir);
+    const filePath = join(dir, name);
+    if (!existsSync(filePath))
+        return null;
+    const store = loadStore(join(kanbanDir, "tasks", taskId));
+    const meta = store.images.find(img => img.name === name && img.taskId === taskId);
+    const contentType = meta?.contentType ?? "application/octet-stream";
+    try {
+        return { buffer: readFileSync(filePath), contentType };
+    }
+    catch {
+        return null;
+    }
+}

package/dist/kanban/import.js

@@ -0,0 +1,295 @@
+// OpenKan — checkbox import scanner.
+// Scans .md/.mdx files for "- [ ]" checkboxes and produces ScanResult hits.
+import { readdirSync, readFileSync, statSync } from "fs";
+import { join, relative } from "path";
+import { createHash } from "node:crypto";
+import { withWrite, getBoard, taskArtifacts } from "./board.js";
+import { extractMetadata } from "./tags.js";
+import { writeTaskMdx, writeBoardMdx } from "./mdx.js";
+import { ensureDir } from "./io.js";
+import { recordEvent } from "./changelog.js";
+/** Compute a short SHA-256 hex digest (first 16 chars) of file content. */
+export function computeSourceHash(content) {
+    return createHash("sha256").update(content).digest("hex").slice(0, 16);
+}
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+const MD_EXTENSIONS = new Set([".md", ".mdx"]);
+// Dirs that are always skipped regardless of include/exclude.
+const SYSTEM_DIRS = new Set([
+    "node_modules", ".git", ".ok", "dist", ".next",
+]);
+function isSystemDir(name) {
+    if (name.startsWith(".") && name !== ".ok")
+        return true;
+    return SYSTEM_DIRS.has(name);
+}
+/** Recursively collect .md/.mdx files under root, respecting include/exclude. */
+export function scanFiles(opts) {
+    const { root, include = [], exclude = [] } = opts;
+    const files = [];
+    let scanned = 0;
+    let skipped = 0;
+    function matches(pattern, name) {
+        // `**` is a multi-segment wildcard. `*` is a basename wildcard within a segment.
+        // We split the pattern at `**` first, then per-segment wildcards go through matchBasename.
+        const norm = name.replace(/^\.\//, "");
+        const pSegs = pattern.split("/");
+        const segs = norm.split("/");
+        return matchPath(pSegs, segs);
+    }
+    function matchPath(pSegs, segs) {
+        if (pSegs.length === 0)
+            return segs.length === 0;
+        if (pSegs[0] === "**") {
+            for (let k = 0; k <= segs.length; k++) {
+                if (matchPath(pSegs.slice(1), segs.slice(k)))
+                    return true;
+            }
+            return false;
+        }
+        if (segs.length === 0)
+            return false;
+        const seg = segs[0];
+        if (pSegs[0].includes("*") && !pSegs[0].includes("/")) {
+            if (!matchBasename(pSegs[0], seg))
+                return false;
+        }
+        else if (pSegs[0] !== seg) {
+            return false;
+        }
+        return matchPath(pSegs.slice(1), segs.slice(1));
+    }
+    function matchBasename(pattern, name) {
+        const base = name.split("/").pop() ?? name;
+        // Convert glob to anchored regex: `*` → `.*`, `?` → `.`, literals escaped.
+        const re = new RegExp("^" + pattern.split("*").map(escapeRegex).join(".*") + "$");
+        return re.test(base);
+    }
+    function escapeRegex(s) {
+        return s.replace(/[\\^$.+?()[\]{}|]/g, "\\$&");
+    }
+    function matchesAny(patterns, relPath, baseName) {
+        for (const p of patterns) {
+            if (matches(p, relPath) || matches(p, baseName))
+                return true;
+        }
+        return false;
+    }
+    function walk(dir) {
+        let entries;
+        try {
+            entries = readdirSync(dir);
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const full = join(dir, entry);
+            let stat;
+            try {
+                stat = statSync(full);
+            }
+            catch {
+                continue;
+            }
+            if (stat.isDirectory()) {
+                if (isSystemDir(entry)) {
+                    skipped++;
+                    continue;
+                }
+                walk(full);
+            }
+            else if (stat.isFile()) {
+                const dot = entry.lastIndexOf(".");
+                const ext = dot >= 0 ? entry.slice(dot) : "";
+                if (!MD_EXTENSIONS.has(ext))
+                    continue;
+                // include/exclude: default to docs/** + *.md + *.mdx
+                const defaultInclude = ["docs/**", "*.md", "*.mdx"];
+                const effectiveInclude = include.length ? include : defaultInclude;
+                const rel = relative(root, full).replace(/\\/g, "/");
+                if (effectiveInclude.length && !matchesAny(effectiveInclude, rel, entry)) {
+                    skipped++;
+                    continue;
+                }
+                if (exclude.length && matchesAny(exclude, rel, entry)) {
+                    skipped++;
+                    continue;
+                }
+                files.push(full);
+                scanned++;
+            }
+        }
+    }
+    walk(root);
+    return { files, scanned, skipped };
+}
+// ─── Checkbox parser ─────────────────────────────────────────────────────────
+/**
+ * Extract all checkbox lines from file content.
+ * - Ignores checkboxes inside fenced code blocks (backtick OR tilde fences,
+ *   CommonMark style — closing fence must match opener kind).
+ * - Matches indented checkboxes (leading whitespace preserved in raw).
+ * - `- [x]` (done) → hit.done = true (caller filters as needed).
+ */
+export function parseCheckboxes(content, repoRelPath) {
+    const hits = [];
+    const lines = content.split("\n");
+    // Track which delimiter opened the fence (` for backtick, ~ for tilde),
+    // null when not inside a fence. CommonMark: closing fence must use a
+    // delimiter that matches the opening one (or any ≥3-length sequence of
+    // the same char, but for our purposes same + ≥3 is enough).
+    let fenceChar = null;
+    for (let i = 0; i < lines.length; i++) {
+        const raw = lines[i];
+        const trimmed = raw.trimStart();
+        // Detect a fence line: at least three backticks or three tildes, followed by optional info string.
+        const fenceMatch = trimmed.match(/^(`{3,}|~{3,})(.*)$/);
+        if (fenceMatch) {
+            const opener = fenceMatch[1][0];
+            if (fenceChar === null) {
+                fenceChar = opener === "`" ? "`" : "~";
+                continue;
+            }
+            // Closing fence must match opener kind.
+            if (fenceChar === opener) {
+                fenceChar = null;
+                continue;
+            }
+            // Wrong-kind delimiter inside a fence is just content; skip in either case.
+            if (fenceChar !== null)
+                continue;
+        }
+        if (fenceChar !== null)
+            continue;
+        // - [ ] or - [x] — allow leading whitespace
+        const m = trimmed.match(/^-\s*\[([ x])\]\s*(.*)$/);
+        if (!m)
+            continue;
+        const done = m[1] === "x";
+        const text = m[2].trim();
+        hits.push({
+            path: repoRelPath,
+            line: i + 1, // 1-indexed
+            raw: text,
+            done,
+        });
+    }
+    return hits;
+}
+// ─── Stable ID ───────────────────────────────────────────────────────────────
+/** Format a stable, deterministic import ID from a checkbox hit. */
+export function stableImportId(hit) {
+    const slug = slugFromRaw(hit.raw);
+    const input = `${hit.path}:${hit.line}:${slug}`;
+    const short = createHash("sha256").update(input).digest("hex").slice(0, 12);
+    return `imp-${short}`;
+}
+/** Derive a URL-safe slug from checkbox raw text. */
+export function slugFromRaw(raw) {
+    return raw
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 32) || "untitled";
+}
+/**
+ * Core import engine: scans for unchecked checkboxes, creates one Backlog task
+ * per hit, and writes MDX artifacts. Uses withWrite so it's safe under
+ * concurrent writers.
+ */
+export async function runImport(ctx, opts = {}) {
+    const { include = ["docs/**", "*.md", "*.mdx"], exclude = [] } = opts;
+    const kanbanDir = ctx.directory;
+    // Compose scanFiles + parseCheckboxes to get all checkbox hits
+    const { files } = await scanFiles({ root: kanbanDir, include, exclude });
+    const allHits = [];
+    for (const file of files) {
+        const relPath = relative(kanbanDir, file).replace(/\\/g, "/");
+        const content = readFileSync(file, "utf-8");
+        const hits = parseCheckboxes(content, relPath);
+        allHits.push(...hits);
+    }
+    const uncheckedHits = allHits.filter((h) => !h.done);
+    if (uncheckedHits.length === 0) {
+        return { imported: [] };
+    }
+    const now = new Date().toISOString();
+    const createdIds = [];
+    await withWrite(async (board) => {
+        const colTasks = board.tasks.filter((t) => t.column === "backlog");
+        let order = colTasks.length;
+        for (const hit of uncheckedHits) {
+            const id = stableImportId(hit);
+            const title = hit.raw || "Untitled import";
+            const description = "";
+            const derived = extractMetadata({ title, description });
+            // Read full file content for sourceHash
+            let sourceHash = "";
+            try {
+                const fileContent = readFileSync(join(kanbanDir, hit.path), "utf-8");
+                sourceHash = computeSourceHash(fileContent);
+            }
+            catch {
+                // non-fatal: file may have been deleted between scan and now
+            }
+            const arts = taskArtifacts(id);
+            const task = {
+                id,
+                title,
+                description,
+                column: "backlog",
+                order: order++,
+                sessionId: null,
+                agent: "",
+                model: null,
+                status: "idle",
+                state: "idle",
+                lastError: null,
+                createdAt: now,
+                updatedAt: now,
+                artifact: arts.mdxPath,
+                sessionArtifact: null,
+                pendingInputs: [],
+                artifacts: arts,
+                tags: derived.tags,
+                category: derived.category,
+                priority: derived.priority,
+                effort: derived.effort,
+                archived: false,
+                assignees: ["user"],
+                images: [],
+                parentId: null,
+                subtaskIds: [],
+                source: { path: hit.path, line: hit.line, slug: slugFromRaw(hit.raw) },
+                sourceHash,
+            };
+            board.tasks.push(task);
+            createdIds.push(id);
+        }
+    });
+    // Write MDX artifacts for each created task
+    const board = await getBoard();
+    for (const id of createdIds) {
+        const task = board.tasks.find((t) => t.id === id);
+        if (!task)
+            continue;
+        const taskDir = join(kanbanDir, "tasks", id);
+        ensureDir(taskDir);
+        await writeTaskMdx(task, kanbanDir, board);
+    }
+    // Write board MDX and record events
+    await writeBoardMdx(board, kanbanDir);
+    for (const id of createdIds) {
+        const task = board.tasks.find((t) => t.id === id);
+        if (task) {
+            recordEvent(kanbanDir, "task.created", {
+                taskId: id,
+                author: "user",
+                summary: `imported '${task.title}'`,
+                payload: { column: task.column },
+            });
+        }
+    }
+    return { imported: createdIds };
+}

package/dist/kanban/inputs.js

@@ -0,0 +1,94 @@
+// OpenKan — input request CRUD (ask/choice/input/confirm).
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { ensureDir } from "./io.js";
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+const STORE_FILE = "inputs.json";
+function storePath(taskDir) {
+    return join(taskDir, STORE_FILE);
+}
+function loadStore(taskDir) {
+    const p = storePath(taskDir);
+    if (!existsSync(p))
+        return { inputs: [] };
+    try {
+        return JSON.parse(readFileSync(p, "utf-8"));
+    }
+    catch {
+        return { inputs: [] };
+    }
+}
+function saveStore(taskDir, store) {
+    ensureDir(taskDir);
+    writeFileSync(storePath(taskDir), JSON.stringify(store, null, 2), "utf-8");
+}
+function makeId(taskId, question, blockId) {
+    const input = `${taskId}${question}${blockId ?? ""}${Date.now()}`;
+    const sha = createHash("sha1").update(input).digest("hex").slice(0, 12);
+    return `inp-${sha}`;
+}
+// ─── Public API ───────────────────────────────────────────────────────────────
+/** List all inputs for a task, newest first. */
+export function listInputs(taskId, dir) {
+    const taskDir = join(dir, taskId);
+    const { inputs } = loadStore(taskDir);
+    return inputs.filter((i) => i.taskId === taskId).sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+}
+/** Return the most recent pending input for a task, or null. */
+export function getPendingInput(taskId, dir) {
+    const taskDir = join(dir, taskId);
+    const { inputs } = loadStore(taskDir);
+    const pending = inputs
+        .filter((i) => i.taskId === taskId && i.status === "pending")
+        .sort((a, b) => b.createdAt.localeCompare(a.createdAt)); // newest first
+    return pending[0] ?? null;
+}
+/** Create and persist a new input. Returns the new Input. */
+export function addInput(taskId, dir, data) {
+    const taskDir = join(dir, taskId);
+    ensureDir(taskDir);
+    const store = loadStore(taskDir);
+    const input = {
+        ...data,
+        id: makeId(taskId, data.question, data.blockId),
+        taskId,
+        status: "pending",
+        createdAt: new Date().toISOString(),
+        respondedAt: null,
+    };
+    store.inputs.push(input);
+    saveStore(taskDir, store);
+    return input;
+}
+/**
+ * Record a response to an input.
+ * `response` — free-text value (for ask/input/confirm).
+ * `optionId` — selected option id (for choice).
+ */
+export function respondInput(taskId, dir, inputId, response) {
+    const taskDir = join(dir, taskId);
+    const store = loadStore(taskDir);
+    const idx = store.inputs.findIndex((i) => i.id === inputId && i.taskId === taskId);
+    if (idx === -1)
+        throw new Error(`Input ${inputId} not found for task ${taskId}`);
+    const input = store.inputs[idx];
+    input.status = "responded";
+    input.response = response.value ?? null;
+    input.responseOptionId = response.optionId ?? null;
+    input.respondedAt = new Date().toISOString();
+    store.inputs[idx] = input;
+    saveStore(taskDir, store);
+    return input;
+}
+/** Cancel a pending input (mark it cancelled). */
+export function cancelInput(taskId, dir, inputId) {
+    const taskDir = join(dir, taskId);
+    const store = loadStore(taskDir);
+    const idx = store.inputs.findIndex((i) => i.id === inputId && i.taskId === taskId);
+    if (idx === -1)
+        throw new Error(`Input ${inputId} not found for task ${taskId}`);
+    store.inputs[idx].status = "cancelled";
+    saveStore(taskDir, store);
+    return store.inputs[idx];
+}

package/dist/kanban/insights.js

@@ -0,0 +1,140 @@
+// OpenKan — Insights aggregator. Reads `.ok/changelog.jsonl` and
+// produces per-day, per-column move counts for the Insights tab.
+//
+// `task.moved` payload quirk (see kanban/server.ts:641-646): the existing
+// emit writes `payload.from = patch.column`, but at that point `patch.column`
+// is the destination, not the source. The aggregator parses the destination
+// from the summary string ("moved 'X' to <col>") and infers the source
+// from the most recent prior `task.moved` for the same taskId.
+import { readEvents } from "./changelog.js";
+export const COLUMNS = [
+    "backlog",
+    "todo",
+    "doing",
+    "review",
+    "done",
+];
+const MOVE_DEST_RE = /moved '.*' to (\w+)/;
+function zeroBuckets(days, generatedAt) {
+    return {
+        days: [],
+        backlog: new Array(days).fill(0),
+        todo: new Array(days).fill(0),
+        doing: new Array(days).fill(0),
+        review: new Array(days).fill(0),
+        done: new Array(days).fill(0),
+        windowDays: days,
+        generatedAt,
+    };
+}
+/**
+ * Build the list of `days` local YYYY-MM-DD strings ending today (inclusive).
+ * Oldest first.
+ */
+function buildDayWindow(days, endLocalDate) {
+    const out = [];
+    // Parse the local YYYY-MM-DD into a Date at noon local time to avoid DST edges.
+    const parts = endLocalDate.split("-").map(Number);
+    const y = parts[0];
+    const m = parts[1];
+    const d = parts[2];
+    const end = new Date(y, m - 1, d, 12, 0, 0, 0);
+    for (let i = days - 1; i >= 0; i--) {
+        const t = new Date(end);
+        t.setDate(end.getDate() - i);
+        const yyyy = t.getFullYear();
+        const mm = String(t.getMonth() + 1).padStart(2, "0");
+        const dd = String(t.getDate()).padStart(2, "0");
+        out.push(`${yyyy}-${mm}-${dd}`);
+    }
+    return out;
+}
+/** Convert ISO timestamp to local YYYY-MM-DD. Mirrors changelog.ts convention. */
+function toLocalDay(iso) {
+    return new Date(iso).toLocaleDateString("en-CA");
+}
+function indexFor(buckets, localDay) {
+    return buckets.days.indexOf(localDay);
+}
+/** Typed dispatcher: pick the right column-array and add `delta`. */
+function addToColumn(b, col, idx, delta) {
+    if (idx < 0)
+        return;
+    switch (col) {
+        case "backlog":
+            b.backlog[idx] += delta;
+            return;
+        case "todo":
+            b.todo[idx] += delta;
+            return;
+        case "doing":
+            b.doing[idx] += delta;
+            return;
+        case "review":
+            b.review[idx] += delta;
+            return;
+        case "done":
+            b.done[idx] += delta;
+            return;
+    }
+}
+function isColumn(s) {
+    return !!s && COLUMNS.includes(s);
+}
+/**
+ * Compute per-day, per-column move-into counts for the last `days` days,
+ * ending today. Reads the changelog via `readEvents`; bad JSONL lines are
+ * skipped (parseLine warns and returns null) so one corrupt line does
+ * not abort the computation.
+ *
+ * Returns zero-filled arrays when the changelog is missing or empty.
+ */
+export function computeVelocity(okDir, days = 30) {
+    const window = Math.max(1, Math.floor(days));
+    const generatedAt = new Date().toISOString();
+    const todayLocal = new Date().toLocaleDateString("en-CA");
+    const buckets = zeroBuckets(window, generatedAt);
+    buckets.days = buildDayWindow(window, todayLocal);
+    // Pull a generous slice of events. readEvents filters in-memory and
+    // returns newest first; we filter by kind to keep the working set
+    // small and trust parseLine to drop bad lines.
+    const { events } = readEvents(okDir, {
+        kind: ["task.created", "task.moved"],
+        limit: 5000,
+    });
+    if (events.length === 0)
+        return buckets;
+    // Track the most recent destination per task (across ALL events, not
+    // just the window — we need the state before the first in-window move
+    // to infer the source of that first move). We rebuild this from oldest
+    // to newest so "most recent prior" is the previous move in the log.
+    const lastDest = new Map();
+    // Sort oldest-first for the bucketing pass.
+    const ordered = [...events].sort((a, b) => a.ts.localeCompare(b.ts));
+    for (const ev of ordered) {
+        if (ev.kind === "task.created") {
+            const col = ev.payload.column;
+            if (!isColumn(col))
+                continue;
+            const dayIdx = indexFor(buckets, toLocalDay(ev.ts));
+            addToColumn(buckets, col, dayIdx, 1);
+            // First move's source is treated as null (task created into col).
+            lastDest.set(ev.taskId ?? "_anon", col);
+        }
+        else if (ev.kind === "task.moved") {
+            const match = MOVE_DEST_RE.exec(ev.summary ?? "");
+            const dest = match?.[1];
+            if (!dest || !isColumn(dest))
+                continue;
+            const dayIdx = indexFor(buckets, toLocalDay(ev.ts));
+            addToColumn(buckets, dest, dayIdx, 1);
+            // Decrement the prior column (move-out) on the same day.
+            const prior = lastDest.get(ev.taskId ?? "_anon");
+            if (prior && prior !== dest) {
+                addToColumn(buckets, prior, dayIdx, -1);
+            }
+            lastDest.set(ev.taskId ?? "_anon", dest);
+        }
+    }
+    return buckets;
+}