@north-light/crouter 0.3.173 → 0.3.175

package/dist/daemon/reconcilers/dormant-inbox.js

@@ -0,0 +1,143 @@
+import { getNode, getRow, subscribersOf, } from '../../core/canvas/index.js';
+import { fullName } from '../../core/canvas/labels.js';
+import { isSafeNodeId } from '../../core/canvas/paths.js';
+import { emitEvent } from '../../core/events/emit.js';
+import { operationIdContext } from '../../core/events/operation-id.js';
+import { appendControllerDeathNotice, readCursor, readInboxSince, } from '../../core/feed/inbox.js';
+import { fanDoctrineWake } from '../../core/runtime/close.js';
+import { transition } from '../../core/runtime/lifecycle.js';
+import { reviveNode } from '../../core/runtime/revive.js';
+// Idle-release/inbox retry cap (2026-07-10 diagnosis, round 2): the SAME
+// livelock shape as the stranded-relaunch case, but on the separate pass that
+// resumes a dormant idle-released node when its inbox gains an unseen entry.
+// The counter is keyed on inbox-cursor progress, not row-state residency or pid
+// liveness: a transiently-live broker does not prove that delivery completed.
+const IDLE_RELEASE_RELAUNCH_MAX_ATTEMPTS = 6;
+const IDLE_RELEASE_RELAUNCH_MAX_BACKOFF_MS = 10 * 60_000;
+const IDLE_RELEASE_RELAUNCH_BASE_MS = 20_000;
+export class ControllerDeathReconciler {
+    run(_now, ctx) {
+        // Settle every wait whose controller has ended, independent of the waiter's
+        // current status. Active and focused terminal nodes own a live inbox
+        // watcher; idle-released nodes are revived by the following reconciler.
+        for (const row of ctx.rows) {
+            const current = getRow(row.node_id);
+            const controllerId = current?.waiting_for;
+            if (controllerId === null || controllerId === undefined)
+                continue;
+            // Read-gate before the write boundary: only a dead controller warrants a
+            // notice. appendControllerDeathNotice re-checks liveness inside its
+            // transaction, so this gate cannot misfire.
+            const controller = getRow(controllerId);
+            if (controller !== null && (controller.status === 'active' || controller.status === 'idle'))
+                continue;
+            operationIdContext.fresh(() => {
+                appendControllerDeathNotice(row.node_id, controllerId);
+            });
+        }
+    }
+}
+export class DormantInboxReconciler {
+    relaunchState = new Map();
+    run(now, ctx) {
+        // Re-read each row because live supervision may have mutated it earlier in
+        // this tick. A fleet entry is the live engine; no pid probe participates.
+        for (const row of ctx.rows) {
+            const id = row.node_id;
+            let current;
+            try {
+                current = getRow(id);
+                if (current === null) {
+                    this.relaunchState.delete(id);
+                    continue;
+                }
+                // Do not clear state on status flaps or transient liveness. Only cursor
+                // progress, no wake-worthy work, row deletion, or exhaustion ends the
+                // stuck-delivery episode.
+                if (current.status !== 'idle' || current.intent !== 'idle-release')
+                    continue;
+                if (ctx.fleet.has(id))
+                    continue;
+            }
+            catch (err) {
+                operationIdContext.fresh(() => {
+                    emitEvent({
+                        level: 'error',
+                        event: 'inbox.poll.failed',
+                        ...(isSafeNodeId(id) ? { node_id: id } : { fields: { affected_node_id: id } }),
+                        error: err,
+                    });
+                });
+                continue;
+            }
+            operationIdContext.fresh(() => {
+                try {
+                    const cursorNow = readCursor(id);
+                    const entries = readInboxSince(id, cursorNow);
+                    // Deferred entries ride the next natural cycle. A deferred-only unseen
+                    // set neither revives the node nor starts a stuck-relaunch episode.
+                    if (!entries.some((entry) => entry.tier !== 'deferred')) {
+                        this.relaunchState.delete(id);
+                        return;
+                    }
+                    const prior = this.relaunchState.get(id);
+                    const cursorChanged = prior === undefined || prior.cursor !== cursorNow;
+                    const attempts = cursorChanged ? 0 : prior.attempts;
+                    if (attempts >= IDLE_RELEASE_RELAUNCH_MAX_ATTEMPTS) {
+                        this.relaunchState.delete(id);
+                        const meta = getNode(id);
+                        emitEvent({
+                            level: 'warn',
+                            event: 'broker.idle_release.exhausted',
+                            ...(isSafeNodeId(id) ? { node_id: id } : {}),
+                            fields: {
+                                ...(isSafeNodeId(id) ? {} : { affected_node_id: id }),
+                                attempts,
+                                max_attempts: IDLE_RELEASE_RELAUNCH_MAX_ATTEMPTS,
+                            },
+                        });
+                        transition(id, 'crash');
+                        if (meta !== null) {
+                            try {
+                                fanDoctrineWake(id, subscribersOf(id), `Child crashed — ${fullName(meta)} (${id}) failed to relaunch after ${attempts} attempts while trying to ` +
+                                    `deliver a pending inbox message (no delivery progress across any attempt), and is now dead. It stays ` +
+                                    `dead until you revive it — \`crtr node lifecycle revive ${id}\`.`, { reason: 'child-crashed', child: id });
+                            }
+                            catch {
+                                /* best-effort, mirrors the other doctrine fan-outs */
+                            }
+                        }
+                        return;
+                    }
+                    const lastAttempt = cursorChanged ? undefined : prior?.lastAttempt;
+                    const backoff = Math.min(IDLE_RELEASE_RELAUNCH_BASE_MS * 2 ** attempts, IDLE_RELEASE_RELAUNCH_MAX_BACKOFF_MS);
+                    if (lastAttempt !== undefined && now - lastAttempt < backoff)
+                        return;
+                    if (!ctx.hasBrokerCapacity())
+                        return;
+                    this.relaunchState.set(id, { cursor: cursorNow, attempts: attempts + 1, lastAttempt: now });
+                    emitEvent({
+                        level: 'info',
+                        event: 'broker.revive.idle_release',
+                        ...(isSafeNodeId(id) ? { node_id: id } : {}),
+                        attempt: attempts + 1,
+                        fields: {
+                            ...(isSafeNodeId(id) ? {} : { affected_node_id: id }),
+                            attempts: attempts + 1,
+                            max_attempts: IDLE_RELEASE_RELAUNCH_MAX_ATTEMPTS,
+                        },
+                    });
+                    reviveNode(id, { resume: true });
+                }
+                catch (err) {
+                    emitEvent({
+                        level: 'error',
+                        event: 'inbox.poll.failed',
+                        ...(isSafeNodeId(id) ? { node_id: id } : { fields: { affected_node_id: id } }),
+                        error: err,
+                    });
+                }
+            });
+        }
+    }
+}

