@north-light/crouter 0.3.172 → 0.3.174

package/dist/core/broker-client/__tests__/transport-relay.test.js

@@ -1,11 +1,8 @@
-// transport-relay.test.ts — mock-relay coverage for RelayTransport
-// (`../transport-relay.ts`), the REMOTE half of the Transport seam.
-// Fast tier: a plain `ws` WebSocketServer standing in for model-auth-front's
-// relay, no pi boot, no broker. Exercises exactly what the handoff doc
-// flagged as unverified: the Authorization header, the one-JSON-frame-per-
-// WS-message wire, the 1011/1008 "gone" close-code classification (and its
-// NOT-gone counterparts), and a non-101 handshake response (bad token) not
-// hanging connect().
+// transport-relay.test.ts — RelayTransport coverage for the remote half of
+// the Transport seam. This fast plain-`ws` stand-in for crtrd's attach endpoint
+// exercises the required route, Authorization header, one-JSON-frame-per-WS-
+// message wire, 1011/1008 unavailable-broker classification, and a failed
+// handshake without booting pi or a broker.
 import assert from 'node:assert/strict';
 import test, { after, before } from 'node:test';
 import { existsSync, mkdtempSync, rmSync } from 'node:fs';
@@ -15,16 +12,18 @@ import { WebSocketServer } from 'ws';
 import { RelayTransport } from '../transport-relay.js';
 import { BrokerUnavailableError } from '../transport.js';
 import { jobDir } from '../../canvas/paths.js';
