@north-light/crouter 0.3.173 → 0.3.174

package/dist/core/__tests__/spawn-no-kickoff.test.js

@@ -1,115 +0,0 @@
-// spawnChild({ prompt: '' }) — the no-kickoff path `node new --root --no-kickoff`
-// rides. An empty prompt reaches buildPiArgv as `undefined`-equivalent, so the
-// broker comes up idle and goal-less. Fork identity is carried by the canonical
-// session-start bearings message rather than by either kickoff shape.
-import { test, before, after, beforeEach } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { createServer } from 'node:net';
-import { getNode } from '../canvas/canvas.js';
-import { closeDb } from '../canvas/db.js';
-import { nodeDir } from '../canvas/paths.js';
-import { readGoal } from '../runtime/kickoff.js';
-import { spawnChild } from '../runtime/spawn.js';
-import { headlessBrokerHost } from '../runtime/host.js';
-let home;
-before(() => {
-    // Unix-domain socket paths are capped at ~104 bytes on macOS; keep the canvas
-    // home short (mirrors spawn-root.test.ts) since readiness now opens a real
-    // view.sock under it.
-    home = mkdtempSync('/tmp/crtr-no-kickoff-');
-    process.env['CRTR_HOME'] = home;
-});
-beforeEach(() => {
-    closeDb();
-    rmSync(home, { recursive: true, force: true });
-});
-after(() => {
-    closeDb();
-    rmSync(home, { recursive: true, force: true });
-});
-/** Mock the broker host to capture the argv/env it would have launched pi with,
- *  and hand back a real listening view.sock so `readiness: 'await'` resolves. */
-function captureLaunch() {
-    const original = headlessBrokerHost.launch;
-    const invocations = [];
-    const servers = [];
-    headlessBrokerHost.launch = (nodeId, inv, _opts) => {
-        invocations.push(inv);
-        const server = createServer();
-        servers.push(server);
-        server.listen(join(nodeDir(nodeId), 'view.sock'));
-        return { pid: process.pid, exited: new Promise(() => { }) };
-    };
-    return {
-        invocations,
-        servers,
-        restore: () => {
-            headlessBrokerHost.launch = original;
-        },
-    };
-}
-test('no-kickoff root: no positional prompt reaches pi argv, and no goal is persisted', async () => {
-    // buildPiArgv's shape (extensions, -n label, --model, --tools,
-    // --append-system-prompt <per-node path>, ...) is identical between a
-    // no-kickoff and a real-kickoff spawn of the same kind/mode — the ONLY
-    // structural difference a real prompt adds is exactly one trailing argv
-    // token (the positional prompt itself). Comparing argv LENGTH between two
-    // otherwise-identical spawns proves that, without hardcoding flag order/
-    // count assumptions that would drift if buildPiArgv's flag set changes.
-    const cwdNoKickoff = mkdtempSync(join(tmpdir(), 'crtr-no-kickoff-cwd-'));
-    const cwdWithKickoff = mkdtempSync(join(tmpdir(), 'crtr-with-kickoff-cwd-'));
-    const cap = captureLaunch();
-    try {
-        const result = await spawnChild({ kind: 'general', cwd: cwdNoKickoff, root: true, readiness: 'await', prompt: '' });
-        await spawnChild({ kind: 'general', cwd: cwdWithKickoff, root: true, readiness: 'await', prompt: 'hello there' });
-        assert.equal(cap.invocations.length, 2, 'both broker launches happened');
-        const argvNoKickoff = cap.invocations[0].argv;
-        const argvWithKickoff = cap.invocations[1].argv;
-        assert.equal(argvNoKickoff.length + 1, argvWithKickoff.length, 'a real kickoff adds EXACTLY one extra argv token (the prompt) vs. no-kickoff');
-        assert.equal(argvWithKickoff[argvWithKickoff.length - 1], 'hello there', 'the real kickoff prompt rides as the trailing positional');
-        assert.notEqual(argvNoKickoff[argvNoKickoff.length - 1], 'hello there', 'the no-kickoff argv carries no trailing prompt token');
-        assert.equal(readGoal(result.node.node_id), null, 'no goal file was written for an empty (no-kickoff) prompt');
-        assert.equal(getNode(result.node.node_id)?.status, 'active', 'the node still comes up active/idle, ready for a real first prompt');
-    }
-    finally {
-        cap.restore();
-        await Promise.all(cap.servers.filter((s) => s.listening).map((s) => new Promise((resolve) => s.close(() => resolve()))));
-        rmSync(cwdNoKickoff, { recursive: true, force: true });
-        rmSync(cwdWithKickoff, { recursive: true, force: true });
-    }
-});
-test('fork-from keeps identity out of the task prompt with or without kickoff', async () => {
-    const cwdNoKickoff = mkdtempSync(join(tmpdir(), 'crtr-no-kickoff-fork-cwd-'));
-    const cwdWithKickoff = mkdtempSync(join(tmpdir(), 'crtr-kickoff-fork-cwd-'));
-    const seedPathNoKickoff = join(cwdNoKickoff, 'seed.jsonl');
-    const seedPathWithKickoff = join(cwdWithKickoff, 'seed.jsonl');
-    writeFileSync(seedPathNoKickoff, '{"type":"session"}\n');
-    writeFileSync(seedPathWithKickoff, '{"type":"session"}\n');
-    const cap = captureLaunch();
-    try {
-        await spawnChild({ kind: 'general', cwd: cwdNoKickoff, root: true, readiness: 'await', prompt: '', forkFrom: seedPathNoKickoff });
-        await spawnChild({ kind: 'general', cwd: cwdWithKickoff, root: true, readiness: 'await', prompt: 'continue please', forkFrom: seedPathWithKickoff });
-        assert.equal(cap.invocations.length, 2, 'both broker launches happened');
-        const argvNoKickoff = cap.invocations[0].argv;
-        const argvWithKickoff = cap.invocations[1].argv;
-        // Both still fork the seeded history through to pi verbatim.
-        assert.ok(argvNoKickoff.includes('--fork'), 'the no-kickoff fork source still rides through to pi');
-        assert.ok(argvNoKickoff.includes(seedPathNoKickoff), 'the resolved seed path is the no-kickoff fork source');
-        assert.ok(argvWithKickoff.includes('--fork'), 'the real-kickoff fork source still rides through to pi');
-        assert.ok(argvWithKickoff.includes(seedPathWithKickoff), 'the resolved seed path is the real-kickoff fork source');
-        // A real kickoff carries exactly the user's task. The session-start
-        // bearings message owns fork identity for both prompt shapes.
-        const trailingWithKickoff = argvWithKickoff[argvWithKickoff.length - 1];
-        assert.equal(trailingWithKickoff, 'continue please', 'the real fork kickoff is the unmodified user task');
-        assert.notEqual(argvNoKickoff[argvNoKickoff.length - 1], trailingWithKickoff, 'the no-kickoff fork carries no task prompt');
-    }
-    finally {
-        cap.restore();
-        await Promise.all(cap.servers.filter((s) => s.listening).map((s) => new Promise((resolve) => s.close(() => resolve()))));
-        rmSync(cwdNoKickoff, { recursive: true, force: true });
-        rmSync(cwdWithKickoff, { recursive: true, force: true });
-    }
-});

