super-backlog 0.3.1

package/dist/commands/uninstall.js

@@ -0,0 +1,279 @@
+// src/commands/uninstall.ts
+import { existsSync, readFileSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { findGitDir, POINTER_HEADING_RE } from '../init/execute.js';
+import { atomicWrite } from '../lib/atomic.js';
+import { removeGuardHook, removeRefreshHook } from '../lib/hooks.js';
+import { stripOwned } from '../lib/markers.js';
+import { PLUGIN_SPEC } from '../lib/opencode.js';
+import { isOwnedSkillFile } from '../lib/ownership.js';
+import { WANTED_SCRIPTS } from '../lib/pkgjson.js';
+const OWNED_SKILL_DIRS = [
+    '.opencode/skill/spec-to-backlog',
+    '.opencode/skill/backlog-status-report',
+    '.opencode/skill/task-review-gate',
+    '.claude/skills/spec-to-backlog',
+    '.claude/skills/backlog-status-report',
+    '.claude/skills/task-review-gate',
+];
+// ownership probe: the kit's generated dashboard carries both markers
+function isKitDashboard(content) {
+    return content.includes('id="sbl-data"') && content.includes('super-backlog');
+}
+function prettyJson(value) {
+    return `${JSON.stringify(value, null, 2)}\n`;
+}
+function removePointerSection(content) {
+    const lines = content.split('\n');
+    const idx = lines.findIndex((line) => POINTER_HEADING_RE.test(line));
+    if (idx === -1)
+        return { content, removed: false };
+    let end = lines.length;
+    for (let i = idx + 1; i < lines.length; i++) {
+        if (/^#{1,6}\s/.test(lines[i])) {
+            end = i;
+            break;
+        }
+    }
+    const kept = [...lines.slice(0, idx), ...lines.slice(end)];
+    while (kept.length > 0 && kept[kept.length - 1].trim() === '')
+        kept.pop();
+    return { content: kept.length > 0 ? `${kept.join('\n')}\n` : '', removed: true };
+}
+function uninstallPackageJson(cwd, pkg, withBacklog, report) {
+    const path = join(cwd, 'package.json');
+    if (pkg === null) {
+        for (const name of Object.keys(WANTED_SCRIPTS)) {
+            report.push({ verdict: 'skipped', label: `npm script "${name}" (package.json not found)` });
+        }
+        for (const name of ['backlog.md', 'super-backlog']) {
+            report.push({
+                verdict: 'skipped',
+                label: `devDependency "${name}" (package.json not found)`,
+            });
+        }
+        return;
+    }
+    let changed = false;
+    const hadScripts = pkg.scripts !== undefined;
+    const scripts = { ...(pkg.scripts ?? {}) };
+    for (const [name, wanted] of Object.entries(WANTED_SCRIPTS)) {
+        if (!(name in scripts)) {
+            report.push({ verdict: 'skipped', label: `npm script "${name}" (not defined)` });
+        }
+        else if (scripts[name] === wanted) {
+            delete scripts[name];
+            changed = true;
+            report.push({ verdict: 'removed', label: `npm script "${name}"` });
+        }
+        else {
+            report.push({
+                verdict: 'kept',
+                label: `npm script "${name}" (differs from kit default)`,
+            });
+        }
+    }
+    const hadDeps = pkg.devDependencies !== undefined;
+    const devDependencies = { ...(pkg.devDependencies ?? {}) };
+    for (const name of ['backlog.md', 'super-backlog']) {
+        const spec = devDependencies[name];
+        if (spec === undefined) {
+            report.push({ verdict: 'skipped', label: `devDependency "${name}" (not present)` });
+        }
+        else if (withBacklog || spec === 'latest') {
+            delete devDependencies[name];
+            changed = true;
+            report.push({ verdict: 'removed', label: `devDependency "${name}"` });
+        }
+        else {
+            report.push({
+                verdict: 'kept',
+                label: `devDependency "${name}" pinned to ${spec} (use --with-backlog to force removal)`,
+            });
+        }
+    }
+    if (!changed)
+        return;
+    const next = { ...pkg };
+    if (hadScripts || Object.keys(scripts).length > 0)
+        next.scripts = scripts;
+    if (hadDeps || Object.keys(devDependencies).length > 0)
+        next.devDependencies = devDependencies;
+    atomicWrite(path, prettyJson(next));
+}
+function uninstallPluginEntry(cwd, config, report) {
+    const path = join(cwd, 'opencode.json');
+    if (config === null) {
+        report.push({ verdict: 'skipped', label: 'opencode.json plugin entry (file not found)' });
+        return;
+    }
+    const raw = config.plugin;
+    if (raw === undefined) {
+        report.push({ verdict: 'skipped', label: 'opencode.json plugin entry (none)' });
+        return;
+    }
+    const list = Array.isArray(raw) ? [...raw] : [raw];
+    if (list.some((entry) => typeof entry === 'string' && entry === PLUGIN_SPEC)) {
+        const rest = list.filter((entry) => !(typeof entry === 'string' && entry === PLUGIN_SPEC));
+        if (rest.length === 0)
+            delete config.plugin;
+        else
+            config.plugin = rest;
+        atomicWrite(path, prettyJson(config));
+        report.push({ verdict: 'removed', label: 'opencode.json plugin entry' });
+    }
+    else if (list.some((entry) => typeof entry === 'string' && entry.startsWith('superpowers@'))) {
+        report.push({
+            verdict: 'kept',
+            label: 'opencode.json plugin entry (differs from kit default)',
+        });
+    }
+    else {
+        report.push({ verdict: 'skipped', label: 'opencode.json plugin entry (no kit entry)' });
+    }
+}
+export function runUninstall(cwd, args) {
+    const withBacklog = args.values['with-backlog'] === true;
+    const report = [];
+    // validate both JSON files up front - no mutation happens unless parsing succeeds
+    let pkg = null;
+    const pkgPath = join(cwd, 'package.json');
+    if (existsSync(pkgPath)) {
+        try {
+            pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+        }
+        catch {
+            console.error('error: package.json is not valid JSON - fix it manually, then re-run');
+            return 1;
+        }
+    }
+    let opencodeConfig = null;
+    const ocPath = join(cwd, 'opencode.json');
+    if (existsSync(ocPath)) {
+        try {
+            opencodeConfig = JSON.parse(readFileSync(ocPath, 'utf8'));
+        }
+        catch {
+            console.error('error: opencode.json is not valid JSON - fix it manually, then re-run');
+            return 1;
+        }
+    }
+    const agentsPath = join(cwd, 'AGENTS.md');
+    if (!existsSync(agentsPath)) {
+        report.push({ verdict: 'skipped', label: 'AGENTS.md managed block (file not found)' });
+    }
+    else {
+        const stripped = stripOwned(readFileSync(agentsPath, 'utf8'));
+        if (stripped.removed) {
+            atomicWrite(agentsPath, stripped.content);
+            report.push({ verdict: 'removed', label: 'AGENTS.md managed block' });
+        }
+        else {
+            report.push({ verdict: 'skipped', label: 'AGENTS.md managed block (none found)' });
+        }
+    }
+    const claudePath = join(cwd, 'CLAUDE.md');
+    if (!existsSync(claudePath)) {
+        report.push({ verdict: 'skipped', label: 'CLAUDE.md pointer section (file not found)' });
+    }
+    else {
+        const res = removePointerSection(readFileSync(claudePath, 'utf8'));
+        if (res.removed) {
+            atomicWrite(claudePath, res.content);
+            report.push({ verdict: 'removed', label: 'CLAUDE.md pointer section' });
+        }
+        else {
+            report.push({ verdict: 'skipped', label: 'CLAUDE.md pointer section (none found)' });
+        }
+    }
+    for (const rel of OWNED_SKILL_DIRS) {
+        const abs = join(cwd, ...rel.split('/'));
+        const skillMd = join(abs, 'SKILL.md');
+        if (!existsSync(skillMd)) {
+            report.push(existsSync(abs)
+                ? { verdict: 'kept', label: `${rel}/ (no SKILL.md - left untouched)` }
+                : { verdict: 'skipped', label: `${rel}/ (not found)` });
+        }
+        else if (isOwnedSkillFile(readFileSync(skillMd, 'utf8'))) {
+            rmSync(abs, { recursive: true, force: true });
+            report.push({ verdict: 'removed', label: `${rel}/` });
+        }
+        else {
+            report.push({
+                verdict: 'kept',
+                label: `${rel}/ (SKILL.md not managed by super-backlog)`,
+            });
+        }
+    }
+    uninstallPackageJson(cwd, pkg, withBacklog, report);
+    uninstallPluginEntry(cwd, opencodeConfig, report);
+    const gitDir = findGitDir(cwd);
+    if (!gitDir) {
+        report.push({ verdict: 'skipped', label: 'git pre-commit guard hook (no .git directory)' });
+    }
+    else if (!existsSync(join(gitDir, 'hooks', 'pre-commit'))) {
+        report.push({ verdict: 'skipped', label: 'git pre-commit guard hook (not installed)' });
+    }
+    else if (removeGuardHook(gitDir)) {
+        report.push({ verdict: 'removed', label: 'git pre-commit guard hook' });
+    }
+    else {
+        report.push({
+            verdict: 'kept',
+            label: 'git pre-commit hook (no super-backlog guard block)',
+        });
+    }
+    if (!gitDir) {
+        report.push({ verdict: 'skipped', label: 'git post-commit dashboard-refresh hook (no .git directory)' });
+    }
+    else if (!existsSync(join(gitDir, 'hooks', 'post-commit'))) {
+        report.push({ verdict: 'skipped', label: 'git post-commit dashboard-refresh hook (not installed)' });
+    }
+    else if (removeRefreshHook(gitDir)) {
+        report.push({ verdict: 'removed', label: 'git post-commit dashboard-refresh hook' });
+    }
+    else {
+        report.push({
+            verdict: 'kept',
+            label: 'git post-commit hook (no super-backlog dashboard-refresh block)',
+        });
+    }
+    const dashboardPath = join(cwd, 'dashboard.html');
+    if (!existsSync(dashboardPath)) {
+        report.push({ verdict: 'skipped', label: 'dashboard.html (not found)' });
+    }
+    else if (isKitDashboard(readFileSync(dashboardPath, 'utf8'))) {
+        rmSync(dashboardPath);
+        report.push({ verdict: 'removed', label: 'dashboard.html' });
+    }
+    else {
+        report.push({ verdict: 'kept', label: 'dashboard.html (not generated by super-backlog)' });
+    }
+    let dataDeleted = false;
+    const backlogDir = join(cwd, 'backlog');
+    if (!existsSync(backlogDir)) {
+        report.push({ verdict: 'skipped', label: 'backlog/ (not found)' });
+    }
+    else if (withBacklog) {
+        rmSync(backlogDir, { recursive: true, force: true });
+        dataDeleted = true;
+        report.push({ verdict: 'removed', label: 'backlog/ (project task data)' });
+    }
+    else {
+        report.push({
+            verdict: 'kept',
+            label: 'backlog/ (project task data preserved - pass --with-backlog to delete)',
+        });
+    }
+    console.log('super-backlog uninstall');
+    for (const line of report)
+        console.log(`${line.verdict}: ${line.label}`);
+    if (dataDeleted) {
+        console.log('');
+        console.log('============================================================');
+        console.log('DATA DELETED: the backlog/ directory (project task data)');
+        console.log('was permanently removed. This cannot be undone.');
+        console.log('============================================================');
+    }
+    return 0;
+}

package/dist/commands/update.js

@@ -0,0 +1,138 @@
+// src/commands/update.ts
+import { existsSync, readFileSync } from 'node:fs';
+import { basename, join, resolve } from 'node:path';
+import process from 'node:process';
+import { executeActions, findGitDir, InvalidJsonError, validateJsonFile, RefusalError, UpstreamError } from '../init/execute.js';
+import { planInit } from '../init/planner.js';
+import { GUARD_RE, REFRESH_RE } from '../lib/hooks.js';
+import { detectPackageManager } from '../lib/pm.js';
+import { resolveBacklogBin, runCapture } from '../lib/run.js';
+import { KIT_VERSION } from '../lib/version.js';
+const REFRESH_KINDS = new Set([
+    'inject-agents-block',
+    'write-claude-pointer',
+    'copy-skills',
+    'install-guard-hook',
+    'install-refresh-hook',
+    'generate-dashboard',
+]);
+export function refreshActions(all) {
+    return all.filter((action) => REFRESH_KINDS.has(action.kind));
+}
+function firstLine(text) {
+    return text.trim().split(/\r?\n/)[0] ?? '';
+}
+function guardHookInstalled(cwd) {
+    const gitDir = findGitDir(cwd);
+    if (!gitDir)
+        return false;
+    const hookPath = join(gitDir, 'hooks', 'pre-commit');
+    if (!existsSync(hookPath))
+        return false;
+    return GUARD_RE.test(readFileSync(hookPath, 'utf8'));
+}
+function refreshHookInstalled(cwd) {
+    const gitDir = findGitDir(cwd);
+    if (!gitDir)
+        return false;
+    const hookPath = join(gitDir, 'hooks', 'post-commit');
+    if (!existsSync(hookPath))
+        return false;
+    return REFRESH_RE.test(readFileSync(hookPath, 'utf8'));
+}
+export async function runUpdate(cwd, _args) {
+    // Up-front detection-failure check (mirrors uninstall): refuse before mutating anything.
+    for (const f of ['package.json', 'opencode.json']) {
+        const p = join(cwd, f);
+        if (!existsSync(p))
+            continue;
+        try {
+            validateJsonFile(p, f);
+        }
+        catch (err) {
+            if (err instanceof InvalidJsonError) {
+                console.error(`error: ${err.message}`);
+                return 1;
+            }
+            throw err;
+        }
+    }
+    const state = {
+        cwd,
+        detectedPm: detectPackageManager(cwd),
+        hasBacklogConfig: existsSync(join(cwd, 'backlog', 'config.yml')),
+        agentsExists: existsSync(join(cwd, 'AGENTS.md')),
+        claudeMdExists: existsSync(join(cwd, 'CLAUDE.md')),
+        opencodeConfig: undefined,
+        pkgExists: existsSync(join(cwd, 'package.json')),
+    };
+    const projectName = basename(resolve(cwd));
+    const opts = {
+        projectName,
+        harnesses: ['opencode', 'claude'],
+        pm: 'auto',
+        guard: guardHookInstalled(cwd),
+        refreshHook: refreshHookInstalled(cwd),
+        dashboard: existsSync(join(cwd, 'dashboard.html')),
+        skipInstall: false,
+    };
+    const plan = planInit(state, opts, KIT_VERSION);
+    const actions = refreshActions(plan.actions);
+    const warnings = [...plan.warnings];
+    try {
+        const result = await executeActions(cwd, actions, {
+            version: KIT_VERSION,
+            projectName,
+            hasBacklogConfig: state.hasBacklogConfig,
+        });
+        warnings.push(...result.warnings);
+        console.log(`super-backlog update complete - refreshed ${actions.length} action(s), applied ${result.applied}, skipped ${result.skipped}`);
+    }
+    catch (err) {
+        if (err instanceof RefusalError) {
+            console.error(`error: ${err.message}`);
+            return 2;
+        }
+        if (err instanceof UpstreamError) {
+            console.error(`error: upstream command failed: ${err.message}`);
+            return 3;
+        }
+        throw err;
+    }
+    console.log('upstream versions:');
+    const bin = resolveBacklogBin(cwd);
+    if (bin === null) {
+        warnings.push('backlog binary not found - local backlog.md version unavailable');
+    }
+    else {
+        const local = runCapture(bin, ['--version'], cwd);
+        if (local.status === 0) {
+            console.log(`  backlog.md (local):    ${firstLine(local.stdout)}`);
+        }
+        else {
+            warnings.push(`\`${bin} --version\` failed with exit code ${local.status}`);
+        }
+    }
+    const npm = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+    let published = null;
+    try {
+        // test seam: SBL_FORCE_OFFLINE makes e2e runs take the offline path deterministically
+        if (process.env.SBL_FORCE_OFFLINE)
+            throw new Error('forced offline');
+        const view = runCapture(npm, ['view', 'backlog.md', 'version'], cwd);
+        if (view.status === 0)
+            published = firstLine(view.stdout);
+    }
+    catch {
+        published = null;
+    }
+    if (published === null) {
+        warnings.push('could not query the npm registry (offline?) - published version unavailable');
+    }
+    else {
+        console.log(`  backlog.md (latest):   ${published}`);
+    }
+    for (const warning of warnings)
+        console.log(`warning: ${warning}`);
+    return warnings.length > 0 ? 4 : 0;
+}

package/dist/dashboard/data.js

@@ -0,0 +1,281 @@
+// src/dashboard/data.ts
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { resolveBacklogBin, runCapture } from '../lib/run.js';
+import { readSimpleKeys } from '../lib/yamlmini.js';
+function isRecord(v) {
+    return typeof v === 'object' && v !== null && !Array.isArray(v);
+}
+function asString(v) {
+    if (typeof v === 'string' && v.trim().length > 0)
+        return v.trim();
+    if (typeof v === 'number' && Number.isFinite(v))
+        return String(v);
+    return undefined;
+}
+/**
+ * Parse the stdout of `backlog task list --json` defensively.
+ * Accepts `{tasks:[...]}` and bare-array shapes; anything else throws
+ * so the caller can degrade to fallback-empty.
+ */
+export function parseTasksJson(raw) {
+    const trimmed = raw.trim();
+    if (trimmed.length === 0)
+        throw new Error('empty task list output');
+    const parsed = JSON.parse(trimmed);
+    if (Array.isArray(parsed))
+        return parsed.filter(isRecord);
+    if (isRecord(parsed) && Array.isArray(parsed['tasks'])) {
+        return parsed['tasks'].filter(isRecord);
+    }
+    throw new Error('unrecognized task list shape');
+}
+function normalizeAcs(value) {
+    if (!Array.isArray(value))
+        return [];
+    const out = [];
+    for (const item of value) {
+        if (typeof item === 'string') {
+            if (item.trim().length > 0)
+                out.push({ text: item.trim(), checked: false });
+            continue;
+        }
+        if (isRecord(item)) {
+            const text = asString(item['text']) ?? asString(item['title']) ?? asString(item['description']);
+            if (text === undefined)
+                continue;
+            const checked = item['checked'] === true || item['done'] === true;
+            out.push({ text, checked });
+        }
+    }
+    return out;
+}
+export function normalizeTasks(rawTasks) {
+    return rawTasks.map((t) => ({
+        id: asString(t['id']) ?? '',
+        title: asString(t['title']) ?? '(untitled)',
+        status: asString(t['status']) ?? 'Unknown',
+        priority: asString(t['priority']),
+        assignee: asString(t['assignee']),
+        updated: asString(t['updated_at']) ?? asString(t['updated']),
+        milestone: asString(t['milestone']),
+        description: asString(t['description']),
+        acs: normalizeAcs(t['acceptance_criteria']),
+    }));
+}
+export function computeStatuses(tasks) {
+    const counts = new Map();
+    for (const t of tasks)
+        counts.set(t.status, (counts.get(t.status) ?? 0) + 1);
+    return [...counts.entries()]
+        .map(([status, count]) => ({ status, count }))
+        .sort((a, b) => a.status.localeCompare(b.status));
+}
+export function computeMilestones(tasks) {
+    const acc = new Map();
+    for (const t of tasks) {
+        if (!t.milestone)
+            continue;
+        const m = acc.get(t.milestone) ?? { done: 0, total: 0 };
+        m.total++;
+        if (t.status.toLowerCase() === 'done')
+            m.done++;
+        acc.set(t.milestone, m);
+    }
+    return [...acc.entries()]
+        .map(([name, m]) => ({ name, done: m.done, total: m.total }))
+        .sort((a, b) => a.name.localeCompare(b.name));
+}
+/**
+ * Extract dependency edges from raw task JSON. Accepts `dependsOn` or `deps`
+ * as an array of string ids; anything else contributes nothing. Dangling `to`
+ * ids are kept (the graph filters later), malformed entries are dropped.
+ */
+export function computeDeps(rawTasks) {
+    const out = [];
+    for (const t of rawTasks) {
+        const from = asString(t['id']);
+        if (!from)
+            continue;
+        for (const field of ['dependsOn', 'deps']) {
+            const value = t[field];
+            if (!Array.isArray(value))
+                continue;
+            for (const entry of value) {
+                if (typeof entry !== 'string')
+                    continue;
+                const to = entry.trim();
+                if (to.length === 0)
+                    continue;
+                out.push({ from, to });
+            }
+            break;
+        }
+    }
+    return out;
+}
+function isoDay(value) {
+    if (!value)
+        return undefined;
+    const m = /^(\d{4}-\d{2}-\d{2})/.exec(value.trim());
+    if (m)
+        return m[1];
+    const d = new Date(value);
+    return Number.isNaN(d.getTime()) ? undefined : d.toISOString().slice(0, 10);
+}
+function shiftDay(day, deltaDays) {
+    const [y, mo, d] = day.split('-').map(Number);
+    return new Date(Date.UTC(y, mo - 1, d) + deltaDays * 86400000).toISOString().slice(0, 10);
+}
+/** Bucket tasks into exactly 30 UTC daily buckets ending at `today`, oldest first. */
+export function computeActivity(rawTasks, today) {
+    const counts = new Map();
+    for (const t of rawTasks) {
+        const day = isoDay(asString(t['updated_at']) ?? asString(t['updated'])) ??
+            isoDay(asString(t['created_at'])) ??
+            today;
+        counts.set(day, (counts.get(day) ?? 0) + 1);
+    }
+    const start = shiftDay(today, -29);
+    const out = [];
+    for (let i = 0; i < 30; i++) {
+        const date = shiftDay(start, i);
+        out.push({ date, count: counts.get(date) ?? 0 });
+    }
+    return out;
+}
+export const BUILT_IN_GLOSSARY = [
+    { term: 'AC', definition: 'Acceptance criterion — one checkable condition a task must satisfy before it can be done.' },
+    { term: 'DoD', definition: 'Definition of Done — the shared bar every task must clear before moving to Done.' },
+    { term: 'Milestone', definition: 'A named delivery waypoint that groups tasks and tracks done/total progress.' },
+    { term: 'Review Gate', definition: 'A human checkpoint where specs, plans or code are reviewed before work proceeds.' },
+    { term: 'TDD', definition: 'Test-Driven Development — write the failing test first (RED), then minimal code to pass (GREEN).' },
+    { term: 'Brainstorming', definition: 'Structured exploration of intent, requirements and design before any creative work.' },
+    { term: 'Design Gate', definition: 'The point where a human approves the design document before decomposition.' },
+    { term: 'Spec-to-Backlog', definition: 'Decomposing an approved design into reviewed backlog tasks with acceptance criteria.' },
+    { term: 'Plan-before-Code', definition: 'Implementation starts only after a written implementation plan is approved.' },
+    { term: 'Draft', definition: 'An unapproved Backlog.md task proposal awaiting promotion to the board.' },
+    { term: 'Worktree', definition: 'An isolated git checkout (e.g. .worktrees/<branch>) used for feature work.' },
+    { term: 'Backlog.md', definition: 'File-based task management CLI owning specs, statuses and history under backlog/.' },
+    { term: 'Superpowers', definition: 'The methodology skill set that decides HOW the work is done.' },
+    { term: 'Pipeline', definition: 'The nine workflow phases from Idea to Merge & archive.' },
+    { term: 'Freshness Hook', definition: 'A post-commit git hook that regenerates dashboard.html when commits touch backlog/.' },
+];
+/** Split `## Term` headings plus their following non-heading block into entries; empty sections are skipped. */
+export function parseGlossaryMarkdown(content) {
+    const out = [];
+    let term;
+    let buffer = [];
+    const flush = () => {
+        if (term !== undefined) {
+            const definition = buffer.join('\n').trim();
+            if (definition.length > 0)
+                out.push({ term, definition });
+        }
+        term = undefined;
+        buffer = [];
+    };
+    for (const line of content.split(/\r?\n/)) {
+        const heading = /^##\s+(.+?)\s*$/.exec(line);
+        if (heading) {
+            flush();
+            term = heading[1].trim();
+            continue;
+        }
+        if (term !== undefined)
+            buffer.push(line);
+    }
+    flush();
+    return out;
+}
+/** Built-in terms first; project terms override case-insensitively in place, new terms append. */
+export function mergeGlossary(projectEntries) {
+    const out = BUILT_IN_GLOSSARY.map((e) => ({ ...e }));
+    const indexByTerm = new Map(out.map((e, i) => [e.term.toLowerCase(), i]));
+    for (const entry of projectEntries) {
+        const key = entry.term.toLowerCase();
+        const existing = indexByTerm.get(key);
+        if (existing !== undefined) {
+            out[existing] = { term: out[existing].term, definition: entry.definition };
+        }
+        else {
+            indexByTerm.set(key, out.length);
+            out.push({ term: entry.term, definition: entry.definition });
+        }
+    }
+    return out;
+}
+function readProjectGlossary(cwd) {
+    try {
+        const path = join(cwd, 'backlog', 'docs', 'glossary.md');
+        if (!existsSync(path))
+            return [];
+        return parseGlossaryMarkdown(readFileSync(path, 'utf8'));
+    }
+    catch {
+        return [];
+    }
+}
+function readProjectIdentity(cwd) {
+    const cfg = readSimpleKeys(join(cwd, 'backlog', 'config.yml'), [
+        'project_name',
+        'name',
+        'description',
+    ]);
+    let pkg;
+    const pkgPath = join(cwd, 'package.json');
+    if (existsSync(pkgPath)) {
+        try {
+            pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+        }
+        catch {
+            pkg = undefined;
+        }
+    }
+    const name = asString(cfg['project_name']) ??
+        asString(cfg['name']) ??
+        asString(pkg?.['name']) ??
+        'Untitled project';
+    const description = asString(cfg['description']) ?? asString(pkg?.['description']) ?? '';
+    return { name, description };
+}
+export function collectDashboardData(cwd, opts) {
+    const today = opts.today && /^\d{4}-\d{2}-\d{2}$/.test(opts.today.trim())
+        ? opts.today.trim()
+        : new Date().toISOString().slice(0, 10);
+    const base = {
+        project: readProjectIdentity(cwd),
+        generatedAt: new Date().toISOString(),
+        kitVersion: opts.kitVersion,
+        statuses: [],
+        milestones: [],
+        tasks: [],
+        deps: [],
+        activity: computeActivity([], today),
+        glossary: mergeGlossary(readProjectGlossary(cwd)),
+        source: 'fallback-empty',
+    };
+    try {
+        const bin = resolveBacklogBin(cwd);
+        if (!bin)
+            return base;
+        const res = runCapture(bin, ['task', 'list', '--json'], cwd);
+        if (res.status !== 0)
+            return base;
+        const rawTasks = parseTasksJson(res.stdout);
+        const tasks = normalizeTasks(rawTasks);
+        return {
+            ...base,
+            tasks,
+            statuses: computeStatuses(tasks),
+            milestones: computeMilestones(tasks),
+            deps: computeDeps(rawTasks),
+            activity: computeActivity(rawTasks, today),
+            source: 'backlog-json',
+        };
+    }
+    catch {
+        // Any parse/exec failure degrades to an empty dashboard; never crash.
+        return base;
+    }
+}