@phuetz/code-buddy 1.3.0 → 1.3.2

package/dist/fleet/colab-store.js

@@ -35,6 +35,12 @@ const PRIORITY_RANK = {
     low: 0,
 };
 const DEFAULT_CLAIM_TTL_MS = 15 * 60 * 1000;
+/**
+ * Default retry budget (Hermes-kanban parity): how many times a task may fail or
+ * be reclaimed as a zombie before it is dead-lettered to `blocked` (the "Review"
+ * column) instead of spinning forever. Per-task `retryBudget` overrides this.
+ */
+const DEFAULT_RETRY_BUDGET = 3;
 /** Derive the default `<host>/<repo>` agent id from the environment. */
 export function defaultFleetAgentId(cwd = process.cwd()) {
     const host = os.hostname().toLowerCase().split('.')[0] || 'unknown-host';
@@ -58,6 +64,8 @@ export class FleetColabStore {
     now;
     generateId;
     claimTtlMs;
+    retryBudget;
+    writeSeq = 0;
     tasksPath;
     worklogPath;
     presencePath;
@@ -70,6 +78,7 @@ export class FleetColabStore {
         let counter = 0;
         this.generateId = config.generateId ?? ((prefix) => `${prefix}-${this.now()}-${++counter}`);
         this.claimTtlMs = config.claimTtlMs ?? DEFAULT_CLAIM_TTL_MS;
+        this.retryBudget = config.retryBudget && config.retryBudget > 0 ? config.retryBudget : DEFAULT_RETRY_BUDGET;
         this.tasksPath = path.join(this.dir, 'colab-tasks.json');
         this.worklogPath = path.join(this.dir, 'colab-worklog.json');
         this.presencePath = path.join(this.dir, 'presence.json');
@@ -106,10 +115,19 @@ export class FleetColabStore {
         const claimedMs = Date.parse(task.claimedAt);
         return Number.isFinite(claimedMs) && nowMs - claimedMs > this.claimTtlMs;
     }
+    /** The dead-letter threshold for a task (its own `retryBudget`, else the store default). */
+    resolveRetryBudget(task) {
+        return typeof task.retryBudget === 'number' && task.retryBudget > 0 ? task.retryBudget : this.retryBudget;
+    }
     /**
-     * Sweep expired claims back to `open` (for a daemon to call proactively).
-     * Returns the reclaimed task ids. Lazy callers can rely on {@link nextClaimable},
-     * which already treats expired claims as available.
+     * Sweep expired claims (zombie detection) — a crashed agent's claim ages out
+     * because it stopped heartbeating. Each reclaim counts against the task's
+     * retry budget: under budget it returns to `open` for retry; at/over budget it
+     * is dead-lettered to `blocked` (the "Review" column) instead of spinning
+     * forever. Returns every reclaimed task id (re-opened or dead-lettered).
+     * Lazy callers can rely on {@link nextClaimable}, which treats an expired claim
+     * as available — but only the sweep enforces the retry budget, so a daemon
+     * should call this each tick.
      */
     reclaimExpired() {
         const file = this.readTasks();
@@ -117,9 +135,17 @@ export class FleetColabStore {
         const reclaimed = [];
         for (const task of file.tasks) {
             if (this.isClaimExpired(task, nowMs)) {
-                task.status = 'open';
+                task.attempts = (task.attempts ?? 0) + 1;
                 task.claimedBy = null;
                 task.claimedAt = null;
+                task.lastHeartbeatAt = null;
+                if (task.attempts >= this.resolveRetryBudget(task)) {
+                    task.status = 'blocked';
+                    task.blockedReason = `Reclaimed ${task.attempts}× (retry budget ${this.resolveRetryBudget(task)} exhausted) — needs review`;
+                }
+                else {
+                    task.status = 'open';
+                }
                 reclaimed.push(task.id);
             }
         }
@@ -127,6 +153,55 @@ export class FleetColabStore {
             this.writeTasks(file);
         return reclaimed;
     }
+    /**
+     * Renew a claim's lease (Hermes-kanban heartbeat). Re-stamps `claimedAt` and
+     * `lastHeartbeatAt` so a long-running but live worker is not reclaimed as a
+     * zombie. Only valid while the task is `in_progress`; when `agentId` is given it
+     * must match the current claimant.
+     */
+    heartbeat(taskId, agentId = this.agentId) {
+        const file = this.readTasks();
+        const task = file.tasks.find((t) => t.id === taskId);
+        if (!task)
+            throw new Error(`Unknown fleet task '${taskId}'`);
+        if (task.status !== 'in_progress') {
+            throw new Error(`Task '${taskId}' is '${task.status}', not in_progress — cannot heartbeat`);
+        }
+        if (task.claimedBy && agentId && task.claimedBy !== agentId) {
+            throw new Error(`Task '${taskId}' is claimed by '${task.claimedBy}', not '${agentId}'`);
+        }
+        const stamp = this.isoNow();
+        task.claimedAt = stamp;
+        task.lastHeartbeatAt = stamp;
+        this.writeTasks(file);
+        return { ...task };
+    }
+    /**
+     * Record a failed attempt (persisted retry-budget counter). Increments
+     * `attempts` and reports whether the budget is now exhausted, so the caller can
+     * dead-letter (`blockTask`) vs retry (`releaseTask`). Does not change status —
+     * the daemon owns the worklog/release flow.
+     */
+    recordFailure(taskId) {
+        const file = this.readTasks();
+        const task = file.tasks.find((t) => t.id === taskId);
+        if (!task)
+            throw new Error(`Unknown fleet task '${taskId}'`);
+        task.attempts = (task.attempts ?? 0) + 1;
+        this.writeTasks(file);
+        return { task: { ...task }, attempts: task.attempts, exhausted: task.attempts >= this.resolveRetryBudget(task) };
+    }
+    /** Reset the retry-budget counter (call on a successful attempt). */
+    resetAttempts(taskId) {
+        const file = this.readTasks();
+        const task = file.tasks.find((t) => t.id === taskId);
+        if (!task)
+            throw new Error(`Unknown fleet task '${taskId}'`);
+        if (task.attempts)
+            task.attempts = 0;
+        this.writeTasks(file);
+        return { ...task };
+    }
     /** Dependency ids that are not yet `completed` (unknown/missing ids count as unmet). */
     unmetDependencies(task, tasks) {
         if (!task.dependsOn || task.dependsOn.length === 0)
@@ -251,9 +326,11 @@ export class FleetColabStore {
             id: input.id ?? this.generateId('task'),
             title: input.title,
             ...(input.description ? { description: input.description } : {}),
-            status: 'open',
+            status: input.status ?? 'open',
             priority: input.priority ?? 'medium',
             assignedAgent: null,
+            ...(input.assignee ? { assignee: input.assignee } : {}),
+            ...(input.tags && input.tags.length > 0 ? { tags: [...new Set(input.tags)] } : {}),
             claimedBy: null,
             claimedAt: null,
             ...(input.filesToModify ? { filesToModify: input.filesToModify } : {}),
@@ -262,6 +339,7 @@ export class FleetColabStore {
             ...(input.dependsOn && input.dependsOn.length > 0 ? { dependsOn: [...new Set(input.dependsOn)] } : {}),
             ...(input.goalMode ? { goalMode: true } : {}),
             ...(goalMaxTurns !== undefined ? { goalMaxTurns } : {}),
+            ...(input.retryBudget && input.retryBudget > 0 ? { retryBudget: input.retryBudget } : {}),
             createdBy: input.createdBy ?? this.agentId,
             createdAt: this.isoNow(),
         };
@@ -302,6 +380,82 @@ export class FleetColabStore {
         this.writeTasks(file);
         return true;
     }
+    // ── Board surface (Hermes-kanban parity, drives the unified kanban_* tools) ──
+    /** Append a comment to a task's discussion thread. */
+    addComment(taskId, text, author) {
+        const trimmed = text.trim();
+        if (!trimmed)
+            throw new Error('comment text is required');
+        return this.mutateTask(taskId, (task) => {
+            (task.comments ??= []).push({
+                id: this.generateId('cmt'),
+                text: trimmed,
+                createdAt: this.isoNow(),
+                ...(author?.trim() ? { author: author.trim() } : {}),
+            });
+        });
+    }
+    /** Attach a free-form reference (PR/commit/file/url) — not a DAG edge (see {@link link}). */
+    addLink(taskId, target, label) {
+        const trimmed = target.trim();
+        if (!trimmed)
+            throw new Error('link target is required');
+        return this.mutateTask(taskId, (task) => {
+            (task.links ??= []).push({
+                id: this.generateId('lnk'),
+                target: trimmed,
+                createdAt: this.isoNow(),
+                ...(label?.trim() ? { label: label.trim() } : {}),
+            });
+        });
+    }
+    /**
+     * Tool-facing heartbeat: records a progress ping AND renews the lease. Lenient
+     * (unlike {@link heartbeat}, which is the strict programmatic lease-renewal):
+     * an `open` task transitions to `in_progress` and is claimed by `agentId`, so
+     * an agent pinging a fresh card takes ownership the way Hermes's kanban does.
+     */
+    recordHeartbeat(taskId, message, author, agentId = this.agentId) {
+        return this.mutateTask(taskId, (task) => {
+            const stamp = this.isoNow();
+            if (task.status === 'open') {
+                task.status = 'in_progress';
+                task.claimedBy = task.claimedBy ?? agentId;
+            }
+            task.claimedAt = stamp;
+            task.lastHeartbeatAt = stamp;
+            (task.heartbeats ??= []).push({
+                id: this.generateId('hb'),
+                createdAt: stamp,
+                ...(message?.trim() ? { message: message.trim() } : {}),
+                ...(author?.trim() ? { author: author.trim() } : {}),
+            });
+        });
+    }
+    /** Resume a blocked task (back to in_progress) and record why. Mirrors `kanban_unblock`. */
+    unblockTask(taskId, comment, author) {
+        return this.mutateTask(taskId, (task) => {
+            if (task.status === 'blocked')
+                task.status = 'in_progress';
+            delete task.blockedReason;
+            (task.comments ??= []).push({
+                id: this.generateId('cmt'),
+                text: comment?.trim() || 'Unblocked',
+                createdAt: this.isoNow(),
+                ...(author?.trim() ? { author: author.trim() } : {}),
+            });
+        });
+    }
+    /** Shared read-modify-write helper for single-task surface mutations. */
+    mutateTask(taskId, mutate) {
+        const file = this.readTasks();
+        const task = file.tasks.find((t) => t.id === taskId);
+        if (!task)
+            throw new Error(`Unknown fleet task '${taskId}'`);
+        mutate(task);
+        this.writeTasks(file);
+        return { ...task };
+    }
     // ── Worklog ───────────────────────────────────────────────────────────────
     appendWorklog(entry) {
         const file = this.readWorklog();
@@ -399,9 +553,30 @@ export class FleetColabStore {
             return null;
         }
     }
+    /**
+     * Atomic write (temp file + rename). `fs.renameSync` is atomic on POSIX, so a
+     * concurrent same-host reader/writer never sees a half-written file — important
+     * now that the daemon, the `kanban_*` tools, and `/colab` can all drive the
+     * same `colab-tasks.json`. (Cross-machine arbitration stays git-push-order by
+     * design; this guards only the local race.) Mirrors the idiom in
+     * `src/kanban/kanban-store.ts`.
+     */
     writeJson(filePath, value) {
         fs.mkdirSync(path.dirname(filePath), { recursive: true });
-        fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`, 'utf-8');
+        const tempPath = `${filePath}.${process.pid}.${++this.writeSeq}.tmp`;
+        try {
+            fs.writeFileSync(tempPath, `${JSON.stringify(value, null, 2)}\n`, 'utf-8');
+            fs.renameSync(tempPath, filePath);
+        }
+        catch (err) {
+            try {
+                fs.rmSync(tempPath, { force: true });
+            }
+            catch {
+                /* best-effort cleanup */
+            }
+            throw err;
+        }
     }
 }
 //# sourceMappingURL=colab-store.js.map

package/dist/index.js

@@ -508,6 +508,23 @@ async function saveCommandLineSettings(apiKey, baseURL) {
         cli.warn(`⚠️ Could not save settings to file: ${error instanceof Error ? error.message : "Unknown error"}`);
     }
 }
+/**
+ * A saved/default model is only usable if it matches the detected provider's
+ * backend: a `grok-*` slug 404s on the ChatGPT/Codex backend, and a `gpt-5.*`
+ * slug 404s on xAI. We only enforce this for the two providers with a known
+ * hard incompatibility (grok ↔ chatgpt); other providers are left untouched so
+ * local/OpenAI/Anthropic model names pass through as before.
+ */
+function isModelCompatibleWithProvider(model, provider) {
+    if (!provider)
+        return true;
+    const looksGrok = /grok/i.test(model);
+    if (provider === 'grok')
+        return looksGrok;
+    if (provider === 'chatgpt')
+        return /^(gpt-|o[1-9]|codex)/i.test(model) && !looksGrok;
+    return true;
+}
 // Load model from detected provider or user settings
 async function loadModel() {
     await ensureEnvLoaded();
@@ -517,15 +534,15 @@ async function loadModel() {
     const detected = await getDetectedProvider();
     // 2. Project/user settings override auto-detection — UNLESS the saved model is
     //    incompatible with the detected provider. A `gpt-5.5` left in settings.json
-    //    would 404 against xAI after `buddy login xai`; prefer the Grok default then.
+    //    would 404 against xAI after `buddy login xai`; symmetrically, a stale
+    //    `grok-code-fast-1` default 404s against the ChatGPT/Codex backend (which
+    //    then falls back to another unsupported slug and crashes). In either
+    //    mismatch, prefer the detected provider's own default model.
     try {
         const getSettingsManager = await lazyImport.settingsManager();
         const settingsModel = getSettingsManager().getCurrentModel();
-        if (settingsModel) {
-            const grokProvider = detected?.provider === 'grok';
-            if (!grokProvider || /grok/i.test(settingsModel)) {
-                return settingsModel;
-            }
+        if (settingsModel && isModelCompatibleWithProvider(settingsModel, detected?.provider)) {
+            return settingsModel;
         }
     }
     catch (_err) {
@@ -827,7 +844,7 @@ async function processPromptHeadless(prompt, apiKey, baseURL, model, maxToolRoun
     const previousHeadless = process.env.CODEBUDDY_HEADLESS;
     // Headless defaults MCP OFF (startup cost / determinism), but respect an
     // explicit opt-in so `CODEBUDDY_DISABLE_MCP=false buddy -p …` can use MCP
-    // servers (e.g. the Code Explorer / gitnexus bridge, or the benchmark's
+    // servers (e.g. the Code Explorer / code-explorer bridge, or the benchmark's
     // "with graph" condition). Mirrors the opt-in pattern in goal-cli.ts.
     process.env.CODEBUDDY_DISABLE_MCP = process.env.CODEBUDDY_DISABLE_MCP ?? 'true';
     process.env.CODEBUDDY_HEADLESS = 'true';
@@ -839,7 +856,7 @@ async function processPromptHeadless(prompt, apiKey, baseURL, model, maxToolRoun
         await applyActiveLlmFailover(agent);
         await agent.systemPromptReady;
         // When MCP is opted in for this headless run, wait for the servers to finish
-        // connecting so their tools (e.g. the Code Explorer / gitnexus bridge) are
+        // connecting so their tools (e.g. the Code Explorer / code-explorer bridge) are
         // registered before the first turn — otherwise the one-shot turn races init
         // and the agent never sees the MCP tools.
         if (process.env.CODEBUDDY_DISABLE_MCP !== 'true') {
@@ -2461,9 +2478,9 @@ addLazyCommandGroup(program, 'fleet', 'Inspect Fleet routing and dispatch policy
     const { registerFleetCommands } = await import('./commands/cli/fleet-commands.js');
     registerFleetCommands(program);
 });
-addLazyCommandGroup(program, 'gitnexus', 'Interact with GitNexus for code understanding and session syncing', async () => {
-    const { registerGitNexusCommands } = await import('./commands/cli/gitnexus-commands.js');
-    registerGitNexusCommands(program);
+addLazyCommandGroup(program, 'code-explorer', 'Interact with CodeExplorer for code understanding and session syncing', async () => {
+    const { registerCodeExplorerCommands } = await import('./commands/cli/code-explorer-commands.js');
+    registerCodeExplorerCommands(program);
 });
 addLazyCommandGroup(program, 'hermes', 'Inspect the native Hermes-inspired Code Buddy agent profile', async () => {
     const { registerHermesCommands } = await import('./commands/cli/hermes-commands.js');

package/dist/kanban/colab-kanban-adapter.d.ts

@@ -0,0 +1,31 @@
+import { FleetColabStore } from '../fleet/colab-store.js';
+import type { CreateKanbanCardInput, KanbanCard, KanbanStoreOptions, ListKanbanCardsFilter } from './kanban-store.js';
+export declare class ColabKanbanAdapter {
+    private readonly store;
+    private readonly createId;
+    constructor(options?: KanbanStoreOptions);
+    /** The shared board file — now colab-tasks.json, not kanban-board.json. */
+    get path(): string;
+    createCard(input: CreateKanbanCardInput): Promise<KanbanCard>;
+    listCards(filter?: ListKanbanCardsFilter): Promise<KanbanCard[]>;
+    showCard(id: string): Promise<KanbanCard>;
+    completeCard(id: string, comment?: string, author?: string): Promise<KanbanCard>;
+    blockCard(id: string, reason: string, author?: string): Promise<KanbanCard>;
+    unblockCard(id: string, comment?: string, author?: string): Promise<KanbanCard>;
+    commentCard(id: string, text: string, author?: string): Promise<KanbanCard>;
+    heartbeatCard(id: string, message?: string, author?: string): Promise<KanbanCard>;
+    linkCard(id: string, target: string, label?: string): Promise<KanbanCard>;
+    private getOrThrow;
+    private buildCardId;
+}
+/**
+ * Migrate cards from a legacy `kanban-board.json` (read as {@link KanbanCard}s)
+ * into the unified fleet board. Idempotent: a card whose id already exists is
+ * skipped, as are archived cards (colab has no archived state). Comments and
+ * free-form links are carried over; ephemeral heartbeats are not. Returns the
+ * imported / skipped ids so a CLI can report the migration.
+ */
+export declare function importKanbanCards(cards: KanbanCard[], store: FleetColabStore): {
+    imported: string[];
+    skipped: string[];
+};

package/dist/kanban/colab-kanban-adapter.js

@@ -0,0 +1,232 @@
+/**
+ * ColabKanbanAdapter — the unification seam (Hermes/OpenClaw parity).
+ *
+ * Exposes the subset of the {@link KanbanStore} API that the `kanban_*` tools
+ * use, but backed by {@link FleetColabStore} so the agent's kanban tools and the
+ * autonomous daemon drive ONE shared board (`.codebuddy/colab-tasks.json`)
+ * instead of two disconnected files. A card created with `kanban_create` is now
+ * claimable by the daemon; a task the daemon completes shows up in `kanban_list`.
+ *
+ * The output keeps the {@link KanbanCard} shape (so the tool contract is stable),
+ * with a faithful status/priority mapping. Crucially `urgent ↔ critical`, so a
+ * card marked `urgent` becomes a `critical` colab task — which
+ * {@link FleetColabStore.isAutoClaimable} refuses to auto-claim. That is the
+ * intended safety carry-over: urgent work needs human eyes, it is not silently
+ * grabbed by the daemon.
+ *
+ * Free-form `kanban_link` references (PRs/commits/files) are kept as free-form
+ * links — they are NOT folded into the `dependsOn` DAG (which stays a distinct,
+ * task-id-only concept surfaced via `buddy autonomy tasks link`).
+ *
+ * The richer multi-board surface (board registry, assign, archive, unlink, stats)
+ * stays on {@link KanbanStore} / the `hermes kanban` CLI — those are not exposed
+ * as the 9 `kanban_*` tools, so they are intentionally out of this adapter.
+ */
+import * as path from 'path';
+import { FleetColabStore, } from '../fleet/colab-store.js';
+const STATUS_TO_KANBAN = {
+    open: 'todo',
+    in_progress: 'in_progress',
+    completed: 'done',
+    blocked: 'blocked',
+};
+const STATUS_TO_COLAB = {
+    todo: 'open',
+    in_progress: 'in_progress',
+    blocked: 'blocked',
+    done: 'completed',
+    archived: 'open', // archived has no colab equivalent; treat as open (archive lives on KanbanStore)
+};
+const PRIORITY_TO_KANBAN = {
+    critical: 'urgent',
+    high: 'high',
+    medium: 'medium',
+    low: 'low',
+};
+const PRIORITY_TO_COLAB = {
+    urgent: 'critical',
+    high: 'high',
+    medium: 'medium',
+    low: 'low',
+};
+export class ColabKanbanAdapter {
+    store;
+    createId;
+    constructor(options = {}) {
+        const rootDir = options.rootDir ?? process.cwd();
+        const config = { dir: path.join(rootDir, '.codebuddy') };
+        if (options.now) {
+            const toDate = options.now;
+            config.now = () => toDate().getTime();
+        }
+        this.createId = options.createId;
+        if (options.createId) {
+            const make = options.createId;
+            config.generateId = (prefix) => `${prefix}-${make()}`;
+        }
+        this.store = new FleetColabStore(config);
+    }
+    /** The shared board file — now colab-tasks.json, not kanban-board.json. */
+    get path() {
+        return path.join(this.store.getDir(), 'colab-tasks.json');
+    }
+    async createCard(input) {
+        const title = input.title.trim();
+        if (!title)
+            throw new Error('title is required');
+        const task = this.store.addTask({
+            title,
+            ...(input.id?.trim() ? { id: input.id.trim() } : { id: this.buildCardId(title) }),
+            ...(input.description?.trim() ? { description: input.description.trim() } : {}),
+            ...(input.status ? { status: STATUS_TO_COLAB[input.status] } : {}),
+            ...(input.priority ? { priority: PRIORITY_TO_COLAB[input.priority] } : {}),
+            ...(input.assignee?.trim() ? { assignee: input.assignee.trim() } : {}),
+            ...(input.tags && input.tags.length > 0 ? { tags: normalizeTags(input.tags) } : {}),
+        });
+        return toKanbanCard(task);
+    }
+    async listCards(filter = {}) {
+        const includeDone = filter.includeDone !== false;
+        const includeArchived = filter.includeArchived === true || filter.status === 'archived';
+        return this.store
+            .listTasks()
+            .map(toKanbanCard)
+            .filter((card) => {
+            if (!includeDone && card.status === 'done')
+                return false;
+            if (!includeArchived && card.status === 'archived')
+                return false;
+            if (filter.status && card.status !== filter.status)
+                return false;
+            if (filter.priority && card.priority !== filter.priority)
+                return false;
+            if (filter.assignee && card.assignee !== filter.assignee)
+                return false;
+            if (filter.tag && !card.tags.includes(filter.tag))
+                return false;
+            return true;
+        })
+            .sort(compareCards);
+    }
+    async showCard(id) {
+        return toKanbanCard(this.getOrThrow(id));
+    }
+    async completeCard(id, comment, author) {
+        this.getOrThrow(id);
+        this.store.completeTask(id, { summary: comment?.trim() || 'Completed', ...(author ? { agentId: author } : {}) });
+        if (comment?.trim())
+            this.store.addComment(id, comment, author);
+        return toKanbanCard(this.getOrThrow(id));
+    }
+    async blockCard(id, reason, author) {
+        const trimmed = reason.trim();
+        if (!trimmed)
+            throw new Error('reason is required');
+        this.store.blockTask(id, trimmed);
+        this.store.addComment(id, `Blocked: ${trimmed}`, author);
+        return toKanbanCard(this.getOrThrow(id));
+    }
+    async unblockCard(id, comment, author) {
+        return toKanbanCard(this.store.unblockTask(id, comment, author));
+    }
+    async commentCard(id, text, author) {
+        return toKanbanCard(this.store.addComment(id, text, author));
+    }
+    async heartbeatCard(id, message, author) {
+        return toKanbanCard(this.store.recordHeartbeat(id, message, author, author));
+    }
+    async linkCard(id, target, label) {
+        return toKanbanCard(this.store.addLink(id, target, label));
+    }
+    getOrThrow(id) {
+        const task = this.store.getTask(id.trim());
+        if (!task)
+            throw new Error(`kanban card not found: ${id}`);
+        return task;
+    }
+    buildCardId(title) {
+        const slug = title.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 48) || 'card';
+        const raw = this.createId ? this.createId() : `${process.pid}${process.hrtime.bigint()}`;
+        const suffix = raw.replace(/[^a-zA-Z0-9]/g, '').slice(0, 8) || 'card';
+        return `kb-${slug}-${suffix}`;
+    }
+}
+/**
+ * Migrate cards from a legacy `kanban-board.json` (read as {@link KanbanCard}s)
+ * into the unified fleet board. Idempotent: a card whose id already exists is
+ * skipped, as are archived cards (colab has no archived state). Comments and
+ * free-form links are carried over; ephemeral heartbeats are not. Returns the
+ * imported / skipped ids so a CLI can report the migration.
+ */
+export function importKanbanCards(cards, store) {
+    const imported = [];
+    const skipped = [];
+    const existing = new Set(store.listTasks().map((t) => t.id));
+    for (const card of cards) {
+        if (card.status === 'archived' || existing.has(card.id)) {
+            skipped.push(card.id);
+            continue;
+        }
+        store.addTask({
+            id: card.id,
+            title: card.title,
+            status: STATUS_TO_COLAB[card.status],
+            priority: PRIORITY_TO_COLAB[card.priority],
+            ...(card.description ? { description: card.description } : {}),
+            ...(card.tags.length > 0 ? { tags: card.tags } : {}),
+            ...(card.assignee ? { assignee: card.assignee } : {}),
+        });
+        for (const c of card.comments)
+            store.addComment(card.id, c.text, c.author);
+        for (const l of card.links)
+            store.addLink(card.id, l.target, l.label);
+        imported.push(card.id);
+    }
+    return { imported, skipped };
+}
+function toKanbanCard(task) {
+    const createdAt = task.createdAt ?? task.claimedAt ?? new Date(0).toISOString();
+    const updatedAt = task.completedAt ?? task.lastHeartbeatAt ?? task.claimedAt ?? task.createdAt ?? createdAt;
+    return {
+        id: task.id,
+        title: task.title,
+        status: STATUS_TO_KANBAN[task.status],
+        priority: PRIORITY_TO_KANBAN[task.priority],
+        tags: normalizeTags(task.tags ?? []),
+        links: (task.links ?? []).map((l) => ({
+            id: l.id,
+            target: l.target,
+            createdAt: l.createdAt,
+            ...(l.label ? { label: l.label } : {}),
+        })),
+        comments: (task.comments ?? []).map((c) => ({
+            id: c.id,
+            text: c.text,
+            createdAt: c.createdAt,
+            ...(c.author ? { author: c.author } : {}),
+        })),
+        heartbeats: (task.heartbeats ?? []).map((h) => ({
+            id: h.id,
+            createdAt: h.createdAt,
+            ...(h.message ? { message: h.message } : {}),
+            ...(h.author ? { author: h.author } : {}),
+        })),
+        createdAt,
+        updatedAt,
+        ...(task.description ? { description: task.description } : {}),
+        ...(task.assignee ? { assignee: task.assignee } : {}),
+        ...(task.blockedReason ? { blockedReason: task.blockedReason } : {}),
+        ...(task.completedAt ? { completedAt: task.completedAt } : {}),
+    };
+}
+function normalizeTags(tags) {
+    return [...new Set(tags.map((t) => t.trim()).filter(Boolean))].sort((a, b) => a.localeCompare(b));
+}
+function compareCards(a, b) {
+    const statusOrder = { blocked: 0, in_progress: 1, todo: 2, done: 3, archived: 4 };
+    const priorityOrder = { urgent: 0, high: 1, medium: 2, low: 3 };
+    return (statusOrder[a.status] - statusOrder[b.status] ||
+        priorityOrder[a.priority] - priorityOrder[b.priority] ||
+        a.createdAt.localeCompare(b.createdAt));
+}
+//# sourceMappingURL=colab-kanban-adapter.js.map

package/dist/knowledge/community-detector.d.ts

@@ -1,5 +1,5 @@
 /**
- * Community Detection — GitNexus Knowledge Graph
+ * Community Detection — CodeExplorer Knowledge Graph
  *
  * Simplified label propagation algorithm for detecting architectural
  * modules/clusters in the code graph. Each node starts with its own

package/dist/knowledge/community-detector.js

@@ -1,5 +1,5 @@
 /**
- * Community Detection — GitNexus Knowledge Graph
+ * Community Detection — CodeExplorer Knowledge Graph
  *
  * Simplified label propagation algorithm for detecting architectural
  * modules/clusters in the code graph. Each node starts with its own

package/dist/knowledge/process-detector.d.ts

@@ -1,5 +1,5 @@
 /**
- * Process Detection — GitNexus Knowledge Graph
+ * Process Detection — CodeExplorer Knowledge Graph
  *
  * Detects execution flows by BFS from entry points in the code graph.
  * Entry points are functions with no internal callers (or matching

package/dist/knowledge/process-detector.js

@@ -1,5 +1,5 @@
 /**
- * Process Detection — GitNexus Knowledge Graph
+ * Process Detection — CodeExplorer Knowledge Graph
  *
  * Detects execution flows by BFS from entry points in the code graph.
  * Entry points are functions with no internal callers (or matching