package/dist/daemon/reconcilers/storage-maintenance.d.ts

@@ -0,0 +1,22 @@
+export declare const DEAD_REAP_GRACE_MS: number;
+/** Recurring storage cleanup. The in-memory throttle clocks intentionally reset
+ * on daemon boot, so the first tick runs both full sweeps. */
+export declare class StorageMaintenanceReconciler {
+    private lastPruneAt;
+    private lastSpareSweepAt;
+    run(now: number): void;
+    /** Milliseconds since meta/telemetry was last written. Inbox activity is
+     * deliberately excluded: children can keep writing a dead manager's inbox. */
+    private msSinceDiskActivity;
+    /** Reap only the physical placement residue of long-dead nodes. The durable
+     * row, graph, and on-disk state remain available for a later manual revive. */
+    private reapDeadResidue;
+    /** Delete focus rows whose recorded tmux pane no longer exists. A failed tmux
+     * probe is "can't tell" and never authorizes deleting every viewport. */
+    private gcStaleFocuses;
+    /** Count-based full-canvas prune, throttled to once per hour. Live rows are
+     * never deleted by pruneToLimit, so the true floor can exceed AUTO_PRUNE_MAX. */
+    private autoPrune;
+    /** Collect dead or expired hidden warm-pool spares. */
+    private gcWarmPool;
+}

package/dist/daemon/reconcilers/storage-maintenance.js

