@north-light/crouter 0.3.312 → 0.3.313

package/dist/clients/inbox/dto-adapt.js

@@ -0,0 +1,93 @@
+// dto-adapt.ts — the one place daemon human DTOs become the shapes the inbox
+// and the attach viewer render. Pure: no I/O, no canvas state, no second read.
+//
+// The viewer surfaces used to build these shapes by scanning canvas SQL
+// themselves. They now read the daemon's projections, so every field below
+// comes from one already-consistent snapshot rather than from a field-by-field
+// re-derivation each surface had to keep in step.
+import { validatePageManifest } from '../../core/human/page-schema.js';
+/** The wire response map and the renderer's differ in one place: an anchor is a
+ *  flat optional-field object on the wire and a discriminated union in core.
+ *  Nothing here re-validates, because the responses a page renders are the ones
+ *  the daemon already accepted against the same manifest — the read path this
+ *  replaced did not validate them either, and an in-flight partial autosave is
+ *  deliberately allowed to be incomplete. */
+function responsesFromDTO(responses) {
+    return responses;
+}
+function pageRowFromDTO(dto) {
+    return {
+        dir: dto.request_dir,
+        id: dto.request_id,
+        inboxTicketId: dto.ticket_id,
+        kind: 'page',
+        title: dto.title,
+        subtitle: dto.subtitle ?? '',
+        dialect: dto.dialect,
+        placement: dto.placement,
+        inbox: dto.inbox,
+        steps: dto.steps,
+        slotKinds: dto.slot_kinds,
+        awaitsResponse: dto.awaits_response,
+        source: dto.source,
+        emittedAt: dto.emitted_at,
+        recommendedOptions: (dto.recommended_options ?? []).map((option) => ({
+            slotId: option.slot_id,
+            optionId: option.option_id,
+            label: option.label,
+        })),
+        ...(dto.fast_action === undefined
+            ? {}
+            : { fastAction: { kind: dto.fast_action.kind, responses: responsesFromDTO(dto.fast_action.responses) } }),
+        state: dto.state,
+        ...(dto.answer_digest === undefined ? {} : { answerDigest: dto.answer_digest }),
+    };
+}
+function reviewRowFromDTO(dto) {
+    return {
+        dir: dto.request_dir,
+        id: dto.request_id,
+        inboxTicketId: dto.ticket_id,
+        kind: 'review',
+        title: dto.title,
+        subtitle: dto.subtitle,
+        blockedSince: dto.blocked_since,
+        source: dto.source,
+    };
+}
+export function inboxRowFromDTO(dto) {
+    return dto.kind === 'page' ? pageRowFromDTO(dto) : reviewRowFromDTO(dto);
+}
+export function pageViewFromDTO(dto) {
+    return {
+        // The manifest is parsed, not cast: a page whose manifest no longer
+        // validates must fail loudly here rather than reach the renderer.
+        manifest: validatePageManifest(dto.page),
+        document: dto.source_document,
+        progress: dto.progress === null ? null : responsesFromDTO(dto.progress.responses),
+        state: dto.state,
+        revision: dto.revision,
+    };
+}
+/** The stored one-line answer digest, or undefined when the page was not
+ *  answered. A canceled page carries no digest by construction. */
+export function answerDigestOf(dto) {
+    const result = dto.result;
+    if (result === null || result.kind !== 'page')
+        return undefined;
+    return result.summary.replace(/\s+/g, ' ').trim();
+}
+/** What a surface says when a settled request refuses a second settlement. */
+export function settledStatusOf(dto) {
+    const result = dto.result;
+    if (result !== null && result.kind === 'canceled')
+        return 'ticket was already canceled';
+    if (result !== null && result.kind === 'page')
+        return 'ticket was already resolved: page submitted';
+    return 'ticket was already resolved';
+}
+/** The row sort every inbox surface shares: newest first, request id breaking ties. */
+export function byNewestFirst(a, b) {
+    const time = (row) => row.kind === 'page' ? row.emittedAt : row.blockedSince;
+    return time(b).localeCompare(time(a)) || a.id.localeCompare(b.id);
+}

package/dist/clients/inbox/page-adapter.d.ts

@@ -1,10 +1,11 @@
 import type { ProductPageComponents } from '../../types.js';
 import type { PageResponses } from '../../core/human/page-schema.js';