-/** Stand up a bare `ws` server on an ephemeral loopback port — the "relay" a
- *  RelayTransport dials. Records the Authorization header + accepted sockets
- *  of every connection so a test can assert on the wire, not just behavior. */
+/** Stand up a bare `ws` crtrd attach endpoint on an ephemeral loopback port.
+ *  It records each request URL, Authorization header, and accepted socket so
+ *  the tests assert the wire contract directly. */
 function startMockRelay() {
     return new Promise((resolve) => {
         const wss = new WebSocketServer({ port: 0 });
         const authHeaders = [];
+        const requestUrls = [];
         const sockets = [];
         wss.on('connection', (ws, req) => {
             authHeaders.push(req.headers.authorization ?? '');
+            requestUrls.push(req.url ?? '');
             sockets.push(ws);
         });
         wss.once('listening', () => {
@@ -33,6 +32,7 @@ function startMockRelay() {
             resolve({
                 target: { previewEndpoint: `http://127.0.0.1:${port}`, relayToken: 'test-token' },
                 authHeaders,
+                requestUrls,
                 sockets,
                 close: () => new Promise((res) => wss.close(() => res())),
             });
@@ -57,10 +57,11 @@ function connectTransport(transport) {
         transport.connect();
     });
 }
-test('RelayTransport sends Authorization: Bearer <token> on connect', async () => {
+test('RelayTransport dials crtrd attach with Authorization: Bearer <token>', async () => {
     const relay = await startMockRelay();
     const transport = new RelayTransport('node-auth', relay.target);
     await connectTransport(transport);
+    assert.equal(relay.requestUrls[0], '/v1/nodes/node-auth/attach');
     assert.equal(relay.authHeaders[0], 'Bearer test-token');
     transport.destroy();
     await relay.close();
@@ -109,10 +110,8 @@ test('a 1000 normal close does NOT surface BrokerUnavailableError', async () =>
     await relay.close();
 });
 test('an immediate post-upgrade 1011 "no node <id>" close is still caught by a listener installed BEFORE connect() is dialed', async () => {
-    // Mirrors server.ts's bridgeConnection exactly: the relay ACCEPTS the WS
-    // upgrade unconditionally, then discovers synchronously (no data exchange,
-    // no delay from app logic) that the node doesn't exist and closes 1011 —
-    // in the SAME tick the 'connection' handler runs. This is the ordering that
+    // Simulate a crtrd attach connection that closes 1011 immediately after its
+    // WebSocket upgrade. This is the ordering that
     // broke `viewer.ts`'s original startup race: the transport's 'connect'
     // (WS 'open') is structurally guaranteed to fire before any close frame can
     // be parsed (a close can't precede the handshake that establishes the

package/dist/core/broker-client/__tests__/transport-socket.test.js

@@ -0,0 +1,28 @@
+import assert from 'node:assert/strict';
+import { mkdirSync, mkdtempSync, rmSync } from 'node:fs';
+import test from 'node:test';
+import { nodeDir } from '../../canvas/paths.js';
+import { readFault } from '../../runtime/fault.js';
+import { SocketTransport } from '../transport-socket.js';
+test('a missing dormant broker does not leave a viewer↔broker fault', async () => {
+    const previousHome = process.env['CRTR_HOME'];
+    const home = mkdtempSync('/tmp/crtr-transport-socket-');
+    process.env['CRTR_HOME'] = home;
+    try {
+        const nodeId = 'dormant-node';
+        mkdirSync(nodeDir(nodeId), { recursive: true });
+        const transport = new SocketTransport(nodeId);
+        await assert.rejects(transport.redial());
+        assert.equal(readFault(nodeId)?.link, 'viewer↔broker', 'an ordinary failed redial records the outage');
+        await assert.rejects(transport.redial({ brokerUnavailableIsExpected: true }));
+        assert.equal(readFault(nodeId), null, 'a dormant node with no broker is normal, not a fault');
+        transport.destroy();
+    }
+    finally {
+        if (previousHome === undefined)
+            delete process.env['CRTR_HOME'];
+        else
+            process.env['CRTR_HOME'] = previousHome;
+        rmSync(home, { recursive: true, force: true });
+    }
+});

package/dist/core/broker-client/client.d.ts

@@ -1,7 +1,7 @@
 import { EventEmitter } from 'node:events';
 import type { NodeRow } from '../canvas/types.js';
 import type { BrokerDataFrame, BrokerToClient, ClientToBroker, DequeueFrame, GetHumanForkCoordinatesFrame, GetSettingsFrame, GetTreeFrame, ListMemoryRefsFrame, ListModelsFrame, ListScopedModelsFrame, ListSessionsFrame } from '../runtime/broker-protocol.js';
-import { type Transport } from './transport.js';
+import { type RedialOptions, type Transport } from './transport.js';
 export { BrokerUnavailableError, type Transport } from './transport.js';
 export { SocketTransport } from './transport-socket.js';
 export { RelayTransport, type RelayTarget } from './transport-relay.js';
@@ -76,7 +76,7 @@ export declare class BrokerClient extends EventEmitter {
     /** Re-establish the connection after a broker exit (a yield→revive cycle),
      *  to the SAME target. Resolves on `connect` (caller re-sends `hello`);
      *  rejects on a retryable dial failure. */
-    redial(): Promise<void>;
+    redial(options?: RedialOptions): Promise<void>;
     /** Encode + send one client→broker frame. No-op on a dead/absent
      *  connection; never throws. */
     send(frame: ClientToBroker): void;

package/dist/core/broker-client/client.js

@@ -1,15 +1,12 @@
 // client.ts — THE broker protocol client. Every Node process that talks to a
 // node's broker over `view.sock` uses this one class: the `crtr surface attach`
 // viewer, `auth-reload`, `model-swap`, and the human-prompt dequeue path.
-// (The browser has its own module under
-// `clients/web/web-client/` until that is made isomorphic — see the target
-// architecture note; `daemon/api/bridge.ts` is a byte relay, not a client.)
 //
 // The §0 ONE-WRITER INVARIANT lives here: a client has ONLY a Transport
 // (`transport.ts`) to an ALREADY-running headless broker — locally over its
 // unix socket (`SocketTransport`, `nodeDir(id)/view.sock`), or remotely over a
-// relayed WebSocket to the Blaxel preview endpoint (`RelayTransport`,
-// `transport-relay.ts`). BrokerClient NEVER spawns pi, NEVER opens the session
+// bearer-authenticated WebSocket to crtrd's preview-served attach endpoint
+// (`RelayTransport`, `transport-relay.ts`). BrokerClient NEVER spawns pi, NEVER opens the session
 // `.jsonl`, NEVER constructs an engine — if the broker is not running, connect
 // fails and the caller exits (focus/revive is what keeps a broker alive, not
 // attach). It also never uses pi's `RpcClient` (which would spawn its own
@@ -128,8 +125,8 @@ export class BrokerClient extends EventEmitter {
     /** Re-establish the connection after a broker exit (a yield→revive cycle),
      *  to the SAME target. Resolves on `connect` (caller re-sends `hello`);
      *  rejects on a retryable dial failure. */
-    redial() {
-        return this.transport.redial();
+    redial(options) {
+        return this.transport.redial(options);
     }
     /** Encode + send one client→broker frame. No-op on a dead/absent
      *  connection; never throws. */

package/dist/core/broker-client/transport-relay.d.ts

@@ -1,6 +1,6 @@
 import { EventEmitter } from 'node:events';
 import type { ClientToBroker } from '../runtime/broker-protocol.js';
-import { type Transport } from './transport.js';
+import { type RedialOptions, type Transport } from './transport.js';
 /** A resolved remote canvas target — see `core/remote-canvas-target.ts` for how
  *  this is assembled from config (`relayTokenRef`) plus the 0600 secrets store
  *  via `resolveRemoteCanvasTarget`. This transport itself never takes the
@@ -10,7 +10,7 @@ import { type Transport } from './transport.js';
 export interface RelayTarget {
     /** The preview endpoint origin, e.g. `https://<hash>.preview.bl.run`. */
     previewEndpoint: string;
-    /** The raw relay/bearer token. NEVER logged, NEVER echoed. */
+    /** The raw bearer token. NEVER logged, NEVER echoed. */
     relayToken: string;
 }
 export declare class RelayTransport extends EventEmitter implements Transport {
@@ -22,27 +22,21 @@ export declare class RelayTransport extends EventEmitter implements Transport {
     private get url();
     private dial;
     connect(): void;
-    /** Re-dial the SAME `wss://<previewEndpoint>/node/<id>` — the preview
-     *  endpoint is the stable anchor remotely, as `view.sock` is locally. */
-    redial(): Promise<void>;
+    /** Re-dial the same crtrd attach endpoint — the preview endpoint is the
+     *  stable remote anchor, as `view.sock` is locally. */
+    redial(_options?: RedialOptions): Promise<void>;
     send(frame: ClientToBroker): void;
     destroy(): void;
     private onMessage;
     private onError;
-    /** WS close codes mirror the browser relay client's semantics: 1008 invalid
-     *  id, or a 1011 whose
-     *  REASON starts with "no running broker"/"no node " (the relay's exact
-     *  wording — `src/clients/web/server.ts`), are the terminal "gone" signals —
-     *  surfaced as BrokerUnavailableError so the reconnect supervisor's normal
-     *  give-up path applies uniformly across transports. `fault-classifier.ts`'s
-     *  `classify` is consulted only for the 1008/protocol case (parity with the
-     *  browser client), NOT for 1011 — `classifyWsClose`'s 1011 case answers "is
-     *  this reason connection-shaped", the OPPOSITE question from "is the
-     *  broker/node gone", so branching on its `kind` here previously inverted
-     *  the gone/not-gone decision (a real bug caught by the mock-relay test, see
-     *  `transport-relay.test.ts`). Everything else (1006 abnormal, 1000 normal,
-     *  or an unrecognized 1011 reason) is a transient/expected drop the caller
-     *  may redial. */
+    /** A 1008 invalid-id close or a 1011 whose reason starts with "no running
+     *  broker" or "no node " is a terminal unavailable-broker signal from the
+     *  crtrd attach bridge. Surface it as BrokerUnavailableError so the reconnect
+     *  supervisor applies its normal give-up path across transports. `classify`
+     *  only handles the 1008/protocol case: its 1011 classification answers
+     *  whether a close is connection-shaped, not whether the broker is gone.
+     *  Everything else (1006 abnormal, 1000 normal, or an unrecognized 1011
+     *  reason) is a transient or expected drop that the caller may redial. */
     private onClose;
     /** Emit `error` only when a listener exists — a bare EventEmitter `error`
      *  with no listener throws, and this transport must never throw uncaught. */

package/dist/core/broker-client/transport-relay.js

@@ -1,20 +1,11 @@
-// transport-relay.ts — the REMOTE Transport: a relayed WebSocket straight to
-// `wss://<previewEndpoint>/node/<id>`, through the in-guest model-auth-front
-// (bearer-gated on the home's relay token), to the SAME `/node/<id>` handler
-// `crtr surface web serve` already exposes for the browser client
-// (`src/clients/web/server.ts`). One JSON frame per WS message, both
-// directions — no FrameDecoder needed (WS preserves message boundaries).
+// transport-relay.ts — the REMOTE Transport: a bearer-authenticated WebSocket
+// to crtrd's `wss://<previewEndpoint>/v1/nodes/<id>/attach` endpoint. One JSON
+// frame per WS message in both directions; no FrameDecoder is needed because
+// WebSocket preserves message boundaries.
 //
-// Deliberately NOT the Hearth CP relay: the CP hard-pins its WS upstream to
-// the home's single `home_agent_target`, so it can only ever reach the home
-// node (findings-remote-attach-feasibility.md D1). model-auth-front does not
-// pin — it forwards path verbatim — so this is the only route that reaches an
-// arbitrary node id, which is what makes multi-node remote attach possible.
-//
-// The relay token is the SAME in-guest credential model-auth-front already
-// gates on; holding it is the in-guest trust tier, not a new one. Callers
-// must keep it off argv/shell history (see `core/remote-canvas-target.ts`) — this
-// transport only ever sends it as a request header, never logs it.
+// Callers keep the bearer token off argv and shell history (see
+// `core/remote-canvas-target.ts`). This transport sends it only as a request
+// header and never logs it.
 import { EventEmitter } from 'node:events';
 import { WebSocket } from 'ws';
 import { classify } from '../fault-classifier.js';
@@ -22,7 +13,7 @@ import { BrokerUnavailableError } from './transport.js';
 function relayUrl(target, nodeId) {
     const url = new URL(target.previewEndpoint);
     url.protocol = url.protocol === 'http:' ? 'ws:' : 'wss:';
-    url.pathname = `/node/${encodeURIComponent(nodeId)}`;
+    url.pathname = `/v1/nodes/${encodeURIComponent(nodeId)}/attach`;
     url.search = '';
     url.hash = '';
     return url.toString();
@@ -57,9 +48,9 @@ export class RelayTransport extends EventEmitter {
         ws.on('error', (err) => this.onError(err));
         ws.on('close', (code, reason) => this.onClose(code, reason.toString()));
     }
-    /** Re-dial the SAME `wss://<previewEndpoint>/node/<id>` — the preview
-     *  endpoint is the stable anchor remotely, as `view.sock` is locally. */
-    redial() {
+    /** Re-dial the same crtrd attach endpoint — the preview endpoint is the
+     *  stable remote anchor, as `view.sock` is locally. */
+    redial(_options) {
         this.destroy();
         this.closeEmitted = false;
         return new Promise((resolve, reject) => {
@@ -132,20 +123,14 @@ export class RelayTransport extends EventEmitter {
         this.emitError(new Error(`relay transport error: ${err.message}`));
         // 'close' follows 'error'; teardown converges there.
     }
-    /** WS close codes mirror the browser relay client's semantics: 1008 invalid
-     *  id, or a 1011 whose
-     *  REASON starts with "no running broker"/"no node " (the relay's exact
-     *  wording — `src/clients/web/server.ts`), are the terminal "gone" signals —
-     *  surfaced as BrokerUnavailableError so the reconnect supervisor's normal
-     *  give-up path applies uniformly across transports. `fault-classifier.ts`'s
-     *  `classify` is consulted only for the 1008/protocol case (parity with the
-     *  browser client), NOT for 1011 — `classifyWsClose`'s 1011 case answers "is
-     *  this reason connection-shaped", the OPPOSITE question from "is the
-     *  broker/node gone", so branching on its `kind` here previously inverted
-     *  the gone/not-gone decision (a real bug caught by the mock-relay test, see
-     *  `transport-relay.test.ts`). Everything else (1006 abnormal, 1000 normal,
-     *  or an unrecognized 1011 reason) is a transient/expected drop the caller
-     *  may redial. */
+    /** A 1008 invalid-id close or a 1011 whose reason starts with "no running
+     *  broker" or "no node " is a terminal unavailable-broker signal from the
+     *  crtrd attach bridge. Surface it as BrokerUnavailableError so the reconnect
+     *  supervisor applies its normal give-up path across transports. `classify`
+     *  only handles the 1008/protocol case: its 1011 classification answers
+     *  whether a close is connection-shaped, not whether the broker is gone.
+     *  Everything else (1006 abnormal, 1000 normal, or an unrecognized 1011
+     *  reason) is a transient or expected drop that the caller may redial. */
     onClose(code, reason) {
         if (this.closeEmitted)
             return;

package/dist/core/broker-client/transport-socket.d.ts

@@ -1,6 +1,6 @@
 import { EventEmitter } from 'node:events';
 import { type ClientToBroker } from '../runtime/broker-protocol.js';
-import { type Transport } from './transport.js';
+import { type RedialOptions, type Transport } from './transport.js';
 export declare class SocketTransport extends EventEmitter implements Transport {
     private readonly nodeId;
     private socket;
@@ -17,7 +17,7 @@ export declare class SocketTransport extends EventEmitter implements Transport {
     /** Re-establish the socket after a broker exit, on the SAME stable
      *  `view.sock` path. Installs a FRESH FrameDecoder (a half-frame from the
      *  dead stream must not corrupt the new one). */
-    redial(): Promise<void>;
+    redial(options?: RedialOptions): Promise<void>;
     send(frame: ClientToBroker): void;
     destroy(): void;
     private onData;

package/dist/core/broker-client/transport-socket.js

@@ -62,10 +62,14 @@ export class SocketTransport extends EventEmitter {
     /** Re-establish the socket after a broker exit, on the SAME stable
      *  `view.sock` path. Installs a FRESH FrameDecoder (a half-frame from the
      *  dead stream must not corrupt the new one). */
-    redial() {
+    redial(options = {}) {
         this.destroy();
         this.decoder = new FrameDecoder(CLIENT_READ_CAPS);
         this.closeEmitted = false;
+        if (options.brokerUnavailableIsExpected) {
+            this.redialFaultRecorded = false;
+            clearFault(this.nodeId, { link: 'viewer↔broker' });
+        }
         return new Promise((resolve, reject) => {
             const socket = createConnection(this.socketPath);
             this.socket = socket;
@@ -86,7 +90,10 @@ export class SocketTransport extends EventEmitter {
                     return;
                 }
                 settled = true;
-                this.recordSocketFault('redial', err);
+                const brokerUnavailable = err.code === 'ECONNREFUSED' || err.code === 'ENOENT';
+                if (!options.brokerUnavailableIsExpected || !brokerUnavailable) {
+                    this.recordSocketFault('redial', err);
+                }
                 try {
                     socket.destroy();
                 }

package/dist/core/broker-client/transport.d.ts

@@ -1,5 +1,9 @@
 import type { EventEmitter } from 'node:events';
 import type { BrokerToClient, ClientToBroker } from '../runtime/broker-protocol.js';
+export interface RedialOptions {
+    /** The node is dormant, so no broker at the target is normal until it wakes. */
+    brokerUnavailableIsExpected?: boolean;
+}
 export interface Transport extends EventEmitter {
     /** Open the connection. Emits 'connect' on success, 'error' on a fatal
      *  connect-time failure. Call once. */
@@ -7,7 +11,7 @@ export interface Transport extends EventEmitter {
     /** Re-establish the connection to the SAME target after a drop. Resolves on
      *  a fresh 'connect'; rejects on a retryable dial failure (the caller's
      *  reconnect supervisor decides whether to try again). */
-    redial(): Promise<void>;
+    redial(options?: RedialOptions): Promise<void>;
     /** Encode + send one client→broker frame. No-op on a dead/absent connection;
      *  never throws. */
     send(frame: ClientToBroker): void;
@@ -23,8 +27,8 @@ export interface Transport extends EventEmitter {
     off(event: 'error', listener: (err: Error) => void): this;
 }
 /** Surfaced when a Transport's target has no reachable broker — locally, no
- *  socket file / nothing listening; remotely, a relay close signaling "no
- *  broker for this node". The command catches this to exit non-zero with a
+ *  socket file / nothing listening; remotely, a crtrd attach close signaling
+ *  "no broker for this node". The command catches this to exit non-zero with a
  *  focus/revive hint — same meaning regardless of which Transport raised it. */
 export declare class BrokerUnavailableError extends Error {
     readonly nodeId: string;

package/dist/core/broker-client/transport.js

@@ -1,7 +1,7 @@
 // transport.ts — the Transport seam: BrokerClient's broker I/O, abstracted
 // so the SAME correlation/pending/close logic can ride either the LOCAL unix
-// socket (SocketTransport, transport-socket.ts) or a relayed WebSocket to a
-// remote broker (RelayTransport, transport-relay.ts). Both speak the same
+// socket (SocketTransport, transport-socket.ts) or a WebSocket to crtrd's
+// remote attach endpoint (RelayTransport, transport-relay.ts). Both speak the same
 // broker-protocol JSON frames; only how bytes cross the wire differs.
 //
 // A Transport is a pure duplex frame pump — connect (dial), redial (re-dial
@@ -13,8 +13,8 @@
 // seam — request correlation, the pending map, redial-vs-give-up policy — is
 // BrokerClient's job and never moves into a Transport implementation.
 /** Surfaced when a Transport's target has no reachable broker — locally, no
- *  socket file / nothing listening; remotely, a relay close signaling "no
- *  broker for this node". The command catches this to exit non-zero with a
+ *  socket file / nothing listening; remotely, a crtrd attach close signaling
+ *  "no broker for this node". The command catches this to exit non-zero with a
  *  focus/revive hint — same meaning regardless of which Transport raised it. */
 export class BrokerUnavailableError extends Error {
     nodeId;

package/dist/core/canvas/__tests__/attention.test.js

@@ -8,7 +8,7 @@ import { atomicWriteJson, deckPath } from '../../human/convention.js';
 import { createNode } from '../canvas.js';
 import { closeDb } from '../db.js';
 import { nodeDir } from '../paths.js';
-import { countTickets, ticketCountsForNodes, pendingTicketsForView, invalidateTicketCounts } from '../attention.js';
+import { ticketCountsForNodes, pendingTicketsForView, invalidateTicketCounts } from '../attention.js';
 function meta(id, cwd, extra) {
     return {
         node_id: id,
@@ -67,23 +67,6 @@ test('ticketCountsForNodes follows bridge parents even when asking nodes share a
     seedDeck('hc');
     assert.deepEqual(ticketCountsForNodes(['a', 'b', 'c']), { a: 2, b: 1, c: 1 });
 });
-test('countTickets counts only tickets asked by that node', () => {
-    createNode(meta('a', sharedCwd));
-    createNode(meta('b', sharedCwd));
-    bridge('ha', 'a', sharedCwd);
-    bridge('hb', 'b', sharedCwd);
-    seedDeck('ha');
-    seedDeck('hb');
-    assert.equal(countTickets('a'), 1);
-    assert.equal(countTickets('b'), 1);
-});
-test('every requested id is present with 0 when it has no tickets', () => {
-    createNode(meta('a', sharedCwd));
-    createNode(meta('c', soloCwd));
-    bridge('ha', 'a', sharedCwd);
-    seedDeck('ha');
-    assert.deepEqual(ticketCountsForNodes(['a', 'c']), { a: 1, c: 0 });
-});
 test('pendingTicketsForView returns the asking node rather than a cwd bucket', () => {
     createNode(meta('a', sharedCwd));
     createNode(meta('b', sharedCwd));

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

@@ -116,59 +116,6 @@ test('every request POSTs argv leading with --json, and the token appears ONLY i
         assert.ok(!String(v).includes('secret-relay-token'), `header ${k} must not carry the token`);
     }
 });
-test('getNode/getRow project the show response correctly', async (t) => {
-    const server = await startMockCrtrServer((args) => {
-        if (args[3] === 'show')
-            return { kind: 'json', body: showResponse('a') };
-        return { kind: 'json', status: 500, body: {} };
-    });
-    t.after(() => server.close());
-    const source = new RemoteCanvasSource(server.url, 'tok');
-    const node = await source.getNode('a');
-    assert.equal(node?.node_id, 'a');
-    assert.equal(node?.status, 'active');
-    const row = await source.getRow('a');
-    assert.equal(row?.node_id, 'a');
-    assert.equal(row?.kind, 'general');
-    assert.equal(row?.host_kind, null);
-    assert.equal(row?.profile_id, null);
-});
-test('listNodes passes --status only when a filter is given', async (t) => {
-    const seenArgs = [];
-    const server = await startMockCrtrServer((args) => {
-        seenArgs.push(args);
-        const nodes = [];
-        return { kind: 'json', body: { nodes } };
-    });
-    t.after(() => server.close());
-    const source = new RemoteCanvasSource(server.url, 'tok');
-    await source.listNodes();
-    assert.deepEqual(seenArgs[0], ['--json', 'node', 'inspect', 'list']);
-    await source.listNodes({ status: 'active' });
-    assert.deepEqual(seenArgs[1], ['--json', 'node', 'inspect', 'list', '--status', 'active']);
-    await source.listNodes({ status: ['active', 'idle'] });
-    assert.deepEqual(seenArgs[2], ['--json', 'node', 'inspect', 'list', '--status', 'active,idle']);
-});
-test('subscriptionsOf/subscribersOf map reports/managers with created: \'\'', async (t) => {
-    const server = await startMockCrtrServer((args) => {
-        if (args[3] === 'show') {
-            return {
-                kind: 'json',
-                body: {
-                    ...showResponse(args[4], [{ node_id: 'child', active: true }]),
-                    managers: [{ node_id: 'boss', name: 'boss', kind: 'general', status: 'active', active: false }],
-                },
-            };
-        }
-        return { kind: 'json', status: 500, body: {} };
-    });
-    t.after(() => server.close());
-    const source = new RemoteCanvasSource(server.url, 'tok');
-    const subs = await source.subscriptionsOf('a');
-    assert.deepEqual(subs, [{ node_id: 'child', active: true, created: '' }]);
-    const managers = await source.subscribersOf('a');
-    assert.deepEqual(managers, [{ node_id: 'boss', active: false, created: '' }]);
-});
 test('view BFS traverses subscriptionsOf and is cycle-safe', async (t) => {
     // root -> a -> b -> a (cycle back to a).
     const graph = {
@@ -237,7 +184,7 @@ test('malformed success JSON (exit 0, wrong shape) degrades cleanly instead of r
     // `{}` — no `node` key at all. Without shape validation this would cast
     // through as a truthy "valid" RemoteShowResponse (an object with `.node ===
     // undefined`), and a consumer like `node inspect show`'s remote passthrough
-    // branch (src/commands/node.ts) treats any non-null return as found, then
+    // branch (src/commands/node/inspect.ts) treats any non-null return as found, then
     // its renderer dereferences fields on `undefined` and throws.
     assert.equal(await source.getNode('empty-object'), null, 'a shape with no node key must degrade to null, not a malformed object');
     assert.equal(await source.rawShow('empty-object'), null);
@@ -326,12 +273,12 @@ test('isValidShowResponse rejects a payload missing/malformed on artifacts/pendi
     assert.equal(await source.rawShow('missing-artifacts'), null, 'a payload with no artifacts key must degrade to null');
     assert.equal(await source.rawShow('artifacts-wrong-type'), null, 'artifacts.report as a string must degrade to null');
     assert.equal(await source.rawShow('missing-pending-crons'), null, 'a payload with no pending_crons key must degrade to null');
-    assert.equal(await source.rawShow('paths-session-file-undefined'), null, 'paths.session_file entirely absent (not null) must degrade to null');
+    assert.notEqual(await source.rawShow('paths-session-file-undefined'), null, 'an omitted session file is valid for a node that has not started a pi session');
     assert.notEqual(await source.rawShow('paths-session-file-null'), null, 'paths.session_file explicitly null (no session yet) must be ACCEPTED');
     assert.equal(await source.rawShow('missing-follow-up'), null, 'a payload with no follow_up key must degrade to null');
     assert.notEqual(await source.rawShow('fully-valid'), null, 'the tightened validator must not false-reject the real, fully-valid shape');
 });
-test('a malformed row element does not crash the browse snapshot path (dashboardRowsAllFromSource / renderForestFromSource)', async (t) => {
+test('a malformed row element does not crash dashboard row or forest rendering', async (t) => {
     const server = await startMockCrtrServer((args) => {
         if (args[3] === 'list') {
             return { kind: 'json', body: { nodes: [null, { node_id: 'partial-only' }, fullNodeRow('good')] } };
@@ -343,16 +290,15 @@ test('a malformed row element does not crash the browse snapshot path (dashboard
     });
     t.after(() => server.close());
     const source = new RemoteCanvasSource(server.url, 'tok');
-    // `browse/app.ts`'s `rebuildSnapshot` calls `listNodes()` and dereferences
-    // `n.parent`/`n.kind`/`n.node_id` on every row, and `dashboardRowsAllFromSource`
-    // reaches the same shape via `dashboardRowFromNodeRow` — both rely on
-    // `listNodes()` having already dropped the malformed `null` element.
+    // `dashboardRowsAllFromSource` reaches the row shape through
+    // `dashboardRowFromNodeRow`; it relies on `listNodes()` dropping malformed
+    // elements before the renderer consumes them.
     const rows = await dashboardRowsAllFromSource(source);
     assert.deepEqual(rows.map((r) => r.node_id), ['good']);
     const forest = await renderForestFromSource(source);
     assert.ok(forest.includes('good'));
 });
-test('cache coalescing: two getNode calls inside the TTL hit the server once; invalidate() busts it', async (t) => {
+test('cache coalescing: two getNode calls inside the TTL hit the server once', async (t) => {
     let hitCount = 0;
     const server = await startMockCrtrServer((args) => {
         if (args[3] === 'show') {
@@ -366,7 +312,4 @@ test('cache coalescing: two getNode calls inside the TTL hit the server once; in
     await source.getNode('a');
     await source.getNode('a');
     assert.equal(hitCount, 1);
-    source.invalidate();
-    await source.getNode('a');
-    assert.equal(hitCount, 2);
 });

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

@@ -27,9 +27,8 @@ function startStalledServer() {
 }
 test('a stalled endpoint returns a timeout failure within the configured bound instead of hanging forever', async (t) => {
     const server = await startStalledServer();
-    // 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).
+    // Register the close before assertions so a failure cannot leave a listening
+    // server holding this test process open.
     t.after(() => server.close());
     const exec = createRemoteExec(server.url, 'tok', 100); // small timeout for the test
     const started = Date.now();