package/dist/core/__tests__/steer-note.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/core/__tests__/steer-note.test.js

@@ -1,41 +0,0 @@
-// Run: node --import tsx/esm --test src/core/__tests__/steer-note.test.ts
-//
-// Context-size steering text (canvas-stophook `steerNote`) is keyed on MODE
-// first, then LIFECYCLE — NOT on lifecycle alone. The key regression this
-// guards: a TERMINAL/ORCHESTRATOR must get roadmap-checkpoint-and-yield
-// guidance (it has a roadmap), never the worker "push final" text.
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { steerNote } from '../../pi-extensions/canvas-stophook.js';
-test('an orchestrator (terminal) is steered to checkpoint roadmap + yield, never push final', () => {
-    const msg = steerNote(150_000, 'terminal', 'orchestrator');
-    assert.match(msg, /roadmap\.md/, 'points at the roadmap to checkpoint');
-    assert.match(msg, /node yield/, 'steers it to yield');
-    assert.doesNotMatch(msg, /push final/, 'an orchestrator never finishes with push final');
-});
-test('an orchestrator (resident) gets the same roadmap/yield steering as a terminal orchestrator', () => {
-    const t = steerNote(150_000, 'terminal', 'orchestrator');
-    const r = steerNote(150_000, 'resident', 'orchestrator');
-    assert.equal(r, t, 'mode drives the message, not lifecycle');
-});
-test('a terminal BASE worker is steered to yield-or-finish, never at a bare promote', () => {
-    const msg = steerNote(170_000, 'terminal', 'base');
-    assert.match(msg, /node yield/, 'a base worker is told to yield to continue (mode-preserving — no auto-promote)');
-    assert.match(msg, /push final/, 'and to finish with push final when close');
-    assert.doesNotMatch(msg, /node promote/, 'never the heavy "become an orchestrator" framing that bred yield-avoidance');
-    assert.doesNotMatch(msg, /roadmap\.md/, 'a base worker has no roadmap.md to checkpoint');
-});
-test('a resident BASE root is steered to yield-or-wrap-up, never at a bare promote or roadmap', () => {
-    const msg = steerNote(150_000, 'resident', 'base');
-    assert.match(msg, /node yield/, 'a root growing into a job is told to yield (mode-preserving — no auto-promote)');
-    assert.doesNotMatch(msg, /node promote/, 'never the heavy "become an orchestrator" framing');
-    assert.doesNotMatch(msg, /roadmap\.md/, 'a root has no roadmap.md to point at');
-    assert.doesNotMatch(msg, /push final/, 'a resident node never finishes with push final');
-});
-test('below the first band there is no nudge boundary issue — pushy escalation kicks in at 185k', () => {
-    // Sanity: the orchestrator branch escalates (pushy) at/after 185k.
-    const firm = steerNote(150_000, 'terminal', 'orchestrator');
-    const pushy = steerNote(185_000, 'terminal', 'orchestrator');
-    assert.notEqual(firm, pushy, 'the 185k band reads differently from the 150k band');
-    assert.match(pushy, /overflow/i, 'the pushy band warns about overflow');
-});

