@north-light/api 0.3.580 → 0.3.588

package/dist/core/inspector/model.js

@@ -0,0 +1,225 @@
+// ── 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
+    job: cp(0xf013), // cog — one live background bash job
+    log: cp(0xf120), // terminal — the job's log stream
+    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);
+    });
+}
+/** Elapsed duration in the shape every bash-handoff surface uses: `12s`,
+ *  `3m 40s`, `1h 04m`. Duplicated from core/bash-jobs.ts on purpose — a view
+ *  module stays a pure read and never pulls the node:fs job scanner in. */
+export function elapsed(ms) {
+    const totalSeconds = Math.max(0, Math.floor(ms / 1000));
+    if (totalSeconds < 60)
+        return `${totalSeconds}s`;
+    const totalMinutes = Math.floor(totalSeconds / 60);
+    if (totalMinutes < 60)
+        return `${totalMinutes}m ${String(totalSeconds % 60).padStart(2, '0')}s`;
+    return `${Math.floor(totalMinutes / 60)}h ${String(totalMinutes % 60).padStart(2, '0')}m`;
+}
+/** How a running job's age reads at a glance: an ordered ramp, not decoration.
+ *  Fresh work is green, a job past 15m is amber, past an hour is red — the same
+ *  good/warn/bad progression the node status glyphs use. */
+export function jobTone(elapsedMs) {
+    if (elapsedMs >= 60 * 60_000)
+        return 'bad';
+    if (elapsedMs >= 15 * 60_000)
+        return 'warn';
+    return 'good';
+}
+/** Milliseconds a job has been running, live from `started_at`. */
+export function jobElapsedMs(job, now = Date.now()) {
+    const at = Date.parse(job.started_at);
+    return Number.isFinite(at) ? now - at : job.elapsed_ms;
+}
+/** Live elapsed time for a job row — recomputed from `started_at` so the number
+ *  keeps ticking between the view's 5s refreshes; `elapsed_ms` is the fallback. */
+export function jobElapsed(job, now = Date.now()) {
+    return elapsed(jobElapsedMs(job, now));
+}
+/** First line of a command, whitespace-collapsed and capped for a one-row cell. */
+export function commandCell(command, cap = 60) {
+    const oneLine = (command.split('\n')[0] ?? '').replace(/\s+/g, ' ').trim();
+    return oneLine.length > cap ? `${oneLine.slice(0, cap - 1)}…` : oneLine;
+}
+/** A person-readable purpose leads when present; legacy jobs retain their
+ * command label. */
+export function jobLabel(job, cap = 60) {
+    return commandCell(job.purpose ?? job.command, cap);
+}
+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: '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 { InspectorText } from './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: InspectorText<InspectorState>;

package/dist/core/inspector/text.js

