@north-light/crouter 0.3.173 → 0.3.174

package/dist/core/canvas/__tests__/render-remote.test.js

@@ -85,48 +85,6 @@ function row(id) {
         pane: null,
     };
 }
-test('dashboardRowsAllFromSource shows a node watched through its live broker', async () => {
-    const localRow = row('watched');
-    mkdirSync(jobDir('watched'), { recursive: true });
-    writeFileSync(join(jobDir('watched'), 'attach.json'), JSON.stringify({ viewers: 1 }));
-    const source = {
-        getNode: async () => meta('watched'),
-        getRow: async () => localRow,
-        listNodes: async () => [localRow],
-        subscriptionsOf: async () => [],
-        subscribersOf: async () => [],
-        view: async () => [],
-        ticketCountsForView: async () => ({}),
-        hasActiveLiveSubscription: async () => false,
-    };
-    const rows = await dashboardRowsAllFromSource(source);
-    assert.equal(rows[0]?.viewed, true);
-});
-test('enrichRowsFromSource serializes a full dashboard source read', async () => {
-    const nodeRows = ['a', 'b', 'c'].map(row);
-    let inFlight = 0;
-    let maxInFlight = 0;
-    const source = {
-        getNode: async (id) => {
-            inFlight++;
-            maxInFlight = Math.max(maxInFlight, inFlight);
-            await new Promise((resolve) => setImmediate(resolve));
-            inFlight--;
-            return meta(id);
-        },
-        getRow: async () => null,
-        listNodes: async () => nodeRows,
-        subscriptionsOf: async () => [],
-        subscribersOf: async () => [],
-        view: async () => [],
-        ticketCountsForView: async () => ({}),
-        hasActiveLiveSubscription: async () => false,
-    };
-    const rows = await dashboardRowsAllFromSource(source);
-    await enrichRowsFromSource(source, rows);
-    assert.equal(maxInFlight, 1);
-    assert.deepEqual(rows.map((entry) => entry.name), ['a', 'b', 'c']);
-});
 let home;
 let localCwd;
 let sessionFile;
@@ -207,8 +165,7 @@ test('dashboardRowsAllFromSource / enrichRowsFromSource / loadPreviewFromSource
         return { status: 500, body: {} };
     });
     // Register the close BEFORE any assertion runs — a listening server left
-    // open by a thrown assertion keeps this test file's process alive forever
-    // (see the CI-hang postmortem on rebuild-coalescer.test.ts).
+    // open by a thrown assertion keeps this test file's process alive forever.
     t.after(() => server.close());
     const source = new RemoteCanvasSource(server.url, 'tok');
     const rows = await dashboardRowsAllFromSource(source);
@@ -227,14 +184,12 @@ test('dashboardRowsAllFromSource / enrichRowsFromSource / loadPreviewFromSource
     assert.equal(previewed.lastAssistant, undefined, 'a local session transcript must not leak into a remote preview');
     assert.equal(previewed.previewLoaded, true);
 });