package/dist/core/__tests__/subcommand-tier.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/core/__tests__/subcommand-tier.test.js

@@ -1,99 +0,0 @@
-// Tests for the subcommand visibility tier (hidden | normal | common | important)
-// and the parent-level listing affordance.
-// Run with: node --import tsx/esm --test src/core/__tests__/subcommand-tier.test.ts
-//
-// Contract:
-//  - Each child def (defineLeaf/defineBranch) owns its own description /
-//    whenToUse / tier; defineBranch assembles `help.listing` from those defs —
-//    the parent never copies a child's self-description (principle 16).
-//  - renderRoot promotes a subtree's `important` children (name + shortform
-//    desc) and `common` children (bare qualified path) into that command's
-//    block, then names how many other non-hidden subcommands stay behind
-//    `crtr <name> -h`.
-//  - `hidden` children never appear (not even in the subtree's own -h) and are
-//    not counted in any "[+N]" remainder.
-//  - renderBranch renders one self-closing <subcommand> per non-hidden child
-//    and adds a `subcommands="N"` attribute when a branch child owns children.
-import { test, describe } from 'node:test';
-import assert from 'node:assert/strict';
-import { defineRoot, defineBranch, defineLeaf } from '../command.js';
-import { renderRoot, renderBranch } from '../help.js';
-const leaf = (name, opts = {}) => defineLeaf({
-    name,
-    description: opts.description,
-    whenToUse: opts.whenToUse,
-    tier: opts.tier,
-    help: { name, summary: name, output: [], outputKind: 'object', effects: ['None. Read-only.'] },
-    run: async () => ({}),
-});
-// A nested branch so we can assert the `subcommands="N"` depth flag. Its own
-// parent-level self-description (description/whenToUse) lives on the def, as a
-// sibling of `name`.
-const inspect = defineBranch({
-    name: 'inspect',
-    description: 'inspect things',
-    whenToUse: 'x',
-    help: { name: 'thing inspect', summary: 'inspect' },
-    children: [
-        leaf('list', { description: 'list', whenToUse: 'x' }),
-        leaf('show', { description: 'show', whenToUse: 'x' }),
-    ],
-});
-const thing = defineBranch({
-    name: 'thing',
-    rootEntry: { concept: 'a thing', desc: 'things', useWhen: 'doing things' },
-    help: { name: 'thing', summary: 'do things' },
-    children: [
-        leaf('make', { description: 'make a thing', whenToUse: 'x', tier: 'important' }),
-        leaf('promote', { description: 'promote a thing', whenToUse: 'x', tier: 'common' }),
-        inspect,
-        leaf('secret', { description: 'secret op', whenToUse: 'x', tier: 'hidden' }),
-        leaf('plain', { description: 'plain op', whenToUse: 'x' }),
-    ],
-});
-const root = defineRoot({ tagline: 'test runtime', globals: [], subtrees: [thing] });
-describe('renderRoot: subcommand promotion', () => {
-    const out = renderRoot(root.help);
-    test('important child surfaces with its shortform desc', () => {
-        assert.match(out, /\n {2}thing make {2,}make a thing\n/);
-    });
-    test('common child surfaces as a bare qualified path (no desc)', () => {
-        assert.match(out, /\n {2}thing promote\n/);
-        assert.doesNotMatch(out, /thing promote {2,}promote a thing/);
-    });
-    test('hidden child is never promoted and not counted', () => {
-        assert.doesNotMatch(out, /secret/);
-        // 5 children, 1 hidden => 4 listable, 2 promoted => 2 remaining.
-        assert.match(out, /\[\+2 other subcommands — `crtr thing -h`\]/);
-    });
-});
-describe('renderRoot: commands with no promotions', () => {
-    test('still advertise their subcommand count', () => {
-        const bare = defineBranch({
-            name: 'bare',
-            rootEntry: { concept: 'bare', desc: 'bare', useWhen: 'x' },
-            help: { name: 'bare', summary: 'bare' },
-            children: [leaf('one', { description: 'one', whenToUse: 'x' })],
-        });
-        const r = defineRoot({ tagline: 't', globals: [], subtrees: [bare] });
-        const out = renderRoot(r.help);
-        assert.match(out, /\[\+1 subcommand — `crtr bare -h`\]/); // singular, no "other"
-    });
-});
-describe('renderBranch: hidden filter + depth flag (XML)', () => {
-    const out = renderBranch(thing.help);
-    test('hidden child is dropped from the branch listing', () => {
-        assert.doesNotMatch(out, /secret/);
-    });
-    test('all non-hidden children are listed as <subcommand> rows', () => {
-        for (const n of ['make', 'promote', 'inspect', 'plain']) {
-            assert.match(out, new RegExp(`name="${n}"`));
-        }
-    });
-    test('a branch child flags how many subcommands it owns', () => {
-        assert.match(out, /name="inspect"[^>]*subcommands="2"/);
-    });
-    test('leaf children carry no subcommand flag', () => {
-        assert.doesNotMatch(out, /name="make"[^>]*subcommands=/);
-    });
-});

