@north-light/crouter 0.3.173 → 0.3.174

package/dist/core/__tests__/{full/idle-release-settlement.test.js → seam/dormancy-release.test.js}

@@ -1,7 +1,18 @@
-// Run with: node --import tsx/esm --test src/core/__tests__/full/idle-release-settlement.test.ts
+// Run with: node --import tsx/esm --test src/core/__tests__/seam/dormancy-release.test.ts
 //
-// Issue #222: a real idle-release cycle must settle the inbox watcher before the
-// broker exits. The daemon may only revive for a row strictly after that cursor.
+// The two real dormancy journeys of a live broker, sharing one harness and one
+// acting root:
+//
+//  (1) Issue #222/#353 — a real idle-release cycle must settle the inbox watcher
+//      before the broker exits, and the daemon may only revive for a row strictly
+//      after the committed cursor.
+//  (2) The observed 57-broker / ~5.4GB leak — a boot-revived settled node that
+//      receives no new work must still traverse bounded release: DAEMON
+//      SUPERVISION, not an agent event, owns the unattended park clock, and the
+//      exit policy frees the fleet slot without reviving.
+//
+// Both drive a real broker process through the real watcher/supervision paths, so
+// they belong to the compiled seam tier; neither needs tmux.
 import { after, before, test } from 'node:test';
 import assert from 'node:assert/strict';
 import { appendInbox, readCursor, readInboxSince } from '../../feed/inbox.js';
