@north-light/crouter 0.3.154

package/dist/core/inspector/core.js

@@ -0,0 +1,148 @@
+import { record, scheduledItems } from './model.js';
+function error(kind, headline, explanation, blocking) {
+    return { kind, display: { headline, explanation, nextStep: 'Press g to retry.', level: 'error', blocking } };
+}
+function parseJson(raw, command, blocking) {
+    if (!raw.ok)
+        return { ok: false, error: error('unavailable', 'Inspector unavailable', `Could not run crtr: ${raw.stderr || 'command not found'}`, blocking) };
+    if (raw.exitCode !== 0)
+        return { ok: false, error: error('failed', blocking ? 'Node is gone' : 'Schedule unavailable', raw.stderr || raw.stdout || `crtr ${command} failed`, blocking) };
+    try {
+        const data = JSON.parse(raw.stdout);
+        if (data === null || typeof data !== 'object' || Array.isArray(data))
+            throw new Error('not an object');
+        return { ok: true, data: data };
+    }
+    catch {
+        return { ok: false, error: error('parse', 'Inspector unavailable', `Could not parse crtr ${command} JSON.`, blocking) };
+    }
+}
+const dossierSource = {
+    id: 'dossier',
+    request: (target) => ({ kind: 'exec', bin: 'crtr', args: ['--json', 'node', 'inspect', 'show', target] }),
+    parse: (raw) => parseJson(raw, 'node inspect show', true),
+};
+const scheduleSource = {
+    id: 'schedule',
+    request: () => ({ kind: 'exec', bin: 'crtr', args: ['--json', 'cron', 'list'] }),
+    parse: (raw) => {
+        const result = parseJson(raw, 'cron list', false);
+        if (!result.ok)
+            return result;
+        const crons = result.data['crons'];
+        if (!Array.isArray(crons))
+            return { ok: false, error: error('parse', 'Schedule unavailable', 'The cron list did not contain cron rows.', false) };
+        return { ok: true, data: crons };
+    },
+};
+const cancelCommand = {
+    id: 'cancel',
+    request: (id) => ({ kind: 'exec', bin: 'crtr', args: ['--json', 'cron', 'cancel', id] }),
+    parse: (raw) => {
+        const result = parseJson(raw, 'cron cancel', false);
+        if (!result.ok)
+            return result;
+        return { ok: true, data: { canceled: String(result.data['canceled'] ?? '') } };
+    },
+};
+function section(value) {
+    return value === 'schedule' || value === 'raw' ? value : 'overview';
+}
+function reconcile(state, next) {
+    const items = scheduledItems(next);
+    const had = state.selectedCronId;
+    if (had !== null && items.some((item) => item.cron.cron_id === had))
+        return { ...state, schedule: { data: next, error: null, fetchedAt: Date.now() } };
+    const previousIndex = scheduledItems(state.schedule.data ?? []).findIndex((item) => item.cron.cron_id === had);
+    const replacement = items[Math.min(Math.max(0, previousIndex), Math.max(0, items.length - 1))];
+    return { ...state, schedule: { data: next, error: null, fetchedAt: Date.now() }, selectedCronId: replacement?.cron.cron_id ?? null, expanded: false, pendingCancel: null };
+}
+export const inspectorCore = {
+    manifest: { id: 'inspector', title: 'Inspector', description: 'Node overview and scheduled crons', refreshMs: 5000 },
+    init(options) {
+        return {
+            target: options['target'] ?? '', section: section(options['section']),
+            dossier: { data: null, error: null, fetchedAt: 0 }, schedule: { data: null, error: null, fetchedAt: 0 },
+            selectedCronId: null, expanded: false, pendingCancel: null,
+            scroll: { overview: 0, schedule: 0, raw: 0 },
+        };
+    },
+    sources: { dossier: dossierSource, schedule: scheduleSource },
+    commands: { cancel: cancelCommand },
+    intents: {
+        async refresh(ctx) {
+            ctx.signal.setStatus('Refreshing…');
+            const dossier = await ctx.resolve(dossierSource, ctx.state.target);
+            if (!dossier.ok) {
+                ctx.set((state) => ({ ...state, dossier: { ...state.dossier, error: dossier.error } }));
+                ctx.signal.setBanner(`${dossier.error.display.headline}: ${dossier.error.display.explanation}`, 'error');
+                ctx.signal.setStatus(null);
+                return;
+            }
+            ctx.set((state) => ({ ...state, dossier: { data: dossier.data, error: null, fetchedAt: Date.now() } }));
+            const schedule = await ctx.resolve(scheduleSource, ctx.state.target);
+            if (!schedule.ok) {
+                ctx.set((state) => ({ ...state, schedule: { ...state.schedule, error: schedule.error } }));
+                ctx.signal.setBanner(schedule.error.display.explanation, 'error');
+            }
+            else {
+                const before = ctx.state.selectedCronId;
+                ctx.set((state) => reconcile(state, schedule.data));
+                if (before !== null && !schedule.data.some((cron) => cron.cron_id === before))
+                    ctx.signal.setStatus('Selected cron disappeared; moved to the next item.');
+                else
+                    ctx.signal.setStatus(`${schedule.data.length} cron(s) armed`);
+                ctx.signal.clearBanner();
+            }
+            const node = record(ctx.state.dossier.data?.['node']);
+            ctx.signal.setSubtitle(`${node['name'] ?? ctx.state.target} · ${ctx.state.section}`);
+        },
+        sectionNext(ctx) { const order = ['overview', 'schedule', 'raw']; const next = order[(order.indexOf(ctx.state.section) + 1) % order.length]; ctx.set((state) => ({ ...state, section: next })); ctx.signal.setSubtitle(`${ctx.state.target} · ${next}`); },
+        sectionPrev(ctx) { const order = ['overview', 'schedule', 'raw']; const next = order[(order.indexOf(ctx.state.section) + order.length - 1) % order.length]; ctx.set((state) => ({ ...state, section: next })); ctx.signal.setSubtitle(`${ctx.state.target} · ${next}`); },
+        down(ctx) { ctx.set((state) => move(state, 1)); },
+        up(ctx) { ctx.set((state) => move(state, -1)); },
+        pageDown(ctx) { ctx.set((state) => ({ ...state, scroll: { ...state.scroll, [state.section]: state.scroll[state.section] + 8 } })); },
+        pageUp(ctx) { ctx.set((state) => ({ ...state, scroll: { ...state.scroll, [state.section]: Math.max(0, state.scroll[state.section] - 8) } })); },
+        toggleDetail(ctx) { if (ctx.state.selectedCronId !== null)
+            ctx.set((state) => ({ ...state, expanded: !state.expanded })); },
+        cancelItem(ctx) { if (ctx.state.selectedCronId === null)
+            return; ctx.set((state) => ({ ...state, pendingCancel: state.selectedCronId })); ctx.signal.setBanner(`Cancel ${ctx.state.selectedCronId}? Press y to confirm.`, 'action'); },
+        async confirm(ctx) {
+            const id = ctx.state.pendingCancel;
+            if (id === null)
+                return;
+            ctx.signal.setStatus('Canceling cron…');
+            const result = await ctx.execute(cancelCommand, id);
+            ctx.set((state) => ({ ...state, pendingCancel: null }));
+            if (!result.ok) {
+                ctx.signal.setBanner(result.error.display.explanation, 'error');
+                return;
+            }
+            await ctx.dispatch('refresh');
+            const stillArmed = (ctx.state.schedule.data ?? []).some((cron) => cron.cron_id === id);
+            ctx.signal.setBanner(stillArmed ? 'Cron remains armed; refresh and retry.' : 'Cron canceled.', stillArmed ? 'error' : 'info');
+        },
+        dismiss(ctx) { ctx.set((state) => ({ ...state, pendingCancel: null })); ctx.signal.clearBanner(); },
+        retarget(ctx) {
+            const cron = selectedItem(ctx.state)?.cron;
+            const next = cron?.anchor_node ?? cron?.created_by;
+            if (!next)
+                return;
+            ctx.set((state) => ({ ...state, target: next, selectedCronId: null, expanded: false, pendingCancel: null, dossier: { data: null, error: null, fetchedAt: 0 }, schedule: { data: null, error: null, fetchedAt: 0 } }));
+            void ctx.dispatch('refresh');
+        },
+        quit(ctx) { ctx.signal.quit(); },
+    },
+};
+function selectedItem(state) { return scheduledItems(state.schedule.data ?? []).find((item) => item.cron.cron_id === state.selectedCronId); }
+function move(state, delta) {
+    if (state.section !== 'schedule')
+        return { ...state, scroll: { ...state.scroll, [state.section]: Math.max(0, state.scroll[state.section] + delta) } };
+    const items = scheduledItems(state.schedule.data ?? []);
+    if (items.length === 0)
+        return state;
+    const current = Math.max(0, items.findIndex((item) => item.cron.cron_id === state.selectedCronId));
+    const next = Math.max(0, Math.min(items.length - 1, current + delta));
+    return { ...state, selectedCronId: items[next].cron.cron_id, expanded: false, pendingCancel: null };
+}
+export { scheduledItems };