-// The non-TTY `canvas browse` path (browse/app.ts's `if (!process.stdin.isTTY)`
-// branch) calls `renderForestFromSource(source)` directly — a SEPARATE code
-// path from `dashboardRowsAllFromSource`/`enrichRowsFromSource`/
-// `loadPreviewFromSource` above, with its own remote suppression in
-// `renderTreeFromSource`/`nodeLineFromSource` (render.ts). The poisoned-state
-// test above never exercises it, so a regression that reintroduced local
-// telemetry/ask/fault reads into the static forest renderer specifically would
-// pass that test while still leaking poisoned local state here.
+// `renderForestFromSource` is a separate path from
+// `dashboardRowsAllFromSource`/`enrichRowsFromSource`/`loadPreviewFromSource`
+// above, with its own remote suppression in `renderTreeFromSource`/
+// `nodeLineFromSource` (render.ts). The poisoned-state test above never
+// exercises it, so a regression that reintroduced local telemetry/ask/fault
+// reads into the static forest renderer would still leak poisoned local state.
 test('renderForestFromSource suppresses local-read fields (ctx, asks, hanging) for a RemoteCanvasSource, even with conflicting local state for the same node id', async (t) => {
     const sf = seedPoisonedLocalState();
     const server = await startMockCrtrServer((args) => {

package/dist/core/canvas/browse/app.d.ts

@@ -1,34 +1,19 @@
 import type { CanvasSource } from '../source.js';
-import type { RemoteEventStream } from '../remote-event-stream.js';
-import { type CoalescedRebuilder } from './rebuild-coalescer.js';
 import { type BindingId, type BindingResolution, type RawTerminalInput } from '../../keybindings/index.js';
 declare const BROWSE_NAV_ACTIONS: readonly ["crtr.browse.quit", "crtr.browse.down", "crtr.browse.up", "crtr.browse.first", "crtr.browse.last", "crtr.browse.expand-or-child", "crtr.browse.collapse-or-parent", "crtr.browse.toggle-fold", "crtr.browse.tab-next", "crtr.browse.tab-previous", "crtr.browse.tab.1", "crtr.browse.tab.2", "crtr.browse.tab.3", "crtr.browse.tab.4", "crtr.browse.tab.5", "crtr.browse.close-subtree", "crtr.browse.sort", "crtr.browse.scope", "crtr.browse.profile", "crtr.browse.residents", "crtr.browse.preview", "crtr.browse.search", "crtr.browse.revive-now", "crtr.browse.focus", "crtr.browse.focus-background"];
 declare const BROWSE_SEARCH_ACTIONS: readonly ["crtr.browse.search.cancel", "crtr.browse.search.commit", "crtr.browse.search.delete", "crtr.browse.search.quit"];
 export declare function resolveBrowseNavAction(bindings: BindingResolution<BindingId>, raw: RawTerminalInput): (typeof BROWSE_NAV_ACTIONS)[number] | null;
 export declare function resolveBrowseSearchAction(bindings: BindingResolution<BindingId>, raw: RawTerminalInput): (typeof BROWSE_SEARCH_ACTIONS)[number] | null;
-/** Wires a RemoteEventStream's `nodes`/`inbox` events through the coalescer
- *  (`rebuild-coalescer.ts`) so a burst of SSE events collapses to ONE rebuild
- *  round, never one N+1 remote-subprocess rebuild per event. Exported (rather
- *  than left inline in `runBrowse`) so the coalescer integration test can
- *  drive this ACTUAL wiring, not just `createCoalescedRebuilder` in isolation
- *  — the test asserts this function routes through the coalescer rather than
- *  calling `rebuild()` directly per event. */
-export declare function wireEventStreamRebuild(eventStream: Pick<RemoteEventStream, 'subscribe' | 'start'>, rebuild: () => Promise<void>): {
-    rebuilder: CoalescedRebuilder;
-    unsubscribe: () => void;
-};
 export declare function runBrowse(opts: {
     returnPane?: string;
     cwd?: string;
     /** Profile to show initially. Undefined means no profile is selected, so the
      *  initial view includes all profiles and the profile toggle is unavailable. */
     profileId?: string;
-    /** The read source (required) — canvas-browse always injects one
-     *  (`cliCanvasSource`/remote); no in-process openDb fallback exists here. */
+    /** The local API-backed read source. No in-process openDb fallback exists here. */
     source: CanvasSource;
-    eventStream?: RemoteEventStream;
     /** Local viewer registry projection. Kept separate from CanvasSource because
-     *  focus rows describe this machine's screens, not remote canvas state. */
+     *  focus rows describe this machine's screens. */
     viewedNodeIds?: () => Promise<ReadonlySet<string>>;
     /** Route the `x` close-out through the daemon API (the CLI injects
      *  `cliClient().closeNode(id, { finish: true })`). Kept as a callback so this

package/dist/core/canvas/browse/app.js

@@ -10,11 +10,9 @@
 import { execFileSync } from 'node:child_process';
 import { resolve } from 'node:path';
 import { dashboardRowsAllFromSource, enrichRowsFromSource, loadPreviewFromSource, renderForestFromSource } from '../render-source.js';
-import { RemoteCanvasSource } from '../remote-canvas-source.js';
 import { setupTerminal, restoreTerminal, getTerminalSize, parseKeypress, } from '../../tui/terminal.js';
 import { buildTree, flatten, pruneNode, TABS } from './model.js';
 import { loadPins, savePins } from './pins.js';
-import { createCoalescedRebuilder } from './rebuild-coalescer.js';
 import { matchesTerminalInput, resolveUserKeybindings, } from '../../keybindings/index.js';
 const BROWSE_NAV_ACTIONS = [
     'crtr.browse.quit', 'crtr.browse.down', 'crtr.browse.up', 'crtr.browse.first', 'crtr.browse.last',
@@ -49,22 +47,8 @@ function viewportHeight(rowsTotal, inputLine, previewOn) {
     const previewH = previewOn ? PREVIEW_HEIGHT : 0;
     return Math.max(1, rows - headerHeight(inputLine) - 1 /* footer */ - previewH);
 }
-/** Wires a RemoteEventStream's `nodes`/`inbox` events through the coalescer
- *  (`rebuild-coalescer.ts`) so a burst of SSE events collapses to ONE rebuild
- *  round, never one N+1 remote-subprocess rebuild per event. Exported (rather
- *  than left inline in `runBrowse`) so the coalescer integration test can
- *  drive this ACTUAL wiring, not just `createCoalescedRebuilder` in isolation
- *  — the test asserts this function routes through the coalescer rather than
- *  calling `rebuild()` directly per event. */
-export function wireEventStreamRebuild(eventStream, rebuild) {
-    const rebuilder = createCoalescedRebuilder(rebuild);
-    const unsubscribe = eventStream.subscribe(() => rebuilder.trigger());
-    eventStream.start();
-    return { rebuilder, unsubscribe };
-}
 export async function runBrowse(opts) {
     const source = opts.source;
-    const isRemote = source instanceof RemoteCanvasSource;
     const bindings = resolveUserKeybindings();
     // No TTY → print the static forest and exit 0 (no raw mode).
     if (!process.stdin.isTTY) {
@@ -73,25 +57,20 @@ export async function runBrowse(opts) {
     }
     // Snapshot the canvas. Drop kind:'human' control-plane decks — they have no pi
     // session, so `surface node focus` refuses them; they are never a navigation/resume
-    // target (mirrors the surface-node focus guard). Factored into a function so the SSE
-    // listener below can re-pull the tree on a `nodes`/`inbox` event instead of
-    // recomputing over a stale snapshot.
+    // target (mirrors the surface-node focus guard).
     let rows;
     let nodeRows;
     let rootIds;
     let childIds;
     let tree;
     let totalNodes;
-    // Remote-only: pending human-ticket counts per node, merged from one
-    // `ticketCountsForView` call per forest root (RemoteCanvasSource.ticketCountsForView
-    // already shells a single `canvas attention map --view <root>` per root, same
-    // cost class as the per-node `subscriptionsOf` fan-out this snapshot already
-    // does below) — fetched once per snapshot rebuild, not per flush/keystroke, so
-    // enrichRowsFromSource's per-row loop stays a pure sync-shaped map lookup.
-    let remoteAskCounts = {};
+    // Pending human-ticket counts per node, merged from one `ticketCountsForView`
+    // call per forest root. Fetch once per snapshot rebuild, not per flush or
+    // keystroke, so enrichRowsFromSource's per-row loop stays a pure map lookup.
+    let askCounts = {};
     const rebuildSnapshot = async () => {
         let viewedNodeIds = new Set();
-        if (!isRemote && opts.viewedNodeIds !== undefined) {
+        if (opts.viewedNodeIds !== undefined) {
             try {
                 viewedNodeIds = await opts.viewedNodeIds();
             }
@@ -110,11 +89,9 @@ export async function runBrowse(opts) {
         tree = buildTree(rows, rootIds, (id) => childIds.get(id) ?? []);
         totalNodes = tree.nodes.size;
         // Ask counts per node, merged from one `ticketCountsForView` call per root
-        // (covers the whole canvas — rootIds is every non-human root). Fetched for BOTH
-        // the local API source and a remote canvas, since neither can do a per-node
-        // openDb ticket scan; feeds enrichRowsFromSource's per-row map lookup.
+        // (covers the whole canvas — rootIds is every non-human root).
         const maps = await Promise.all(rootIds.map((root) => source.ticketCountsForView(root).catch(() => ({}))));
-        remoteAskCounts = Object.assign({}, ...maps);
+        askCounts = Object.assign({}, ...maps);
     };
     await rebuildSnapshot();
     // The launch dir is retained only as the optional cwd filter target. Browse opens
@@ -164,43 +141,10 @@ export async function runBrowse(opts) {
             restoreTerminal();
         }
         catch { /* best-effort */ }
-        unsubscribeEventStream?.();
-        rebuilder?.stop();
-        opts.eventStream?.stop();
     };
     // Safety net: an uncaught throw in the (un-unit-tested) keystroke path must
     // never strand the tty in raw + alt-screen + hidden-cursor.
     process.once('exit', cleanup);
-    // Remote-only live invalidation: `canvas browse` has no local fs-watch/poll to
-    // replace (there is none — this is a one-shot snapshot TUI, re-rendering only
-    // on keystrokes). This is net-new plumbing for the remote case only: when a
-    // pre-built RemoteEventStream is threaded in (canvas-browse.ts, once it has
-    // already resolved the target's credentials), a `nodes`/`inbox` SSE event
-    // invalidates the remote source's cache and triggers the same recompute +
-    // coalesced repaint a keystroke would. The local (no eventStream) path is
-    // untouched.
-    let unsubscribeEventStream;
-    let rebuilder;
-    if (opts.eventStream !== undefined) {
-        if (source instanceof RemoteCanvasSource)
-            source.invalidate();
-        // `trigger()` debounces a burst into one rebuild, and single-flights it
-        // against an already-in-flight rebuild — see wireEventStreamRebuild above.
-        const wired = wireEventStreamRebuild(opts.eventStream, async () => {
-            try {
-                if (source instanceof RemoteCanvasSource)
-                    source.invalidate();
-                await rebuildSnapshot();
-                recompute(curRow()?.id);
-                scheduleFlush();
-            }
-            catch (err) {
-                logAsyncFailure('SSE rebuild failed', err);
-            }
-        });
-        rebuilder = wired.rebuilder;
-        unsubscribeEventStream = wired.unsubscribe;
-    }
     const logAsyncFailure = (label, err) => {
         process.stderr.write(`[crtr browse] ${label}: ${String(err?.message ?? err)}\n`);
     };
@@ -287,7 +231,7 @@ export async function runBrowse(opts) {
             if (r !== undefined)
                 slice.push(r);
         }
-        await enrichRowsFromSource(source, slice, remoteAskCounts);
+        await enrichRowsFromSource(source, slice, askCounts);
         const cur = curRow();
         if (cur !== undefined) {
             const r = rowOf(cur.id);
@@ -302,7 +246,7 @@ export async function runBrowse(opts) {
             pinned: state.pinned, help: state.help,
             rename: state.rename, renameBuf: state.renameBuf,
             message: state.message, messageBuf: state.messageBuf,
-            readOnly: isRemote,
+            readOnly: false,
         }, size, caps);
         process.stdout.write(frame);
     };
@@ -708,10 +652,7 @@ export async function runBrowse(opts) {
         }
         // Close-out the selected node (+ its exclusive subtree). If anything in that
         // subtree is actively streaming, confirm first (y/n); otherwise close at once.
-        // No-op against a remote canvas — mutations are disabled (footer says so).
         if (action === 'crtr.browse.close-subtree') {
-            if (isRemote)
-                return;
             if (row === undefined) {
                 scheduleFlush();
                 return;
@@ -756,7 +697,7 @@ export async function runBrowse(opts) {
             scheduleFlush();
             return;
         }
-        // Pin / unpin (local, view-only — works against a remote canvas too).
+        // Pin or unpin in the local, view-only pin set.
         if (input === 'f') {
             if (row !== undefined)
                 togglePin(row.id);
@@ -769,10 +710,8 @@ export async function runBrowse(opts) {
             scheduleFlush();
             return;
         }
-        // Rename the node inline (mutation — no-op on a remote canvas).
+        // Rename the node inline.
         if (input === 'R') {
-            if (isRemote)
-                return;
             if (row !== undefined) {
                 state.rename = true;
                 state.renameTarget = row.id;
@@ -781,10 +720,8 @@ export async function runBrowse(opts) {
             scheduleFlush();
             return;
         }
-        // Message the node without resuming it (mutation — no-op on a remote canvas).
+        // Message the node without resuming it.
         if (input === 'm') {
-            if (isRemote)
-                return;
             if (row !== undefined) {
                 state.message = true;
                 state.messageTarget = row.id;
@@ -810,10 +747,7 @@ export async function runBrowse(opts) {
         // waiting out the 5-min auto-revive grace. Shells `node lifecycle revive <id>
         // --now` (browse goes through commands, never touching the runtime directly). 'k' is
         // vim-up here, so the kick is on SHIFT-K.
-        // No-op against a remote canvas — mutations are disabled (footer says so).
         if (action === 'crtr.browse.revive-now') {
-            if (isRemote)
-                return;
             if (row !== undefined) {
                 const r = rowOf(row.id);
                 if (r?.hanging != null)
@@ -822,21 +756,15 @@ export async function runBrowse(opts) {
             scheduleFlush();
             return;
         }
-        // Resume. No-op against a remote canvas — mutations/focus are disabled
-        // (footer says so).
+        // Resume the selected node.
         if (action === 'crtr.browse.focus') {
-            if (isRemote)
-                return;
             if (row !== undefined)
                 selectAndFocus(row.id);
             return;
         }
         // Resume in the BACKGROUND (Shift+O): focus the node into the pane behind this
-        // popup but keep the navigator open so you can resume more nodes. Same remote
-        // guard as plain focus.
+        // popup but keep the navigator open so you can resume more nodes.
         if (action === 'crtr.browse.focus-background') {
-            if (isRemote)
-                return;
             if (row !== undefined)
                 selectAndFocusKeepOpen(row.id);
             scheduleFlush();
@@ -877,7 +805,7 @@ export async function runBrowse(opts) {
             return;
         const end = Math.min(warmIdx + WARM_CHUNK, warmRows.length);
         const slice = warmRows.slice(warmIdx, end);
-        await enrichRowsFromSource(source, slice, remoteAskCounts);
+        await enrichRowsFromSource(source, slice, askCounts);
         await Promise.all(slice.map((r) => loadPreviewFromSource(source, r)));
         warmIdx = end;
         // A live search may match the freshly-warmed prompts → recompute + repaint.

package/dist/core/canvas/browse/model.d.ts

@@ -1,5 +1,4 @@
 import type { DashboardRow } from '../render.js';
-import type { NodeStatus } from '../types.js';
 export type Tab = 'All' | 'Live' | 'Dormant' | 'Attention' | 'Pinned';
 export declare const TABS: readonly Tab[];
 /** How the visible rows are ordered.
@@ -28,9 +27,6 @@ export interface Tree {
     roots: string[];
     nodes: Map<string, TreeNode>;
 }
-/** Sort rank for roots/stragglers — live first (active, then idle), dormant
- *  after. Mirrors render.ts statusRank. */
-export declare function statusRank(status: NodeStatus): number;
 /**
  * Build a spanning tree of the whole canvas.
  *   - `rows`       — one DashboardRow per node (display text + status/asks).

package/dist/core/canvas/browse/model.js

@@ -4,6 +4,7 @@
 // it is exhaustively unit-testable. The app layer (app.ts) wires the canvas data
 // access (dashboardRowsAll / listNodes / subscriptionsOf) into buildTree, then
 // drives flatten() on each keystroke.
+import { statusRank } from '../node-order.js';
 export const TABS = ['All', 'Live', 'Dormant', 'Attention', 'Pinned'];
 export const SORTS = ['tree', 'attention', 'relevance', 'recency'];
 /** Does a node belong to this tab's slice?
@@ -21,18 +22,6 @@ export function tabPredicate(tab, row, isPinned = false) {
         case 'Pinned': return isPinned;
     }
 }
-/** Sort rank for roots/stragglers — live first (active, then idle), dormant
- *  after. Mirrors render.ts statusRank. */
-export function statusRank(status) {
-    switch (status) {
-        case 'active': return 0;
-        case 'idle': return 1;
-        case 'done': return 2;
-        case 'canceled': return 3;
-        case 'dead': return 4;
-        default: return 5;
-    }
-}
 /**
  * Build a spanning tree of the whole canvas.
  *   - `rows`       — one DashboardRow per node (display text + status/asks).

package/dist/core/canvas/browse/render.js

@@ -316,9 +316,12 @@ function statusLine(state) {
     const dim = (s) => `${DIM}${s}${RESET}`;
     const profile = state.profileScope === undefined ? 'all profiles' : 'current';
     const scope = state.cwdScope === null ? 'all dirs' : baseDir(state.cwdScope);
-    const segs = [`${dim('profile')} ${profile}`, `${dim('scope')} ${scope}`, `${dim('sort')} ${state.sort}`];
-    if (state.residentsOnly)
-        segs.push(`${dim('show')} residents`);
+    const segs = [
+        `${dim('profile')} ${profile}`,
+        `${dim('scope')} ${scope}`,
+        `${dim('sort')} ${state.sort}`,
+        `${dim('lifecycle')} ${state.residentsOnly ? 'residents' : 'all'}`,
+    ];
     if (!state.search && state.query !== '')
         segs.push(`${dim('filter')} ${state.query}`);
     return segs.join(dim('  ·  '));

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

@@ -138,11 +138,14 @@ export declare function listCrons(scope: {
 }): Cron[];
 /** DELETE one cron — the explicit user/surface cancel. Idempotent: an absent
  *  row is a no-op `false`. Kills any in-flight run process group before
- *  deleting, under one canvas write boundary (the reapThenDelete precedent):
- *  lease acquisition linearizes either before this selection (the run is
- *  observed and killed) or after the delete (and loses the lease). The FK
- *  cascade reaps the cron's run history with it. */
-export declare function cancelCron(cron_id: string): boolean;
+ *  deleting unless the daemon has proved the caller is that exact run; then
+ *  the process must finish and deliver its already-produced output. The lease
+ *  acquisition still linearizes before this selection (the run is observed
+ *  and killed) or after the delete (and loses the lease). The FK cascade reaps
+ *  the cron's run history with it. */
+export declare function cancelCron(cron_id: string, options?: {
+    preserveRunningProcess?: boolean;
+}): boolean;
 /** DELETE one cron by id — one-shot consumption after its run settles.
  *  Returns whether a live row was removed, so a consumer racing an explicit
  *  cancel can no-op instead of double-settling. */

package/dist/core/canvas/crons.js

@@ -172,17 +172,18 @@ export function listCrons(scope) {
 }
 /** DELETE one cron — the explicit user/surface cancel. Idempotent: an absent
  *  row is a no-op `false`. Kills any in-flight run process group before
- *  deleting, under one canvas write boundary (the reapThenDelete precedent):
- *  lease acquisition linearizes either before this selection (the run is
- *  observed and killed) or after the delete (and loses the lease). The FK
- *  cascade reaps the cron's run history with it. */
-export function cancelCron(cron_id) {
+ *  deleting unless the daemon has proved the caller is that exact run; then
+ *  the process must finish and deliver its already-produced output. The lease
+ *  acquisition still linearizes before this selection (the run is observed
+ *  and killed) or after the delete (and loses the lease). The FK cascade reaps
+ *  the cron's run history with it. */
+export function cancelCron(cron_id, options) {
     return withCanvasWrite((db) => {
         const row = db.prepare('SELECT * FROM crons WHERE cron_id = ?').get(cron_id);
         if (row === undefined)
             return false;
         const cron = cronFrom(row);
-        if (cron.run_state === 'running')
+        if (cron.run_state === 'running' && options?.preserveRunningProcess !== true)
             killLeasedCronRun(cron);
         db.prepare('DELETE FROM crons WHERE cron_id = ?').run(cron_id);
         return true;

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

@@ -1,5 +1,9 @@
 export declare const CANVAS_EXTENSION_NAMES: readonly ["canvas-inbox-watcher", "canvas-review-boundary", "canvas-stophook", "canvas-recap", "canvas-goal-capture", "canvas-passive-context", "canvas-context-intro", "canvas-tool-guide", "canvas-doc-substrate", "canvas-structured-output", "canvas-bash-valve"];
-/** Remove a complete persisted canvas prefix while retaining every genuine
- * caller/kind extra, including a custom extension whose basename happens to
- * resemble a canvas hook. */
+/** Structural shipped-hook identity: a canvas-hook stem directly under a
+ * `pi-extensions` directory. A user's own extension elsewhere may share the
+ * stem and is not shipped. */
+export declare function isShippedCanvasExtension(path: string): boolean;
+/** Remove persisted shipped canvas extensions while retaining genuine
+ * caller/kind extras, including a custom extension whose basename happens to
+ * resemble a canvas hook outside a pi-extensions directory. */
 export declare function customExtensionPaths(extensions: readonly string[] | undefined): string[];

package/dist/core/canvas/extensions.js

@@ -1,3 +1,4 @@
+import { extname } from 'node:path';
 // Canvas-extension identity is structural, not basename-based: old runtime roots
 // are recognized only when they carry a complete shipped canvas prefix.
 // canvas-inbox-watcher must load before canvas-stophook: at agent_settled it
@@ -44,10 +45,21 @@ function extensionPrefixLength(extensions) {
     const prefixes = [CANVAS_EXTENSION_NAMES, ...HISTORICAL_CANVAS_EXTENSION_PREFIXES];
     return prefixes.find((names) => matchesExtensionPrefix(extensions, names))?.length ?? 0;
 }
-/** Remove a complete persisted canvas prefix while retaining every genuine
- * caller/kind extra, including a custom extension whose basename happens to
- * resemble a canvas hook. */
+/** Structural shipped-hook identity: a canvas-hook stem directly under a
+ * `pi-extensions` directory. A user's own extension elsewhere may share the
+ * stem and is not shipped. */
+export function isShippedCanvasExtension(path) {
+    const normalized = path.replaceAll('\\', '/');
+    const lastSlash = normalized.lastIndexOf('/');
+    const parent = normalized.slice(0, lastSlash).split('/').at(-1);
+    const filename = normalized.slice(lastSlash + 1);
+    const name = filename.slice(0, filename.length - extname(filename).length);
+    return parent === 'pi-extensions' && CANVAS_EXTENSION_NAMES.includes(name);
+}
+/** Remove persisted shipped canvas extensions while retaining genuine
+ * caller/kind extras, including a custom extension whose basename happens to
+ * resemble a canvas hook outside a pi-extensions directory. */
 export function customExtensionPaths(extensions) {
     const paths = extensions ?? [];
-    return paths.slice(extensionPrefixLength(paths));
+    return paths.slice(extensionPrefixLength(paths)).filter((path) => !isShippedCanvasExtension(path));
 }

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

@@ -34,10 +34,6 @@ export declare function subtreeIds(root: string): string[];
  *  with navigable children (folded or not). In GRAPH the ▸ caret separately marks
  *  a collapsed row, so this stays a pure count and never doubles as a fold badge. */
 export declare function childBadge(node: NodeMeta | null): string;
-/** Sort rank for sibling ordering — live nodes (active, then idle) ahead of
- *  terminal ones, so sessions still running surface at the TOP of each child
- *  group instead of being buried under finished/failed ones. */
-export declare function statusRank(id: string): number;
 /** Direct children, live-first — the sibling order used both when flattening
  *  the tree and when stepping into a subtree (`l`). Array.sort is stable, so
  *  equal-status siblings keep their creation order. */

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

@@ -14,6 +14,7 @@ import { getNode, subscribersOf, subscriptionsOf } from './index.js';
 import { activeFaultForDisplay } from './render.js';
 import { readFault } from '../runtime/fault.js';
 import { faultSummary } from './status-glyph.js';
+import { statusRank } from './node-order.js';
 import { beginFrameTelem, nodeGlyph, navLabel, shortId, tokensCell, activityCell, cycleBadge, askBadge, liveBelowBadge, truncate, fillBar, fillWidth, isAttached, BOLD, DIM, RESET, REVERSE, BG_ATTACHED, } from './nav-render.js';
 // Re-export the pure render/telemetry half so existing nav-model importers
 // (chrome/canvas-panels, overlays/graph, resume) keep resolving these here.
@@ -170,24 +171,11 @@ export function childBadge(node) {
     const m = childCount(node.node_id);
     return m > 0 ? ` ${DIM}⤳${m}${RESET}` : '';
 }
-/** Sort rank for sibling ordering — live nodes (active, then idle) ahead of
- *  terminal ones, so sessions still running surface at the TOP of each child
- *  group instead of being buried under finished/failed ones. */
-export function statusRank(id) {
-    switch (cNode(id)?.status) {
-        case 'active': return 0;
-        case 'idle': return 1;
-        case 'done': return 2;
-        case 'canceled': return 3;
-        case 'dead': return 4;
-        default: return 5;
-    }
-}
 /** Direct children, live-first — the sibling order used both when flattening
  *  the tree and when stepping into a subtree (`l`). Array.sort is stable, so
  *  equal-status siblings keep their creation order. */
 export function sortedChildIds(id) {
-    return convoChildIds(id).sort((a, b) => statusRank(a) - statusRank(b));
+    return convoChildIds(id).sort((a, b) => statusRank(cNode(a)?.status) - statusRank(cNode(b)?.status));
 }
 // ---------------------------------------------------------------------------
 // GRAPH model — flatten the local graph fold-aware. Rebuilt every render (cheap

package/dist/core/canvas/node-order.d.ts

@@ -0,0 +1,3 @@
+import type { NodeStatus } from './types.js';
+/** Sort live work before terminal work; unknown statuses sort last. */
+export declare function statusRank(status: NodeStatus | undefined): number;

package/dist/core/canvas/node-order.js

@@ -0,0 +1,12 @@
+// node-order.ts — canonical live-first ordering for canvas node statuses.
+/** Sort live work before terminal work; unknown statuses sort last. */
+export function statusRank(status) {
+    switch (status) {
+        case 'active': return 0;
+        case 'idle': return 1;
+        case 'done': return 2;
+        case 'canceled': return 3;
+        case 'dead': return 4;
+        default: return 5;
+    }
+}

package/dist/core/canvas/remote-canvas-source.d.ts

@@ -1,7 +1,7 @@
 import type { CanvasSource } from './source.js';
 import type { NodeMeta, NodeRow, NodeStatus, SubscriptionRef } from './types.js';
 /** The exact JSON shape `crtr --json node inspect show <id>` emits (see
- *  `nodeShow`'s `run`, `src/commands/node.ts`) — mirrored here, not imported,
+ *  `nodeShow` in `src/commands/node/inspect.ts`) — mirrored here, not imported,
  *  to avoid a commands→canvas value dependency. */
 export interface RemoteShowResponse {
     node: NodeMeta;
@@ -28,7 +28,7 @@ export interface RemoteShowResponse {
     paths: {
         context_dir: string;
         reports_dir: string;
-        session_file: string | null;
+        session_file?: string | null;
     };
     follow_up: string;
 }
@@ -40,13 +40,10 @@ export declare class RemoteCanvasSource implements CanvasSource {
     private rosterCache;
     private viewCache;
     constructor(previewEndpoint: string, relayToken: string);
-    /** Drops every cached entry — called on a `RemoteEventStream` `'nodes'` (or
-     *  `'inbox'`) event so the next read re-fetches fresh state. */
-    invalidate(): void;
     private execJson;
     private fetchShow;
     /** The full passthrough object `node inspect show` produces — used by
-     *  `nodeShow`'s remote branch (`src/commands/node.ts`) to return the exact
+     *  `nodeShow`'s remote branch (`src/commands/node/inspect.ts`) to return the exact
      *  same shape a local read would, without re-deriving it. */
     rawShow(id: string): Promise<RemoteShowResponse | null>;
     getNode(id: string): Promise<NodeMeta | null>;