@@ -0,0 +1,213 @@
+import { statSync } from 'node:fs';
+import { join } from 'node:path';
+import { closeFocusRow, listFocuses, listNodes, pruneToLimit, } from '../../core/canvas/index.js';
+import { isSafeNodeId, jobDir, nodeDir } from '../../core/canvas/paths.js';
+import { emitEvent } from '../../core/events/emit.js';
+import { operationIdContext } from '../../core/events/operation-id.js';
+import { listLivePanes, tearDownNode } from '../../core/runtime/placement.js';
+import { reapStaleSpares } from '../../core/runtime/warm-pool.js';
+// How long a dead node's on-disk record must be quiet before its leftover
+// placement is reaped. A fresh crash keeps its pane for inspection.
+export const DEAD_REAP_GRACE_MS = 10 * 60_000;
+const AUTO_PRUNE_MAX = 2000;
+const PRUNE_INTERVAL_MS = 60 * 60 * 1000;
+const SPARE_SWEEP_INTERVAL_MS = 60 * 1000;
+/** Recurring storage cleanup. The in-memory throttle clocks intentionally reset
+ * on daemon boot, so the first tick runs both full sweeps. */
+export class StorageMaintenanceReconciler {
+    lastPruneAt = Number.NEGATIVE_INFINITY;
+    lastSpareSweepAt = Number.NEGATIVE_INFINITY;
+    run(now) {
+        // Placement reap MUST precede focus GC, so GC catches a focus row the reap
+        // strands. Both run after dormant-inbox reconciliation, so a same-tick
+        // revive has already had the chance to re-anchor its focus.
+        this.reapDeadResidue(now);
+        this.gcStaleFocuses();
+        this.autoPrune(now);
+        this.gcWarmPool(now);
+    }
+    /** Milliseconds since meta/telemetry was last written. Inbox activity is
+     * deliberately excluded: children can keep writing a dead manager's inbox. */
+    msSinceDiskActivity(nodeId, now) {
+        let latest = 0;
+        for (const path of [join(nodeDir(nodeId), 'meta.json'), join(jobDir(nodeId), 'telemetry.json')]) {
+            try {
+                const mtime = statSync(path).mtimeMs;
+                if (mtime > latest)
+                    latest = mtime;
+            }
+            catch {
+                /* absent — contributes nothing */
+            }
+        }
+        return latest === 0 ? Number.POSITIVE_INFINITY : now - latest;
+    }
+    /** Reap only the physical placement residue of long-dead nodes. The durable
+     * row, graph, and on-disk state remain available for a later manual revive. */
+    reapDeadResidue(now) {
+        let rows;
+        try {
+            rows = listNodes({ status: ['dead'] });
+        }
+        catch (err) {
+            operationIdContext.fresh(() => {
+                emitEvent({ level: 'error', event: 'residue.reap_scan.failed', error: err });
+            });
+            return;
+        }
+        for (const row of rows) {
+            if (row.pane == null && row.window == null && row.tmux_session == null)
+                continue;
+            try {
+                if (this.msSinceDiskActivity(row.node_id, now) < DEAD_REAP_GRACE_MS)
+                    continue;
+            }
+            catch (err) {
+                operationIdContext.fresh(() => {
+                    emitEvent({
+                        level: 'error',
+                        event: 'residue.reap.failed',
+                        ...(isSafeNodeId(row.node_id) ? { node_id: row.node_id } : {}),
+                        error: err,
+                        fields: {
+                            ...(isSafeNodeId(row.node_id) ? {} : { affected_node_id: row.node_id }),
+                            pane: row.pane,
+                            window: row.window,
+                            tmux_session: row.tmux_session,
+                        },
+                    });
+                });
+                continue;
+            }
+            operationIdContext.fresh(() => {
+                try {
+                    emitEvent({
+                        level: 'info',
+                        event: 'residue.reaped',
+                        ...(isSafeNodeId(row.node_id) ? { node_id: row.node_id } : {}),
+                        fields: {
+                            ...(isSafeNodeId(row.node_id) ? {} : { affected_node_id: row.node_id }),
+                            pane: row.pane,
+                            window: row.window,
+                            tmux_session: row.tmux_session,
+                        },
+                    });
+                    tearDownNode(row.node_id);
+                }
+                catch (err) {
+                    emitEvent({
+                        level: 'error',
+                        event: 'residue.reap.failed',
+                        ...(isSafeNodeId(row.node_id) ? { node_id: row.node_id } : {}),
+                        error: err,
+                        fields: {
+                            ...(isSafeNodeId(row.node_id) ? {} : { affected_node_id: row.node_id }),
+                            pane: row.pane,
+                            window: row.window,
+                            tmux_session: row.tmux_session,
+                        },
+                    });
+                }
+            });
+        }
+    }
+    /** Delete focus rows whose recorded tmux pane no longer exists. A failed tmux
+     * probe is "can't tell" and never authorizes deleting every viewport. */
+    gcStaleFocuses() {
+        let rows;
+        try {
+            rows = listFocuses();
+        }
+        catch (err) {
+            operationIdContext.fresh(() => {
+                emitEvent({ level: 'error', event: 'focus.gc.failed', error: err });
+            });
+            return;
+        }
+        if (rows.length === 0)
+            return;
+        let live;
+        try {
+            live = listLivePanes();
+        }
+        catch (err) {
+            operationIdContext.fresh(() => {
+                emitEvent({ level: 'error', event: 'focus.gc.failed', error: err });
+            });
+            return;
+        }
+        if (live === null)
+            return;
+        for (const focus of rows) {
+            if (focus.pane === null || live.has(focus.pane))
+                continue;
+            const removed = operationIdContext.fresh(() => {
+                try {
+                    emitEvent({
+                        level: 'info',
+                        event: 'focus.gc.removed',
+                        ...(isSafeNodeId(focus.node_id) ? { node_id: focus.node_id } : {}),
+                        fields: {
+                            focus_id: focus.focus_id,
+                            focus_node_id: focus.node_id,
+                            pane: focus.pane,
+                        },
+                    });
+                    closeFocusRow(focus.focus_id);
+                    return true;
+                }
+                catch (err) {
+                    emitEvent({ level: 'error', event: 'focus.gc.failed', error: err });
+                    return false;
+                }
+            });
+            if (!removed)
+                return;
+        }
+    }
+    /** Count-based full-canvas prune, throttled to once per hour. Live rows are
+     * never deleted by pruneToLimit, so the true floor can exceed AUTO_PRUNE_MAX. */
+    autoPrune(now) {
+        if (now - this.lastPruneAt < PRUNE_INTERVAL_MS)
+            return;
+        this.lastPruneAt = now;
+        operationIdContext.fresh(() => {
+            try {
+                const before = listNodes().length;
+                const { pruned } = pruneToLimit({ maxNodes: AUTO_PRUNE_MAX });
+                if (pruned.length > 0) {
+                    emitEvent({
+                        level: 'info',
+                        event: 'canvas.auto_prune.completed',
+                        outcome: 'succeeded',
+                        fields: {
+                            before_count: before,
+                            kept_count: before - pruned.length,
+                            pruned_count: pruned.length,
+                        },
+                    });
+                }
+            }
+            catch (err) {
+                emitEvent({ level: 'error', event: 'canvas.auto_prune.failed', error: err });
+            }
+        });
+    }
+    /** Collect dead or expired hidden warm-pool spares. */
+    gcWarmPool(now) {
+        if (now - this.lastSpareSweepAt < SPARE_SWEEP_INTERVAL_MS)
+            return;
+        this.lastSpareSweepAt = now;
+        operationIdContext.fresh(() => {
+            const reaped = reapStaleSpares();
+            if (reaped.length > 0) {
+                emitEvent({
+                    level: 'info',
+                    event: 'warm_pool.spares_reaped',
+                    outcome: 'succeeded',
+                    fields: { reaped_count: reaped.length },
+                });
+            }
+        });
+    }
+}