package/dist/core/inspector/model.d.ts

@@ -0,0 +1,54 @@
+import type { CronDTO } from '../../api/dto/crons.js';
+export type InspectorSection = 'overview' | 'schedule' | 'raw';
+export interface ScheduledItem {
+    cron: CronDTO;
+    nextAt: string;
+    cadence: string;
+    target: string;
+}
+export declare const ICON: {
+    readonly identity: string;
+    readonly state: string;
+    readonly place: string;
+    readonly graph: string;
+    readonly artifacts: string;
+    readonly paths: string;
+    readonly cron: string;
+    readonly section: string;
+    readonly raw: string;
+    readonly empty: string;
+};
+/** Semantic tone for a value. Hue is always paired with a word or glyph so the
+ *  meaning survives NO_COLOR / a mono terminal. */
+export type Tone = 'plain' | 'dim' | 'good' | 'warn' | 'bad' | 'accent';
+export interface Field {
+    label: string;
+    value: string;
+    tone?: Tone;
+    /** Glyph drawn immediately before the value, in the value's tone. */
+    glyph?: string;
+}
+export interface Group {
+    icon: string;
+    title: string;
+    fields: Field[];
+}
+export declare function statusVisual(status: string): {
+    glyph: string;
+    tone: Tone;
+};
+export declare function scheduledItems(crons: readonly CronDTO[]): ScheduledItem[];
+export declare function relativeTime(iso: string | null, now?: number): string;
+/** How long ago an ISO timestamp was, e.g. `3d ago`. `—` when absent. */
+export declare function ago(iso: unknown, now?: number): string;
+/** `$HOME/x` → `~/x`; everything else verbatim. Paths are long and the tail is
+ *  the informative end, so the draw layer clips them, not this. */
+export declare function shortPath(input: unknown, home?: string): string;
+/** 97526 → `97.5k`. Token counts are read at a glance, not audited. */
+export declare function compactCount(input: unknown): string;
+/** The overview, grouped into the cards the presenters draw. Ordering is the
+ *  reading order: who → what it is doing → where → its graph → what it produced
+ *  → where that lives on disk. */
+export declare function overviewGroups(dossier: Record<string, unknown> | null): Group[];
+export declare function record(value: unknown): Record<string, unknown>;
+export declare function value(value: unknown): string;