package/dist/core/__tests__/subscription-delivery.test.js

@@ -1,211 +0,0 @@
-// Run with: node --import tsx/esm --test src/core/__tests__/subscription-delivery.test.ts
-//
-// MULTI-LEVEL SUBSCRIPTION DELIVERY — the DELIVERY-vs-WAKE distinction across a
-// graph >=2 levels deep. The whole split is pure canvas/feed/daemon model logic,
-// so this is driven by FABRICATING the topology + dormant states directly
-// (foundation-spec §E.2) and exercising the real model layer (feed.push,
-// evaluateStop, superviseTick) — NO real tmux session, NO pane chrome, and NO
-// real broker boot (which would cost ~5s each). Every assertion reads the canvas
-// data layer and is checked against the state-model ORACLE (§3b, §5, §6).
-//
-// HEADLESS / FABRICATED RETARGET (foundation-spec §C.15 + §E). All nodes are
-// broker-hosted (paneless). Dormancy, which a tmux node shows as a closed pane,
-// a broker shows as an EXITED process (status=idle, intent=idle-release, pi_pid
-// dead) — fabricated directly. A daemon revive is observed via getNode().cycles
-// (reviveNode bumps cycles + transition('revive') BEFORE it spawns — revive.ts:
-// 114,145 — so the model effect is instant, no awaitBoot), never a real boot.
-//
-// (1) BUG LOCKED — the DELIVERY-vs-WAKE split (Invariant D + stop-guard): an
-//     ACTIVE subscriber's pointer lands in inbox.jsonl and the daemon's 2nd pass
-//     REVIVES it on that unseen entry; a PASSIVE subscriber's pointer lands in
-//     passive.jsonl and NEVER wakes; a PASSIVE-only tie does NOT legitimize an
-//     idle-release (hasActiveLiveSubscription filters active=1).
-// (2) WHY MODEL-LEVEL, NOT TMUX CHROME — routing (feed.ts), the active/passive
-//     edge filter (canvas.ts), the 2nd-pass inbox gate (crtrd.ts), and one-hop
-//     fan-out are all pure data-layer; the only thing a pane ever provided was a
-//     visible "dormant" signal, which a broker expresses as a dead pid — and
-//     which fabrication sets directly.
-// (3) HOW THE FABRICATED DRIVE STILL FAILS IF THE BUG REGRESSES — after T's
-//     pushFinal, one h.tick() must revive the ACTIVE subscriber B (cycles bumps,
-//     status→active) while the PASSIVE subscriber P stays idle with cycles==0. If
-//     inbox-vs-passive routing breaks, either B's entry never reaches its inbox
-//     (the 2nd-pass gate finds nothing → B not revived → cycles stays 0) or P
-//     gets an inbox entry and IS woken (its cycles/status asserts go RED).
-//     Verified by routing passive deliveries into the inbox (see bug-injection
-//     report).
-//
-// THE ORACLE CONTRACT under test:
-//   • feed.push fans to subscribersOf(target): active → inbox.jsonl (wakes),
-//     passive → passive.jsonl (accumulates, NEVER wakes). (state-model §5; feed.ts)
-//   • The daemon's 2nd pass revives an idle-released node ONLY on an unseen INBOX
-//     entry (crtrd.ts) — so a passive subscriber's idle-released node never wakes.
-//   • hasActiveLiveSubscription excludes passive edges (canvas.ts active=1) — a
-//     passive tie does NOT legitimize idle-release (stop-guard §3b).
-//   • Wake is ONE HOP per push: a push fans to DIRECT subscribers only; an indirect
-//     ancestor hears nothing until a middle node explicitly re-pushes. (state-model §5)
-//
-// Graph (>=2 levels; T is two hops under A):
-//        A  (resident root — the user's virtual front door)
-//        └── B  (terminal)         A→B active seed  ── ACTIVE subscriber of T
-//            ├── T  (terminal)     B→T active seed  ── THE TARGET (level 2)
-//            ├── K  (terminal)     B→K active seed  ── keepalive (stays active)
-//            └── P  (terminal)     B→P active seed  ── PASSIVE subscriber of T
-//                  P→T passive  (wired via subscribe(P,T,false))
-//                  P→K active   (the ONLY tie that legitimizes P's release;
-//                                P→T passive is excluded from the stop-guard)
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { spawnSync } from 'node:child_process';
-import { createHarness } from './helpers/harness.js';
-import { closeDb } from '../canvas/db.js';
-import { subscribe } from '../canvas/canvas.js';
-import { pushFinal, pushUpdate } from '../feed/feed.js';
-import { readPassive } from '../feed/passive.js';
-import { evaluateStop, STALL_REPROMPT } from '../runtime/stop-guard.js';
-// A pid reaped (dead) by the time spawnSync returns — a released broker's exited
-// process (the headless analog of a closed pane).
-function deadPid() {
-    const r = spawnSync('true', [], { stdio: 'ignore' });
-    return r.pid ?? 0x7ffffffe;
-}
-// LOCAL helper: read a node's PASSIVE accumulator (passive.jsonl) straight off
-// the data layer, mirroring the harness's own `inbox()` reader. The harness
-// exposes inbox() but NOT passive() — this fills that gap.
-function passive(nodeId) {
-    closeDb();
-    return readPassive(nodeId);
-}
-// `{node_id, active}` arrays → a stable comparable set of `id:active|passive`.
-function edgeSet(arr) {
-    return new Set(arr.map((e) => `${e.node_id}:${e.active ? 'active' : 'passive'}`));
-}
-test('multi-level subscription delivery: active subscriber WOKEN vs passive subscriber DELIVERED-not-woken, on the same dormant target', { timeout: 30_000 }, async () => {
-    const h = await createHarness({ headless: true, sessionPrefix: 'crtr-subdeliv' });
-    try {
-        // ===================================================================
-        // S1 — Build the graph by FABRICATION (no boots). A is a resident root
-        //      (inline, daemon-untouched); B/T/K/P/X are broker nodes whose
-        //      liveness fields are set directly. Each parent→child spine edge is
-        //      wired ACTIVE.
-        // ===================================================================
-        const A = h.spawnRoot('front door'); // resident root, active, no placement
-        // T (the target) and K (keepalive) are LIVE-active workers; B and P start
-        // already DORMANT (idle-released, broker exited = dead pid) — exactly the
-        // post-stop state the delivery split is judged against.
-        const T = h.fabricateBrokerNode({ status: 'active', pi_pid: deadPid(), pi_session_id: 'sess-T' });
-        const K = h.fabricateBrokerNode({ status: 'active', pi_pid: deadPid(), pi_session_id: 'sess-K' });
-        const B = h.fabricateBrokerNode({ status: 'idle', intent: 'idle-release', pi_pid: deadPid(), pi_session_id: 'sess-B' });
-        const P = h.fabricateBrokerNode({ status: 'idle', intent: 'idle-release', pi_pid: deadPid(), pi_session_id: 'sess-P' });
-        // Spine seeds: A→B, B→T, B→K, B→P all ACTIVE (subscriber, publisher).
-        subscribe(A, B, true);
-        subscribe(B, T, true);
-        subscribe(B, K, true);
-        subscribe(B, P, true);
-        // PASSIVE axis under test: P passively subscribes to T; P actively to K
-        // (the only tie that legitimizes P's own idle-release).
-        subscribe(P, T, false);
-        subscribe(P, K, true);
-        assert.deepEqual(edgeSet(h.subscribers(T)), new Set([`${B}:active`, `${P}:passive`]), 'T has B(active) + P(passive) as subscribers — the same-target split');
-        assert.deepEqual(edgeSet(h.subscribers(B)), new Set([`${A}:active`]), 'A→B active seed');
-        assert.deepEqual(edgeSet(h.subscriptions(P)), new Set([`${T}:passive`, `${K}:active`]), 'P subscribes_to T(passive) + K(active)');
-        // ===================================================================
-        // S2 — PASSIVE-EXCLUSION via the PURE stop-guard (the active/passive split
-        //      half). evaluateStop is pure given the canvas; X holds a PASSIVE-only
-        //      tie to the same live K that P holds ACTIVELY. hasActiveLiveSubscription
-        //      filters active=1 (canvas.ts), so X's passive K-tie is invisible →
-        //      'stalled' (STALL_REPROMPT); P's active K-tie → 'awaiting'. Same
-        //      publisher K, opposite outcome purely by edge mode (oracle §3b, §5).
-        // ===================================================================
-        const X = h.fabricateBrokerNode({ status: 'active' });
-        subscribe(X, K, false); // X→K PASSIVE-only — its ONLY subscription
-        assert.deepEqual(edgeSet(h.subscriptions(X)), new Set([`${K}:passive`]), 'X holds exactly one tie: K(passive) — no active live subscription');
-        {
-            const xStop = evaluateStop(X, { pushedFinal: false, askedHuman: false });
-            assert.equal(xStop.action, 'reprompt', 'X (passive-only) → reprompt, NOT awaiting');
-            assert.equal(xStop.reason, 'stalled', 'X classified stalled — passive tie does not hold it');
-            assert.equal(xStop.message, STALL_REPROMPT, 'X gets the stall re-prompt');
-            const pStop = evaluateStop(P, { pushedFinal: false, askedHuman: false });
-            assert.equal(pStop.action, 'allow', 'P (active K-tie) → allow');
-            assert.equal(pStop.reason, 'awaiting', 'P classified awaiting on its ACTIVE K-sub — the discriminating positive');
-        }
-        // Pre-push baseline: keepalive up, grandparent untouched, nothing delivered.
-        assert.equal(h.status(K), 'active', 'K active (keepalive holds P legitimately dormant)');
-        assert.equal(h.status(A), 'active', 'A (resident root) untouched');
-        assert.equal(h.inbox(A).length, 0, 'A inbox empty before the push');
-        assert.equal(h.inbox(B).length, 0, 'B inbox empty before the push');
-        assert.equal(passive(P).length, 0, 'P passive accumulator empty before the push');
-        assert.equal(h.node(B).cycles ?? 0, 0, 'B not yet revived');
-        assert.equal(h.node(P).cycles ?? 0, 0, 'P not yet revived');
-        // ===================================================================
-        // S3 — T FINISHES via the model layer (pushFinal). feed.push fans the
-        //      pointer to subscribersOf(T) = {B(active), P(passive)} ONLY, by the
-        //      delivery split: B's lands in inbox.jsonl, P's in passive.jsonl. A
-        //      (the grandparent, NOT a subscriber of T) gets NOTHING — one-hop.
-        // ===================================================================
-        const TARGET_FINAL = 'TARGET-FINAL-BODY: the worker completed';
-        await pushFinal(T, TARGET_FINAL);
-        closeDb();
-        {
-            assert.equal(h.status(T), 'done', 'T done after pushFinal (transition finalize)');
-            assert.equal(h.node(T).intent, 'done', 'T intent=done');
-            // ACTIVE delivery → B's INBOX (the wake channel).
-            const bFinal = h.inbox(B).find((e) => e.from === T && e.kind === 'final');
-            assert.ok(bFinal, 'ACTIVE subscriber B: T-final pointer DELIVERED to inbox.jsonl');
-            // PASSIVE delivery → P's ACCUMULATOR, NOT its inbox (no wake channel).
-            const pPassive = passive(P);
-            assert.equal(pPassive.length, 1, 'PASSIVE subscriber P: exactly one passive entry');
-            assert.equal(pPassive[0].from, T, "P's passive entry is from T");
-            assert.equal(pPassive[0].kind, 'final', "P's passive entry is the final");
-            assert.equal(h.inbox(P).length, 0, 'PASSIVE subscriber P: inbox.jsonl stays EMPTY (no wake channel)');
-            // ONE-HOP: the indirect ancestor and the non-subscriber sibling hear nothing.
-            assert.equal(h.inbox(A).length, 0, 'A (grandparent, not a subscriber of T) NOT delivered — one-hop');
-            assert.equal(h.inbox(K).length, 0, 'K (sibling, not a subscriber of T) NOT delivered');
-        }
-        // ===================================================================
-        // S4 — The DAEMON decision pass. Its 2nd pass revives an idle-released node
-        //      ONLY on an unseen INBOX entry. B has one (active) → REVIVED. P has
-        //      none (its entry went to passive.jsonl) → stays idle. The WAKE half
-        //      of delivery-vs-wake, decided in ONE tick — observed via cycles.
-        // ===================================================================
-        await h.tick();
-        // ACTIVE subscriber: WOKEN — reviveNode bumped cycles + transition(revive).
-        {
-            const b = h.node(B);
-            assert.equal(b.cycles ?? 0, 1, 'ACTIVE subscriber B: daemon pass-2 REVIVED (cycles bumped to 1)');
-            assert.equal(b.status, 'active', 'B revive → active');
-            assert.equal(b.intent ?? null, null, 'B intent cleared by revive');
-        }
-        // PASSIVE subscriber: NOT WOKEN — the same tick did NOT revive P.
-        {
-            const p = h.node(P);
-            assert.equal(p.cycles ?? 0, 0, 'PASSIVE subscriber P: NOT revived (cycles still 0)');
-            assert.equal(p.status, 'idle', 'P STILL idle — daemon did NOT wake it');
-            assert.equal(p.intent, 'idle-release', 'P still intent=idle-release (untouched)');
-        }
-        assert.equal(passive(P).length, 1, "P's passive entry is still pending (drained only on its next message)");
-        assert.equal(h.inbox(P).length, 0, "P's inbox still empty");
-        // The grandparent is STILL untouched even though B woke — one-hop confirmed.
-        assert.equal(h.inbox(A).length, 0, 'A inbox STILL empty after B woke — wake did not propagate up');
-        assert.equal(h.status(A), 'active', 'A unchanged');
-        // ===================================================================
-        // S5 — SECOND SITE: one-hop fan-out on a re-push. The indirect ancestor A
-        //      hears B ONLY when B explicitly re-pushes up its own spine. B (now
-        //      active) pushes an UPDATE → it fans to subscribersOf(B) = {A} only.
-        // ===================================================================
-        await pushUpdate(B, 'B re-pushing the rolled-up result');
-        closeDb();
-        {
-            const aInbox = h.inbox(A);
-            assert.equal(aInbox.length, 1, "A inbox now has exactly B's update (one hop, on B's explicit re-push)");
-            assert.equal(aInbox[0].from, B, "A's entry is from B");
-            assert.equal(aInbox[0].kind, 'update', "A's entry is the update");
-        }
-        // The re-push reached its DIRECT subscriber A only — siblings/observer untouched.
-        assert.equal(h.inbox(P).length, 0, "P inbox untouched by B's re-push (P does not subscribe to B)");
-        assert.equal(h.inbox(K).length, 0, "K inbox untouched by B's re-push");
-        assert.equal(passive(P).length, 1, "P's passive backlog unchanged by B's re-push");
-    }
-    finally {
-        await h.dispose();
-    }
-});