-import type { PageTicket } from '../../core/human/tickets.js';
+import type { InboxPageView } from './dto-adapt.js';
 import type { Key } from './tui/keys.js';
 export interface PageAdapterOptions {
-    dir: string;
-    ticket: PageTicket;
+    /** The opaque inbox ticket id autosave posts against. */
+    ticketId: string;
+    page: InboxPageView;
     productKinds: ProductPageComponents;
     cols: number;
     rows: number;
@@ -27,6 +28,6 @@ export declare class PageAdapter {
     setInputBuffer(text: string): void;
     canAcceptHostKeys(): boolean;
     handleKey(input: string, key: Key): void;
-    reload(ticket: PageTicket): void;
+    reload(page: InboxPageView): void;
     close(): void;
 }

package/dist/clients/inbox/page-adapter.js

@@ -1,5 +1,5 @@
 import { pageAwaitsResponse } from '../../core/human/page-schema.js';
-import { writePageProgress } from '../../core/human/tickets.js';
+import { cliClient } from '../../commands/api-client.js';
 import { mountPanel } from './tui/panel.js';
 /** Embeds the page renderer in a controller-owned rectangle. */
 export class PageAdapter {
@@ -9,19 +9,19 @@ export class PageAdapter {
     manifest;
     constructor(opts) {
         this.opts = opts;
-        this.manifest = opts.ticket.manifest;
+        this.manifest = opts.page.manifest;
         this.panel = mountPanel({
-            manifest: opts.ticket.manifest,
-            document: opts.ticket.document,
+            manifest: opts.page.manifest,
+            document: opts.page.document,
             productKinds: opts.productKinds,
-            initialResponses: opts.ticket.progress,
+            initialResponses: opts.page.progress,
             cols: opts.cols,
             rows: opts.rows,
             onProgress: (responses) => {
-                try {
-                    writePageProgress(opts.dir, responses);
-                }
-                catch { /* partial in-flight input may not validate yet */ }
+                // Autosave is advisory: partial in-flight input may not validate yet,
+                // and the answer the person actually submits goes through the respond
+                // route, which revalidates. A rejected autosave loses nothing.
+                void cliClient().postInboxProgress(opts.ticketId, responses).catch(() => { });
                 opts.onProgress?.(responses);
             },
             onComplete: opts.onComplete,
@@ -46,9 +46,9 @@ export class PageAdapter {
         }
         this.panel.handleKey(input, key);
     }
-    reload(ticket) {
-        this.manifest = ticket.manifest;
-        this.panel.loadPage(ticket.manifest, { document: ticket.document, initialResponses: ticket.progress, productKinds: this.opts.productKinds });
+    reload(page) {
+        this.manifest = page.manifest;
+        this.panel.loadPage(page.manifest, { document: page.document, initialResponses: page.progress, productKinds: this.opts.productKinds });
         this.opts.onDirty();
     }
     close() { this.panel.unmount(); }

package/dist/clients/inbox/resolve.d.ts

@@ -1,11 +1,16 @@
 import type { PageResponses } from '../../core/human/page-schema.js';
-export declare function ticketIdFor(dir: string): string;
-export declare function resolveTicketPage(dir: string, responses: PageResponses): Promise<void>;
-export declare function cancelTicketViaDaemon(dir: string, opts: {
+/** Settle a page request with the person's answer. The request id a scan
+ *  already carries IS the settlement identity — there is no bridge node to
+ *  derive one from. An omitted actor is what records a person, not a
+ *  programmatic writer, as the author of the result. */
+export declare function resolveTicketPage(requestId: string, responses: PageResponses): Promise<void>;
+/** Close a page request from the inbox without answering it. The inbox is the
+ *  recipient surface, so this is always a dismissal, never the requester
+ *  withdrawing its own request. */
+export declare function dismissTicketViaDaemon(requestId: string, opts: {
     reason: string;
     actor: string;
-    disposition?: 'canceled' | 'dismissed';
 }): Promise<void>;
 export declare function daemonErrorMessage(err: unknown): string;
-export type ResolveFailure = 'unreachable' | 'already_resolved' | 'delivery_failed' | 'other';
+export type ResolveFailure = 'unreachable' | 'already_settled' | 'other';
 export declare function resolveFailureKind(err: unknown): ResolveFailure;

package/dist/clients/inbox/resolve.js

@@ -1,14 +1,17 @@
-import { basename } from 'node:path';
 import { ApiError } from '../../api/errors.js';
 import { cliClient } from '../../commands/api-client.js';
-export function ticketIdFor(dir) {
-    return basename(dir);
+/** Settle a page request with the person's answer. The request id a scan
+ *  already carries IS the settlement identity — there is no bridge node to
+ *  derive one from. An omitted actor is what records a person, not a
+ *  programmatic writer, as the author of the result. */
+export async function resolveTicketPage(requestId, responses) {
+    await cliClient().respondHumanRequest(requestId, { responses });
 }
-export async function resolveTicketPage(dir, responses) {
-    await cliClient().resolveHumanTicket(ticketIdFor(dir), { responses });
-}
-export async function cancelTicketViaDaemon(dir, opts) {
-    await cliClient().cancelHumanTicket(ticketIdFor(dir), opts);
+/** Close a page request from the inbox without answering it. The inbox is the
+ *  recipient surface, so this is always a dismissal, never the requester
+ *  withdrawing its own request. */
+export async function dismissTicketViaDaemon(requestId, opts) {
+    await cliClient().dismissHumanRequest(requestId, opts);
 }
 function isUnreachable(err) {
     if (err instanceof ApiError)
@@ -26,9 +29,7 @@ export function daemonErrorMessage(err) {
 export function resolveFailureKind(err) {
     if (isUnreachable(err))
         return 'unreachable';
-    if (err instanceof ApiError && err.status === 409 && err.code === 'ticket_already_resolved')
-        return 'already_resolved';
-    if (err instanceof ApiError && err.status === 500 && err.code === 'delivery_failed')
-        return 'delivery_failed';
+    if (err instanceof ApiError && err.status === 409 && err.code === 'already_settled')
+        return 'already_settled';
     return 'other';
 }

package/dist/clients/inbox/review/review-client.d.ts

@@ -14,7 +14,6 @@ export interface ResolvedReview {
 }
 export interface ReviewClient {
     byId(reviewId: string): Promise<ResolvedReview>;
-    byBridge(bridgeNodeId: string): Promise<ResolvedReview>;
     createInline(p: {
         originNodeId: string;
         file: string;

package/dist/clients/inbox/review/review-client.js

@@ -40,10 +40,6 @@ export function createReviewClient(opts = {}) {
             const review = await request(() => cliClient().getReview(reviewId));
             return await resolveReview(review, review.companion_node_id, request);
         },
-        async byBridge(bridgeNodeId) {
-            const review = await request(() => cliClient().getReviewByBridge(bridgeNodeId));
-            return await resolveReview(review, review.companion_node_id, request);
-        },
         async createInline(p) {
             const review = await request(() => cliClient().createReview({
                 origin_kind: 'inline',

package/dist/clients/inbox/review-adapter.d.ts

@@ -1,7 +1,8 @@
 import type { SurfaceHost } from '../surfaces/host.js';
 export interface ReviewAdapterOptions {
     host: SurfaceHost;
-    dir: string;
+    /** The review request's own id — the same id its inbox row carries. */
+    reviewId: string;
 }
 /** Resolve a durable review ticket and open it in its own tmux window. */
 export declare class ReviewAdapter {

package/dist/clients/inbox/review-adapter.js

@@ -1,4 +1,3 @@
-import { basename } from 'node:path';
 import { openReviewWindow } from './review/launch.js';
 import { createReviewClient, ReviewTerminalError, terminalRefusalNotice } from './review/review-client.js';
 /** Resolve a durable review ticket and open it in its own tmux window. */
@@ -25,20 +24,19 @@ export class ReviewAdapter {
             this.opts.host.notice('The review is unavailable in a remote attach — the file and companion live on the host.');
             return;
         }
-        const bridgeNodeId = basename(this.opts.dir);
         let review;
         try {
-            review = await createReviewClient().byBridge(bridgeNodeId);
+            review = await createReviewClient().byId(this.opts.reviewId);
         }
         catch (error) {
-            this.opts.host.notice(noticeForBridgeFailure(error));
+            this.opts.host.notice(noticeForLookupFailure(error));
             return;
         }
         if (!this.stopped)
             openReviewWindow(this.opts.host, review);
     }
 }
-function noticeForBridgeFailure(error) {
+function noticeForLookupFailure(error) {
     if (error instanceof ReviewTerminalError)
         return terminalRefusalNotice(error);
     return error instanceof Error ? error.message : String(error);

package/dist/clients/inbox/surface.d.ts

@@ -1,9 +1,9 @@
 import type { SurfaceHost } from '../surfaces/host.js';
-import type { TicketSummary } from '../../core/human/types.js';
+import type { InboxRow } from './dto-adapt.js';
 export interface InboxSurfaceOptions {
     host: SurfaceHost;
     /** Injection seams for tests; production passes none. */
-    scan?: () => TicketSummary[];
+    scan?: () => Promise<InboxRow[]>;
 }
 export interface InboxSurfaceOwner {
     /** Mount when closed and close when open. */

package/dist/clients/inbox/surface.js

@@ -1,7 +1,6 @@
 import { InboxController } from './controller.js';
-import { scanInbox } from '../../core/human/scan.js';
+import { byNewestFirst, inboxRowFromDTO } from './dto-adapt.js';
 import { cliClient } from '../../commands/api-client.js';
-import { filterVisibleReviewTickets } from './review-visibility.js';
 import { decodeInboxKey } from './tui/keys.js';
 import { clipLine, visibleWidth } from './tui/ansi.js';
 class InboxComponent {
@@ -46,6 +45,14 @@ function padFrame(lines, cols, rows) {
         return clipped + ' '.repeat(Math.max(0, cols - visibleWidth(clipped)));
     });
 }
+/** Reach the row source once before mounting, so a daemon that cannot answer
+ *  surfaces as a notice instead of an inbox that silently has nothing in it. */
+async function probeRows(opts) {
+    if (opts.scan !== undefined)
+        return opts.scan();
+    const { tickets } = await cliClient().listHumanInbox();
+    return tickets.map(inboxRowFromDTO).sort(byNewestFirst);
+}
 export function createInboxSurface(opts) {
     let session;
     const close = () => {
@@ -62,12 +69,11 @@ export function createInboxSurface(opts) {
     const mount = (current) => {
         if (current.closed || session !== current)
             return;
-        const localScan = opts.scan ?? scanInbox;
         const nextController = new InboxController({
             host: opts.host,
             onDirty: () => current.handle?.invalidate(),
             onClosed: close,
-            scan: () => filterVisibleReviewTickets(localScan(), current.visibleIds),
+            ...(opts.scan === undefined ? {} : { scan: opts.scan }),
             onInboxActivity: () => refresh(current),
             ...(current.preselectDir === undefined ? {} : { initialSelection: current.preselectDir }),
         });
@@ -89,16 +95,22 @@ export function createInboxSurface(opts) {
             throw error;
         }
     };
+    // The first load decides whether the inbox opens at all — an unreachable
+    // daemon is a notice, not an empty surface. Afterwards the controller owns
+    // its own rows, so activity only has to tell it to re-read.
     const refresh = (current, initial = false) => {
+        if (!initial && current.controller !== undefined) {
+            void current.controller.invalidate();
+            return;
+        }
         const generation = ++current.refreshGeneration;
-        void cliClient().listHumanInbox().then(({ tickets }) => {
+        void probeRows(opts).then(() => {
             if (current.closed || session !== current || generation !== current.refreshGeneration)
                 return;
-            current.visibleIds = new Set(tickets.map((ticket) => ticket.ticket_id));
             if (current.controller === undefined)
                 mount(current);
             else
-                current.controller.invalidate();
+                void current.controller.invalidate();
         }, (error) => {
             if (!initial || current.closed || session !== current || generation !== current.refreshGeneration)
                 return;
@@ -119,7 +131,6 @@ export function createInboxSurface(opts) {
         const current = {
             closed: false,
             refreshGeneration: 0,
-            visibleIds: new Set(),
             ...(preselectDir === undefined ? {} : { preselectDir }),
         };
         session = current;

package/dist/clients/inbox/tui.d.ts

@@ -1,8 +1,8 @@
-import type { TicketSummary } from '../../core/human/types.js';
+import type { InboxRow } from './dto-adapt.js';
 export declare const KIND_ICON: Record<string, string>;
 export declare const KIND_COLOR: Record<string, string>;
 export declare function formatTimeAgo(iso: string): string;
 /** Pure inbox rows; selection and terminal ownership belong to InboxController. */
-export declare function buildInboxLines(items: TicketSummary[], width: number, selectedIndex: number, height?: number): string[];
+export declare function buildInboxLines(items: InboxRow[], width: number, selectedIndex: number, height?: number): string[];
 /** What the agent suggests, for a row that says so without opening the page. */
-export declare function recommendedLabel(item: TicketSummary): string | undefined;
+export declare function recommendedLabel(item: InboxRow): string | undefined;

package/dist/commands/__tests__/human.test.js

@@ -1,7 +1,7 @@
 // Run with: node --import tsx/esm --test 'src/commands/__tests__/human.test.ts'
 import { test, describe } from 'node:test';
 import assert from 'node:assert/strict';
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { mkdirSync, mkdtempSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { Readable } from 'node:stream';
@@ -13,6 +13,8 @@ import { humanSend as buildHumanSend } from '../human/prompts.js';
 const humanSend = buildHumanSend();
 import { registerHuman } from '../human.js';
 import { pageHelpText } from '../human/shared.js';
+import { writeRawConfig } from '../../core/config.js';
+import { initializeFreshScopedStore } from '../../core/scoped-state/migrate.js';
 const nlThreadRegistration = {
     kind: 'nl-thread',
     description: 'message conversation with participants and metadata',
@@ -37,7 +39,8 @@ function withPageSurface(pageSurface, run) {
     const originalHome = process.env['HOME'];
     process.env['HOME'] = home;
     mkdirSync(join(home, '.crouter'), { recursive: true });
-    writeFileSync(join(home, '.crouter', 'config.json'), JSON.stringify({ page_surface: pageSurface }));
+    initializeFreshScopedStore({ kind: 'user', root: join(home, '.crouter') });
+    writeRawConfig('user', { page_surface: pageSurface });
     try {
         return run();
     }
@@ -140,17 +143,30 @@ test('human components catalog and contracts teach product registrations', () =>
     assert.equal(renderComponentContract('ProductCard', [legacyRegistration]), "`<ProductCard>` — product-registered, wire kind `product-card`\n\nproduct-registered; config is passed through unvalidated (unvalidated: true) — see the product's own docs");
 });
 test('human components show resolves every registry name, families included', async () => {
-    const show = humanComponents.children.find((child) => child.name === 'show');
-    assert.ok(show !== undefined && show.kind === 'leaf');
-    const question = await show.run({ component: 'UserQuestion' });
-    assert.ok(question !== undefined);
-    assert.equal(question['contract'], componentDoc('UserQuestion')?.contract);
-    assert.match(String(question['contract']), /wire kind `options`/);
-    // A shadcn family member resolves to the family contract that documents it.
-    const cardHeader = await show.run({ component: 'CardHeader' });
-    assert.equal(cardHeader?.['contract'], componentDoc('Card')?.contract);
-    await assert.rejects(() => show.run({ component: 'crtr-options' }), (err) => {
-        assert.equal(err.code, 'unknown_component');
-        return true;
-    });
+    const home = mkdtempSync(join(tmpdir(), 'crtr-human-components-'));
+    const originalHome = process.env['HOME'];
+    process.env['HOME'] = home;
+    initializeFreshScopedStore({ kind: 'user', root: join(home, '.crouter') });
+    try {
+        const show = humanComponents.children.find((child) => child.name === 'show');
+        assert.ok(show !== undefined && show.kind === 'leaf');
+        const question = await show.run({ component: 'UserQuestion' });
+        assert.ok(question !== undefined);
+        assert.equal(question['contract'], componentDoc('UserQuestion')?.contract);
+        assert.match(String(question['contract']), /wire kind `options`/);
+        // A shadcn family member resolves to the family contract that documents it.
+        const cardHeader = await show.run({ component: 'CardHeader' });
+        assert.equal(cardHeader?.['contract'], componentDoc('Card')?.contract);
+        await assert.rejects(() => show.run({ component: 'crtr-options' }), (err) => {
+            assert.equal(err.code, 'unknown_component');
+            return true;
+        });
+    }
+    finally {
+        if (originalHome === undefined)
+            delete process.env['HOME'];
+        else
+            process.env['HOME'] = originalHome;
+        rmSync(home, { recursive: true, force: true });
+    }
 });

package/dist/commands/__tests__/integration/dashboard-snapshot.test.js

@@ -1,13 +1,17 @@
 import assert from 'node:assert/strict';
-import { existsSync, mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdtempSync, mkdirSync, rmSync } from 'node:fs';
 import { spawn } from 'node:child_process';
 import { createServer } from 'node:http';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import test from 'node:test';
 import { createNode, subscribe } from '../../../core/canvas/canvas.js';
-import { closeDb } from '../../../core/canvas/db.js';
+import { closeDb, migrate, openDb } from '../../../core/canvas/db.js';
 import { apiSocketPath } from '../../../core/canvas/paths.js';
+import { updateConfig, updateState } from '../../../core/config.js';
+import { closeScopedStores } from '../../../core/scoped-state/db.js';
+import { initializeFreshScopedStore } from '../../../core/scoped-state/migrate.js';
+import { setRelayToken } from '../../../core/secrets.js';
 import { Router } from '../../../daemon/api/router.js';
 import { createApiServer } from '../../../daemon/api/server.js';
 function node(id, parent) {
@@ -86,13 +90,19 @@ function startMockRemoteCanvas(route) {
 test('canvas dashboard renders scoped and full cycles from one node snapshot without per-node API reads', async (t) => {
     const root = mkdtempSync(join(tmpdir(), 'crtr-dashboard-'));
     const home = join(root, 'canvas');
+    const userHome = join(root, 'user');
     mkdirSync(home, { recursive: true });
-    const previousHome = process.env['CRTR_HOME'];
+    const previousCanvasHome = process.env['CRTR_HOME'];
+    const previousUserHome = process.env['HOME'];
     const originalHandle = Router.prototype.handle;
     const requests = [];
     try {
         process.env['CRTR_HOME'] = home;
+        process.env['HOME'] = userHome;
+        mkdirSync(join(userHome, '.crouter'), { recursive: true });
         closeDb();
+        migrate(openDb());
+        initializeFreshScopedStore({ kind: 'user', root: join(userHome, '.crouter') });
         createNode(node('root', null));
         createNode(node('left', 'root'));
         createNode(node('right', 'root'));
@@ -162,10 +172,15 @@ test('canvas dashboard renders scoped and full cycles from one node snapshot wit
     finally {
         Router.prototype.handle = originalHandle;
         closeDb();
-        if (previousHome === undefined)
+        closeScopedStores();
+        if (previousCanvasHome === undefined)
             delete process.env['CRTR_HOME'];
         else
-            process.env['CRTR_HOME'] = previousHome;
+            process.env['CRTR_HOME'] = previousCanvasHome;
+        if (previousUserHome === undefined)
+            delete process.env['HOME'];
+        else
+            process.env['HOME'] = previousUserHome;
         rmSync(root, { recursive: true, force: true });
     }
 });
@@ -173,6 +188,7 @@ test('canvas dashboard reads full-forest ticket counts from the selected remote
     const root = mkdtempSync(join(tmpdir(), 'crtr-dashboard-remote-'));
     const home = join(root, 'canvas');
     const userHome = join(root, 'user');
+    const previousUserHome = process.env['HOME'];
     const remote = await startMockRemoteCanvas((args) => {
         if (args[1] === 'node' && args[2] === 'inspect' && args[3] === 'list') {
             return { nodes: [node('root', null), node('child', 'root')] };
@@ -187,13 +203,17 @@ test('canvas dashboard reads full-forest ticket counts from the selected remote
     });
     t.after(() => remote.close());
     try {
+        process.env['HOME'] = userHome;
         mkdirSync(join(userHome, '.crouter'), { recursive: true });
-        writeFileSync(join(userHome, '.crouter', 'config.json'), JSON.stringify({
-            remoteCanvas: { targets: { remote: { previewEndpoint: remote.url, relayTokenRef: 'remote' } } },
-        }));
-        writeFileSync(join(userHome, '.crouter', 'state.json'), JSON.stringify({ activeCanvas: 'remote' }));
-        writeFileSync(join(userHome, '.crouter', 'secrets.json'), JSON.stringify({ relayTokens: { remote: 'test-token' } }));
-        const result = await runDashboard(home, undefined, { HOME: userHome });
+        initializeFreshScopedStore({ kind: 'user', root: join(userHome, '.crouter') });
+        updateConfig('user', (config) => {
+            config.remoteCanvas.targets['remote'] = { previewEndpoint: remote.url, relayTokenRef: 'remote' };
+        });
+        updateState('user', (state) => {
+            state.activeCanvas = 'remote';
+        });
+        setRelayToken('remote', 'test-token', 'user');
+        const result = await runDashboard(home);
         assert.equal(result.code, 0, result.stderr);
         const output = JSON.parse(result.stdout);
         assert.deepEqual(output.rows.map((row) => ({ node_id: row.node_id, asks: row.asks })), [
@@ -207,6 +227,11 @@ test('canvas dashboard reads full-forest ticket counts from the selected remote
         assert.equal(remote.requests.length, 3, `remote issued ${remote.requests.length} commands: ${remote.requests.map((args) => args.join(' ')).join(' | ')}`);
     }
     finally {
+        closeScopedStores();
+        if (previousUserHome === undefined)
+            delete process.env['HOME'];
+        else
+            process.env['HOME'] = previousUserHome;
         rmSync(root, { recursive: true, force: true });
     }
 });