@north-light/crouter 0.3.311 → 0.3.313

package/dist/core/__tests__/spawn-worktree-id-conflict.test.js

@@ -14,7 +14,7 @@ import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { gitSync } from '../git.js';
 import { getNode } from '../canvas/canvas.js';
-import { closeDb } from '../canvas/db.js';
+import { closeDb, migrate, openDb } from '../canvas/db.js';
 import { spawnNode } from '../runtime/nodes.js';
 import { spawnChild } from '../runtime/spawn.js';
 import { managedWorktreePath } from '../worktree.js';
@@ -41,6 +41,7 @@ beforeEach(() => {
     closeDb();
     rmSync(home, { recursive: true, force: true });
     process.env['CRTR_HOME'] = home;
+    migrate(openDb());
 });
 after(async () => {
     closeDb();
@@ -50,7 +51,7 @@ after(async () => {
 });
 test('a --worktree spawn at an already-existing node id throws and leaves NO worktree registered', async () => {
     const nodeId = 'duplicate-id';
-    spawnNode({ kind: 'general', cwd: '/tmp/work', nodeId });
+    await spawnNode({ kind: 'general', cwd: '/tmp/work', nodeId });
     await assert.rejects(() => spawnChild({ kind: 'general', cwd: repoDir, prompt: '', worktree: true, nodeId }));
     assert.ok(!existsSync(managedWorktreePath(nodeId)), 'the conflicting spawn must not leave a worktree checkout directory');
     assert.equal(gitSync(['show-ref', '--verify', '--quiet', `refs/heads/crtr/${nodeId}`], repoDir).status, 1, 'the conflicting spawn must not leave a registered crtr/<id> branch');
@@ -59,12 +60,12 @@ test('a --worktree spawn at an already-existing node id throws and leaves NO wor
     assert.equal(getNode(nodeId).kind, 'general');
     assert.equal(getNode(nodeId).managed_worktree, undefined);
 });
-test('spawnNode({ nodeId }): a hyphen-less opaque id spawns at the exact given id', () => {
+test('spawnNode({ nodeId }): a hyphen-less opaque id spawns at the exact given id', async () => {
     // Regression for the reviewed opaque-id-contract violation: the old validator
     // required >=2 hyphen segments and rejected a hyphen-less id outright,
     // contradicting the design's "opaque, never parsed for structure" ID scheme
     // that remote and cloud spawns depend on.
-    const meta = spawnNode({ kind: 'general', cwd: '/tmp/work', nodeId: 'remote42' });
+    const meta = await spawnNode({ kind: 'general', cwd: '/tmp/work', nodeId: 'remote42' });
     assert.equal(meta.node_id, 'remote42');
     assert.notEqual(getNode('remote42'), null);
 });

package/dist/core/__tests__/stop-guard.test.js

@@ -10,7 +10,7 @@ import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { createNode, deliverAndSettleMessageWait, getNode, subscribe, setMessageWait, setStatus } from '../canvas/canvas.js';
 import { armCron, cancelCron, setCronState } from '../canvas/crons.js';
-import { closeDb, openDb } from '../canvas/db.js';
+import { closeDb, openDb, migrate } from '../canvas/db.js';
 import { hasLiveObligation } from '../../daemon/reconcilers/live-obligation.js';
 import { contextDir } from '../canvas/paths.js';
 import { bashJobPaths } from '../bash-jobs.js';
@@ -61,6 +61,7 @@ before(() => {
 beforeEach(() => {
     closeDb();
     rmSync(home, { recursive: true, force: true });
+    migrate(openDb());
 });
 after(() => {
     closeDb();

package/dist/core/__tests__/subscription-pool-credential-guard.test.js

@@ -6,18 +6,19 @@
 // an async writer whose provider returned an incomplete token set.
 import { before, test } from 'node:test';
 import assert from 'node:assert/strict';
-import { mkdtempSync, readFileSync } from 'node:fs';
+import { mkdtempSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
+import { initializeFreshScopedStore } from '../scoped-state/migrate.js';
 const agentDir = mkdtempSync(join(tmpdir(), 'crtr-pool-guard-'));
 process.env['PI_CODING_AGENT_DIR'] = agentDir;
 // Imported dynamically so `PI_CODING_AGENT_DIR` is already set: the pool path is resolved per
 // access, but the import must not race the env write in any future refactor.
 let state;
 before(async () => {
+    initializeFreshScopedStore({ kind: 'provider', root: agentDir });
     state = await import('../subscription-state.js');
 });
-const POOL = join(agentDir, 'openai-codex-subscriptions.json');
 async function seed() {
     await state.writeSubscriptionPool('openai-codex', [
         {
@@ -33,7 +34,7 @@ async function seed() {
     ]);
 }
 function stored() {
-    const pool = JSON.parse(readFileSync(POOL, 'utf8'));
+    const pool = state.readSubscriptionPool('openai-codex');
     assert.equal(pool.length, 1, 'the row itself must survive every refused write');
     return pool[0];
 }

package/dist/core/__tests__/warm-claim-preference-snapshot.test.js

@@ -10,30 +10,44 @@
 // Run: node --import tsx/esm --test src/core/__tests__/warm-claim-preference-snapshot.test.ts
 import { test, before, beforeEach, after } from 'node:test';
 import assert from 'node:assert/strict';
-import { mkdtempSync, mkdirSync, rmSync } from 'node:fs';
+import { mkdtempSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
-import { closeDb } from '../canvas/db.js';
+import { closeDb, migrate, openDb } from '../canvas/db.js';
+import { resetScopeCache } from '../scope.js';
+import { closeScopedStores } from '../scoped-state/db.js';
+import { initializeFreshScopedStore } from '../scoped-state/migrate.js';
 import { spawnNode } from '../runtime/nodes.js';
 import { deliverBearingsLive } from '../runtime/deliver-live.js';
 import { loadContextExposureState } from '../substrate/injected-store.js';
 let home;
+const previousHome = process.env['HOME'];
 before(() => {
     home = mkdtempSync(join(tmpdir(), 'crtr-warm-snapshot-'));
-    process.env['CRTR_HOME'] = home;
+    process.env['HOME'] = home;
+    process.env['CRTR_HOME'] = join(home, 'canvas');
 });
 beforeEach(() => {
     closeDb();
+    closeScopedStores();
     rmSync(home, { recursive: true, force: true });
-    mkdirSync(home, { recursive: true });
+    resetScopeCache();
+    initializeFreshScopedStore({ kind: 'user', root: join(home, '.crouter') });
+    migrate(openDb());
 });
 after(() => {
     closeDb();
+    closeScopedStores();
     rmSync(home, { recursive: true, force: true });
     delete process.env['CRTR_HOME'];
+    if (previousHome === undefined)
+        delete process.env['HOME'];
+    else
+        process.env['HOME'] = previousHome;
+    resetScopeCache();
 });
 test('the claim path persists a frozen preference snapshot', async () => {
-    const meta = spawnNode({ kind: 'general', cwd: '/tmp/work', parent: null });
+    const meta = await spawnNode({ kind: 'general', cwd: '/tmp/work', parent: null });
     assert.equal(loadContextExposureState(meta.node_id).preferenceSnapshot, null, 'a spare mints with nothing frozen');
     await deliverBearingsLive(meta.node_id);
     assert.notEqual(loadContextExposureState(meta.node_id).preferenceSnapshot, null, 'claim freezes the snapshot the persona gate requires');

package/dist/core/__tests__/yield-ensures-daemon.test.js

@@ -13,7 +13,7 @@ import { mkdtempSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { createNode, getNode } from '../canvas/canvas.js';
-import { closeDb } from '../canvas/db.js';
+import { closeDb, migrate, openDb } from '../canvas/db.js';
 import { requestYield } from '../runtime/promote.js';
 let home;
 function mkOrchestrator(id) {
@@ -36,6 +36,7 @@ before(() => {
 beforeEach(() => {
     closeDb();
     rmSync(home, { recursive: true, force: true });
+    migrate(openDb());
 });
 after(() => {
     closeDb();

package/dist/core/bootstrap.js

@@ -2,6 +2,7 @@ import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { findProjectScopeRoot, resetScopeCache, userScopeRoot } from './scope.js';
 import { ensureScopeInitialized } from './config.js';
+import { initializeFreshScopedStore } from './scoped-state/migrate.js';
 import { CRTR_DIR_NAME } from '../types.js';
 import { envDebug } from '../shared/env.js';
 const SKIP_SUBCOMMANDS = new Set([
@@ -29,6 +30,7 @@ export function ensureProjectScope(argv) {
             return;
         if (shouldSkipForArgv(argv))
             return;
+        initializeFreshScopedStore({ kind: 'user', root: userScopeRoot() });
         // Already inside a project scope (here or in an ancestor) — nothing to do.
         if (findProjectScopeRoot() !== null)
             return;

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

@@ -1,24 +1,69 @@
 import assert from 'node:assert/strict';
-import { mkdirSync, mkdtempSync, rmSync } from 'node:fs';
+import { existsSync, mkdtempSync, rmSync } from 'node:fs';
 import test from 'node:test';
-import { nodeDir } from '../../canvas/paths.js';
-import { readFault } from '../../runtime/fault.js';
+import { CrtrClient } from '../../../api/client.js';
+import { createNode } from '../../canvas/canvas.js';
+import { closeDb, migrate, openDb } from '../../canvas/db.js';
+import { apiSocketPath } from '../../canvas/paths.js';
+import { readFault } from '../../canvas/recovery.js';
+import { createApiServer } from '../../../daemon/api/server.js';
 import { SocketTransport } from '../transport-socket.js';
+async function waitFor(check, label) {
+    for (let i = 0; i < 200; i++) {
+        if (check())
+            return;
+        await new Promise((resolve) => setTimeout(resolve, 5));
+    }
+    throw new Error(`timed out waiting for ${label}`);
+}
+async function waitForSocket() {
+    const client = CrtrClient.forLocalSocket({ autostart: false });
+    await waitFor(() => existsSync(apiSocketPath()), 'the API socket path');
+    for (let i = 0; i < 200; i++) {
+        try {
+            await client.healthz();
+            return;
+        }
+        catch {
+            await new Promise((resolve) => setTimeout(resolve, 5));
+        }
+    }
+    throw new Error('timed out waiting for the API socket');
+}
+function node(nodeId) {
+    return {
+        node_id: nodeId,
+        name: nodeId,
+        created: new Date().toISOString(),
+        cwd: '/tmp/work',
+        kind: 'general',
+        mode: 'base',
+        lifecycle: 'terminal',
+        status: 'active',
+    };
+}
 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-');
+    let server;
     process.env['CRTR_HOME'] = home;
+    closeDb();
+    migrate(openDb());
     try {
+        server = createApiServer();
+        await waitForSocket();
         const nodeId = 'dormant-node';
-        mkdirSync(nodeDir(nodeId), { recursive: true });
+        createNode(node(nodeId));
         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 waitFor(() => readFault(nodeId)?.link === 'viewer↔broker', 'the failed redial fault');
         await assert.rejects(transport.redial({ brokerUnavailableIsExpected: true }));
-        assert.equal(readFault(nodeId), null, 'a dormant node with no broker is normal, not a fault');
+        await waitFor(() => readFault(nodeId) === null, 'the expected-unavailable fault clear');
         transport.destroy();
     }
     finally {
+        await server?.close();
+        closeDb();
         if (previousHome === undefined)
             delete process.env['CRTR_HOME'];
         else

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

@@ -20,6 +20,7 @@ export declare class SocketTransport extends EventEmitter implements Transport {
     redial(options?: RedialOptions): Promise<void>;
     send(frame: ClientToBroker): void;
     destroy(): void;
+    private clearSocketFault;
     private onData;
     private onError;
     private onClose;

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

@@ -11,7 +11,8 @@ import { EventEmitter } from 'node:events';
 import { createConnection } from 'node:net';
 import { viewSocketPath } from '../canvas/paths.js';
 import { classify } from '../fault-classifier.js';
-import { clearFault, recordFault } from '../runtime/fault.js';
+import { clearNodeFault, recordNodeFault } from '../runtime/broker/daemon-ops.js';
+import { emitEvent } from '../events/emit.js';
 import { CLIENT_READ_CAPS, encodeFrame, FrameDecoder, FrameOverflowError, } from '../runtime/broker-protocol.js';
 import { BrokerUnavailableError } from './transport.js';
 export class SocketTransport extends EventEmitter {
@@ -37,7 +38,7 @@ export class SocketTransport extends EventEmitter {
             this.redialFaultRecorded = true;
         }
         const classified = classify('viewer↔broker', err);
-        recordFault(this.nodeId, {
+        void recordNodeFault(this.nodeId, {
             link: 'viewer↔broker',
             op,
             kind: classified.kind,
@@ -45,6 +46,8 @@ export class SocketTransport extends EventEmitter {
                 ? { disposition: 'auto', by: 'client' }
                 : { disposition: 'manual' },
             message: err instanceof Error ? err.message : String(err),
+        }).catch((error) => {
+            emitEvent({ event: 'broker.daemon.operation.failed', level: 'error', node_id: this.nodeId, error, fields: { operation: 'viewer_fault_record' } });
         });
     }
     connect() {
@@ -52,7 +55,7 @@ export class SocketTransport extends EventEmitter {
         this.socket = socket;
         socket.on('connect', () => {
             this.redialFaultRecorded = false;
-            clearFault(this.nodeId, { link: 'viewer↔broker' });
+            this.clearSocketFault();
             this.emit('connect');
         });
         socket.on('data', (chunk) => this.onData(chunk));
@@ -68,7 +71,7 @@ export class SocketTransport extends EventEmitter {
         this.closeEmitted = false;
         if (options.brokerUnavailableIsExpected) {
             this.redialFaultRecorded = false;
-            clearFault(this.nodeId, { link: 'viewer↔broker' });
+            this.clearSocketFault();
         }
         return new Promise((resolve, reject) => {
             const socket = createConnection(this.socketPath);
@@ -79,7 +82,7 @@ export class SocketTransport extends EventEmitter {
                     return;
                 settled = true;
                 this.redialFaultRecorded = false;
-                clearFault(this.nodeId, { link: 'viewer↔broker' });
+                this.clearSocketFault();
                 this.emit('connect');
                 resolve();
             });
@@ -127,6 +130,11 @@ export class SocketTransport extends EventEmitter {
             }
         }
     }
+    clearSocketFault() {
+        void clearNodeFault(this.nodeId, { link: 'viewer↔broker' }).catch((error) => {
+            emitEvent({ event: 'broker.daemon.operation.failed', level: 'error', node_id: this.nodeId, error, fields: { operation: 'viewer_fault_clear' } });
+        });
+    }
     onData(chunk) {
         let frames;
         try {

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

@@ -1,14 +1,14 @@
-// attention.test.ts — tickets are keyed by their human bridge node directory.
+// attention.test.ts — pending requests are attributed by requester identity.
 import { test, before, beforeEach, after } from 'node:test';
 import assert from 'node:assert/strict';
-import { mkdtempSync, rmSync, mkdirSync } from 'node:fs';
+import { mkdtempSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
-import { atomicWriteJson, bindTicketReplyRoute, pageManifestPath } from '../../human/convention.js';
+import { createPageRequest } from '../../human/requests.js';
 import { createNode } from '../canvas.js';
 import { closeDb } from '../db.js';
-import { nodeDir } from '../paths.js';
 import { ticketCountsForNodes, pendingTicketsForView, invalidateTicketCounts } from '../attention.js';
+import { migrate, openDb } from '../db.js';
 function meta(id, cwd, extra) {
     return {
         node_id: id,
@@ -22,26 +22,25 @@ function meta(id, cwd, extra) {
         ...extra,
     };
 }
-// A ticket only counts as attention when it routes a reply back, so the fixture binds
-// the reply route the same way `human send` does before writing the page manifest.
-function seedPage(bridgeId) {
-    const dir = nodeDir(bridgeId);
-    mkdirSync(dir, { recursive: true });
-    bindTicketReplyRoute(dir, bridgeId);
-    atomicWriteJson(pageManifestPath(dir), {
-        schema: 'crtr.page/v2',
-        dialect: 'jsx',
-        title: bridgeId,
-        subtitle: 'Acknowledge this ticket so the request can proceed.',
-        delivery: { placement: 'inline', inbox: true, reply: true },
-        document: 'page.tsx',
-        steps: 1,
-        slots: [],
+function seedPage(requestId, requesterNodeId) {
+    createPageRequest({
+        request_id: requestId,
+        requester_node_id: requesterNodeId,
+        prepared: {
+            document: '<html><head><title>Request</title></head><body>Request</body></html>',
+            manifest: {
+                schema: 'crtr.page/v2',
+                dialect: 'html',
+                title: requestId,
+                subtitle: 'Acknowledge this ticket so the request can proceed.',
+                delivery: { placement: 'inline', inbox: true, reply: true },
+                document: 'page.html',
+                steps: 1,
+                slots: [],
+            },
+        },
     });
 }
-function bridge(id, parent, cwd) {
-    createNode(meta(id, cwd, { kind: 'human', parent }));
-}
 let home;
 let sharedCwd;
 let soloCwd;
@@ -55,6 +54,7 @@ beforeEach(() => {
     closeDb();
     invalidateTicketCounts();
     rmSync(home, { recursive: true, force: true });
+    migrate(openDb());
 });
 after(() => {
     closeDb();
@@ -62,27 +62,21 @@ after(() => {
         rmSync(d, { recursive: true, force: true });
     delete process.env['CRTR_HOME'];
 });
-test('ticketCountsForNodes follows bridge parents even when asking nodes share a cwd', () => {
+test('ticketCountsForNodes follows requester identity even when asking nodes share a cwd', () => {
     createNode(meta('a', sharedCwd));
     createNode(meta('b', sharedCwd));
     createNode(meta('c', soloCwd));
-    bridge('ha1', 'a', sharedCwd);
-    bridge('ha2', 'a', sharedCwd);
-    bridge('hb', 'b', sharedCwd);
-    bridge('hc', 'c', soloCwd);
-    seedPage('ha1');
-    seedPage('ha2');
-    seedPage('hb');
-    seedPage('hc');
+    seedPage('request-a1', 'a');
+    seedPage('request-a2', 'a');
+    seedPage('request-b', 'b');
+    seedPage('request-c', 'c');
     assert.deepEqual(ticketCountsForNodes(['a', 'b', 'c']), { a: 2, b: 1, c: 1 });
 });
 test('pendingTicketsForView returns the asking node rather than a cwd bucket', () => {
     createNode(meta('a', sharedCwd));
     createNode(meta('b', sharedCwd));
-    bridge('ha', 'a', sharedCwd);
-    bridge('hb', 'b', sharedCwd);
-    seedPage('ha');
-    seedPage('hb');
+    seedPage('request-a', 'a');
+    seedPage('request-b', 'b');
     assert.deepEqual(pendingTicketsForView('a').map(({ node_id, count }) => ({ node_id, count })), [
         { node_id: 'a', count: 1 },
     ]);

package/dist/core/canvas/__tests__/history-transcript.test.js

@@ -8,12 +8,12 @@
 // regression rather than a reader bug, so it is worth pinning.
 import { test, before, beforeEach, after } from 'node:test';
 import assert from 'node:assert/strict';
-import { mkdtempSync, rmSync, mkdirSync, writeFileSync } from 'node:fs';
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { createNode } from '../canvas.js';
-import { closeDb } from '../db.js';
-import { nodeDir, sessionPtrPath } from '../paths.js';
+import { closeDb, migrate, openDb } from '../db.js';
+import { resetSession } from '../sessions.js';
 import { nodeArtifacts, groupCorpus } from '../history.js';
 const NODE = 'test-transcript-node';
 function meta(id, cwd) {
@@ -45,8 +45,6 @@ function stampEntry(msgTs, origin) {
 /** A session file in the real on-disk shape: stamps precede their messages,
  *  one inbound turn is unstamped, and an assistant turn sits between them. */
 function seedSession(home) {
-    const dir = nodeDir(NODE);
-    mkdirSync(dir, { recursive: true });
     const file = join(home, 'session.jsonl');
     writeFileSync(file, [
         JSON.stringify({ type: 'custom', customType: 'crtr-stamp', data: { v: 1, kind: 'session', payload: { node: NODE, crtr: '0.0.0' } } }),
@@ -57,7 +55,7 @@ function seedSession(home) {
         messageEntry('user', 'a delivery', 2000),
         messageEntry('user', 'no stamp for this one', 3000),
     ].join('\n'), 'utf8');
-    writeFileSync(sessionPtrPath(NODE), file, 'utf8');
+    resetSession(NODE, { sessionId: 'history-transcript-session', transcriptPath: file });
 }
 let home;
 let cwd;
@@ -68,6 +66,8 @@ before(() => {
 });
 beforeEach(() => {
     closeDb();
+    rmSync(home, { recursive: true, force: true });
+    migrate(openDb());
 });
 after(() => {
     closeDb();

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

@@ -1,9 +1,12 @@
 // render-remote.test.ts — the safe-defaults contract for `render.ts`'s
 // `*FromSource` functions when given a `RemoteCanvasSource`: every field that
-// would require a local disk/SQLite read (hanging, streaming, viewed, ctx
-// tokens, asks, goal, prompts, lastAssistant) must come back suppressed to
-// its safe default instead of touching this process's local state. Reuses
-// the mock-server harness shape from `remote-canvas-source.test.ts`.
+// would require a local disk/SQLite read (viewed, ctx tokens, asks, goal,
+// prompts, lastAssistant) must come back suppressed to its safe default
+// instead of touching this process's local state. `hanging`/`streaming` are
+// not suppressed — they are projected by the REMOTE daemon and arrive on the
+// row, so the contract for them is that the row carries the remote fault and
+// never the local one. Reuses the mock-server harness shape from
+// `remote-canvas-source.test.ts`.
 //
 // This is adversarial, not merely a clean-machine assertion: BEFORE calling
 // the render functions, the test seeds real, CONFLICTING local state for the
@@ -23,10 +26,10 @@ import { atomicWriteJson, pageManifestPath } from '#core/human/convention';
 import { RemoteCanvasSource } from '../remote-canvas-source.js';
 import { dashboardRowsAllFromSource, enrichRowsFromSource, loadPreviewFromSource, renderForestFromSource } from '../render-source.js';
 import { createNode } from '../canvas.js';
-import { closeDb } from '../db.js';
+import { closeDb, migrate, openDb } from '../db.js';
 import { openFocusRow } from '../focuses.js';
 import { jobDir, contextDir, nodeDir } from '../paths.js';
-import { recordFault } from '../../runtime/fault.js';
+import { recordFault } from '../recovery.js';
 function startMockCrtrServer(route) {
     return new Promise((resolve) => {
         const server = createServer((req, res) => {
@@ -63,8 +66,9 @@ function meta(id, extra) {
         ...extra,
     };
 }
-function row(id) {
+function row(id, fault) {
     return {
+        ...(fault === undefined ? {} : { fault }),
         node_id: id,
         name: id,
         kind: 'general',
@@ -97,6 +101,7 @@ beforeEach(() => {
     closeDb();
     rmSync(home, { recursive: true, force: true });
     rmSync(nodeDir('poison-ask'), { recursive: true, force: true });
+    migrate(openDb());
 });
 after(() => {
     closeDb();
@@ -146,11 +151,22 @@ function seedPoisonedLocalState() {
     ].join('\n'));
     return sf;
 }
+/** What the remote daemon projected onto its own row — the only fault a remote
+ *  row may ever show. */
+const remoteFault = {
+    link: 'daemon→node',
+    op: 'remote turn',
+    kind: 'wedged',
+    retry: { disposition: 'manual' },
+    message: 'remote daemon fault',
+    since: new Date().toISOString(),
+    operation_id: '44444444444444444444444444444444',
+};
 test('dashboardRowsAllFromSource / enrichRowsFromSource / loadPreviewFromSource suppress every local-read field to its safe default for a RemoteCanvasSource, even with conflicting local state for the same node id', async (t) => {
     sessionFile = seedPoisonedLocalState();
     const server = await startMockCrtrServer((args) => {
         if (args[1] === 'node' && args[2] === 'inspect' && args[3] === 'list') {
-            return { body: { nodes: [row('a')] } };
+            return { body: { nodes: [row('a', remoteFault)] } };
         }
         if (args[1] === 'node' && args[2] === 'inspect' && args[3] === 'show') {
             return {
@@ -177,7 +193,7 @@ test('dashboardRowsAllFromSource / enrichRowsFromSource / loadPreviewFromSource
     const rows = await dashboardRowsAllFromSource(source);
     assert.equal(rows.length, 1);
     const r = rows[0];
-    assert.equal(r.hanging, null, 'local active fault must not leak into a remote row');
+    assert.equal(r.hanging?.message, 'remote daemon fault', 'the remote row must carry the fault its own daemon projected');
     assert.equal(r.streaming, false);
     assert.equal(r.viewed, false, 'local focus must not leak into a remote row');
     await enrichRowsFromSource(source, rows);

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

@@ -3,13 +3,10 @@ export interface TicketEntry {
     name: string;
     cwd: string;
     count: number;
-    /** Open ticket titles for this node, newest first (scan order). */
+    /** Open ticket titles for this node, newest first. */
     subjects: string[];
 }
-/** Drop the cached walk. Callers that swap the canvas home out from under a live
- *  process (tests, and any in-process home switch) must call this: the cache is
- *  keyed only by time, so a stale window would otherwise serve the old home's
- *  counts. */
+/** Kept for callers that reset a canvas home in process. SQL has no directory-scan cache to invalidate. */
 export declare function invalidateTicketCounts(): void;
 /** Count pending tickets asked by one node. */
 export declare function countTickets(nodeId: string): number;