@@ -0,0 +1,45 @@
+import { jobElapsed, jobLabel, 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)}`);
+        }
+        lines.push('', 'BACKGROUND BASH JOBS');
+        if (state.jobs.error) {
+            lines.push(`  ${state.jobs.error.display.explanation}`, `  ${state.jobs.error.display.nextStep}`);
+            return lines.join('\n');
+        }
+        const jobs = state.jobs.data ?? [];
+        if (jobs.length === 0)
+            lines.push('  nothing running');
+        for (const job of jobs) {
+            lines.push('', `  ${jobLabel(job)} · ${jobElapsed(job)}`, `    id        ${job.job_id}`, ...(job.purpose === null ? [] : [`    command   ${job.command.split('\n')[0]}`]), `    started   ${job.started_at}`, `    log       ${job.log_path}`);
+            for (const line of job.log_tail.slice(-5))
+                lines.push(`    | ${line}`);
+        }
+        return lines.join('\n');
+    },
+};

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

@@ -0,0 +1,6 @@
+import type { RawResponse, SourceRequest } from './contract.js';
+export declare function createInspectorTransport(options?: {
+    cwd?: string;
+}): {
+    send(request: SourceRequest): Promise<RawResponse>;
+};

package/dist/core/inspector/transport.js

@@ -0,0 +1,36 @@
+import { execFile } from 'node:child_process';
+const MAX_BUFFER = 10 * 1024 * 1024;
+export function createInspectorTransport(options = {}) {
+    const baseCwd = options.cwd ?? process.cwd();
+    return {
+        send(request) {
+            return new Promise((resolve) => {
+                const child = execFile(request.bin, request.args, { cwd: request.cwd ?? baseCwd, maxBuffer: MAX_BUFFER, encoding: 'utf8' }, (error, stdout, stderr) => {
+                    if (!error) {
+                        resolve({ ok: true, exitCode: 0, stdout, stderr });
+                        return;
+                    }
+                    const code = error.code;
+                    if (typeof code === 'number') {
+                        resolve({ ok: true, exitCode: code, stdout: stdout ?? '', stderr: stderr ?? '' });
+                        return;
+                    }
+                    const signal = error.signal;
+                    if (signal) {
+                        const detail = stderr && stderr.trim() !== ''
+                            ? stderr
+                            : `killed by signal ${signal}${signal === 'SIGKILL' ? ' (often out-of-memory)' : ''}`;
+                        resolve({ ok: true, exitCode: 1, stdout: stdout ?? '', stderr: detail });
+                        return;
+                    }
+                    const message = code === 'ENOENT' ? `${request.bin}: command not found` : error.message;
+                    resolve({ ok: false, stdout: stdout ?? '', stderr: message });
+                });
+                if (request.stdin !== undefined && child.stdin) {
+                    child.stdin.write(request.stdin);
+                    child.stdin.end();
+                }
+            });
+        },
+    };
+}

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

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

package/dist/core/inspector/tui.js

@@ -0,0 +1,295 @@
+import { ICON, commandCell, jobElapsed, jobElapsedMs, jobLabel, jobTone, 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: 'jobs', label: 'jobs' },
+    { 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}`
+            : section.id === 'jobs'
+                ? ` ${(state.jobs.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,
+    };
+}
+/** One live background job as a list item. Collapsed it shows the single thing
+ *  a watcher wants — the newest log line — under the command and its running
+ *  time; expanding adds the job's identity and a live tail of its log, so the
+ *  Inspector answers "what is it doing right now" without a second surface. */
+function jobItem(job, expanded, width) {
+    const tone = TONE[jobTone(jobElapsedMs(job))];
+    const last = job.log_tail[job.log_tail.length - 1];
+    const lines = [];
+    if (!expanded) {
+        lines.push([{ text: `${INDENT}${INDENT}${last === undefined ? 'no output yet' : logCell(last, width - 6)}`, style: { dim: true } }]);
+    }
+    else {
+        const details = [
+            ['job', job.job_id],
+            ...(job.purpose === null ? [] : [['command', commandCell(job.command, Math.max(20, width - 26))]]),
+            ['started', job.started_at],
+            ['log', shortPath(job.log_path)],
+            ['watch', `tail -f ${shortPath(job.log_path)}`],
+        ];
+        for (const [label, text] of details) {
+            lines.push([{ text: `${INDENT}${INDENT}${label.padEnd(LABEL_COL)}`, style: LABEL_STYLE }, { text, style: label === 'watch' ? { fg: '36' } : undefined }]);
+        }
+        lines.push([]);
+        lines.push(groupHeader(ICON.log, `last ${job.log_tail.length} lines`, width - 2));
+        if (job.log_tail.length === 0)
+            lines.push([{ text: `${INDENT}${INDENT}no output yet`, style: { dim: true } }]);
+        for (const line of job.log_tail)
+            lines.push([{ text: `${INDENT}${INDENT}${logCell(line, width - 6)}`, style: { dim: true } }]);
+    }
+    lines.push([]); // one blank row between jobs — each item reads as its own block
+    return {
+        spans: [
+            { text: ` ${ICON.job} `, style: tone },
+            { text: jobLabel(job, Math.max(20, width - 26)), style: { bold: true } },
+        ],
+        right: [{ text: `${jobElapsed(job)} `, style: tone }],
+        lines,
+    };
+}
+/** A log line, tabs expanded and clipped to the card — never wrapped, so one
+ *  runaway line cannot push the rest of the tail off the screen. */
+function logCell(line, width) {
+    const flat = line.replace(/\t/g, '  ').replace(/[\u0000-\u0008\u000b-\u001f]/g, '');
+    const cap = Math.max(10, width);
+    return flat.length > cap ? `${flat.slice(0, cap - 1)}…` : flat;
+}
+function jobsEmptyRows() {
+    return [
+        [{ text: ` ${ICON.empty} nothing running`, style: { dim: true } }],
+        [],
+        [{ text: `${INDENT}This node has no bash commands running in the background.`, style: { dim: true } }],
+    ];
+}
+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.section === 'jobs') {
+            if (state.jobs.error) {
+                const d = state.jobs.error.display;
+                paint(state, errorRows(d.headline, d.explanation, d.nextStep), draw, content);
+                return;
+            }
+            const jobs = state.jobs.data ?? [];
+            if (jobs.length === 0) {
+                paint(state, jobsEmptyRows(), draw, content);
+                return;
+            }
+            draw.spans(content.row, content.col, tabStrip(state, content.width), content.width);
+            const cursor = Math.max(0, jobs.findIndex((job) => job.job_id === state.selectedJobId));
+            const rows = jobs.map((job, index) => jobItem(job, index === cursor && state.expanded, content.width));
+            draw.list({ ...content, row: content.row + 2, height: Math.max(0, content.height - 2) }, rows, cursor, state.scroll.jobs);
+            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.inspector.down', intent: 'down', hint: { label: 'move' } },
+        { bindingId: 'crtr.inspector.up', intent: 'up' },
+        { bindingId: 'crtr.inspector.section-next', intent: 'sectionNext', hint: { label: 'section' } },
+        { bindingId: 'crtr.inspector.section-prev', intent: 'sectionPrev' },
+        { bindingId: 'crtr.inspector.page-down', intent: 'pageDown' },
+        { bindingId: 'crtr.inspector.page-up', intent: 'pageUp' },
+        { bindingId: 'crtr.inspector.toggle-detail', intent: 'toggleDetail', when: (state) => (state.section === 'schedule' && state.selectedCronId !== null) || (state.section === 'jobs' && state.selectedJobId !== null), hint: { label: 'details' } },
+        { bindingId: 'crtr.inspector.cancel-item', intent: 'cancelItem', when: (state) => !state.readOnly && state.section === 'schedule' && state.selectedCronId !== null, hint: { label: 'cancel' } },
+        { bindingId: 'crtr.inspector.cancel-item', intent: 'cancelItem', when: (state) => !state.readOnly && state.section === 'jobs' && state.selectedJobId !== null, hint: { label: 'stop job' } },
+        { bindingId: 'crtr.inspector.open-log', intent: 'openLog', when: (state) => state.section === 'jobs' && state.selectedJobId !== null, hint: { label: 'open log' } },
+        { bindingId: 'crtr.inspector.confirm', intent: 'confirm', when: (state) => state.pendingCancel !== null, hint: { label: 'confirm' } },
+        { bindingId: 'crtr.inspector.dismiss', intent: 'dismiss', hint: { label: 'dismiss' } },
+        { bindingId: 'crtr.inspector.retarget', intent: 'retarget', when: (state) => state.section === 'schedule' && state.selectedCronId !== null, hint: { label: 'retarget' } },
+        { bindingId: 'crtr.inspector.refresh', intent: 'refresh', hint: { label: 'refresh' } },
+        { bindingId: 'crtr.inspector.quit', intent: 'quit', hint: { label: 'quit' } },
+    ],
+};

package/dist/core/io.js

@@ -310,6 +310,13 @@ export function apiErrorToCliError(err, next, options = {}) {
             next: 'Start it with `crtr sys daemon start`, then retry.',
         });
     }
+    // The relay inside a node could not reach Northlight: keep its own next step, not the generic 503 one.
+    if (err.code === 'northlight_unreachable') {
+        const relayed = err.details?.next;
+        return new CrtrError('northlight_unreachable', err.message, ExitCode.NETWORK, {
+            next: typeof relayed === 'string' && relayed !== '' ? relayed : "Check this computer's internet connection, then retry.",
+        });
+    }
     // A node start through an app's exec without a signed-in AI subscription: the person signs in at the URL.
     if (err.code === 'model_sign_in_required') {
         const url = err.details?.url;

package/dist/core/keybindings/background-bash.d.ts

@@ -0,0 +1,13 @@
+import type { BindingId } from './catalog.js';
+import type { BindingResolution } from './types.js';
+/** The Alt+C -> b gesture pair for the background-bash tmux menu item, e.g.
+ *  `Alt+C b`. Null when either the menu-open gesture or the background-bash
+ *  selector is disabled (no bindings) — there is no fallback rendering for a
+ *  disabled binding. Bindings default to the user's resolved config; callers
+ *  holding a live snapshot (e.g. the attach viewer) pass it so a `/reload`
+ *  rebind is honored. */
+export declare function backgroundBashShortcut(bindings?: BindingResolution<BindingId>): string | null;
+/** Footer hint for the background-bash gesture: "<shortcut> to background", or
+ *  null when disabled. No CLI fallback — the tmux gesture is the only way to
+ *  invoke this handoff. */
+export declare function backgroundBashHint(bindings?: BindingResolution<BindingId>): string | null;