package/dist/core/inspector/model.js

@@ -0,0 +1,182 @@
+// ── Visual vocabulary ────────────────────────────────────────────────────────
+//
+// Nerd Font private-use-area glyphs, same convention (and codepoint style) as
+// the command icons in preview-registry.ts. Every glyph is decoration ON TOP of
+// a word — nothing here is the sole carrier of meaning, so a terminal without
+// the font still reads correctly.
+const cp = (code) => String.fromCodePoint(code);
+export const ICON = {
+    identity: cp(0xf2c0), // user-circle — who this node is
+    state: cp(0xf111), // circle — what it is doing
+    place: cp(0xf07b), // folder — where it runs
+    graph: cp(0xf1e0), // share-alt — its spine neighbours
+    artifacts: cp(0xf1da), // history/archive — what it left behind
+    paths: cp(0xf0f6), // file-text — on-disk locations
+    cron: cp(0xf017), // clock — one armed cron
+    section: cp(0xf192), // dot-circle — the active tab marker
+    raw: cp(0xf121), // code — the raw record
+    empty: cp(0xf1b3), // cubes — nothing armed
+};
+/** Node-status glyph + tone. Mirrors canvas/status-glyph.ts, which cannot be
+ *  imported here: it pulls the runtime fault/event modules into a view module
+ *  that must stay a thin read over `crtr --json` output. */
+const STATUS_VISUAL = {
+    active: { glyph: '●', tone: 'good' },
+    idle: { glyph: '○', tone: 'warn' },
+    done: { glyph: '✓', tone: 'accent' },
+    dead: { glyph: '✗', tone: 'bad' },
+    canceled: { glyph: '⊘', tone: 'dim' },
+};
+export function statusVisual(status) {
+    return STATUS_VISUAL[status] ?? { glyph: '◆', tone: 'plain' };
+}
+export function scheduledItems(crons) {
+    return crons.map((cron) => ({
+        cron,
+        nextAt: cron.fire_at,
+        cadence: cron.recur === null || cron.recur === 'none' ? 'one-shot' : cron.recur,
+        target: cron.sink ?? cron.anchor_node ?? 'daemon',
+    })).sort((a, b) => {
+        if (a.nextAt !== b.nextAt)
+            return a.nextAt.localeCompare(b.nextAt);
+        return a.cron.cron_id.localeCompare(b.cron.cron_id);
+    });
+}
+export function relativeTime(iso, now = Date.now()) {
+    if (iso === null)
+        return '—';
+    const at = Date.parse(iso);
+    if (!Number.isFinite(at))
+        return iso;
+    const diff = at - now;
+    if (diff <= 0)
+        return 'due now';
+    const minutes = Math.ceil(diff / 60_000);
+    if (minutes < 60)
+        return `in ${minutes}m`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `in ${hours}h${minutes % 60 ? ` ${minutes % 60}m` : ''}`;
+    return `in ${Math.floor(hours / 24)}d${hours % 24 ? ` ${hours % 24}h` : ''}`;
+}
+/** How long ago an ISO timestamp was, e.g. `3d ago`. `—` when absent. */
+export function ago(iso, now = Date.now()) {
+    if (typeof iso !== 'string' || iso === '')
+        return '—';
+    const at = Date.parse(iso);
+    if (!Number.isFinite(at))
+        return String(iso);
+    const seconds = Math.max(0, Math.floor((now - at) / 1000));
+    if (seconds < 60)
+        return `${seconds}s ago`;
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m ago`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours}h ago`;
+    const days = Math.floor(hours / 24);
+    return days < 30 ? `${days}d ago` : `${Math.floor(days / 30)}mo ago`;
+}
+/** `$HOME/x` → `~/x`; everything else verbatim. Paths are long and the tail is
+ *  the informative end, so the draw layer clips them, not this. */
+export function shortPath(input, home = process.env['HOME'] ?? '') {
+    const text = value(input);
+    if (home !== '' && text.startsWith(`${home}/`))
+        return `~${text.slice(home.length)}`;
+    return text;
+}
+/** 97526 → `97.5k`. Token counts are read at a glance, not audited. */
+export function compactCount(input) {
+    const n = Number(input);
+    if (!Number.isFinite(n))
+        return value(input);
+    if (n < 1000)
+        return String(n);
+    if (n < 1_000_000)
+        return `${(n / 1000).toFixed(n < 10_000 ? 1 : 0)}k`;
+    return `${(n / 1_000_000).toFixed(1)}M`;
+}
+function neighbors(input) {
+    return Array.isArray(input) ? input.filter((n) => typeof n === 'object' && n !== null) : [];
+}
+function neighborLine(list) {
+    if (list.length === 0)
+        return '—';
+    const names = list.slice(0, 3).map((n) => n.name ?? n.node_id ?? '?');
+    return list.length > 3 ? `${names.join(', ')} +${list.length - 3}` : names.join(', ');
+}
+/** The overview, grouped into the cards the presenters draw. Ordering is the
+ *  reading order: who → what it is doing → where → its graph → what it produced
+ *  → where that lives on disk. */
+export function overviewGroups(dossier) {
+    const node = record(dossier?.['node']);
+    const paths = record(dossier?.['paths']);
+    const artifacts = record(dossier?.['artifacts']);
+    const status = value(node['status']);
+    const visual = statusVisual(status);
+    const intent = value(node['intent']);
+    const waiting = value(node['waiting_for']);
+    const managers = neighbors(dossier?.['managers']);
+    const reports = neighbors(dossier?.['reports']);
+    const crons = Number(dossier?.['pending_crons'] ?? 0);
+    return [
+        {
+            icon: ICON.identity, title: 'identity', fields: [
+                { label: 'name', value: value(node['name']), tone: 'accent' },
+                { label: 'id', value: value(node['node_id']), tone: 'dim' },
+                { label: 'role', value: join(node['kind'], node['mode'], node['lifecycle']) },
+                { label: 'model', value: value(node['model'] ?? node['model_override']), tone: node['model'] ?? node['model_override'] ? 'plain' : 'dim' },
+            ],
+        },
+        {
+            icon: ICON.state, title: 'state', fields: [
+                { label: 'status', value: status, tone: visual.tone, glyph: visual.glyph },
+                { label: 'intent', value: intent, tone: intent === '—' ? 'dim' : 'warn' },
+                { label: 'waiting on', value: waiting, tone: waiting === '—' ? 'dim' : 'warn' },
+                { label: 'context', value: `${compactCount(node['context_tokens'])} tokens · ${value(node['cycles'])} cycle(s)` },
+                { label: 'created', value: `${ago(node['created'])}`, tone: 'dim' },
+            ],
+        },
+        {
+            icon: ICON.place, title: 'place', fields: [
+                { label: 'workspace', value: shortPath(node['cwd']) },
+                { label: 'profile', value: value(node['profile_id']), tone: 'dim' },
+                { label: 'host', value: join(node['host_kind'], node['pi_pid'] ? `pid ${String(node['pi_pid'])}` : null), tone: 'dim' },
+            ],
+        },
+        {
+            icon: ICON.graph, title: 'graph', fields: [
+                { label: 'managers', value: neighborLine(managers), tone: managers.length === 0 ? 'dim' : 'plain' },
+                { label: 'reports', value: neighborLine(reports), tone: reports.length === 0 ? 'dim' : 'plain' },
+                { label: 'parent', value: value(node['parent']), tone: 'dim' },
+            ],
+        },
+        {
+            icon: ICON.artifacts, title: 'output', fields: [
+                { label: 'artifacts', value: `${count(artifacts['doc'])} doc · ${count(artifacts['report'])} report · ${count(artifacts['roadmap'])} roadmap` },
+                { label: 'crons', value: crons === 0 ? 'none armed' : `${crons} armed`, tone: crons === 0 ? 'dim' : 'accent' },
+            ],
+        },
+        {
+            icon: ICON.paths, title: 'paths', fields: [
+                { label: 'context', value: shortPath(paths['context_dir']), tone: 'dim' },
+                { label: 'reports', value: shortPath(paths['reports_dir']), tone: 'dim' },
+                { label: 'session', value: shortPath(paths['session_file'] ?? node['pi_session_file']), tone: 'dim' },
+            ],
+        },
+    ];
+}
+function count(input) {
+    const n = Number(input ?? 0);
+    return Number.isFinite(n) ? String(n) : '0';
+}
+export function record(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+export function value(value) {
+    return value === null || value === undefined || value === '' ? '—' : String(value);
+}
+function join(...values) {
+    return values.map(value).filter((part) => part !== '—').join(' · ') || '—';
+}

package/dist/core/inspector/text.d.ts

@@ -0,0 +1,5 @@
+import type { TextPresenter } from '../view/contract.js';
+import type { InspectorState } from './core.js';
+/** The piped path: same information and grouping as the TUI, minus the glyphs
+ *  and hue a pipe cannot carry. */
+export declare const inspectorText: TextPresenter<InspectorState>;

package/dist/core/inspector/text.js

@@ -0,0 +1,32 @@
+import { overviewGroups, relativeTime, scheduledItems, value } from './model.js';
+/** The piped path: same information and grouping as the TUI, minus the glyphs
+ *  and hue a pipe cannot carry. */
+export const inspectorText = {
+    dump(state, ctx) {
+        const lines = [`Inspector — ${state.target}`];
+        if (ctx?.banner)
+            lines.push('', `[${ctx.banner.level}] ${ctx.banner.msg}`);
+        if (state.dossier.error) {
+            lines.push('', state.dossier.error.display.headline, state.dossier.error.display.explanation);
+            return lines.join('\n');
+        }
+        for (const group of overviewGroups(state.dossier.data)) {
+            lines.push('', `${group.title.toUpperCase()}`);
+            for (const field of group.fields)
+                lines.push(`  ${field.label.padEnd(12)}${field.value}`);
+        }
+        lines.push('', `SNAPSHOT`, `  taken       ${new Date().toISOString()}`, '', 'SCHEDULE');
+        if (state.schedule.error) {
+            lines.push(`  ${state.schedule.error.display.explanation}`, `  ${state.schedule.error.display.nextStep}`);
+            return lines.join('\n');
+        }
+        const items = scheduledItems(state.schedule.data ?? []);
+        if (items.length === 0)
+            lines.push('  nothing armed');
+        for (const item of items) {
+            const cron = item.cron;
+            lines.push('', `  ${cron.name} · ${item.cadence} · ${relativeTime(item.nextAt)}`, `    id        ${cron.cron_id}`, `    next      ${item.nextAt}`, `    state     ${value(cron.state)}`, `    output    ${cron.on_output}${cron.sink ? ` → ${cron.sink}` : ''}`, `    expires   ${value(cron.expires_at)}`);
+        }
+        return lines.join('\n');
+    },
+};

package/dist/core/inspector/tui.d.ts

@@ -0,0 +1,3 @@
+import type { TuiPresenter } from '../view/contract.js';
+import type { InspectorState } from './core.js';
+export declare const inspectorTui: TuiPresenter<InspectorState>;

package/dist/core/inspector/tui.js

@@ -0,0 +1,220 @@
+import { ICON, overviewGroups, relativeTime, scheduledItems, shortPath, value, } from './model.js';
+// ── Visual grammar ───────────────────────────────────────────────────────────
+//
+// Three primitives carry the whole screen: a TAB STRIP (where am I / where can
+// I go), GROUP CARDS of aligned label→value rows (the overview and the expanded
+// cron), and the host's own list highlight (the schedule cursor). Hue always
+// rides alongside a word or glyph, never alone.
+const LABEL_COL = 12;
+const INDENT = '  ';
+const TONE = {
+    plain: undefined,
+    dim: { dim: true },
+    good: { fg: '32' },
+    warn: { fg: '33' },
+    bad: { fg: '31', bold: true },
+    accent: { fg: '36' },
+};
+const LABEL_STYLE = { dim: true };
+const RULE_STYLE = { dim: true };
+const HEAD_STYLE = { fg: '36', bold: true };
+const SECTIONS = [
+    { id: 'overview', label: 'overview' },
+    { id: 'schedule', label: 'schedule' },
+    { id: 'raw', label: 'raw' },
+];
+/** `label` padded into the dim label column, then the value. */
+function fieldRow(label, spans) {
+    return [{ text: `${INDENT}${label.padEnd(LABEL_COL)}`, style: LABEL_STYLE }, ...spans];
+}
+function valueSpans(text, tone, glyph) {
+    const style = TONE[tone ?? 'plain'];
+    const body = glyph === undefined ? text : `${glyph} ${text}`;
+    return [{ text: body, style }];
+}
+/** ` <icon> TITLE ─────` — a card header that also acts as the separator. */
+function groupHeader(icon, title, width) {
+    const head = `${icon} ${title}`;
+    const rule = Math.max(0, width - head.length - 3);
+    return [
+        { text: ' ' },
+        { text: head, style: HEAD_STYLE },
+        { text: ` ${'─'.repeat(rule)}`, style: RULE_STYLE },
+    ];
+}
+function tabStrip(state, width) {
+    const spans = [{ text: ' ' }];
+    SECTIONS.forEach((section, index) => {
+        if (index > 0)
+            spans.push({ text: '  ·  ', style: { dim: true } });
+        const active = section.id === state.section;
+        const badge = section.id === 'schedule'
+            ? ` ${scheduledItems(state.schedule.data ?? []).length}`
+            : '';
+        spans.push({
+            text: active ? `${ICON.section} ${section.label}${badge}` : `${section.label}${badge}`,
+            style: active ? { fg: '36', bold: true } : { dim: true },
+        });
+    });
+    const used = spans.reduce((n, s) => n + s.text.length, 0);
+    spans.push({ text: ` ${'─'.repeat(Math.max(0, width - used - 1))}`, style: RULE_STYLE });
+    return spans;
+}
+function groupRows(groups, width) {
+    const rows = [];
+    for (const group of groups) {
+        rows.push(groupHeader(group.icon, group.title, width));
+        for (const field of group.fields)
+            rows.push(fieldRow(field.label, valueSpans(field.value, field.tone, field.glyph)));
+        rows.push([]);
+    }
+    if (rows[rows.length - 1]?.length === 0)
+        rows.pop();
+    return rows;
+}
+function overviewRows(state, width) {
+    if (state.dossier.data === null)
+        return [[{ text: `${INDENT}loading node overview…`, style: { dim: true } }]];
+    return groupRows(overviewGroups(state.dossier.data), width);
+}
+/** Raw JSON, syntax-toned: keys accent, strings plain, numbers/keywords warm,
+ *  structure dim. The record is for reading, not for parsing by eye. */
+function rawRows(state) {
+    if (state.dossier.data === null)
+        return [[{ text: `${INDENT}loading raw record…`, style: { dim: true } }]];
+    return JSON.stringify(state.dossier.data, null, 2).split('\n').map((line) => {
+        const match = /^(\s*)"([^"]+)":\s?(.*)$/.exec(line);
+        if (match === null)
+            return [{ text: line, style: RULE_STYLE }];
+        const [, indent = '', key = '', rest = ''] = match;
+        const literal = rest.startsWith('"') ? undefined
+            : rest.startsWith('{') || rest.startsWith('[') ? RULE_STYLE
+                : { fg: '33' };
+        return [
+            { text: indent },
+            { text: key, style: { fg: '36' } },
+            { text: ': ', style: RULE_STYLE },
+            { text: rest, style: literal },
+        ];
+    });
+}
+function errorRows(headline, explanation, nextStep) {
+    return [
+        [{ text: ` ✗ ${headline}`, style: { fg: '31', bold: true } }],
+        [],
+        [{ text: `${INDENT}${explanation}` }],
+        [],
+        [{ text: `${INDENT}${nextStep}`, style: { dim: true } }],
+    ];
+}
+/** One cron as a list item: a status-toned head row plus dim detail rows that
+ *  share its cursor highlight. Expanding adds the full record. */
+function cronItem(item, expanded) {
+    const cron = item.cron;
+    const paused = cron.state === 'paused';
+    const due = relativeTime(item.nextAt) === 'due now';
+    const headTone = paused ? { dim: true } : due ? { fg: '33', bold: true } : { fg: '32' };
+    const lines = [[
+            { text: `${INDENT}${INDENT}${item.cadence}`, style: { dim: true } },
+            { text: ' · ', style: { dim: true } },
+            { text: `${cron.on_output}${cron.sink ? ` → ${cron.sink}` : ''}`, style: { dim: true } },
+            ...(paused ? [{ text: '  paused', style: { fg: '33' } }] : []),
+        ]];
+    if (expanded) {
+        const detail = [
+            ['id', cron.cron_id],
+            ['next fire', `${relativeTime(item.nextAt)}  ${value(cron.fire_at)}`],
+            ['recurrence', item.cadence],
+            ['state', value(cron.state)],
+            ['target', shortPath(item.target)],
+            ['expires', value(cron.expires_at)],
+        ];
+        lines.push([]);
+        for (const [label, detailValue] of detail) {
+            lines.push([
+                { text: `${INDENT}${INDENT}${label.padEnd(LABEL_COL)}`, style: LABEL_STYLE },
+                { text: detailValue },
+            ]);
+        }
+    }
+    lines.push([]); // one blank row between crons — the list gives each item its own block
+    return {
+        spans: [
+            { text: ` ${ICON.cron} `, style: headTone },
+            { text: cron.name, style: { bold: true } },
+        ],
+        right: [{ text: `${relativeTime(item.nextAt)} `, style: headTone }],
+        lines,
+    };
+}
+function scheduleEmptyRows() {
+    return [
+        [{ text: ` ${ICON.empty} nothing armed`, style: { dim: true } }],
+        [],
+        [{ text: `${INDENT}This node has no crons waiting to fire.`, style: { dim: true } }],
+        [{ text: `${INDENT}Arm one with `, style: { dim: true } }, { text: 'crtr cron add', style: { fg: '36' } }, { text: '.', style: { dim: true } }],
+    ];
+}
+/** Window `rows` to the content rect using the section's scroll offset. */
+function paint(state, rows, draw, content) {
+    const strip = tabStrip(state, content.width);
+    const body = content.height - 2;
+    draw.spans(content.row, content.col, strip, content.width);
+    if (body <= 0)
+        return;
+    const maxStart = Math.max(0, rows.length - body);
+    const start = Math.min(Math.max(0, state.scroll[state.section]), maxStart);
+    rows.slice(start, start + body).forEach((row, index) => draw.spans(content.row + 2 + index, content.col, row, content.width));
+    if (rows.length > body) {
+        const pct = maxStart === 0 ? 100 : Math.round(((start + body) / rows.length) * 100);
+        draw.spansRight(content.row, content.col + content.width, [{ text: ` ${pct}% `, style: { dim: true } }]);
+    }
+}
+export const inspectorTui = {
+    render(state, draw, content) {
+        if (state.dossier.error?.display.blocking) {
+            const d = state.dossier.error.display;
+            paint(state, errorRows(d.headline, d.explanation, d.nextStep), draw, content);
+            return;
+        }
+        if (state.section === 'overview') {
+            paint(state, overviewRows(state, content.width), draw, content);
+            return;
+        }
+        if (state.section === 'raw') {
+            paint(state, rawRows(state), draw, content);
+            return;
+        }
+        if (state.schedule.error) {
+            const d = state.schedule.error.display;
+            paint(state, errorRows(d.headline, d.explanation, d.nextStep), draw, content);
+            return;
+        }
+        const items = scheduledItems(state.schedule.data ?? []);
+        if (items.length === 0) {
+            paint(state, scheduleEmptyRows(), draw, content);
+            return;
+        }
+        draw.spans(content.row, content.col, tabStrip(state, content.width), content.width);
+        const cursor = Math.max(0, items.findIndex((item) => item.cron.cron_id === state.selectedCronId));
+        const rows = items.map((item, index) => cronItem(item, index === cursor && state.expanded));
+        // draw.list clamps the local viewport and keeps the selected cron's header
+        // visible across refreshes and resize without mutating core state.
+        draw.list({ ...content, row: content.row + 2, height: Math.max(0, content.height - 2) }, rows, cursor, state.scroll.schedule);
+    },
+    keymap: [
+        { bindingId: 'crtr.view.inspector.down', intent: 'down', hint: { label: 'move' } },
+        { bindingId: 'crtr.view.inspector.up', intent: 'up' },
+        { bindingId: 'crtr.view.inspector.section-next', intent: 'sectionNext', hint: { label: 'section' } },
+        { bindingId: 'crtr.view.inspector.section-prev', intent: 'sectionPrev' },
+        { bindingId: 'crtr.view.inspector.page-down', intent: 'pageDown' },
+        { bindingId: 'crtr.view.inspector.page-up', intent: 'pageUp' },
+        { bindingId: 'crtr.view.inspector.toggle-detail', intent: 'toggleDetail', when: (state) => state.section === 'schedule' && state.selectedCronId !== null, hint: { label: 'details' } },
+        { bindingId: 'crtr.view.inspector.cancel-item', intent: 'cancelItem', when: (state) => state.section === 'schedule' && state.selectedCronId !== null, hint: { label: 'cancel' } },
+        { bindingId: 'crtr.view.inspector.confirm', intent: 'confirm', when: (state) => state.pendingCancel !== null, hint: { label: 'confirm' } },
+        { bindingId: 'crtr.view.inspector.dismiss', intent: 'dismiss', hint: { label: 'dismiss' } },
+        { bindingId: 'crtr.view.inspector.retarget', intent: 'retarget', when: (state) => state.section === 'schedule' && state.selectedCronId !== null, hint: { label: 'retarget' } },
+        { bindingId: 'crtr.view.inspector.refresh', intent: 'refresh', hint: { label: 'refresh' } },
+        { bindingId: 'crtr.view.inspector.quit', intent: 'quit', hint: { label: 'quit' } },
+    ],
+};