@nonbot/mcp 0.2.4 → 0.3.1

package/README.md

@@ -100,9 +100,9 @@ Ask your agent to "list my non.bot portfolios", "show what rules apply before I
 ## Tools
 
 <!-- tool-table:start — generated by `npm run gen:tools`; tests/readme-tool-table.test.ts fails if this drifts from the code -->
-### Portfolio (27)
+### Portfolio (37)
 
-The SAFe portfolio canvas: epics, features, stories, snapshots, personas, and the Run launch surface.
+The SAFe portfolio canvas: epics, features, stories, snapshots, releases, personas, and the Run launch surface.
 
 | Tool | What it does | Kind | PAT scope |
 |---|---|---|---|
@@ -127,12 +127,22 @@ The SAFe portfolio canvas: epics, features, stories, snapshots, personas, and th
 | `portfolio_snapshot` | Save a labeled version snapshot of a portfolio’s CURRENT graph — a time-travel restore point. | write | `portfolio:write` |
 | `portfolio_move_subtree` | Move one item AND every descendant (by parentItemId) out of a portfolio into another one — an existing portfolio (target_portfolio_id) or a brand-new one (new_… | write | `portfolio:write` |
 | `portfolio_comment_post` | Post a comment on one portfolio item (optionally as a reply via parent_comment_id). | write | `portfolio:write` |
+| `portfolio_preview` | Draw the portfolio as an SVG schematic — every card at its stored Map (default) or Timeline position and size, with its level, state and title (done cards pale… | read | `portfolio:read` |
 | `portfolio_create` | Create a new, empty portfolio owned by the caller and return its id + version. | write | `portfolio:write` |
 | `portfolio_add_items` | Add up to 200 items of any level (objective, key-result, epic, feature, story, enabler, milestone) in one versioned write. | write | `portfolio:write` |
 | `portfolio_patch_item` | Change fields of ONE portfolio item without rewriting the graph (PATCH /api/portfolio/graph/node): `set` writes allowlisted PortfolioItemData fields (title, de… | write | `portfolio:write` |
 | `portfolio_layout` | Re-position every item so the Timeline reads cleanly: x from each item's start date (the canvas reads dates off x), y top-down — objectives, key results, then… | write | `portfolio:write` |
+| `portfolio_style` | Give a portfolio one consistent look in ONE versioned write: rules, applied in order, each matching cards by levels / states / ids / hasImage and setting how t… | write | `portfolio:write` |
 | `portfolio_set_meta` | Graph-level settings that travel with the portfolio (the `__graph_meta__` record): `context_text` (the portfolio's context notes — what a newcomer reads first)… | write | `portfolio:write` |
 | `portfolio_asset_upload` | Store one image (PNG / JPEG / WebP / GIF, ≤ 2.2 MB — downscale first; the app keeps images at 1024 px JPEG) in your private asset store and get back its URL, f… | write | `portfolio:write` |
+| `portfolio_completed_work` | The done items of a portfolio in a date window, computed from the graph: each row names its done date and the clock it came from (doneAt — stamped when filed,… | read | `portfolio:read` |
+| `portfolio_rebuild_done_work` | For every done card with no finish clock (no doneAt, no stateChangedAt), gather POINTERS — not verdicts — to when it finished: commits in the local git repo at… | read | `portfolio:read` (+ `radbugs:read` for radBUGS evidence) |
+| `portfolio_release_list` | The releases of a portfolio, oldest first: id, name, from–to window, draft / approvedAt / open, the chain (previous / next release by the OUT wire), member cou… | read | `portfolio:read` |
+| `portfolio_propose_releases` | Write DRAFT releases for done work that is not filed yet: one per calendar week (Mon–Sun, by each card's done date) and — unless objective_releases is false —… | write | `portfolio:write` |
+| `portfolio_release_create` | Add one release (a Release node) covering from–to, chained after the release whose window ends latest before it starts (and before the one that starts next), p… | write | `portfolio:write` |
+| `portfolio_release_file` | File cards into a release, each WITH its subtree (children by parent; from an objective, its key results' linked epics). | write | `portfolio:write` |
+| `portfolio_release_unfile` | Take cards out of their release: item_ids (exactly those cards — no subtree), or release_id for every member of one release. | write | `portfolio:write` |
+| `portfolio_release_approve` | Turn a DRAFT release into a release: files exactly the cards it proposes (still-done ones; each keeps its parent, edges and position, gets releaseId and doneAt… | write | `portfolio:write` |
 
 ### IP node (11)
 
@@ -209,12 +219,13 @@ The supervisor surface: what the daemon and the fleet are doing, plus the three
 | `run_prompt_answer` | Answer a mid-run prompt on the operator's behalf — the daemon types the answer into the live pane. | destructive | `runs:respond` (explicit; a wildcard token does not satisfy it) |
 | `run_stop_daemon` | The panic button — queue a remote shutdown for the operator's daemon (CLI ≥0.9.12). | destructive | `runs:control` |
 
-### radBUGS (1)
+### radBUGS (2)
 
-File a bug straight into the radBUGS inbox, stamped as filed from MCP.
+File a bug straight into the radBUGS inbox, stamped as filed from MCP; the site owner can list them.
 
 | Tool | What it does | Kind | PAT scope |
 |---|---|---|---|
+| `radbug_list` | List radBUGS from the non.bot inbox, newest first (open ones lead): id (ti_…), status (open \| ai_flagged \| done \| wontfix), priority, area, page URL, descripti… | read | `radbugs:read` (site owner only) |
 | `radbug_file` | File a bug report into the non.bot radBUGS inbox, stamped as filed from MCP. | write | `radbugs:write` |
 <!-- tool-table:end -->
 
@@ -245,8 +256,10 @@ Safety rails on writes: `portfolio_update` pre-fetches the live version, backs t
 - `core/http.ts` — token-bound fetch wrapper
 - `core/validate.ts` — pre-flight graph validation
 - `core/server.ts` — `registerAll(server, ctx)` (the transport-agnostic heart) + `createNonbotMcpServer(ctx)`
-- `core/toolsets/{portfolio,whygraph,run,monitor,ip,radbugs}.ts`, `core/resources.ts`, `core/prompts.ts`
-- `src/stdio.ts` — the `nonbot-mcp` bin: env/CLI-auth token + filesystem backup hook
+- `core/toolsets/{portfolio,build,release,ip,whygraph,run,monitor,radbugs}.ts`, `core/resources.ts`, `core/prompts.ts`
+- `core/releases.ts` — the Release node's membership + chain rules, restated from the app (`apps/web/src/modules/portfolio/lib/releases.ts`, `src/modules/release/lib/releaseChain.ts`) and parity-tested against it; `core/completedWork.ts` — done work, draft proposals and evidence matching
+- `core/layout.ts` — the Timeline (packed), Map and Full Stack layouts (`portfolio_layout` / `portfolio_add_items`; Full Stack's five rows restate the app's `FULL_STACK_TEMPLATE` and set y only on the Timeline, where x is the date); `core/satellites.ts` — inner-loop satellite sizes and rosters, restated from the app (`lib/innerLoopLayout.ts`, `theme/portfolio-theme.ts`) and parity-tested against it, for the Full Stack epic columns and the preview's satellite bands
+- `src/stdio.ts` — the `nonbot-mcp` bin: env/CLI-auth token + filesystem backup hook + the `git log` hook (`src/gitLog.ts`: execFile with an argv array, absolute `repo_path` only) used by `portfolio_rebuild_done_work`
 - `scripts/gen-tool-table.mjs` — prints the tool tables above from the live definitions (`--portfolio-mcp` does the same for the legacy server)
 
 ```bash

package/dist/core/completedWork.d.ts

@@ -0,0 +1,127 @@
+import { type Edge, type GraphNode } from './releases.js';
+export type DateSource = 'doneAt' | 'stateChangedAt' | 'updatedAt' | 'none';
+export declare const isoDay: (ms: number) => string;
+export declare const isoTime: (ms: number) => string;
+export declare function doneClock(n: GraphNode): {
+    at: number | null;
+    source: DateSource;
+};
+export declare function windowMs(from?: string, to?: string): {
+    lo: number;
+    hi: number;
+};
+export declare function rollupParent(n: GraphNode, byId: ReadonlyMap<string, GraphNode>, edges: ReadonlyArray<Edge>): GraphNode | null;
+export interface CompletedRow {
+    id: string;
+    title: string;
+    level: string;
+    done_at: string | null;
+    date_source: DateSource;
+    release?: {
+        id: string;
+        name: string;
+    };
+    path: string[];
+}
+export interface RollupNode {
+    id: string;
+    title: string;
+    level: string;
+    state: string;
+    counted: boolean;
+    done_at?: string | null;
+    date_source?: DateSource;
+    partially_done?: true;
+    why_not_counted?: string;
+    children: RollupNode[];
+}
+export declare function completedWork(nodes: ReadonlyArray<GraphNode>, edges: ReadonlyArray<Edge>, opts?: {
+    from?: string;
+    to?: string;
+    includeFiled?: boolean;
+}): {
+    counts: Record<string, number>;
+    date_sources: Record<DateSource, number>;
+    rows: CompletedRow[];
+    rollup: RollupNode[];
+    partially_done_parents: {
+        id: string;
+        title: string;
+        level: string;
+        state: string;
+        done_children: number;
+    }[];
+    undated: {
+        id: string;
+        title: string;
+        level: string;
+    }[];
+    filed_skipped: number;
+};
+export declare function weekName(from: string): string;
+export interface DraftProposal {
+    kind: 'week' | 'objective';
+    name: string;
+    from: string;
+    to: string;
+    proposed: string[];
+    objective_id?: string;
+}
+export declare function proposeReleases(nodes: ReadonlyArray<GraphNode>, edges: ReadonlyArray<Edge>, opts?: {
+    from?: string;
+    to?: string;
+    objectiveReleases?: boolean;
+}): {
+    drafts: DraftProposal[];
+    undated: {
+        id: string;
+        title: string;
+        level: string;
+    }[];
+    already_proposed: string[];
+    filed_skipped: number;
+};
+export interface Commit {
+    hash: string;
+    date: string;
+    subject: string;
+    body?: string;
+}
+export interface Radbug {
+    id: string;
+    status?: string;
+    description?: string;
+    rawMessage?: string | null;
+    pageUrl?: string | null;
+    createdAt?: unknown;
+    updatedAt?: unknown;
+}
+export interface Comment {
+    id?: unknown;
+    content?: unknown;
+    createdAt?: unknown;
+    userName?: unknown;
+}
+export interface Evidence {
+    kind: 'commit' | 'radbug' | 'comment';
+    ref: string;
+    date: string | null;
+    why: string;
+    text: string;
+}
+export declare function toMs(v: unknown): number | null;
+export declare const radbugTokens: (s: string) => string[];
+export declare function cites(text: string, id: string): boolean;
+export declare function matchEvidence(card: GraphNode, inputs: {
+    commits?: Commit[];
+    radbugs?: Radbug[];
+    comments?: Comment[];
+}): {
+    evidence: Evidence[];
+    proposal: {
+        done_at: string | null;
+        done_at_ms: number | null;
+        basis: 'commit' | 'radbug' | 'comment' | 'unknown';
+    };
+};
+export declare function clocklessDone(nodes: ReadonlyArray<GraphNode>): GraphNode[];

package/dist/core/completedWork.js

@@ -0,0 +1,287 @@
+import { isDone, isFiled, releaseIdOf, releaseModulesFromGraphNodes, subtreeOf, weekWindow } from './releases.js';
+const ROLLUP_ORDER = ['objective', 'key-result', 'epic', 'feature', 'story', 'enabler', 'milestone'];
+const num = (v) => (typeof v === 'number' && Number.isFinite(v) && v > 0 ? v : null);
+const title = (n) => String(n.data?.title ?? n.data?.label ?? '').trim();
+const level = (n) => String(n.data?.hierarchyLevel ?? 'item');
+const pad = (n) => String(n).padStart(2, '0');
+export const isoDay = (ms) => { const d = new Date(ms); return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`; };
+export const isoTime = (ms) => new Date(ms).toISOString();
+export function doneClock(n) {
+    const d = n.data ?? {};
+    if (num(d.doneAt))
+        return { at: d.doneAt, source: 'doneAt' };
+    if (num(d.stateChangedAt))
+        return { at: d.stateChangedAt, source: 'stateChangedAt' };
+    if (num(d.updatedAt))
+        return { at: d.updatedAt, source: 'updatedAt' };
+    return { at: null, source: 'none' };
+}
+export function windowMs(from, to) {
+    const day = (s) => new Date(Number(s.slice(0, 4)), Number(s.slice(5, 7)) - 1, Number(s.slice(8, 10)));
+    const lo = from ? day(from).getTime() : -Infinity;
+    let hi = Infinity;
+    if (to) {
+        const d = day(to);
+        d.setDate(d.getDate() + 1);
+        hi = d.getTime() - 1;
+    }
+    return { lo, hi };
+}
+const items = (nodes) => nodes.filter(n => n.type === 'portfolio-item' && typeof n.id === 'string');
+export function rollupParent(n, byId, edges) {
+    if (level(n) === 'epic') {
+        const krs = [
+            ...edges.filter(e => (e.dependencyType ?? e.type) === 'okr-link' && e.target === n.id).map(e => e.source),
+            ...[...byId.values()].filter(k => level(k) === 'key-result' && Array.isArray(k.data?.linkedEpicIds) && k.data.linkedEpicIds.includes(n.id)).map(k => k.id),
+        ];
+        for (const kr of krs) {
+            const obj = byId.get(String(byId.get(kr)?.data?.parentItemId ?? ''));
+            if (obj && level(obj) === 'objective')
+                return obj;
+        }
+    }
+    const p = n.data?.parentItemId;
+    const parent = typeof p === 'string' ? byId.get(p) : undefined;
+    return parent && parent.id !== n.id ? parent : null;
+}
+export function completedWork(nodes, edges, opts = {}) {
+    const releases = releaseModulesFromGraphNodes(nodes);
+    const all = items(nodes);
+    const byId = new Map(all.map(n => [n.id, n]));
+    const { lo, hi } = windowMs(opts.from, opts.to);
+    const windowed = opts.from !== undefined || opts.to !== undefined;
+    const counted = new Map();
+    const undated = [];
+    let filedSkipped = 0;
+    for (const n of all) {
+        if (!isDone(n))
+            continue;
+        if (!opts.includeFiled && isFiled(n, releases)) {
+            filedSkipped++;
+            continue;
+        }
+        const c = doneClock(n);
+        if (c.at === null) {
+            if (windowed) {
+                undated.push({ id: n.id, title: title(n), level: level(n) });
+                continue;
+            }
+        }
+        else if (c.at < lo || c.at > hi)
+            continue;
+        counted.set(n.id, c);
+    }
+    const chainOf = (n) => {
+        const out = [];
+        const seen = new Set([n.id]);
+        for (let p = rollupParent(n, byId, edges); p && !seen.has(p.id); p = rollupParent(p, byId, edges)) {
+            out.unshift(p);
+            seen.add(p.id);
+        }
+        return out;
+    };
+    const releaseName = (n) => {
+        const rid = releaseIdOf(n);
+        const r = rid ? releases.get(rid) : undefined;
+        return r ? { id: r.id, name: String(r.data.name ?? '') } : undefined;
+    };
+    const rows = [];
+    const tree = new Map();
+    const roots = [];
+    const nodeFor = (n) => {
+        let t = tree.get(n.id);
+        if (t)
+            return t;
+        const c = counted.get(n.id);
+        t = { id: n.id, title: title(n), level: level(n), state: String(n.data?.state ?? ''), counted: !!c, children: [] };
+        if (c) {
+            t.done_at = c.at === null ? null : isoTime(c.at);
+            t.date_source = c.source;
+        }
+        else if (!isDone(n))
+            t.partially_done = true;
+        else
+            t.why_not_counted = !opts.includeFiled && isFiled(n, releases) ? 'filed' : 'outside the window';
+        tree.set(n.id, t);
+        return t;
+    };
+    const partial = new Map();
+    for (const [id, c] of counted) {
+        const n = byId.get(id);
+        const chain = chainOf(n);
+        const rel = releaseName(n);
+        rows.push({ id, title: title(n), level: level(n), done_at: c.at === null ? null : isoTime(c.at), date_source: c.source, ...(rel ? { release: rel } : {}), path: chain.map(title) });
+        let parent = null;
+        for (const a of [...chain, n]) {
+            const t = nodeFor(a);
+            if (parent) {
+                if (!parent.children.includes(t))
+                    parent.children.push(t);
+            }
+            else if (!roots.includes(t))
+                roots.push(t);
+            parent = t;
+        }
+        for (const a of chain)
+            if (!isDone(a)) {
+                const p = partial.get(a.id) ?? { id: a.id, title: title(a), level: level(a), state: String(a.data?.state ?? ''), done_children: 0 };
+                p.done_children++;
+                partial.set(a.id, p);
+            }
+    }
+    const childIds = new Set();
+    for (const t of tree.values())
+        for (const c of t.children)
+            childIds.add(c.id);
+    const finalRoots = roots.filter(r => !childIds.has(r.id));
+    const rank = (t) => { const i = ROLLUP_ORDER.indexOf(t.level); return i < 0 ? 99 : i; };
+    const sortRec = (list) => { list.sort((a, b) => rank(a) - rank(b) || String(a.done_at ?? '').localeCompare(String(b.done_at ?? '')) || a.title.localeCompare(b.title)); for (const t of list)
+        sortRec(t.children); };
+    sortRec(finalRoots);
+    rows.sort((a, b) => String(a.done_at ?? '').localeCompare(String(b.done_at ?? '')) || a.title.localeCompare(b.title));
+    const counts = {};
+    for (const r of rows)
+        counts[r.level] = (counts[r.level] ?? 0) + 1;
+    const bySource = { doneAt: 0, stateChangedAt: 0, updatedAt: 0, none: 0 };
+    for (const r of rows)
+        bySource[r.date_source]++;
+    return { counts, date_sources: bySource, rows, rollup: finalRoots, partially_done_parents: [...partial.values()], undated, filed_skipped: filedSkipped };
+}
+const MONTHS = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+export function weekName(from) {
+    return `Week of ${MONTHS[Number(from.slice(5, 7)) - 1]} ${Number(from.slice(8, 10))}, ${from.slice(0, 4)}`;
+}
+export function proposeReleases(nodes, edges, opts = {}) {
+    const releases = releaseModulesFromGraphNodes(nodes);
+    const all = items(nodes);
+    const { lo, hi } = windowMs(opts.from, opts.to);
+    const inDraft = new Set();
+    for (const r of releases.values())
+        if (r.data.draft === true && Array.isArray(r.data.proposed))
+            for (const id of r.data.proposed)
+                if (typeof id === 'string')
+                    inDraft.add(id);
+    const clock = new Map();
+    const undated = [];
+    const alreadyProposed = [];
+    let filed = 0;
+    for (const n of all) {
+        if (!isDone(n))
+            continue;
+        if (isFiled(n, releases)) {
+            filed++;
+            continue;
+        }
+        if (inDraft.has(n.id)) {
+            alreadyProposed.push(n.id);
+            continue;
+        }
+        const c = doneClock(n);
+        if (c.at === null) {
+            undated.push({ id: n.id, title: title(n), level: level(n) });
+            continue;
+        }
+        if (c.at < lo || c.at > hi)
+            continue;
+        clock.set(n.id, c.at);
+    }
+    const drafts = [];
+    const claimed = new Set();
+    if (opts.objectiveReleases !== false) {
+        const objectives = all.filter(n => level(n) === 'objective' && clock.has(n.id)).sort((a, b) => clock.get(a.id) - clock.get(b.id));
+        for (const o of objectives) {
+            const members = [...subtreeOf([o.id], all, edges)].filter(id => clock.has(id) && !claimed.has(id));
+            if (!members.length)
+                continue;
+            for (const id of members)
+                claimed.add(id);
+            const times = members.map(id => clock.get(id));
+            drafts.push({ kind: 'objective', objective_id: o.id, name: title(o) || 'Objective', from: isoDay(Math.min(...times)), to: isoDay(Math.max(...times)), proposed: sortByClock(members, clock) });
+        }
+    }
+    const weeks = new Map();
+    for (const [id, at] of clock) {
+        if (claimed.has(id))
+            continue;
+        const w = weekWindow(new Date(at));
+        const g = weeks.get(w.from) ?? weeks.set(w.from, { to: w.to, ids: [] }).get(w.from);
+        g.ids.push(id);
+    }
+    for (const [from, g] of weeks)
+        drafts.push({ kind: 'week', name: weekName(from), from, to: g.to, proposed: sortByClock(g.ids, clock) });
+    drafts.sort((a, b) => a.from.localeCompare(b.from) || a.to.localeCompare(b.to) || a.name.localeCompare(b.name));
+    return { drafts, undated, already_proposed: alreadyProposed, filed_skipped: filed };
+}
+const sortByClock = (ids, clock) => [...ids].sort((a, b) => clock.get(a) - clock.get(b) || a.localeCompare(b));
+export function toMs(v) {
+    if (typeof v === 'number' && Number.isFinite(v) && v > 0)
+        return v;
+    if (typeof v === 'string' && v) {
+        const t = Date.parse(v);
+        return Number.isFinite(t) ? t : null;
+    }
+    return null;
+}
+const TI_RE = /\bti_[0-9a-f]{8,16}\b/g;
+export const radbugTokens = (s) => [...new Set(s.match(TI_RE) ?? [])];
+const escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+export function cites(text, id) {
+    if (id.length < 6)
+        return false;
+    return new RegExp(`(^|[^A-Za-z0-9_-])${escapeRe(id)}($|[^A-Za-z0-9_-])`).test(text);
+}
+const clip = (s, n) => String(s ?? '').replace(/\s+/g, ' ').trim().slice(0, n);
+export function matchEvidence(card, inputs) {
+    const comments = inputs.comments ?? [];
+    const own = JSON.stringify(card.data ?? {}) + ' ' + comments.map(c => String(c.content ?? '')).join(' ');
+    const tokens = radbugTokens(own);
+    const closed = (inputs.radbugs ?? []).filter(b => b.status === 'done');
+    const tied = new Map();
+    for (const b of closed) {
+        if (tokens.some(t => b.id.startsWith(t)))
+            tied.set(b.id, 'the card or its comments cite it');
+        else if (cites(`${b.description ?? ''} ${b.rawMessage ?? ''} ${b.pageUrl ?? ''}`, card.id))
+            tied.set(b.id, 'it mentions the card id');
+    }
+    for (const t of tokens)
+        if (![...tied.keys()].some(id => id.startsWith(t)))
+            tied.set(t, 'the card or its comments cite it');
+    const evidence = [];
+    for (const b of closed) {
+        const why = tied.get(b.id);
+        if (!why)
+            continue;
+        const at = toMs(b.updatedAt) ?? toMs(b.createdAt);
+        evidence.push({ kind: 'radbug', ref: b.id, date: at === null ? null : isoTime(at), why: `closed radBUG — ${why}`, text: clip(b.description, 160) });
+    }
+    const tiedIds = [...tied.keys()];
+    for (const c of inputs.commits ?? []) {
+        const msg = `${c.subject}\n${c.body ?? ''}`;
+        let why = cites(msg, card.id) ? 'cites the card id' : '';
+        if (!why) {
+            const hit = radbugTokens(msg).find(t => tiedIds.some(id => id.startsWith(t) || t.startsWith(id)));
+            if (hit)
+                why = `cites radBUG ${hit}`;
+        }
+        if (why)
+            evidence.push({ kind: 'commit', ref: c.hash.slice(0, 12), date: toMs(c.date) === null ? null : isoTime(toMs(c.date)), why, text: clip(c.subject, 160) });
+    }
+    for (const c of comments) {
+        const at = toMs(c.createdAt);
+        evidence.push({ kind: 'comment', ref: String(c.id ?? ''), date: at === null ? null : isoTime(at), why: `comment${c.userName ? ` by ${clip(c.userName, 40)}` : ''}`, text: clip(c.content, 160) });
+    }
+    const latest = (kinds) => {
+        let best = null;
+        for (const e of evidence)
+            if (kinds.includes(e.kind) && e.date && (!best || e.date > best.date))
+                best = e;
+        return best;
+    };
+    const strong = latest(['commit', 'radbug']);
+    const pick = strong ?? latest(['comment']);
+    const ms = pick?.date ? Date.parse(pick.date) : null;
+    return { evidence, proposal: { done_at: pick?.date ?? null, done_at_ms: ms, basis: pick ? pick.kind : 'unknown' } };
+}
+export function clocklessDone(nodes) {
+    return items(nodes).filter(n => isDone(n) && !num(n.data?.doneAt) && !num(n.data?.stateChangedAt));
+}

package/dist/core/config.d.ts

@@ -5,5 +5,13 @@ export interface ApiContext {
     readonly: boolean;
     backup?: (id: string, json: unknown) => Promise<void>;
     readLocalImage?: (path: string) => Promise<string>;
+    gitLog?: (repoPath: string, since: string) => Promise<GitCommit[]>;
     fetchImpl?: typeof fetch;
 }
+export interface GitCommit {
+    hash: string;
+    date: string;
+    subject: string;
+    body?: string;
+}
+export declare function checkRepoPath(p: unknown): string | null;

package/dist/core/config.js

@@ -32,3 +32,14 @@ export function resolveApiBase(raw0) {
     }
     return raw;
 }
+export function checkRepoPath(p) {
+    if (typeof p !== 'string' || !p || p.length > 1024)
+        return 'repo_path must be a non-empty absolute path (≤ 1024 chars)';
+    if (/[\0\r\n]/.test(p))
+        return 'repo_path contains a control character';
+    if (!(p.startsWith('/') || /^[A-Za-z]:[\\/]/.test(p)))
+        return 'repo_path must be absolute';
+    if (p.split(/[\\/]+/).some(seg => seg === '..'))
+        return 'repo_path must not contain a ".." segment';
+    return null;
+}

package/dist/core/layout.d.ts

@@ -10,9 +10,17 @@ export interface LayoutNode {
     };
     data?: Record<string, any>;
 }
+export interface LayoutEdge {
+    source: string;
+    target: string;
+    dependencyType?: string;
+}
 export interface LayoutOptions {
     now?: Date;
     heights?: Record<string, number>;
+    group?: 'objective';
+    edges?: LayoutEdge[];
+    objectiveOrder?: string[];
 }
 export interface LayoutResult {
     positions: Map<string, {
@@ -36,3 +44,80 @@ export declare const isItem: (n: LayoutNode) => boolean;
 export declare const isIpNode: (n: LayoutNode) => boolean;
 export declare function layoutTimeline(nodes: LayoutNode[], opts?: LayoutOptions): LayoutResult;
 export declare function applyLayout<T extends LayoutNode>(nodes: T[], res: LayoutResult): T[];
+export declare const MAP_WIDTH: Record<Level, number>;
+export declare const MAP_GRID_COLS = 3;
+export declare const MAP_GRID_MAX_COLS = 6;
+export interface MapLayoutOptions {
+    edges?: LayoutEdge[];
+    objectiveOrder?: string[];
+    heights?: Record<string, number>;
+    sizes?: Record<string, {
+        width: number;
+        height: number;
+    }>;
+    pack?: 'stack' | 'grid';
+    aspect?: number;
+    headerHeight?: number;
+    columnHeight?: number;
+}
+export interface MapBand {
+    kind: 'objective' | 'loose' | 'rest' | 'modules';
+    objectiveId: string | null;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    header: boolean;
+    items: number;
+    done: number;
+    epics: number;
+}
+export declare function layoutMap(nodes: LayoutNode[], opts?: MapLayoutOptions): Map<string, {
+    x: number;
+    y: number;
+}>;
+export declare function layoutMapDetailed(nodes: LayoutNode[], opts?: MapLayoutOptions): {
+    positions: Map<string, {
+        x: number;
+        y: number;
+    }>;
+    bands: MapBand[];
+};
+export declare function applyMapLayout<T extends LayoutNode>(nodes: T[], positions: Map<string, {
+    x: number;
+    y: number;
+}>): T[];
+export declare const FS_ROW: Record<Level, number>;
+export declare const FS_EPIC_STAGGER = 20;
+export declare const FS_LEAF_PITCH = 240;
+export declare const FS_MILESTONE_LIFT_GAP = 20;
+export declare const FS_FEATURE_MIN_WIDTH = 600;
+export declare const FS_GROUP_GAP = 240;
+export interface FullStackOptions {
+    edges?: LayoutEdge[];
+    objectiveOrder?: string[];
+    sizes?: Record<string, {
+        width: number;
+        height: number;
+    }>;
+}
+export declare function layoutFullStack(nodes: LayoutNode[], opts?: FullStackOptions): Map<string, {
+    x: number;
+    y: number;
+}>;
+export declare function applyFullStackTimeline<T extends LayoutNode>(nodes: T[], positions: Map<string, {
+    x: number;
+    y: number;
+}>): T[];
+export declare function timelineRowOverlaps(nodes: LayoutNode[]): number;
+export declare function mapBoxes(n: LayoutNode & {
+    freePosition?: {
+        x: number;
+        y: number;
+    };
+}): Array<{
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}>;