package/dist/daemon/review/finish.js

@@ -204,8 +204,6 @@ export async function submitReviewApproval(reviewId) {
             return terminalConflict(review, 'submit');
         if (review.state === 'approved')
             return { outcome: 'already_settled', review, result: approvedResult(review) };
-        if (review.state !== 'open')
-            throw new ReviewOperationError('review_not_open', 'review is not open', { review_id: reviewId, state: review.state });
         const snapshot = snapshotCommentsLocked(db, reviewId);
         const at = now();
         const result = buildReviewResult(review, snapshot, source.sha256, at);
@@ -240,9 +238,8 @@ export async function cancelReview(reviewId, args) {
     const review = requireVisibleReview(reviewId);
     if (review.state === 'approved')
         return terminalConflict(review, 'cancel');
-    if (review.state !== 'canceled') {
-        throw new ReviewOperationError('review_not_open', 'review is not open', { review_id: reviewId, state: review.state });
-    }
+    if (review.state !== 'canceled')
+        throw new Error(`review ${reviewId} did not reach its canceled state`);
     if (winningWrite)
         signalReviewActivity();
     const finished = await serializedFinish(reviewId, () => finishCanceled(review, winningWrite, args));

package/dist/pi-extensions/__tests__/canvas-context-intro.test.js

@@ -1,18 +1,30 @@
 // Run with: node --import tsx/esm --test src/pi-extensions/__tests__/canvas-context-intro.test.ts
 //
-// A fresh branch receives the full context baseline. A forked crouter branch
-// receives a compact node-scoped update after its inherited baseline. Resumes
-// remain idempotent through the exact node-id stamp.
-import { test, before, after, beforeEach } from 'node:test';
+// A forked crouter branch receives a compact node-scoped update after its
+// inherited baseline, and a resume re-injects nothing — idempotency keyed on
+// the exact node-id stamp, independent of the bearings text.
+import { test, before, after, beforeEach, afterEach } from 'node:test';
 import assert from 'node:assert/strict';
-import { mkdtempSync, rmSync } from 'node:fs';
+import { existsSync, mkdtempSync, mkdirSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
-import { buildContextIntro, buildForkContextIntro, registerCanvasContextIntro, CONTEXT_INTRO_CUSTOM_TYPE, } from '../canvas-context-intro.js';
+import { registerCanvasContextIntro, CONTEXT_INTRO_CUSTOM_TYPE, } from '../canvas-context-intro.js';
+import { buildContextBearings as buildContextIntro } from '../../core/runtime/bearings.js';
 import { createNode } from '../../core/canvas/canvas.js';
+import { apiSocketPath } from '../../core/canvas/paths.js';
+import { createApiServer } from '../../daemon/api/server.js';
 import { closeDb } from '../../core/canvas/db.js';
 let home;
 let origNode;
+let server;
+async function waitForSocket(path) {
+    for (let i = 0; i < 200; i++) {
+        if (existsSync(path))
+            return;
+        await new Promise((resolve) => setTimeout(resolve, 10));
+    }
+    throw new Error(`api socket never bound at ${path}`);
+}
 function node(id, over = {}) {
     return {
         node_id: id,
@@ -45,21 +57,27 @@ function makeFakePi() {
         registerMessageRenderer() {
             /* display-only; irrelevant here */
         },
-        fireSessionStart(entries) {
-            handler?.(undefined, { sessionManager: { getEntries: () => entries } });
+        async fireSessionStart(entries) {
+            await handler?.(undefined, { sessionManager: { getEntries: () => entries } });
         },
     };
 }
 before(() => {
     origNode = process.env['CRTR_NODE_ID'];
 });
-beforeEach(() => {
+beforeEach(async () => {
     closeDb();
     if (home)
         rmSync(home, { recursive: true, force: true });
     home = mkdtempSync(join(tmpdir(), 'crtr-context-intro-'));
     process.env['CRTR_HOME'] = home;
     delete process.env['CRTR_NODE_ID'];
+    mkdirSync(home, { recursive: true });
+    server = createApiServer();
+    await waitForSocket(apiSocketPath());
+});
+afterEach(async () => {
+    await server.close();
 });
 after(() => {
     closeDb();
@@ -71,44 +89,7 @@ after(() => {
     else
         process.env['CRTR_NODE_ID'] = origNode;
 });
-test('full boot intro leads with the node\'s own identity', () => {
-    createNode(node('alpha', { name: 'fix-auth', kind: 'developer' }));
-    const intro = buildContextIntro('alpha');
-    assert.match(intro, /<crtr-bearings>/, 'opens with the bearings section');
-    assert.match(intro, /You are node alpha/, 'names the node by its own id');
-    assert.match(intro, /kind developer/, 'states the node kind');
-    assert.doesNotMatch(intro, /FORK of/, 'a fresh node carries no fork framing');
-    // Identity leads the bearings block.
-    assert.match(intro, /<crtr-bearings>\nYou are node alpha/, 'identity leads the bearings block');
-    assert.ok(intro.indexOf('<crtr-bearings>') < intro.indexOf('<project_context>'), 'bearings precede project context');
-});
-test('fork bearings contain only the new node-scoped facts', () => {
-    createNode(node('src7', { name: 'looking-pi-crouter', description: 'monitor-telemetry' }));
-    createNode(node('fork9', { fork_from: 'src7', lifecycle: 'resident' }));
-    const intro = buildForkContextIntro('fork9');
-    assert.match(intro, /You are node fork9/, 'the fork receives its own id');
-    assert.match(intro, /new FORK of src7/, 'the fork names its source');
-    assert.match(intro, /not src7/, 'the fork does not adopt the source identity');
-    assert.match(intro, /looking-pi-crouter/, 'the source label identifies the copied history');
-    assert.match(intro, /Lifecycle: resident/, 'the fork receives its current lifecycle');
-    assert.match(intro, /independent root/, 'the fork receives its current graph role');
-    assert.ok(intro.includes(join(home, 'nodes', 'fork9', 'context')), 'the fork receives its own context path');
-    assert.match(intro, /first real user message/, 'the fork waits for its new mandate');
-    assert.doesNotMatch(intro, /<memory kind="knowledge">/, 'the inherited knowledge catalog is not repeated');
-    assert.doesNotMatch(intro, /<auto-loaded-context>/, 'inherited workspace docs are not repeated');
-    assert.doesNotMatch(intro, /<project_context>/, 'the inherited project snapshot is not repeated');
-    createNode(node('plain2'));
-    const plain = buildContextIntro('plain2');
-    assert.match(plain, /You are node plain2/);
-    assert.ok(!/FORK of/.test(plain), 'a fresh node carries no fork callout');
-    // A path-valued provenance remains an opaque label.
-    const pathSource = '/Users/silasrhyneer/.crouter/canvas/human-work/queue/20260717T000000-abc.json';
-    createNode(node('fork10', { fork_from: pathSource }));
-    const pathIntro = buildForkContextIntro('fork10');
-    assert.match(pathIntro, /You are node fork10/);
-    assert.match(pathIntro, new RegExp(`new FORK of ${pathSource.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}`), 'a path-valued source is named without a node lookup');
-});
-test('session_start appends compact fork bearings after an inherited source baseline', () => {
+test('session_start appends compact fork bearings after an inherited source baseline', async () => {
     createNode(node('srcA'));
     createNode(node('forkB', { fork_from: 'srcA' }));
     // A fork boots with the SOURCE's whole conversation copied in — including the
@@ -117,7 +98,7 @@ test('session_start appends compact fork bearings after an inherited source base
     process.env['CRTR_NODE_ID'] = 'forkB';
     const pi = makeFakePi();
     registerCanvasContextIntro(pi);
-    pi.fireSessionStart([inheritedSourceBlock]);
+    await pi.fireSessionStart([inheritedSourceBlock]);
     // The inherited baseline belongs to srcA, so forkB receives its own compact update.
     assert.equal(pi.sent.length, 1, 'fork injects its OWN bearings over the inherited source block');
     assert.equal(pi.sent[0].customType, CONTEXT_INTRO_CUSTOM_TYPE);
@@ -130,10 +111,10 @@ test('session_start appends compact fork bearings after an inherited source base
     process.env['CRTR_NODE_ID'] = 'externalF';
     const externalPi = makeFakePi();
     registerCanvasContextIntro(externalPi);
-    externalPi.fireSessionStart([]);
+    await externalPi.fireSessionStart([]);
     assert.match(externalPi.sent[0].content, /<project_context>/, 'an external-session fork receives the full baseline');
 });
-test('resume idempotency uses the exact details stamp independent of block text', () => {
+test('resume idempotency uses the exact details stamp independent of block text', async () => {
     createNode(node('stampD'));
     // The exact node-id stamp is authoritative even when prose carries no id.
     const stampedNoIdInText = {
@@ -145,16 +126,16 @@ test('resume idempotency uses the exact details stamp independent of block text'
     process.env['CRTR_NODE_ID'] = 'stampD';
     const pi = makeFakePi();
     registerCanvasContextIntro(pi);
-    pi.fireSessionStart([stampedNoIdInText]);
+    await pi.fireSessionStart([stampedNoIdInText]);
     assert.equal(pi.sent.length, 0, 'exact details-stamp match skips re-injection even when the text omits the id');
 });
-test('session_start stays idempotent on a genuine resume', () => {
+test('session_start stays idempotent on a genuine resume', async () => {
     createNode(node('resumeC'));
     // A resume restores this node's already-stamped bearings.
     const ownBlock = introEntry(buildContextIntro('resumeC'));
     process.env['CRTR_NODE_ID'] = 'resumeC';
     const pi = makeFakePi();
     registerCanvasContextIntro(pi);
-    pi.fireSessionStart([ownBlock]);
+    await pi.fireSessionStart([ownBlock]);
     assert.equal(pi.sent.length, 0, 'our own bearings already present → no duplicate injection');
 });