@@ -12,8 +23,8 @@ import { createHarness } from '../helpers/harness.js';
 let h;
 let root;
 before(async () => {
-    h = await createHarness({ headless: true, sessionPrefix: 'crtr-settle' });
-    root = h.spawnRoot('settlement suite root');
+    h = await createHarness({ headless: true, sessionPrefix: 'crtr-dormancy' });
+    root = h.spawnRoot('dormancy-release suite root');
 });
 after(async () => {
     if (h !== undefined)
@@ -38,18 +49,11 @@ test('idle-release settles its real watcher before exit; daemon revives exactly
     // launch.env, and calling reviveNode rather than through `spawnHeadlessChild`.
     //
     // The same launch.env carries the REAL canvas-inbox-watcher's injectable
-    // cadence seam (CRTR_WATCHER_TICK_MS / CRTR_WATCHER_DEBOUNCE_MS — the same
-    // seam canvas-inbox-watcher.test.ts/canvas-inbox-watcher-hold.test.ts/
-    // deferred-no-wake.test.ts already drive fast, there via ambient env since
-    // they run the watcher in-process). Left at the production 800ms/1000ms
-    // default, this test's two full delivery cycles bake in >=3.6s of pure
-    // wall-clock polling on top of two real broker boots — negligible in
-    // isolation, but on a loaded CI runner deep in the serial `heavy` lane (the
-    // only heavy-tier test that calls h.awaitWake()'s real, non-overridable 15s
-    // cap) that starved interval tick has repeatedly lost the race and timed
-    // out (issue: CI runs 29549096301/29549658681/29550017548, always at the
-    // first h.awaitWake). Driving the cadence fast here removes the wall-clock
-    // dependency entirely without weakening what's under test: the settlement
+    // cadence seam (CRTR_WATCHER_TICK_MS / CRTR_WATCHER_DEBOUNCE_MS). The
+    // ordinary source watcher suites drive it through ambient env because they
+    // run in-process. Keeping this compiled seam at production cadence would add
+    // multiple seconds of polling around two real broker boots, so it uses the
+    // same fast cadence without weakening what it proves: the settlement
     // lifecycle, cursor semantics, and hasPendingMessages veto are all
     // independent of how fast the watcher polls.
     const manager = h.fabricateBrokerNode({ id: 'settle-veto-manager', status: 'idle', parent: root });
@@ -106,3 +110,51 @@ test('idle-release settles its real watcher before exit; daemon revives exactly
     await h.tick();
     assert.equal(h.node(manager).cycles ?? 0, cyclesAfterRelease + 1, 'the settled later row does not cause a duplicate revival');
 });
+test('a revived settled node with no work releases on the daemon park clock and leaves no broker', { timeout: 30_000 }, async () => {
+    // The park clock is read per supervision pass (unattendedParkMsForDaemon), so
+    // it is armed for THIS test only — a file-global 1500ms park clock would also
+    // apply to the idle-release manager above and race its own release path.
+    const priorParkMs = process.env['CRTR_TEST_UNATTENDED_PARK_MS'];
+    process.env['CRTR_TEST_UNATTENDED_PARK_MS'] = '1500';
+    try {
+        const nodeId = h.fabricateBrokerNode({
+            id: 'settled-no-work',
+            parent: root,
+            status: 'idle',
+            intent: 'idle-release',
+        });
+        updateNode(nodeId, {
+            launch: {
+                extensions: [],
+                tools: [],
+                systemPrompt: '',
+                env: {},
+            },
+        });
+        reviveNode(nodeId, { resume: true });
+        const boot = await h.awaitBoot(nodeId);
+        assert.equal(h.fleet.has(nodeId), true, 'the revived broker is fleet-owned');
+        const seenAt = 10_000;
+        await h.tick(seenAt);
+        await h.tick(seenAt + 1499);
+        assert.equal(h.fleet.has(nodeId), true, 'the daemon keeps the broker through the full grace');
+        await h.tick(seenAt + 1500);
+        await h.waitFor(() => {
+            const node = h.node(nodeId);
+            return node?.status === 'idle' && node.intent === 'idle-release' && !isPidAlive(boot.pid);
+        }, { timeoutMs: 10_000, intervalMs: 20, label: 'park-clock release and broker exit' });
+        // The pid vanishing is not the fleet learning about it: wait for the child
+        // 'exit' delivery + its policy job, which is what actually frees the slot.
+        await h.awaitFleetExit(nodeId);
+        assert.equal(h.fleet.has(nodeId), false, 'exit policy forgets the idle-release broker');
+        assert.equal(h.node(nodeId)?.intent, 'idle-release', 'the row remains durably dormant');
+        await h.tick();
+        assert.equal(h.fleet.has(nodeId), false, 'a supervision tick does not revive without inbox work');
+    }
+    finally {
+        if (priorParkMs === undefined)
+            delete process.env['CRTR_TEST_UNATTENDED_PARK_MS'];
+        else
+            process.env['CRTR_TEST_UNATTENDED_PARK_MS'] = priorParkMs;
+    }
+});

package/dist/core/__tests__/{full/yield-message-transaction.test.js → seam/yield-refresh-transaction.test.js}

@@ -1,14 +1,17 @@
-// Run with: node --import tsx/esm --test src/core/__tests__/full/yield-message-transaction.test.ts
+// Run with: node --import tsx/esm --test src/core/__tests__/seam/yield-refresh-transaction.test.ts
 //
 // Regression: one-shot <yield-message/> handoff must survive pre-session_start cycle
-// death and only clear once session_start confirms a successful boot. This test
-// runs against the real broker process (headless harness) and a deterministic
-// one-shot pre-start fault injection so a single retry is exercised in-band.
+// death and only clear once session_start confirms a successful boot, and a
+// competing strict-resume revive (issue #146: a real `surface node focus` while
+// the refresh is still pending) must not reopen the old session. This test runs
+// against the real broker process (headless harness) and a deterministic one-shot
+// pre-start fault injection so a single retry is exercised in-band.
 import { test, before, after } from 'node:test';
 import assert from 'node:assert/strict';
 import { existsSync } from 'node:fs';
 import { createHarness } from '../helpers/harness.js';
 import { isPidAlive } from '../../canvas/pid.js';
+import { reviveNode } from '../../runtime/revive.js';
 import { readYieldMessage, yieldMessagePath } from '../../runtime/kickoff.js';
 import { FAIL_BEFORE_SESSION_START_ONCE } from '../fixtures/fake-engine.js';
 let h;
@@ -21,7 +24,7 @@ after(async () => {
     if (h !== undefined)
         await h.dispose();
 });
-// 30s (approved full-tier cap): three real broker boots plus the exit-policy
+// 30s (approved compiled-seam cap): three real broker boots plus the exit-policy
 // respawn throttle's first ~5s backoff before the successful retry.
 test('yield-message survives one pre-session_start retry and clears on session_start', { timeout: 30_000 }, async () => {
     const note = `Issue #146 pre-session_start replay ${FAIL_BEFORE_SESSION_START_ONCE} keeps the wake note`;
@@ -44,15 +47,34 @@ test('yield-message survives one pre-session_start retry and clears on session_s
         return pid != null && pid !== oldPid ? pid : null;
     }, { label: 'exit-event refresh attempt recorded its broker pid', timeoutMs: 30_000 });
     await h.waitFor(() => !isPidAlive(failedCyclePid), { label: 'one-shot cycling broker died before session_start' });
+    // PID death precedes Node's ChildProcess `exit` delivery. Wait through the
+    // authoritative fleet barrier and its queued exit-policy job so the contender
+    // below reaches refresh arbitration instead of returning on stale liveness.
+    // The policy has only armed its backoff timer at this point; no recovery broker
+    // owns the slot yet.
+    await h.awaitFleetExit(id);
     const afterFirstExit = h.node(id);
+    assert.equal(h.fleet.has(id), false, 'the failed broker has left the authoritative fleet before focus competes');
     assert.equal(afterFirstExit?.cycles, baseCycles + 1, 'the first refresh attempt advances cycles');
+    assert.equal(afterFirstExit?.intent, 'refresh', 'the durable refresh intent still confronts the strict-resume contender');
     assert.equal(afterFirstExit?.cycle_pending, true, 'cycle_pending remains true until session_start confirms');
     assert.equal(readYieldMessage(id), note, 'yield note stays present after pre-session_start failure');
     assert.equal(existsSync(yieldMessagePath(id)), true, 'yield file survives the failed cycle');
-    // That failed attempt's real exit classifies row 7 (cycle_pending) and keeps
-    // the retry in cycle mode until session_start confirms. The respawn throttle
-    // may delay it briefly, but no poll is required.
+    // A real `surface node focus` on the node right now asks the revive arbiter for
+    // a STRICT RESUME (issue #146). It must lose to the durable pending refresh:
+    // the retry still roots a fresh cycle carrying the note, never reopening the
+    // old session. Driving reviveNode directly is exactly what focus's revive path
+    // calls, minus a tmux pane this contract does not involve.
+    const focusRevive = reviveNode(id, { resume: true });
+    const focusPid = focusRevive.launch?.pid;
+    assert.ok(focusPid != null, 'the competing focus invocation launches the replacement broker');
+    assert.equal(focusRevive.resumed, false, 'refresh intent overrides this invocation\'s strict-resume request');
+    assert.equal(h.fleet.get(id)?.pid, focusPid, 'the focus invocation synchronously owns the authoritative fleet slot');
+    // Registering the manual launch cancels the exit policy's deferred recovery.
+    // Its pid must therefore be the successful observed boot, proving these
+    // assertions belong to the contender above rather than an already-queued boot.
     const boot = await h.awaitBoot(id, { minCount: baseBoot + 1, timeoutMs: 120_000 });
+    assert.equal(boot.pid, focusPid, 'the competing focus invocation owns the confirmed boot');
     const afterRetry = h.node(id);
     assert.equal(afterRetry?.cycles, baseCycles + 2, 'the retry advances once from the latest locked cycle');
     assert.equal(afterRetry?.cycle_pending, false, 'session_start cleared cycle_pending');
@@ -62,7 +84,7 @@ test('yield-message survives one pre-session_start retry and clears on session_s
     assert.equal(boot.prompt.includes(note), true, 'the successful retry kickoff still contains the yield note');
     assert.match(boot.prompt, /<goal file="[^"]+">/, 'a no-roadmap base refresh includes its original goal');
     assert.equal(boot.prompt.includes('headless worker — yield message transactional retry'), true, 'the kickoff carries the original base-node mandate');
-    assert.equal(boot.resuming, false, 'yield refresh roots a fresh cycle instead of strictly resuming');
+    assert.equal(boot.resuming, false, 'a competing focus resume=true cannot reopen the old session while the refresh is pending');
     const updated = h.node(id);
     assert.equal(updated?.mode, 'base', 'a plain yield refresh remains base');
     assert.ok(updated?.pi_session_id != null, 'successful retry recorded a session id');

package/dist/core/__tests__/secrets.test.js

@@ -7,7 +7,7 @@ import assert from 'node:assert/strict';
 import { mkdtempSync, rmSync, statSync, existsSync, chmodSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
-import { readSecrets, writeSecrets, getRelayToken, setRelayToken, deleteRelayToken, fingerprint } from '../secrets.js';
+import { readSecrets, writeSecrets, getRelayToken, setRelayToken, deleteRelayToken } from '../secrets.js';
 let home;
 let realHome;
 before(() => {
@@ -47,9 +47,3 @@ test('writeSecrets writes secrets.json 0600, even over a pre-existing looser-mod
     writeSecrets('user', { relayTokens: { a: 'x', b: 'y' } });
     assert.equal(statSync(p).mode & 0o777, 0o600);
 });
-test('fingerprint is the sha256(token) hex prefix — pinned, so a reversible encoding fails', () => {
-    assert.equal(fingerprint('sekret-token-value'), '662bda51b31e');
-    assert.notEqual(fingerprint('a-different-token'), fingerprint('sekret-token-value'));
-    assert.match(fingerprint('sekret-token-value'), /^[0-9a-f]{12}$/);
-    assert.ok(!fingerprint('sekret-token-value').includes('sekret-token-value'));
-});

package/dist/core/__tests__/{broker-fork-seam.test.js → serial/broker-fork-seam.test.js}

@@ -1,4 +1,4 @@
-// Run with: node --import tsx/esm --test src/core/__tests__/broker-fork-seam.test.ts
+// Run with: npm run test:serial
 //
 // BUG-REGRESSION (broker-universal-host cut, design §B.broker; U1 report
 // mq8ftenr-5d55313d). Before the cut, the headless broker had NO fork path — its
@@ -24,17 +24,20 @@
 // uses, whose fixture omits forkFrom and so could never exercise this branch. It
 // runs offline (fork + session/services assembly are all local: no network/auth).
 //
-// (fork.test.ts covers the pure argv/resolve layers — buildPiArgv emitting
-// `--fork`, resolveForkSource turning a ref into a path. THIS file covers the
-// broker runtime branch those layers feed.)
+// The tail of this file covers the pre-launch resolve layer that feeds the
+// broker branch: `resolveForkSource` refusing a reference that resolves to no
+// forkable session file.
 import { test, before, after } from 'node:test';
 import assert from 'node:assert/strict';
 import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { createAgentSessionServices, createAgentSessionFromServices, SessionManager, VERSION, } from '../runtime/broker-sdk.js';
-import { buildBrokerSession } from '../runtime/broker.js';
+import { createNode } from '../../canvas/canvas.js';
+import { closeDb } from '../../canvas/db.js';
+import { resolveForkSource } from '../../runtime/spawn.js';
+import { createAgentSessionServices, createAgentSessionFromServices, SessionManager, VERSION, } from '../../runtime/broker-sdk.js';
+import { buildBrokerSession } from '../../runtime/broker.js';
 // M-9 (broker.ts fault-and-die model gate): buildBrokerSession with no cfg.model
 // now calls the REAL SDK's modelRegistry.getAvailable() and faults if it's empty
 // — which it always is on a host/CI runner with no authenticated provider. This
@@ -42,7 +45,7 @@ import { buildBrokerSession } from '../runtime/broker.js';
 // fake-but-authenticated model the C3 wiring tests use, rather than depending on
 // ambient host credentials (which don't exist in CI — see broker-sdk-wiring's
 // c3-custom-provider-ext.ts fixture).
-const HERE = dirname(fileURLToPath(import.meta.url));
+const HERE = join(dirname(fileURLToPath(import.meta.url)), '..');
 const C3_EXT = join(HERE, 'fixtures', 'c3-custom-provider-ext.ts');
 // The REAL engine — bypasses the CRTR_BROKER_ENGINE fake entirely (the whole
 // point: the fake omits forkFrom, so only the real SDK can prove the branch).
@@ -115,3 +118,51 @@ test('D2 broker fork branch: buildBrokerSession(cfg.forkFrom) yields a NEW id +
         session.dispose();
     }
 });
+// ---------------------------------------------------------------------------
+// resolveForkSource — a reference that resolves to no forkable session file
+// must fail loudly BEFORE launch, rather than hand the broker a source it
+// cannot fork.
+// ---------------------------------------------------------------------------
+function nodeRow(id, over = {}) {
+    return {
+        node_id: id,
+        name: id,
+        created: new Date().toISOString(),
+        cwd: '/tmp/work',
+        kind: 'developer',
+        mode: 'base',
+        lifecycle: 'terminal',
+        status: 'active',
+        ...over,
+    };
+}
+test('resolveForkSource refuses every reference that resolves to no forkable session file', () => {
+    const home = mkdtempSync(join(tmpdir(), 'crtr-fork-resolve-'));
+    const sessions = mkdtempSync(join(tmpdir(), 'crtr-pi-agent-'));
+    const previousHome = process.env['CRTR_HOME'];
+    process.env['CRTR_HOME'] = home;
+    process.env['PI_CODING_AGENT_DIR'] = sessions;
+    try {
+        // Broker-cut contract (U6/§B.broker): the broker forks an absolute .jsonl
+        // PATH, never a bare session id, so a node row carrying only pi_session_id
+        // is unforkable.
+        createNode(nodeRow('id-only', { pi_session_id: 'uuid-1' }));
+        assert.throws(() => resolveForkSource('id-only'), /no pi session yet|session FILE/);
+        createNode(nodeRow('fresh'));
+        assert.throws(() => resolveForkSource('fresh'), /no pi session yet/);
+        // An unknown bare/partial uuid is scanned against pi's sessions store and
+        // fails when it matches nothing — never passed through verbatim.
+        assert.throws(() => resolveForkSource('019e8ce3-322e'), /no pi session/);
+        assert.throws(() => resolveForkSource('   '), /requires a node id/);
+    }
+    finally {
+        closeDb();
+        delete process.env['PI_CODING_AGENT_DIR'];
+        if (previousHome === undefined)
+            delete process.env['CRTR_HOME'];
+        else
+            process.env['CRTR_HOME'] = previousHome;
+        rmSync(home, { recursive: true, force: true });
+        rmSync(sessions, { recursive: true, force: true });
+    }
+});

package/dist/core/__tests__/{broker-sdk-wiring.test.js → serial/broker-sdk-wiring.test.js}

@@ -1,4 +1,4 @@
-// Run with: node --import tsx/esm --test src/core/__tests__/broker-sdk-wiring.test.ts
+// Run with: npm run test:serial
 //
 // REAL-SDK regression tests for the latent broker gaps the viewer-reuse scout
 // (node mq5thyli) found (findings-viewer-reuse.md §Q2). These deliberately drive
@@ -25,13 +25,10 @@ import { spawnSync } from 'node:child_process';
 import { tmpdir } from 'node:os';
 import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { createAgentSessionServices, createAgentSessionFromServices, SessionManager, VERSION, } from '../runtime/broker-sdk.js';
-import { buildBrokerSession, makeBrokerUiContext, isLeadingEngineCommand, resolveSteerCall, chooseGuidanceDeliveryMode, promptWithNextTurnGuidance, isHiddenJsonlBranchEntry, stripHiddenEntriesFromJsonlExport, engineLeadingCommandTokens, } from '../runtime/broker.js';
-import { CANVAS_EXTENSIONS } from '../runtime/launch.js';
-import { buildRefInventory } from '../memory/inline-ref-inventory.js';
-import { buildGuidance } from '../memory/inline-ref-guidance.js';
-import { resetScopeCache } from '../scope.js';
-import { clearSessionCache } from '../substrate/session-cache.js';
+import { createAgentSessionServices, createAgentSessionFromServices, SessionManager, VERSION, } from '../../runtime/broker-sdk.js';
+import { buildBrokerSession, makeBrokerUiContext } from '../../runtime/broker.js';
+import { isLeadingEngineCommand, resolveSteerCall, chooseGuidanceDeliveryMode, promptWithNextTurnGuidance, isHiddenJsonlBranchEntry, stripHiddenEntriesFromJsonlExport, engineLeadingCommandTokens, } from '../../runtime/broker/frame-dispatch.js';
+import { CANVAS_EXTENSIONS } from '../../runtime/launch.js';
 // The REAL engine, assembled from broker-sdk's static SDK re-exports — bypasses
 // the CRTR_BROKER_ENGINE seam entirely so these tests can never accidentally hit
 // the fake (the whole point: prove the wiring the mock hid).
@@ -41,7 +38,7 @@ const realEngine = {
     SessionManager,
     VERSION,
 };
-const HERE = dirname(fileURLToPath(import.meta.url));
+const HERE = join(dirname(fileURLToPath(import.meta.url)), '..');
 const C3_EXT = join(HERE, 'fixtures', 'c3-custom-provider-ext.ts');
 const C5_EXT = join(HERE, 'fixtures', 'c5-command-boundary-ext.ts');
 const priorModelIntent = process.env['CRTR_MODEL_INTENT'];
@@ -161,9 +158,9 @@ function runIsolatedManagedLaunch(pool) {
     const home = mkdtempSync(join(tmpdir(), 'crtr-c3-managed-home-'));
     const cwd = mkdtempSync(join(tmpdir(), 'crtr-c3-managed-cwd-'));
     const script = `
-    const { createAgentSessionServices, createAgentSessionFromServices, SessionManager, VERSION } = await import(${JSON.stringify(new URL('../runtime/broker-sdk.ts', import.meta.url).href)});
-    const { buildBrokerSession } = await import(${JSON.stringify(new URL('../runtime/broker.ts', import.meta.url).href)});
-    const { writeSubscriptionPool } = await import(${JSON.stringify(new URL('../subscription-state.ts', import.meta.url).href)});
+    const { createAgentSessionServices, createAgentSessionFromServices, SessionManager, VERSION } = await import(${JSON.stringify(new URL('../../runtime/broker-sdk.ts', import.meta.url).href)});
+    const { buildBrokerSession } = await import(${JSON.stringify(new URL('../../runtime/broker.ts', import.meta.url).href)});
+    const { writeSubscriptionPool } = await import(${JSON.stringify(new URL('../../subscription-state.ts', import.meta.url).href)});
     await writeSubscriptionPool('anthropic', ${JSON.stringify(pool)});
     const realEngine = { createAgentSessionServices, createAgentSessionFromServices, SessionManager, VERSION };
     const engine = {
@@ -358,14 +355,13 @@ test('M2 — a forwarded dialog stays pending when its writable viewer detaches,
     assert.equal(pending.size, 0, 'M2: the pending registry is drained after the timeout');
 });
 // ===========================================================================
-// C5 — inline memory-reference read-op, memoized inventory + reload
-// invalidation, exact leading engine-command suppression, and hidden
-// display:false guidance delivery ordering.
+// C5 — exact leading engine-command suppression and hidden display:false
+// guidance delivery ordering.
 //
 // REACHABILITY NOTE: broker.ts's `handleFrame`/`driveEngine` switches are
-// private closures inside `runBroker`, so the fast tier does not boot a broker
-// process to drive raw wire frames (that end-to-end plumbing lives in the
-// full/ tier alongside the sibling `list_models` read-op). Instead every
+// private closures inside `runBroker`, so this serialized source suite does not
+// boot a broker process to drive raw wire frames (that end-to-end plumbing lives
+// in the compiled seam alongside the sibling `list_models` read-op). Instead every
 // EXPORTED building block those closures call is driven directly — the pure
 // decision functions (`isLeadingEngineCommand`, `chooseGuidanceDeliveryMode`,
 // `engineLeadingCommandTokens`) AND the stateful delivery/export helpers
@@ -374,41 +370,10 @@ test('M2 — a forwarded dialog stays pending when its writable viewer detaches,
 // JSONL bytes, including the exact interception/leak window (Major 1) and the
 // actual exported file (Major 2). What remains untested here is only the
 // one-line frame relay (`sendFrame(client, buildListMemoryRefsData(id))`), a
-// verbatim sibling of the full-tier-covered `list_models` dispatch whose only
+// verbatim sibling of the compiled-seam-covered `list_models` dispatch whose only
 // non-trivial input, `engineLeadingCommandTokens(session)`, is proven below
 // against a real session.
 // ===========================================================================
-test('C5 — isLeadingEngineCommand truth table against structural stubs (pure, no live session)', () => {
-    // Extension command: matches / does not match.
-    const extOnly = { extensionRunner: { getCommand: (name) => (name === 'dev' ? { name: 'dev' } : undefined) } };
-    assert.equal(isLeadingEngineCommand('/dev', extOnly), true, 'registered extension command matches');
-    assert.equal(isLeadingEngineCommand('/dev extra args', extOnly), true, 'space-separated still matches (name up to first space)');
-    assert.equal(isLeadingEngineCommand('/nope', extOnly), false, 'unregistered command name does not match');
-    // Skill: matches / does not match.
-    const skillOnly = { resourceLoader: { getSkills: () => ({ skills: [{ name: 'myskill' }] }) } };
-    assert.equal(isLeadingEngineCommand('/skill:myskill', skillOnly), true, 'registered skill matches');
-    assert.equal(isLeadingEngineCommand('/skill:other', skillOnly), false, 'unregistered skill name does not match');
-    // Template: matches / does not match.
-    const templateOnly = { promptTemplates: [{ name: 'mytemplate' }] };
-    assert.equal(isLeadingEngineCommand('/mytemplate', templateOnly), true, 'registered prompt template matches');
-    assert.equal(isLeadingEngineCommand('/other', templateOnly), false, 'unregistered template name does not match');
-    // Prose with no leading slash never matches any of the three checks.
-    assert.equal(isLeadingEngineCommand('no leading slash here /dev', extOnly), false, 'a leading command check only looks at text start');
-    // An engine missing an accessor entirely degrades to "not a match", never throws.
-    assert.equal(isLeadingEngineCommand('/dev', {}), false, 'a bare {} session (no accessors) degrades to false without throwing');
-    // A throwing accessor for one check must not abort the OTHER independent
-    // checks — here extensionRunner.getCommand throws, but the SAME text still
-    // correctly resolves via promptTemplates.
-    const throwingExtButRealTemplate = {
-        extensionRunner: {
-            getCommand: () => {
-                throw new Error('boom: no live extensionRunner');
-            },
-        },
-        promptTemplates: [{ name: 'mytemplate' }],
-    };
-    assert.equal(isLeadingEngineCommand('/mytemplate', throwingExtButRealTemplate), true, 'a throwing extensionRunner check degrades to false for ITSELF but does not abort the template check');
-});
 test('a streaming extension command uses prompt preflight instead of the rejecting steer queue', () => {
     const session = { extensionRunner: { getCommand: (name) => (name === 'recap' ? { name: 'recap' } : undefined) } };
     assert.equal(resolveSteerCall('/recap', session), 'prompt');
@@ -420,9 +385,8 @@ test('C5 — isLeadingEngineCommand against a REAL session (registered extension
     // (the real broker's initial-boot step, which fires `resources_discover`) —
     // not reachable from `buildBrokerSession` alone, and driving it directly
     // pulls in this machine's full local pi resource corpus (slow, environment-
-    // dependent). Those two branches are covered structurally instead, in the
-    // stub-based truth-table test above — same decision logic, same code path,
-    // proven against a plain object shaped like the real accessors.
+    // dependent). The skill/prompt-template branches run the same accessor-
+    // guarded decision logic as the extension-command branch proven here.
     const cwd = mkdtempSync(join(tmpdir(), 'crtr-c5-cmd-'));
     try {
         const { session } = await buildBrokerSession(realEngine, cfg(cwd, { extensionPaths: [C3_EXT, C5_EXT], model: 'c3prov/c3model' }));
@@ -454,77 +418,6 @@ test('C5 — chooseGuidanceDeliveryMode truth table (pure)', () => {
     // steer, never nextTurn (that would attach guidance to a later, unrelated turn).
     assert.equal(chooseGuidanceDeliveryMode('prompt', 'prompt', true), 'steer');
 });
-test('C5 — buildRefInventory reflects a new doc only after clearSessionCache (the invalidation contract `case \'reload\'` relies on)', () => {
-    const canvasHome = mkdtempSync(join(tmpdir(), 'crtr-c5-inv-canvas-'));
-    const userHome = mkdtempSync(join(tmpdir(), 'crtr-c5-inv-user-'));
-    const projectBase = mkdtempSync(join(tmpdir(), 'crtr-c5-inv-project-'));
-    const projectRoot = join(projectBase, 'root');
-    const prevCanvasHome = process.env['CRTR_HOME'];
-    const prevUserHome = process.env['HOME'];
-    const prevNodeId = process.env['CRTR_NODE_ID'];
-    const prevCwd = process.cwd();
-    try {
-        mkdirSync(projectRoot, { recursive: true });
-        process.env['CRTR_HOME'] = canvasHome;
-        process.env['HOME'] = userHome;
-        delete process.env['CRTR_NODE_ID'];
-        process.chdir(projectRoot);
-        resetScopeCache();
-        clearSessionCache();
-        const memoryDir = join(projectRoot, '.crouter', 'memory');
-        mkdirSync(memoryDir, { recursive: true });
-        writeFileSync(join(memoryDir, 'crtr-c5-inv-first.md'), '---\nkind: knowledge\n---\nBody.\n');
-        const first = buildRefInventory();
-        assert.ok(first.names.has('crtr-c5-inv-first'), 'the first doc is visible on the first build');
-        // A second doc written after the first inventory build must NOT appear
-        // until the session parse cache is cleared — this is the exact mechanism
-        // broker.ts's `case 'reload'` invalidates by calling `clearSessionCache()`
-        // (and, in broker.ts, also resetting its own `memoizedRefInventory`).
-        writeFileSync(join(memoryDir, 'crtr-c5-inv-second.md'), '---\nkind: knowledge\n---\nBody.\n');
-        const stale = buildRefInventory();
-        assert.ok(!stale.names.has('crtr-c5-inv-second'), 'a doc written after the cache was warmed is NOT yet visible');
-        clearSessionCache();
-        const fresh = buildRefInventory();
-        assert.ok(fresh.names.has('crtr-c5-inv-second'), 'clearSessionCache() makes the new doc visible — the reload contract');
-    }
-    finally {
-        process.chdir(prevCwd);
-        resetScopeCache();
-        clearSessionCache();
-        rmSync(canvasHome, { recursive: true, force: true });
-        rmSync(userHome, { recursive: true, force: true });
-        rmSync(projectBase, { recursive: true, force: true });
-        if (prevCanvasHome === undefined)
-            delete process.env['CRTR_HOME'];
-        else
-            process.env['CRTR_HOME'] = prevCanvasHome;
-        if (prevUserHome === undefined)
-            delete process.env['HOME'];
-        else
-            process.env['HOME'] = prevUserHome;
-        if (prevNodeId === undefined)
-            delete process.env['CRTR_NODE_ID'];
-        else
-            process.env['CRTR_NODE_ID'] = prevNodeId;
-    }
-});
-test('C5 — guidance composition mirrors broker.ts\'s private resolveFrameGuidance: leading-command check first, then buildGuidance', () => {
-    // Mirrors broker.ts's private `resolveFrameGuidance(text)`:
-    //   if (isLeadingEngineCommand(text, session)) return null;
-    //   return buildGuidance(text, getRefInventory().names);
-    // `isLeadingEngineCommand`/`buildGuidance` are each independently covered
-    // above / in C4's own suite (inline-memory-refs.test.ts) — this proves only
-    // the ORDER of composition: a leading match short-circuits before any ref
-    // in the SAME text is ever resolved.
-    const stubSession = { extensionRunner: { getCommand: () => undefined } };
-    const names = new Set(['dev']);
-    assert.equal(isLeadingEngineCommand('/dev /dev', stubSession), false, 'not a registered command against this stub');
-    assert.equal(buildGuidance('/dev /dev', names), [
-        'The human explicitly referenced these memory documents. Before acting on the portion of their message that references each document, run the corresponding command and treat its returned content as authoritative context:',
-        '- crtr memory read dev',
-    ].join('\n'), 'a non-leading-command text with a resolvable ref still produces guidance');
-    assert.equal(buildGuidance('/nope has nothing to do with it', names), null, 'an unresolvable ref alone produces no guidance');
-});
 test('C5 — fake-engine sendCustomMessage records the call in order without crashing', async () => {
     const home = mkdtempSync(join(tmpdir(), 'crtr-c5-fake-home-'));
     const cwd = mkdtempSync(join(tmpdir(), 'crtr-c5-fake-cwd-'));
@@ -533,7 +426,7 @@ test('C5 — fake-engine sendCustomMessage records the call in order without cra
     try {
         process.env['CRTR_HOME'] = home;
         process.env['CRTR_NODE_ID'] = 'crtr-c5-fake-node';
-        const fake = await import('./fixtures/fake-engine.js');
+        const fake = await import('.././fixtures/fake-engine.js');
         const services = await fake.createAgentSessionServices({ cwd });
         const sessionManager = fake.SessionManager.create(cwd);
         const { session } = await fake.createAgentSessionFromServices({ services, sessionManager });
@@ -609,27 +502,6 @@ test('promptWithNextTurnGuidance uses a structured-clone-safe cleanup marker', a
     await promptWithNextTurnGuidance(session, 'crtr memory read dev', async () => undefined);
     assert.deepEqual(pending, [], 'clone-safe marker still identifies and clears exactly its own pending entry');
 });
-test('Major 1 fix — pre-fix sequence (sendCustomMessage THEN prompt, no cleanup) reproduces the leak this fix removes', async () => {
-    // Negative control: proves the fixture/interception setup above genuinely
-    // exercises the leak window — the OLD sequencing (what driveEngine did
-    // before this fix) strands the guidance under the exact same interception.
-    const cwd = mkdtempSync(join(tmpdir(), 'crtr-m1-repro-'));
-    try {
-        const { session } = await buildBrokerSession(realEngine, cfg(cwd, { extensionPaths: [C5_EXT] }));
-        try {
-            await session.sendCustomMessage({ customType: 'crtr-memory-refs', content: 'guidance', display: false }, { deliverAs: 'nextTurn' });
-            await session.prompt('/devcmd', {});
-            const pending = session._pendingNextTurnMessages;
-            assert.equal(pending.length, 1, 'Major 1 (control): the pre-fix sequence strands exactly the guidance message it pushed');
-        }
-        finally {
-            session.dispose();
-        }
-    }
-    finally {
-        rmSync(cwd, { recursive: true, force: true });
-    }
-});
 test('Major 1 fix — promptWithNextTurnGuidance leaves the queue drained (not doubly-cleared) on a normal successful prompt', async () => {
     // Guards against the cleanup over-firing on the HAPPY path: a prompt that
     // genuinely reaches pi's drain already empties `_pendingNextTurnMessages`
@@ -718,22 +590,6 @@ test('Major 2 fix — exportToJsonl (via the broker export path) strips display:
 // (RefMeta rows), exactly matching `isLeadingEngineCommand`'s three sources,
 // so viewers can combine it with their own locally-consumed commands.
 // ===========================================================================
-test('Major 6 (broker half) — engineLeadingCommandTokens exactly matches isLeadingEngineCommand\'s sources (round-trip, pure stubs)', () => {
-    const session = {
-        extensionRunner: {
-            getRegisteredCommands: () => [{ invocationName: 'devcmd' }],
-            getCommand: (n) => (n === 'devcmd' ? {} : undefined),
-        },
-        resourceLoader: { getSkills: () => ({ skills: [{ name: 'myskill' }] }) },
-        promptTemplates: [{ name: 'mytemplate' }],
-    };
-    const tokens = engineLeadingCommandTokens(session);
-    assert.deepEqual(new Set(tokens), new Set(['devcmd', 'skill:myskill', 'mytemplate']), 'every one of the three sources is enumerated, in isLeadingEngineCommand\'s own token shape');
-    for (const token of tokens) {
-        assert.equal(isLeadingEngineCommand(`/${token}`, session), true, `emitted token "${token}" round-trips through isLeadingEngineCommand as a leading match`);
-    }
-    assert.equal(isLeadingEngineCommand('/nope', session), false, 'a name NOT in the enumeration correctly does not match');
-});
 test('Major 6 (broker half) — engineLeadingCommandTokens degrades to empty per-source without throwing, and never touches refs/RefMeta shape', () => {
     assert.deepEqual(engineLeadingCommandTokens({}), [], 'a bare session with no accessors at all degrades to an empty enumeration');
     const throwingExtButRealTemplate = {

package/dist/core/__tests__/{broker-snapshot-history.test.js → serial/broker-snapshot-history.test.js}

@@ -1,4 +1,4 @@
-// Run with: node --import tsx/esm --test src/core/__tests__/broker-snapshot-history.test.ts
+// Run with: npm run test:serial
 //
 // BUG-REGRESSION (real, observed; surfaced during the crouter-web build, proven
 // broker-side). After a revive resumes a previously-CLOSED pi session, the
@@ -29,19 +29,19 @@ import { mkdtempSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { createAgentSessionServices, createAgentSessionFromServices, SessionManager, VERSION, } from '../runtime/broker-sdk.js';
-import { CANVAS_EXTENSIONS } from '../runtime/launch.js';
-import { buildBrokerSession, snapshotMessages } from '../runtime/broker.js';
-import { createNode } from '../canvas/canvas.js';
-import { closeDb } from '../canvas/db.js';
-import { transcriptMarkdown } from '../runtime/node-read.js';
+import { createAgentSessionServices, createAgentSessionFromServices, SessionManager, VERSION, } from '../../runtime/broker-sdk.js';
+import { CANVAS_EXTENSIONS } from '../../runtime/launch.js';
+import { buildBrokerSession, snapshotMessages } from '../../runtime/broker.js';
+import { createNode } from '../../canvas/canvas.js';
+import { closeDb } from '../../canvas/db.js';
+import { transcriptMarkdown } from '../../runtime/node-read.js';
 // M-9 (broker.ts fault-and-die model gate): a boot with no cfg.model now calls
 // the REAL SDK's modelRegistry.getAvailable() and faults if it's empty, which it
 // always is on a host/CI runner with no authenticated provider. This test only
 // exercises snapshot/history reconstruction, so it registers the same hermetic
 // fake-but-authenticated model the C3 wiring tests use instead of depending on
 // ambient host credentials (see broker-sdk-wiring's c3-custom-provider-ext.ts).
-const HERE = dirname(fileURLToPath(import.meta.url));
+const HERE = join(dirname(fileURLToPath(import.meta.url)), '..');
 const C3_EXT = join(HERE, 'fixtures', 'c3-custom-provider-ext.ts');
 const realEngine = {
     createAgentSessionServices,
@@ -66,7 +66,7 @@ function assistantMsg(text, stopReason = 'stop') {
         timestamp: Date.now(),
     };
 }
-// 30s (approved in scripts/test-runner.mjs): this boot loads the REAL mandatory
+// 30s: this boot loads the REAL mandatory
 // canvas extension set from TypeScript sources, and those extensions pull the
 // crouter module graph through tsx for the first time in the process — ~6s of
 // the ~9s local runtime, and 12.6s total on a hosted runner, which blew the