package/dist/core/__tests__/test-runner-cheap-sharding.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/core/__tests__/test-runner-cheap-sharding.test.js

@@ -1,97 +0,0 @@
-import assert from 'node:assert/strict';
-import { readFile, rm } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import test from 'node:test';
-// Regression coverage for the PR #386 cheap-lane correction: the default (no
-// file argument) `cheap` selection can no longer fit its aggregate ordinary
-// duration inside one 90s Actions wall (see notes/pr386 diagnosis), so it
-// splits into ORDINARY_SHARDS deterministic, path-hash-stable shards. These
-// tests prove the split is duration-blind, disjoint, and complete; that each
-// shard's timeout is capped correctly; that default cheap sharding activates
-// only for the true default selection; that the forbidden cross-invocation
-// flags are rejected while it is active; and that a targeted single-file
-// cheap selection still runs as one unsharded invocation.
-import { cheapShardTimeoutMs, findTestFiles, hasForbiddenCrossInvocationFlag, isDefaultCheapSelection, laneOf, ORDINARY_SHARDS, pathShard, runTier, } from '../../../scripts/test-runner.mjs';
-test('the default ordinary partition is duration-blind, disjoint, and complete', async () => {
-    const ordinaryFiles = (await findTestFiles()).filter((file) => laneOf(file) === 'ordinary');
-    assert.ok(ordinaryFiles.length > 0, 'expected at least one ordinary-lane file to partition');
-    const shards = Array.from({ length: ORDINARY_SHARDS }, (_, shardIndex) => ordinaryFiles.filter((file) => pathShard(file, ORDINARY_SHARDS) === shardIndex));
-    // Complete: every ordinary file lands in exactly one shard.
-    const union = new Set(shards.flat());
-    assert.equal(union.size, ordinaryFiles.length, 'every ordinary file must appear in the union of shards');
-    // Disjoint: no file appears in more than one shard.
-    for (const file of ordinaryFiles) {
-        const memberships = shards.filter((shard) => shard.includes(file)).length;
-        assert.equal(memberships, 1, `${file} must belong to exactly one shard, got ${memberships}`);
-    }
-    // Stable: membership depends only on the path string, never on measured
-    // duration or file order. Pin fixed path→shard vectors rather than
-    // comparing a call against an immediately repeated call to itself, which
-    // cannot catch an unstable algorithm or membership drift.
-    assert.equal(pathShard('src/core/__tests__/test-runner-cheap-sharding.test.ts', ORDINARY_SHARDS), 1);
-    assert.equal(pathShard('src/core/keybindings/__tests__/bespoke-consumers.test.ts', ORDINARY_SHARDS), 0);
-    assert.equal(pathShard('src/core/__tests__/fixtures/spawn-proof-target.test.ts', ORDINARY_SHARDS), 0);
-});
-test('cheapShardTimeoutMs caps a shard at the 90s tier wall and never past the remaining full-suite budget', () => {
-    const now = Date.now();
-    // No full-suite deadline (a bare `test:cheap`): every shard gets the full 90s.
-    assert.equal(cheapShardTimeoutMs(Infinity, now), 90_000);
-    // Full-suite budget has plenty of room left: still capped at 90s.
-    assert.equal(cheapShardTimeoutMs(now + 600_000, now), 90_000);
-    // Full-suite budget is tighter than 90s: the shard is capped to what remains.
-    assert.equal(cheapShardTimeoutMs(now + 50_000, now), 50_000);
-    // Full-suite budget is already exhausted: the shard gets a non-positive
-    // timeout so the caller can fail fast instead of starting a doomed shard.
-    assert.ok(cheapShardTimeoutMs(now - 1, now) <= 0);
-});
-test('default cheap sharding activates only for the true default (no file argument) cheap selection', () => {
-    assert.equal(isDefaultCheapSelection('cheap', false), true);
-    assert.equal(isDefaultCheapSelection('cheap', true), false);
-    assert.equal(isDefaultCheapSelection('fast', false), false);
-    assert.equal(isDefaultCheapSelection('process', false), false);
-    assert.equal(isDefaultCheapSelection('live', false), false);
-    assert.equal(isDefaultCheapSelection('heavy', false), false);
-});
-test('hasForbiddenCrossInvocationFlag recognizes --test-shard and --test-global-setup in both bare and = forms', () => {
-    assert.equal(hasForbiddenCrossInvocationFlag(['--test-shard', '1/2']), true);
-    assert.equal(hasForbiddenCrossInvocationFlag(['--test-shard=1/2']), true);
-    assert.equal(hasForbiddenCrossInvocationFlag(['--test-global-setup=./setup.mjs']), true);
-    assert.equal(hasForbiddenCrossInvocationFlag(['--test-global-setup', './setup.mjs']), true);
-    assert.equal(hasForbiddenCrossInvocationFlag(['--test-name-pattern=foo']), false);
-    assert.equal(hasForbiddenCrossInvocationFlag([]), false);
-});
-test('runTier rejects --test-shard and --test-global-setup while default cheap partitioning is active', async () => {
-    await assert.rejects(() => runTier('cheap', ['--test-shard=1/2']), /default cheap selection.*path-hash-stable shards/);
-    await assert.rejects(() => runTier('cheap', ['--test-global-setup=./setup.mjs']), /default cheap selection.*path-hash-stable shards/);
-    await assert.rejects(() => runTier('cheap', ['--test-global-setup', './setup.mjs']), /default cheap selection.*path-hash-stable shards/);
-});
-test('a targeted single-file cheap selection stays a single unsharded invocation and its target really executes', async () => {
-    // This is a real explicit-file cheap invocation (the same path a caller
-    // takes with `npm run test:full:cheap -- <file>`), proving the targeted
-    // path still runs the file directly rather than through the shard loop.
-    // The target is a dedicated fixture (fixtures/spawn-proof-target.test.ts)
-    // that writes an observable marker file when asked, so this regression can
-    // tell "the spawned file's own test body actually ran" apart from "the
-    // child process merely exited 0" — the two were indistinguishable under
-    // the bug this guards: `run()`'s spawn inherited NODE_TEST_CONTEXT /
-    // NODE_TEST_WORKER_ID from this already-running node:test process, which
-    // made the spawned child's own recursion guard silently skip the target
-    // file while the process still exited 0. Asserting only `code === 0` (as
-    // this test previously did) would also pass with that fix reverted.
-    const proofFile = join(tmpdir(), `crtr-test-runner-spawn-proof-${process.pid}-${Date.now()}.txt`);
-    const priorProofEnv = process.env.CRTR_SPAWN_PROOF_FILE;
-    process.env.CRTR_SPAWN_PROOF_FILE = proofFile;
-    try {
-        const code = await runTier('cheap', ['src/core/__tests__/fixtures/spawn-proof-target.test.ts']);
-        assert.equal(code, 0);
-        assert.equal(await readFile(proofFile, 'utf8'), 'ran', 'spawned target must actually execute and write its proof marker');
-    }
-    finally {
-        if (priorProofEnv === undefined)
-            delete process.env.CRTR_SPAWN_PROOF_FILE;
-        else
-            process.env.CRTR_SPAWN_PROOF_FILE = priorProofEnv;
-        await rm(proofFile, { force: true });
-    }
-});