@north-light/crouter 0.3.158 → 0.3.160

package/dist/core/__tests__/tmux-surface.test.js

@@ -205,7 +205,7 @@ test('tmux installer remaps owned pairs and preserves occupied user bindings', (
         const currentNode = defaultMenu.indexOf('-#[bold]Current node');
         const lifecycle = defaultMenu.indexOf('-#[bold]Lifecycle');
         const system = defaultMenu.indexOf('-#[bold]System');
-        for (const item of ['resume node', 'graph view', 'focus manager', 'show ›']) {
+        for (const item of ['resume node', 'graph view', 'focus manager', 'show ›', 'view settings ›']) {
             assert.ok(defaultMenu.indexOf(item) > explore && defaultMenu.indexOf(item) < currentNode, `${item} belongs in Explore`);
         }
         assert.match(defaultMenu, /"show ›" s .*display-menu.*metadata.*context \+ reports/);
@@ -213,7 +213,10 @@ test('tmux installer remaps owned pairs and preserves occupied user bindings', (
             assert.ok(defaultMenu.indexOf(item) > currentNode && defaultMenu.indexOf(item) < lifecycle, `${item} belongs to the current node`);
         }
         assert.ok(defaultMenu.indexOf('fork into idle root') > lifecycle && defaultMenu.indexOf('fork into idle root') < system, 'fork belongs in Lifecycle');
-        assert.ok(defaultMenu.indexOf('settings') > system, 'settings belongs in System');
+        assert.match(defaultMenu, /"view settings ›" w .*display-menu.*fold finished tool calls/);
+        // Matched with its selector, so the Explore group's "view settings ›" item
+        // (selector `w`) cannot satisfy this assertion by substring.
+        assert.ok(defaultMenu.indexOf('settings p ') > system, 'settings belongs in System');
         assert.ok(defaultMenu.indexOf('create ›') > system, 'create belongs in System');
         assert.match(tmuxBinding(socket, 'root', 'M-v') ?? '', /switch-client/);
         // The inbox toggle installs at its default key (alt+i → M-i) in the same sweep.

package/dist/core/bash-jobs.d.ts

@@ -5,9 +5,20 @@ export interface BashJobPaths {
     jobLog: string;
     jobExit: string;
     jobBg: string;
+    /** Process-group id of the job's detached supervisor, written at spawn. It is
+     * what makes a job stoppable from outside the agent that started it (the
+     * Inspector's cancel) — without it on disk, only the agent's own handoff
+     * notice knows the group to signal. */
+    jobPgid: string;
 }
 export declare function bashJobsDir(contextDir: string): string;
 export declare function bashJobPaths(contextDir: string, jobId: string): BashJobPaths;
+/** The job's supervisor process group, or undefined for a job started before
+ * pgid was persisted (or a partially-written dir). */
+export declare function readJobPgid(contextDir: string, jobId: string): number | undefined;
+/** Last `count` lines of a job log, cheaply: read at most the trailing 64 KiB
+ * rather than the whole file, which for a long-running job can be enormous. */
+export declare function tailJobLog(logPath: string, count: number): string[];
 /** Mint a fresh job id — `${Date.now()}-${hex}`. The sole minting site; the
  * valve calls this instead of building the literal inline so the epoch-ms
  * prefix is a real contract shared with its parser (jobStartedAtMs), not an

package/dist/core/bash-jobs.js

@@ -3,7 +3,7 @@
 // the prefix menu requests backgrounding by creating job.bg. Keeping that signal
 // on disk means the command can outlive its pi process and still report its exit.
 import { randomBytes } from 'node:crypto';
-import { existsSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { closeSync, existsSync, openSync, readdirSync, readFileSync, readSync, statSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 export function bashJobsDir(contextDir) {
     return join(contextDir, 'jobs');
@@ -17,8 +17,48 @@ export function bashJobPaths(contextDir, jobId) {
         jobLog: join(dir, 'job.log'),
         jobExit: join(dir, 'job.exit'),
         jobBg: join(dir, 'job.bg'),
+        jobPgid: join(dir, 'job.pgid'),
     };
 }
+/** The job's supervisor process group, or undefined for a job started before
+ * pgid was persisted (or a partially-written dir). */
+export function readJobPgid(contextDir, jobId) {
+    try {
+        const n = Number(readFileSync(bashJobPaths(contextDir, jobId).jobPgid, 'utf8').trim());
+        return Number.isInteger(n) && n > 1 ? n : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Last `count` lines of a job log, cheaply: read at most the trailing 64 KiB
+ * rather than the whole file, which for a long-running job can be enormous. */
+export function tailJobLog(logPath, count) {
+    if (count <= 0)
+        return [];
+    const WINDOW = 64 * 1024;
+    let fd;
+    try {
+        const size = statSync(logPath).size;
+        const start = Math.max(0, size - WINDOW);
+        const buf = Buffer.alloc(Math.min(size, WINDOW));
+        fd = openSync(logPath, 'r');
+        readSync(fd, buf, 0, buf.length, start);
+        const text = buf.toString('utf8');
+        // A partial first line (we cut mid-line) is dropped, not shown truncated.
+        const lines = (start > 0 ? text.slice(text.indexOf('\n') + 1) : text).split('\n');
+        if (lines[lines.length - 1] === '')
+            lines.pop();
+        return lines.slice(-count);
+    }
+    catch {
+        return [];
+    }
+    finally {
+        if (fd !== undefined)
+            closeSync(fd);
+    }
+}
 /** Mint a fresh job id — `${Date.now()}-${hex}`. The sole minting site; the
  * valve calls this instead of building the literal inline so the epoch-ms
  * prefix is a real contract shared with its parser (jobStartedAtMs), not an

package/dist/core/canvas/canvas.js

@@ -21,7 +21,7 @@ import { ensureHome, ensureNodeDirs, nodeMetaPath, nodeDir, nodesRoot, jobDir, }
 /** The identity keys meta.json persists. Listed explicitly so no runtime field
  *  can ever leak onto disk even when a fully-hydrated NodeMeta is handed in. */
 const IDENTITY_KEYS = [
-    'node_id', 'name', 'description', 'cycles', 'created', 'cwd', 'host_kind', 'profile_id', 'kind', 'mode',
+    'node_id', 'name', 'description', 'icon', 'cycles', 'created', 'cwd', 'host_kind', 'profile_id', 'kind', 'mode',
     'lifecycle', 'persona_ack', 'parent', 'spawned_by', 'fork_from', 'human_work_target', 'private_fork_phase',
     'private_fork_recipe', 'passive_default', 'pi_session_id', 'pi_session_file', 'cycle_pending', 'model_override',
     'launch', 'managed_worktree',

package/dist/core/canvas/labels.d.ts

@@ -9,6 +9,7 @@ export interface NamedNode {
     name: string;
     kind: string;
     description?: string;
+    icon?: string;
 }
 /** A node's human label: its explicit handle plus the pi-generated description
  *  of its first task, e.g. `fix-auth refactor-login-flow`. The handle is

package/dist/core/canvas/labels.js

@@ -34,5 +34,7 @@ export function personaLabel(meta) {
  *  badge. Recomputed from meta on every revive and pushed live when naming
  *  generates the first task description. */
 export function editorLabel(meta) {
-    return fullName(meta);
+    const icon = (meta.icon ?? '').trim();
+    const name = fullName(meta);
+    return icon !== '' ? `${icon} ${name}` : name;
 }

package/dist/core/canvas/nav-render.d.ts

@@ -23,6 +23,12 @@ export declare const GRAY = "\u001B[90m";
  *  `isPidAlive` / `isBusy` reads entirely (a remote node id may collide with a
  *  local one) and renders the bare status glyph instead. */
 export declare function nodeGlyph(node: NodeMeta | null, remote?: boolean): string;
+/** Drop every SGR sequence, keeping the visible text. The selection bar uses
+ *  this: reverse-video INVERTS a coloured cell into a coloured block, so a row
+ *  built from tinted spans highlights as a patchwork of background swatches
+ *  instead of one bar. Stripping colour first leaves a single clean bar — the
+ *  glyphs (●/○/✓/✗/⚙/◷) still carry the signal, exactly as under NO_COLOR. */
+export declare function stripSgr(s: string): string;
 /** Visible width, ignoring ANSI escapes. */
 export declare function visibleWidth(s: string): number;
 /** Truncate to `max` VISIBLE columns: escape sequences are copied through

package/dist/core/canvas/nav-render.js

@@ -71,6 +71,14 @@ export function nodeGlyph(node, remote = false) {
     return `${ESC}${v.color}m${v.glyph}${RESET}`;
 }
 const ANSI_RE = /\x1b\[[0-9;]*m/g;
+/** Drop every SGR sequence, keeping the visible text. The selection bar uses
+ *  this: reverse-video INVERTS a coloured cell into a coloured block, so a row
+ *  built from tinted spans highlights as a patchwork of background swatches
+ *  instead of one bar. Stripping colour first leaves a single clean bar — the
+ *  glyphs (●/○/✓/✗/⚙/◷) still carry the signal, exactly as under NO_COLOR. */
+export function stripSgr(s) {
+    return s.replace(ANSI_RE, '');
+}
 /** Visible width, ignoring ANSI escapes. */
 export function visibleWidth(s) {
     return s.replace(ANSI_RE, '').length;

package/dist/core/canvas/types.d.ts

@@ -87,6 +87,12 @@ export interface NodeIdentity {
     /** A 2-4 word kebab-case handle derived from the node's first prompt (named
      *  headlessly by pi; see runtime/naming.ts). Shown in the editor label. */
     description?: string;
+    /** A single Nerd Font glyph depicting the node's work, chosen by the same
+   *  headless namer that produced `description` (see runtime/naming.ts). Kept as
+   *  its own field rather than baked into the description so each surface decides
+   *  whether to render it; absent on a node named before icons existed, or when
+   *  the model returned nothing usable. */
+    icon?: string;
     /** How many times this node has been (re)launched — born at 0, bumped on
      *  every revive. Exposed to the pi footer as CRTR_CYCLES so a refresh/crash
      *  cycle reads at a glance there. */

package/dist/core/config.js

@@ -359,12 +359,13 @@ function mergeConfig(partial) {
     const condensed_history = CONDENSED_HISTORY_MODES.includes(partial.condensed_history)
         ? partial.condensed_history
         : defaults.condensed_history;
+    const fold_finished_tools = typeof partial.fold_finished_tools === 'boolean' ? partial.fold_finished_tools : defaults.fold_finished_tools;
     const keybindings = normalizeKeybindings(partial.keybindings);
     const modelLadders = mergeModelLadders(partial.modelLadders);
     const kinds = mergeKinds(partial.kinds);
     const remoteCanvas = mergeRemoteCanvas(partial.remoteCanvas);
     const spawnEnv = mergeSpawnEnv(partial.spawnEnv, defaults.spawnEnv?.allow);
-    return { schema_version, marketplaces, plugins, configuredClis, auto_update, max_panes_per_window, brokerThresholds, completion_bell, live_cycles, condensed_history, keybindings, modelLadders, kinds, remoteCanvas, spawnEnv };
+    return { schema_version, marketplaces, plugins, configuredClis, auto_update, max_panes_per_window, brokerThresholds, completion_bell, live_cycles, condensed_history, fold_finished_tools, keybindings, modelLadders, kinds, remoteCanvas, spawnEnv };
 }
 /** Raw (un-defaulted) partial config for one scope, or null if the scope has
  *  no root or no config.json. Used by `readMergedLaunchConfig` to layer
@@ -497,7 +498,7 @@ export function subKindsAvailableTo(kind) {
  *  an untouched key is never rewritten. */
 const CONFIG_TOP_LEVEL_KEYS = [
     'schema_version', 'marketplaces', 'plugins', 'configuredClis', 'auto_update',
-    'max_panes_per_window', 'brokerThresholds', 'completion_bell', 'live_cycles', 'condensed_history', 'keybindings', 'modelLadders', 'kinds',
+    'max_panes_per_window', 'brokerThresholds', 'completion_bell', 'live_cycles', 'condensed_history', 'fold_finished_tools', 'keybindings', 'modelLadders', 'kinds',
     'remoteCanvas', 'spawnEnv',
 ];
 /** The SPARSE `modelLadders` to persist after a config mutation: the raw

package/dist/core/feed/inbox.d.ts

@@ -75,9 +75,9 @@ export declare function clipBody(body: string): {
  *
  * Format (per sender group):
  *   From <sender> — <N> update(s):
- *     [<kind>] <label> at <absolute report path>:
- *
- *   <short report body>
+ *     [<kind>]
+ *       <short report body>
+ *       (report: <absolute report path>)
  *
  * Large reports remain canonical pointers and add one shared dereference hint.
  */

package/dist/core/feed/inbox.js

@@ -330,15 +330,19 @@ function inlineReport(e) {
 /**
  * Render one entry's digest line(s).
  *
- * Short pushed reports are inlined with their absolute report path. Larger
- * reports stay canonical history pointers. Direct messages retain their bounded
+ * A short pushed report is inlined as its own body, followed by a pointer to
+ * the durable artifact. The label is NOT repeated above it: a report's label is
+ * just its first line (feed.ts `firstLine`), so printing both reads as a
+ * truncated preview stacked on the full text it previews. Larger reports stay
+ * canonical history pointers. Direct messages retain their bounded
  * inline-body/spill behavior.
  */
 function renderEntry(e) {
     const report = inlineReport(e);
     if (report !== null) {
+        const indented = report.body.trimEnd().split('\n').map((l) => `    ${l}`).join('\n');
         return {
-            text: `  [${e.kind}] ${e.label} at ${report.path}:\n\n${report.body}`,
+            text: `  [${e.kind}]\n${indented}\n    (report: ${report.path})`,
             hasCanonicalRef: false,
         };
     }
@@ -364,9 +368,9 @@ function renderEntry(e) {
  *
  * Format (per sender group):
  *   From <sender> — <N> update(s):
- *     [<kind>] <label> at <absolute report path>:
- *
- *   <short report body>
+ *     [<kind>]
+ *       <short report body>
+ *       (report: <absolute report path>)
  *
  * Large reports remain canonical pointers and add one shared dereference hint.
  */

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

@@ -1,6 +1,14 @@
 import type { CronDTO } from '../../api/dto/crons.js';
 import type { SourceError, ViewCore } from '../view/contract.js';
-import { scheduledItems, type InspectorSection } from './model.js';
+import { scheduledItems, type BashJobRow, type InspectorSection } from './model.js';
+/** What a `y` confirmation will act on. Both sections arm cancellation the same
+ *  way, so the pending action carries its own kind rather than the view guessing
+ *  from whichever section happens to be open when the key lands. */
+export type PendingAction = {
+    kind: 'cron' | 'job';
+    id: string;
+    label: string;
+};
 export interface InspectorState {
     target: string;
     section: InspectorSection;
@@ -14,10 +22,17 @@ export interface InspectorState {
         error: SourceError | null;
         fetchedAt: number;
     };
+    jobs: {
+        data: BashJobRow[] | null;
+        error: SourceError | null;
+        fetchedAt: number;
+    };
     selectedCronId: string | null;
+    selectedJobId: string | null;
     expanded: boolean;
-    pendingCancel: string | null;
+    pendingCancel: PendingAction | null;
     scroll: Record<InspectorSection, number>;
 }
 export declare const inspectorCore: ViewCore<InspectorState>;
+export declare function selectedJob(state: InspectorState): BashJobRow | undefined;
 export { scheduledItems };

package/dist/core/inspector/core.js

@@ -35,6 +35,25 @@ const scheduleSource = {
         return { ok: true, data: crons };
     },
 };
+/** Trailing log lines carried with every job row: enough to fill the expanded
+ *  card, so watching a job needs no second surface. */
+const LOG_TAIL_LINES = 14;
+/** Live background bash jobs for the inspected node. Non-blocking, exactly like
+ *  the schedule: a node with no jobs dir (or a remote target) degrades this one
+ *  section, never the whole view. */
+const jobsSource = {
+    id: 'jobs',
+    request: (target) => ({ kind: 'exec', bin: 'crtr', args: ['--json', 'node', 'bash', 'list', '--node', target, '--tail', String(LOG_TAIL_LINES)] }),
+    parse: (raw) => {
+        const result = parseJson(raw, 'node bash list', false);
+        if (!result.ok)
+            return result;
+        const jobs = result.data['jobs'];
+        if (!Array.isArray(jobs))
+            return { ok: false, error: error('parse', 'Jobs unavailable', 'The job list did not contain job rows.', false) };
+        return { ok: true, data: jobs };
+    },
+};
 const cancelCommand = {
     id: 'cancel',
     request: (id) => ({ kind: 'exec', bin: 'crtr', args: ['--json', 'cron', 'cancel', id] }),
@@ -45,8 +64,50 @@ const cancelCommand = {
         return { ok: true, data: { canceled: String(result.data['canceled'] ?? '') } };
     },
 };
+const killJobCommand = {
+    id: 'kill-job',
+    request: ({ target, job }) => ({ kind: 'exec', bin: 'crtr', args: ['--json', 'node', 'bash', 'kill', job, '--node', target] }),
+    parse: (raw) => {
+        const result = parseJson(raw, 'node bash kill', false);
+        if (!result.ok)
+            return result;
+        return { ok: true, data: { job: String(result.data['job_id'] ?? '') } };
+    },
+};
+/** Open the selected job's log in its own tmux window, following like `tail -f`.
+ *  A new window rather than a nested popup: tmux allows one popup per client and
+ *  the Inspector is usually already in one — and a window is where you actually
+ *  want a log you intend to keep watching after the Inspector closes. */
+const openLogCommand = {
+    id: 'open-log',
+    request: ({ path, title }) => ({
+        kind: 'exec',
+        bin: 'tmux',
+        args: ['new-window', '-n', title, `less +F -- ${quote(path)} 2>/dev/null || tail -f -- ${quote(path)}`],
+    }),
+    parse: (raw) => {
+        if (!raw.ok || (raw.exitCode ?? 0) !== 0) {
+            return { ok: false, error: error('no_tmux', 'Could not open the log', raw.stderr || 'tmux new-window failed — the Inspector must be running inside tmux.', false) };
+        }
+        return { ok: true, data: {} };
+    },
+};
+function quote(text) {
+    return `'${text.split("'").join(`'\\''`)}'`;
+}
+const SECTION_ORDER = ['overview', 'schedule', 'jobs', 'raw'];
 function section(value) {
-    return value === 'schedule' || value === 'raw' ? value : 'overview';
+    return value === 'schedule' || value === 'jobs' || value === 'raw' ? value : 'overview';
+}
+/** The section-aware status line: what is pending, counted for what you see. */
+function countsFor(state) {
+    const crons = `${scheduledItems(state.schedule.data ?? []).length} cron(s) armed`;
+    const jobs = `${(state.jobs.data ?? []).length} background job(s) running`;
+    if (state.section === 'schedule')
+        return crons;
+    if (state.section === 'jobs')
+        return jobs;
+    return `${crons} · ${jobs}`;
 }
 function reconcile(state, next) {
     const items = scheduledItems(next);
@@ -58,21 +119,30 @@ function reconcile(state, next) {
     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 },
+    manifest: { id: 'inspector', title: 'Inspector', description: 'Node overview, scheduled crons, and live background bash jobs', 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 },
+            jobs: { data: null, error: null, fetchedAt: 0 },
+            selectedCronId: null, selectedJobId: null, expanded: false, pendingCancel: null,
+            scroll: { overview: 0, schedule: 0, jobs: 0, raw: 0 },
         };
     },
-    sources: { dossier: dossierSource, schedule: scheduleSource },
-    commands: { cancel: cancelCommand },
+    sources: { dossier: dossierSource, schedule: scheduleSource, jobs: jobsSource },
+    commands: { cancel: cancelCommand, killJob: killJobCommand, openLog: openLogCommand },
     intents: {
         async refresh(ctx) {
             ctx.signal.setStatus('Refreshing…');
-            const dossier = await ctx.resolve(dossierSource, ctx.state.target);
+            let note;
+            // All three reads are independent subprocesses, so they run TOGETHER: the
+            // host drops keystrokes while an intent is in flight, and the auto-refresh
+            // fires every 5s — resolving them in series would make the view feel deaf.
+            const [dossier, schedule, jobs] = await Promise.all([
+                ctx.resolve(dossierSource, ctx.state.target),
+                ctx.resolve(scheduleSource, ctx.state.target),
+                ctx.resolve(jobsSource, 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');
@@ -80,7 +150,6 @@ export const inspectorCore = {
                 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');
@@ -89,37 +158,90 @@ export const inspectorCore = {
                 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();
+                    note = 'Selected cron disappeared; moved to the next item.';
+                // Clear ONLY a banner this source raised. A background refresh must not
+                // wipe the user's own "press y to confirm" prompt or an action result.
+                if (ctx.state.schedule.error !== null)
+                    ctx.signal.clearBanner();
+            }
+            if (!jobs.ok)
+                ctx.set((state) => ({ ...state, jobs: { ...state.jobs, error: jobs.error } }));
+            else {
+                const gone = ctx.state.selectedJobId !== null && !jobs.data.some((job) => job.job_id === ctx.state.selectedJobId);
+                ctx.set((state) => reconcileJobs(state, jobs.data));
+                if (gone)
+                    note = 'The selected job finished; moved to the next one.';
             }
+            // One status line, always about the section you are looking at: a count of
+            // crons in schedule, of jobs in jobs, of both in the whole-node sections.
+            ctx.signal.setStatus(note ?? countsFor(ctx.state));
             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}`); },
+        sectionNext(ctx) { const order = SECTION_ORDER; const next = order[(order.indexOf(ctx.state.section) + 1) % order.length]; ctx.set((state) => ({ ...state, section: next, pendingCancel: null })); ctx.signal.clearBanner(); ctx.signal.setStatus(countsFor(ctx.state)); ctx.signal.setSubtitle(`${ctx.state.target} · ${next}`); },
+        sectionPrev(ctx) { const order = SECTION_ORDER; const next = order[(order.indexOf(ctx.state.section) + order.length - 1) % order.length]; ctx.set((state) => ({ ...state, section: next, pendingCancel: null })); ctx.signal.clearBanner(); ctx.signal.setStatus(countsFor(ctx.state)); 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'); },
+        toggleDetail(ctx) {
+            if (ctx.state.section === 'jobs' ? ctx.state.selectedJobId !== null : ctx.state.selectedCronId !== null) {
+                ctx.set((state) => ({ ...state, expanded: !state.expanded }));
+            }
+        },
+        cancelItem(ctx) {
+            const pending = ctx.state.section === 'jobs'
+                ? selectedJob(ctx.state) && { kind: 'job', id: selectedJob(ctx.state).job_id, label: commandHead(selectedJob(ctx.state).command) }
+                : ctx.state.selectedCronId !== null && { kind: 'cron', id: ctx.state.selectedCronId, label: ctx.state.selectedCronId };
+            if (!pending)
+                return;
+            if (pending.kind === 'job' && selectedJob(ctx.state)?.pgid === null) {
+                ctx.signal.setBanner('This job predates recorded process groups — crtr cannot stop it. Open its log and stop it by hand.', 'error');
+                return;
+            }
+            ctx.set((state) => ({ ...state, pendingCancel: pending }));
+            ctx.signal.setBanner(pending.kind === 'job'
+                ? `Stop job “${pending.label}”? It dies now and the node is told. Press y to confirm.`
+                : `Cancel cron ${pending.label}? Press y to confirm.`, 'action');
+        },
+        async openLog(ctx) {
+            const job = selectedJob(ctx.state);
+            if (job === undefined)
+                return;
+            ctx.signal.setStatus('Opening the job log…');
+            const result = await ctx.execute(openLogCommand, { path: job.log_path, title: `job · ${commandHead(job.command, 18)}` });
+            if (!result.ok) {
+                ctx.signal.setBanner(result.error.display.explanation, 'error');
+                return;
+            }
+            ctx.signal.setBanner('Log opened in a new tmux window, following live. Quit the Inspector to read it.', 'info');
+        },
         async confirm(ctx) {
-            const id = ctx.state.pendingCancel;
-            if (id === null)
+            const pending = ctx.state.pendingCancel;
+            if (pending === null)
                 return;
+            if (pending.kind === 'job') {
+                ctx.signal.setStatus('Stopping the job…');
+                const killed = await ctx.execute(killJobCommand, { target: ctx.state.target, job: pending.id });
+                ctx.set((state) => ({ ...state, pendingCancel: null }));
+                if (!killed.ok) {
+                    ctx.signal.setBanner(killed.error.display.explanation, 'error');
+                    return;
+                }
+                await ctx.dispatch('refresh');
+                const stillRunning = (ctx.state.jobs.data ?? []).some((job) => job.job_id === pending.id);
+                ctx.signal.setBanner(stillRunning ? 'The job is still running; refresh and retry.' : 'Job stopped — the node was told it was canceled.', stillRunning ? 'error' : 'info');
+                return;
+            }
             ctx.signal.setStatus('Canceling cron…');
-            const result = await ctx.execute(cancelCommand, id);
+            const result = await ctx.execute(cancelCommand, pending.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);
+            const stillArmed = (ctx.state.schedule.data ?? []).some((cron) => cron.cron_id === pending.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(); },
@@ -128,14 +250,41 @@ export const inspectorCore = {
             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 } }));
+            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 }, jobs: { 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); }
+export function selectedJob(state) {
+    return (state.jobs.data ?? []).find((job) => job.job_id === state.selectedJobId);
+}
+/** First line of a command, for banners and window titles. */
+function commandHead(command, cap = 40) {
+    const line = (command.split('\n')[0] ?? '').replace(/\s+/g, ' ').trim();
+    return line.length > cap ? `${line.slice(0, cap - 1)}…` : line;
+}
+/** Keep the job cursor on the same job across refreshes; when it finished, land
+ *  on whatever took its place rather than losing the cursor entirely. */
+function reconcileJobs(state, next) {
+    const fetched = { data: next, error: null, fetchedAt: Date.now() };
+    if (state.selectedJobId !== null && next.some((job) => job.job_id === state.selectedJobId))
+        return { ...state, jobs: fetched };
+    const previousIndex = (state.jobs.data ?? []).findIndex((job) => job.job_id === state.selectedJobId);
+    const replacement = next[Math.min(Math.max(0, previousIndex), Math.max(0, next.length - 1))];
+    const pendingCancel = state.pendingCancel?.kind === 'job' ? null : state.pendingCancel;
+    return { ...state, jobs: fetched, selectedJobId: replacement?.job_id ?? null, expanded: false, pendingCancel };
+}
 function move(state, delta) {
+    if (state.section === 'jobs') {
+        const jobs = state.jobs.data ?? [];
+        if (jobs.length === 0)
+            return state;
+        const current = Math.max(0, jobs.findIndex((job) => job.job_id === state.selectedJobId));
+        const next = Math.max(0, Math.min(jobs.length - 1, current + delta));
+        return { ...state, selectedJobId: jobs[next].job_id, expanded: false, pendingCancel: null };
+    }
     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 ?? []);

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

@@ -1,5 +1,17 @@
 import type { CronDTO } from '../../api/dto/crons.js';
-export type InspectorSection = 'overview' | 'schedule' | 'raw';
+export type InspectorSection = 'overview' | 'schedule' | 'jobs' | 'raw';
+/** One live background bash job, as `crtr --json node bash list` reports it. */
+export interface BashJobRow {
+    job_id: string;
+    command: string;
+    started_at: string;
+    elapsed_ms: number;
+    log_path: string;
+    /** Supervisor process group — null for a job started before crtr persisted
+     *  one, which is exactly the set of jobs the Inspector cannot stop. */
+    pgid: number | null;
+    log_tail: string[];
+}
 export interface ScheduledItem {
     cron: CronDTO;
     nextAt: string;
@@ -14,6 +26,8 @@ export declare const ICON: {
     readonly artifacts: string;
     readonly paths: string;
     readonly cron: string;
+    readonly job: string;
+    readonly log: string;
     readonly section: string;
     readonly raw: string;
     readonly empty: string;
@@ -38,6 +52,21 @@ export declare function statusVisual(status: string): {
     tone: Tone;
 };
 export declare function scheduledItems(crons: readonly CronDTO[]): ScheduledItem[];
+/** 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 declare function elapsed(ms: number): string;
+/** 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 declare function jobTone(elapsedMs: number): Tone;
+/** Milliseconds a job has been running, live from `started_at`. */
+export declare function jobElapsedMs(job: BashJobRow, now?: number): number;
+/** 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 declare function jobElapsed(job: BashJobRow, now?: number): string;
+/** First line of a command, whitespace-collapsed and capped for a one-row cell. */
+export declare function commandCell(command: string, cap?: number): string;
 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;