@north-light/crouter 0.3.312 → 0.3.313

package/dist/core/__tests__/seam/inbox-reference-guidance.test.js

@@ -7,8 +7,11 @@ import { after, before, test } from 'node:test';
 import assert from 'node:assert/strict';
 import { readFileSync } from 'node:fs';
 import { subscribe } from '../../canvas/index.js';
+import { claimNodeMail } from '../../canvas/deliveries.js';
+import { beginExecution } from '../../canvas/executions.js';
 import { resolveRef } from '../../canvas/history.js';
-import { appendInbox, coalesce, readInboxSince } from '../../feed/inbox.js';
+import { coalesce, nodeMailEntry } from '../../feed/inbox.js';
+import { enqueueNodeMail } from '../../feed/messages.js';
 import { pushUpdate } from '../../feed/feed.js';
 import { contextDirNote } from '../../runtime/bearings-render.js';
 import { coalesceBrokerInbox } from '../../runtime/broker/inbox.js';
@@ -16,15 +19,24 @@ import { createHeadlessHarness } from '../helpers/harness.js';
 let h;
 let root;
 let recipient;
+let recipientExecution;
 before(async () => {
     h = await createHeadlessHarness({ sessionPrefix: 'crtr-inbox-reference-guidance' });
     root = h.spawnRoot('inbox reference guidance seam root');
     recipient = h.fabricateBrokerNode({ id: 'inbox-reference-recipient', parent: root, status: 'idle' });
+    recipientExecution = beginExecution(recipient, { daemonEpoch: h.fleet.epoch() });
 });
 after(async () => {
     if (h !== undefined)
         await h.dispose();
 });
+function latestEntry() {
+    const claim = claimNodeMail(recipient, recipientExecution, 'wake');
+    assert.equal(claim.action, 'claimed');
+    const delivery = claim.deliveries.at(-1);
+    assert.ok(delivery, 'the newly enqueued delivery is handed to the recipient execution');
+    return nodeMailEntry(delivery);
+}
 function onlyCard(entries) {
     const deliveries = coalesce(entries);
     assert.equal(deliveries.length, 1, 'one non-human inbox entry produces one card');
@@ -36,7 +48,7 @@ test('delivered report and message refs name the exact way to read their bodies'
     subscribe(recipient, publisher, true);
     const reportBody = 'published report body';
     await pushUpdate(publisher, reportBody);
-    const reportEntry = readInboxSince(recipient).at(-1);
+    const reportEntry = latestEntry();
     assert.equal(reportEntry.ref?.startsWith(`${publisher}:reports/`), true, 'delivery carries the canonical report handle');
     const reportRef = reportEntry.ref;
     const reportCard = onlyCard([reportEntry]);
@@ -49,13 +61,15 @@ test('delivered report and message refs name the exact way to read their bodies'
         'a'.repeat(1001),
         Array.from({ length: 13 }, (_, i) => `line ${i + 1}`).join('\n'),
     ]) {
-        const message = appendInbox(recipient, {
-            from: publisher,
-            tier: 'normal',
+        enqueueNodeMail(recipient, {
+            senderNodeId: publisher,
+            urgency: 'normal',
+            wake: 1,
             kind: 'message',
             label: 'long message',
-            data: { body },
+            bodyJson: { body },
         });
+        const message = latestEntry();
         assert.ok(message.ref?.startsWith('/'), 'a clipped message stores its full body at an absolute recipient path');
         const messageCard = onlyCard([message]);
         const brokerMessageCard = coalesceBrokerInbox([message], new Map())[0].text;

package/dist/core/__tests__/seam/node-outcome-delivery.test.js

@@ -8,11 +8,35 @@ import assert from 'node:assert/strict';
 import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { closeDb } from '../../canvas/db.js';
-import { readOutcomeDelivery } from '../../canvas/node-outcome-deliveries.js';
+import { messageBodyForDelivery, readExternalActionDelivery } from '../../canvas/deliveries.js';
 import { createHeadlessHarness } from '../helpers/harness.js';
 let h;
 let root;
 let project;
+function outcomeDelivery(nodeId) {
+    const row = readExternalActionDelivery(`node-outcome:${nodeId}`);
+    if (row === null)
+        return null;
+    const adapter = row.adapter;
+    if (adapter?.adapter !== 'subprocess' || !Array.isArray(adapter.argv) || !adapter.argv.every((entry) => typeof entry === 'string') || typeof adapter.cwd !== 'string')
+        throw new Error(`outcome delivery ${row.deliveryId} has an invalid subprocess adapter`);
+    if (row.state !== 'armed' && row.state !== 'pending' && row.state !== 'handed_off' && row.state !== 'acknowledged' && row.state !== 'permanent_failed')
+        throw new Error(`outcome delivery ${row.deliveryId} has an invalid state`);
+    return {
+        state: row.state === 'handed_off' ? 'running' : row.state === 'acknowledged' ? 'accepted' : row.state,
+        actionName: row.destinationId,
+        argv: adapter.argv,
+        cwd: adapter.cwd,
+        configOrigin: typeof adapter.config_origin === 'string' ? adapter.config_origin : '',
+        payload: adapter.payload ?? null,
+        document: row.messageId === null ? null : messageBodyForDelivery(row.deliveryId),
+        attempt: row.attempts,
+        nextAttemptAt: row.nextAttemptAt ?? 0,
+        acceptedAt: row.acknowledgedAt,
+        permanentFailedAt: row.failedAt,
+        lastFailure: row.lastFailure,
+    };
+}
 function assertKeys(value, expected, label) {
     assert.deepEqual(Object.keys(value).sort(), [...expected].sort(), `${label} has the pinned document fields`);
 }
@@ -54,7 +78,7 @@ function assertResultDocument(document, nodeId, action, payloadJson, attempt) {
 function deliveryWhen(nodeId, predicate, label) {
     return h.waitFor(() => {
         closeDb();
-        const delivery = readOutcomeDelivery(nodeId);
+        const delivery = outcomeDelivery(nodeId);
         return delivery !== null && predicate(delivery) ? delivery : null;
     }, { label, timeoutMs: 20_000 });
 }
@@ -71,7 +95,7 @@ async function createAndFinalize(action, payload) {
     const nodeId = createdBody.node_id;
     await h.awaitBoot(nodeId);
     closeDb();
-    const armed = readOutcomeDelivery(nodeId);
+    const armed = outcomeDelivery(nodeId);
     assert.notEqual(armed, null, `node birth arms ${action} delivery`);
     assert.equal(armed.state, 'armed');
     assert.equal(armed.actionName, action);

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();

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,27 +10,41 @@
 // 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 = await spawnNode({ kind: 'general', cwd: '/tmp/work', parent: null });

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);