@north-light/crouter 0.3.318 → 0.3.319

package/dist/core/__tests__/integration/flagship-lifecycle.test.js

@@ -1,264 +0,0 @@
-// Run with: npm run test:integration
-//
-// HEADLESS RETARGET (foundation-spec §C.9 + §E). The flagship end-to-end
-// lifecycle scenario, driven entirely at the MODEL layer against FABRICATED
-// broker-hosted (paneless) nodes — no real tmux session, no pane chrome, and NO
-// real broker boot. The full status×intent×lifecycle×mode state machine is host-
-// independent: every hop is a CLI lifecycle verb (promote/yield) or a pure model
-// op (fabricate + subscribe + transition + pushFinal + superviseTick), so the
-// scenario never pays the ~5s SDK-boot cost.
-//
-// THREE-PART LOCK HEADER ──────────────────────────────────────────────────
-// (1) BUG LOCKED — the full lifecycle state machine (state-model §2): each hop
-//     (spawn → terminal idle-release dormancy → one-hop wake → promote → yield-
-//     refresh → finish) must land in the correct durable (status,intent,
-//     lifecycle,mode) and route completion ONE HOP up the spine (a push fans to
-//     DIRECT subscribers only; an indirect ancestor hears nothing until a middle
-//     node re-pushes).
-// (2) WHY MODEL-LEVEL, NOT PANE/WINDOW — every transition lives in canvas.db +
-//     the lifecycle table (transition()) + the daemon's second-pass wake gate +
-//     the feed fan-out. A tmux node showed dormancy as a closed pane; a broker
-//     shows it as an EXITED process (status=idle, intent=idle-release, pi_pid
-//     dead) — fabricated directly. The only thing a pane ever added was a visible
-//     dormancy signal, which a broker expresses as a dead pid. No pane is read.
-// (3) HOW THE HEADLESS DRIVE STILL FAILS IF THE FIX REGRESSES — the one-hop wake
-//     is asserted via getNode(B).cycles (reviveNode bumps cycles +
-//     transition('revive') BEFORE the detached, unawaited broker spawn — revive.
-//     ts:114,145 — so the wake is observable INSTANTLY). If the daemon's second-
-//     pass reviveNode is removed, the post-inbox tick never bumps cycles → S7's
-//     "B revived" asserts go RED. If a push wrongly fanned past its direct
-//     subscriber, the "A inbox empty" one-hop asserts go RED.
-//
-// HOST-HOOK CAVEAT — fabrication cannot run agent_end or the broker's
-// pre-provider persona gate. This test enacts or asserts model state only;
-// canvas-stophook-agentend.test.ts pins idle release and stall reprompt, while
-// canvas-context-intro.test.ts pins persona transition delivery and ack. Here,
-// personaDrift proves the promoted node remains pending.
-//
-// 2×2 coverage (mode {base,orchestrator} × lifecycle {terminal,resident}):
-//   • base×resident         — A's fabricated row shape at S1 (a spawnRoot
-//                             fixture; the real resident-birth boot path is
-//                             structurally unreachable headlessly).
-//   • orchestrator×resident — A after promote (top-level orchestrator).
-//   • base×terminal         — B/C/D workers (fabricated managed children).
-//   • orchestrator×terminal — B after promote (sub-orchestrator).
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { spawnSync } from 'node:child_process';
-import { createHeadlessHarness } from '../helpers/harness.js';
-import { subscribe } from '../../canvas/canvas.js';
-import { transition } from '../../runtime/lifecycle.js';
-import { pushFinal } from '../../feed/feed.js';
-import { evaluateStop, STALL_REPROMPT } from '../../runtime/stop-guard.js';
-import { formatCard } from '../../../shared/generated-context.js';
-import { personaDrift, commitPersonaAck } from '../../runtime/persona.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;
-}
-test('flagship: full node lifecycle — spawn, dormancy, one-hop wake, promote, yield, finish (headless)', 
-// Spawns real broker children + several full-CLI subprocesses; 30s risked the
-// same slow-CI-runner timeout as the live-mutation tests. 60s = safe margin.
-{ timeout: 60_000 }, async () => {
-    const h = await createHeadlessHarness({ sessionPrefix: 'crtr-flagship' });
-    try {
-        // S1 — A's ROW SHAPE: base × RESIDENT (the user's front door). A spawnRoot
-        //   fixture pins the PERSISTED row shape the scenario builds on; the real
-        //   resident-birth boot path (bootRoot execs pi inline) is unreachable
-        //   headlessly, exactly as in the tmux flagship. The resident BEHAVIOR (no
-        //   idle-release) is exercised in live-mutation.test.ts.
-        const A = h.spawnRoot('top-level orchestrator');
-        {
-            const a = h.node(A);
-            assert.equal(a.mode, 'base', 'A row shape: base');
-            assert.equal(a.lifecycle, 'resident', 'A row shape: resident (fixture, not a real boot)');
-            assert.equal(a.status, 'active', 'A active');
-            assert.equal(a.intent ?? null, null, 'A no intent');
-        }
-        // S2 — A promotes: orchestrator × RESIDENT (top-level orchestrator). The
-        //      real `node promote` verb; mode flips, lifecycle/status/intent
-        //      untouched (no transition()).
-        {
-            const res = h.cli(A, ['node', 'promote']);
-            assert.equal(res.code, 0, `promote A exit 0\n${res.stderr}`);
-            const a = h.node(A);
-            assert.equal(a.mode, 'orchestrator', 'A → orchestrator');
-            assert.equal(a.lifecycle, 'resident', 'A stays resident (no --resident)');
-            assert.equal(a.status, 'active', 'A still active (promote does not transition)');
-            assert.equal(a.intent ?? null, null, 'A intent untouched by promote');
-        }
-        // S3 — A spawns terminal child B: base × TERMINAL. Fabricated as a broker-
-        //      hosted node (pi_pid dead + pi_session_id set, so its later dormant
-        //      wake RESUMES that session); the spine seed is wired explicitly
-        //      (fabrication does not auto-subscribe). B is born acked to its own
-        //      persona (commitPersonaAck), mirroring a real birth.
-        const B = h.fabricateBrokerNode({
-            parent: A, kind: 'developer', mode: 'base', lifecycle: 'terminal',
-            status: 'active', pi_pid: deadPid(), pi_session_id: 'sess-B',
-        });
-        subscribe(A, B, true); // the load-bearing spine seed: A subscribes_to B (active).
-        commitPersonaAck(B, { kind: 'developer', mode: 'base', lifecycle: 'terminal' }); // born acked to its persona
-        {
-            const b = h.node(B);
-            assert.equal(b.host_kind, 'broker', 'B broker-hosted (paneless)');
-            assert.equal(b.mode, 'base', 'B born base');
-            assert.equal(b.lifecycle, 'terminal', 'B born terminal (managed child)');
-            assert.equal(b.status, 'active', 'B active');
-            assert.equal(b.intent ?? null, null, 'B no intent');
-            assert.equal(b.parent, A, 'B spawned_by / parent = A');
-            assert.deepEqual(h.subscribers(B), [{ node_id: A, active: true }], "A is B's sole ACTIVE subscriber (spine seed)");
-            assert.equal(h.inbox(A).length, 0, 'A inbox empty (spawn pushes nothing)');
-        }
-        // S4 — B spawns child C (base × terminal). B now holds an active live
-        //      subscription to C → B is legitimately "awaiting" if it stops.
-        const C = h.fabricateBrokerNode({ parent: B, mode: 'base', lifecycle: 'terminal', status: 'active' });
-        subscribe(B, C, true);
-        {
-            const c = h.node(C);
-            assert.equal(c.mode, 'base', 'C base');
-            assert.equal(c.lifecycle, 'terminal', 'C terminal');
-            assert.equal(c.status, 'active', 'C active');
-            assert.deepEqual(h.subscribers(C), [{ node_id: B, active: true }], "B is C's sole ACTIVE subscriber");
-            assert.deepEqual(h.subscriptions(B), [{ node_id: C, active: true }], 'B subscribes_to C (active)');
-            assert.equal(h.status(B), 'active', 'B still active');
-        }
-        // S5 — B goes DORMANT. PURE precondition: B is TERMINAL holding an active
-        //      live sub to C, so the stop-guard classifies its stop 'awaiting'
-        //      (legitimate idle-release). We then enact the post-stop MODEL state
-        //      directly: transition('release') → idle / idle-release (a released
-        //      broker is a dead pid; pi_pid was fabricated dead at S3). The actual
-        //      agent_end idle-release COMMIT is locked by canvas-stophook-agentend
-        //      ('natural stop while awaiting a live worker → idle-release …').
-        {
-            const stop = evaluateStop(B, { pushedFinal: false, requestedHumanReply: false });
-            assert.equal(stop.action, 'allow', 'awaiting terminal B → allow (legit idle-release)');
-            assert.equal(stop.reason, 'awaiting', "B classified awaiting on its ACTIVE live sub to C");
-        }
-        transition(B, 'release');
-        {
-            const b = h.node(B);
-            assert.equal(b.status, 'idle', 'B idle (released)');
-            assert.equal(b.intent, 'idle-release', 'B intent=idle-release');
-        }
-        assert.equal(h.status(C), 'active', 'C still active while B sleeps');
-        assert.equal(h.status(A), 'active', 'A still active (a dormant worker does not disturb its manager)');
-        assert.equal(h.inbox(A).length, 0, 'A inbox still empty');
-        // S6 — C FINISHES (pushFinal). The pointer fans to subscribersOf(C) = {B}
-        //      ONLY. C → done/done. A is NOT a subscriber of C → A inbox stays
-        //      empty — the one-hop wake contract at the push site.
-        await pushFinal(C, 'C result body');
-        {
-            const c = h.node(C);
-            assert.equal(c.status, 'done', 'C done');
-            assert.equal(c.intent, 'done', 'C intent=done');
-            const cFinal = h.inbox(B).find((e) => e.from === C && e.kind === 'final');
-            assert.ok(cFinal, "B inbox received C's final pointer (one hop)");
-            assert.equal(h.inbox(A).length, 0, 'A inbox empty — A NOT woken by C (one-hop)');
-        }
-        // S7 — WAKE B. The in-process daemon second pass sees B idle/idle-release,
-        //      pi dead, an unseen inbox entry → reviveNode(resume). reviveNode
-        //      bumps cycles + transition('revive') BEFORE the (detached, unawaited)
-        //      broker spawn, so the wake is observable INSTANTLY via cycles — no
-        //      awaitBoot. (The real inbox-watcher's redelivery of C's report on the
-        //      fresh boot is an engine artifact, out of the model tier; the wake
-        //      DECISION is locked here by cycles + the S6 inbox entry.)
-        assert.equal(h.node(B).cycles ?? 0, 0, 'B not yet revived');
-        await h.tick();
-        {
-            const b = h.node(B);
-            assert.equal(b.cycles ?? 0, 1, 'unseen inbox + tick → daemon pass-2 REVIVED (cycles bumped to 1)');
-            assert.equal(b.status, 'active', 'B revived → active');
-            assert.equal(b.intent ?? null, null, 'B intent cleared by revive');
-        }
-        assert.equal(h.inbox(A).length, 0, 'A inbox STILL empty after B woke (one-hop confirmed)');
-        assert.equal(h.status(A), 'active', 'A unchanged');
-        // S8 — B PROMOTES: base → orchestrator, lifecycle TERMINAL unchanged
-        //      (no --resident). orchestrator × terminal (the sub-orchestrator).
-        {
-            const res = h.cli(B, ['node', 'promote', '--kind', 'developer']);
-            assert.equal(res.code, 0, `promote B exit 0\n${res.stderr}`);
-            const b = h.node(B);
-            assert.equal(b.mode, 'orchestrator', 'B → orchestrator');
-            assert.equal(b.lifecycle, 'terminal', 'B stays TERMINAL (promote is mode-only)');
-            assert.equal(b.status, 'active', 'B still active');
-            assert.equal(b.intent ?? null, null, 'B intent untouched by promote');
-        }
-        // S9 — The next provider request must first deliver the pending persona
-        //      transition. Independently, agent_end would stall this orchestrator
-        //      because it has no live subscription and has not pushed a final.
-        {
-            const drift = personaDrift(B);
-            assert.ok(drift !== null, 'the provider gate has a pending persona transition');
-            assert.deepEqual(drift?.from, { kind: 'developer', mode: 'base', lifecycle: 'terminal' }, 'drift.from = the acked base×terminal');
-            assert.deepEqual(drift?.to, { kind: 'developer', mode: 'orchestrator', lifecycle: 'terminal' }, 'drift.to = the new orchestrator persona');
-            assert.match(drift?.guidance ?? '', /ORCHESTRATOR/i, 'the steer carries the base→orchestrator guidance');
-            const stop = evaluateStop(B, { pushedFinal: false, requestedHumanReply: false });
-            assert.equal(stop.action, 'reprompt', 'orchestrator B with no live sub, no final → reprompt');
-            assert.equal(stop.reason, 'stalled', 'classified stalled');
-            assert.equal(stop.action === 'reprompt' ? stop.message : '', formatCard('stop-guard', {}, STALL_REPROMPT), 'the stall reprompt nudge, delivered as a whole-message stop-guard envelope');
-        }
-        // S10 — B YIELDS. The real plain `node yield` verb sets intent=refresh
-        //       while preserving mode (already orchestrator); persona survives the request. We
-        //       then model the daemon's completed refresh-revive with transition
-        //       ('revive') (the in-place fresh boot is engine; its model effect —
-        //       active, intent cleared, persona preserved — is asserted here).
-        {
-            const res = h.cli(B, ['node', 'yield', 'refresh against the roadmap']);
-            assert.equal(res.code, 0, `node yield exit 0\n${res.stderr}`);
-            const b = h.node(B);
-            assert.equal(b.intent, 'refresh', 'yield set intent=refresh');
-            assert.equal(b.mode, 'orchestrator', 'B mode survives the yield request');
-            assert.equal(b.lifecycle, 'terminal', 'B lifecycle survives the yield request');
-        }
-        transition(B, 'revive'); // model the completed refresh-revive (fresh boot is engine)
-        {
-            const b = h.node(B);
-            assert.equal(b.status, 'active', 'B active after the refresh-revive');
-            assert.equal(b.intent ?? null, null, 'B intent=refresh cleared by the fresh boot');
-            assert.equal(b.mode, 'orchestrator', 'B mode survives the refresh');
-            assert.equal(b.lifecycle, 'terminal', 'B lifecycle survives the refresh');
-        }
-        // S11 — B spawns child D (base × terminal). New spine seed B→D active.
-        const D = h.fabricateBrokerNode({ parent: B, mode: 'base', lifecycle: 'terminal', status: 'active' });
-        subscribe(B, D, true);
-        {
-            const d = h.node(D);
-            assert.equal(d.mode, 'base', 'D base');
-            assert.equal(d.lifecycle, 'terminal', 'D terminal');
-            assert.equal(d.status, 'active', 'D active');
-            assert.ok(h.subscriptions(B).some((s) => s.node_id === D && s.active), 'B subscribes_to D (active)');
-        }
-        // S12 — D FINISHES → pointer to B (its only subscriber).
-        await pushFinal(D, 'D result body');
-        {
-            assert.equal(h.node(D).status, 'done', 'D done');
-            const dFinal = h.inbox(B).find((e) => e.from === D && e.kind === 'final');
-            assert.ok(dFinal, "B inbox received D's final pointer");
-        }
-        // S13 — B pushes its FINAL up the spine → done/done; the pointer fans to
-        //       subscribersOf(B) = {A}. NOW A finally hears B (its own explicit
-        //       push — the only way the chain propagates a hop).
-        await pushFinal(B, 'all work complete');
-        {
-            const b = h.node(B);
-            assert.equal(b.status, 'done', 'B done after push final');
-            assert.equal(b.intent, 'done', 'B intent=done');
-            const aInbox = h.inbox(A);
-            assert.equal(aInbox.length, 1, "A inbox now has exactly B's final (one hop, on B's push)");
-            assert.equal(aInbox[0].from, B, "A's entry is from B");
-            assert.equal(aInbox[0].kind, 'final', "A's entry is a final");
-        }
-        // A — the resident top-level orchestrator — is still alive and well.
-        {
-            const a = h.node(A);
-            assert.equal(a.status, 'active', 'A still active at the end');
-            assert.equal(a.mode, 'orchestrator', 'A still orchestrator');
-            assert.equal(a.lifecycle, 'resident', 'A still resident');
-        }
-    }
-    finally {
-        await h.dispose();
-    }
-});

package/dist/core/__tests__/integration/fresh-home-commands.test.d.ts

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

package/dist/core/__tests__/integration/fresh-home-commands.test.js

@@ -1,49 +0,0 @@
-import assert from 'node:assert/strict';
-import { spawnSync } from 'node:child_process';
-import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import test from 'node:test';
-const CLI = fileURLToPath(new URL('../../../cli.ts', import.meta.url));
-const ROOT = new URL('../../../build-root.ts', import.meta.url).href;
-const LOADER = import.meta.resolve('tsx/esm');
-test('command discovery initializes fresh homes and refuses legacy state without conversion', () => {
-    const commands = [
-        [CLI, '-h'],
-        [CLI, 'human', '-h'],
-        ['--input-type=module', '--eval', `import { coreCommandPaths } from ${JSON.stringify(ROOT)}; if (!(await coreCommandPaths()).has('human')) throw new Error('human command missing'); console.log('coreCommandPaths: human present');`],
-    ];
-    for (const legacy of [false, true])
-        for (const command of commands) {
-            const home = mkdtempSync(join(tmpdir(), 'crtr-command-home-'));
-            const config = join(home, '.crouter', 'config.json');
-            const database = join(home, '.crouter', 'operations.db');
-            try {
-                if (legacy) {
-                    mkdirSync(dirname(config), { recursive: true });
-                    writeFileSync(config, '{}\n');
-                }
-                const result = spawnSync(process.execPath, ['--conditions=crtr-src', '--import', LOADER, ...command], {
-                    cwd: home,
-                    env: { HOME: home, PATH: process.env.PATH, CRTR_NO_DAEMON_AUTOSTART: '1', CRTR_NO_AUTO_UPDATE: '1', CRTR_NO_EXPORTS: '1' },
-                    encoding: 'utf8',
-                    timeout: 15_000,
-                });
-                const detail = `${legacy ? 'legacy' : 'fresh'} HOME: ${command.join(' ')}\n${result.stdout}\n${result.stderr}`;
-                assert.ifError(result.error);
-                assert.equal(result.status, legacy ? 1 : 0, detail);
-                assert.equal(existsSync(database), !legacy, detail);
-                if (legacy) {
-                    assert.match(result.stderr, /legacy scoped state exists.*crtr sys daemon restart/s, detail);
-                    assert.equal(readFileSync(config, 'utf8'), '{}\n');
-                }
-                else {
-                    assert.notEqual(result.stdout.trim(), '', detail);
-                }
-            }
-            finally {
-                rmSync(home, { recursive: true, force: true });
-            }
-        }
-});

package/dist/core/__tests__/integration/git-optional-locks.test.d.ts

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

package/dist/core/__tests__/integration/git-optional-locks.test.js

@@ -1,81 +0,0 @@
-// Run with: npm run test:integration
-//
-// Regression: crouter's read-only git calls must not take `.git/index.lock`.
-//
-// `git status` refreshes the index stat cache and writes the index back, which
-// means creating `.git/index.lock` and renaming it over `.git/index`. A process
-// killed between those two steps orphans the lock, and it then blocks every
-// later writer in that checkout with no owning process left to name. Agent
-// processes are killed mid-command routinely — a closed node, a cancelled daemon
-// tick, a timed-out shell — so the residue accumulates in a shared checkout
-// until someone removes it by hand.
-//
-// `GIT_OPTIONAL_LOCKS=0` suppresses exactly that optional lock. These tests pin
-// the two paths that reach git: the shared spawner in `core/git.ts`, and the
-// bearings project-context block, which renders on every node boot and revive
-// and is therefore the most frequent git caller in the runtime.
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, rmSync, statSync, utimesSync, writeFileSync } from 'node:fs';
-import { spawnSync } from 'node:child_process';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { gitSync } from '../../git.js';
-import { buildProjectContextBlock } from '../../runtime/bearings-render.js';
-/** A repo with one committed file whose stat cache is deliberately stale, so a
- *  status that refreshes the index has a reason to write it back. Without the
- *  stale stat there is nothing to refresh and the assertion passes vacuously. */
-function repoWithStaleStatCache() {
-    const dir = mkdtempSync(join(tmpdir(), 'crtr-git-locks-'));
-    const git = (args) => {
-        const result = spawnSync('git', args, { cwd: dir, encoding: 'utf8' });
-        assert.equal(result.status, 0, `git ${args.join(' ')}: ${result.stderr}`);
-    };
-    writeFileSync(join(dir, 'f.txt'), 'a\n', 'utf8');
-    git(['init', '-q', '.']);
-    git(['-c', 'user.email=t@t', '-c', 'user.name=t', 'add', 'f.txt']);
-    git(['-c', 'user.email=t@t', '-c', 'user.name=t', 'commit', '-qm', 'init']);
-    // Move the file's mtime forward so git's cached stat no longer matches.
-    const future = new Date(Date.now() + 10_000);
-    utimesSync(join(dir, 'f.txt'), future, future);
-    return dir;
-}
-function indexMtime(dir) {
-    return statSync(join(dir, '.git', 'index')).mtimeMs;
-}
-test('gitSync status does not rewrite the index', (t) => {
-    if (spawnSync('git', ['--version']).status !== 0) {
-        t.skip('git is unavailable');
-        return;
-    }
-    const dir = repoWithStaleStatCache();
-    try {
-        const before = indexMtime(dir);
-        const result = gitSync(['status', '--porcelain'], dir);
-        assert.equal(result.status, 0, result.stderr);
-        // Suppressing the lock must not change what the command reports.
-        assert.equal(result.stdout, '');
-        assert.equal(indexMtime(dir), before, 'status took .git/index.lock and rewrote the index');
-    }
-    finally {
-        rmSync(dir, { recursive: true, force: true });
-    }
-});
-test('the bearings project-context block does not rewrite the index', (t) => {
-    if (spawnSync('git', ['--version']).status !== 0) {
-        t.skip('git is unavailable');
-        return;
-    }
-    const dir = repoWithStaleStatCache();
-    try {
-        const before = indexMtime(dir);
-        const block = buildProjectContextBlock(dir);
-        // The snapshot still reports real git state; it just does not lock to do it.
-        assert.match(block, /Git: /);
-        assert.match(block, /clean/);
-        assert.equal(indexMtime(dir), before, 'the bearings snapshot took .git/index.lock');
-    }
-    finally {
-        rmSync(dir, { recursive: true, force: true });
-    }
-});

package/dist/core/__tests__/integration/host-teardown-process-group.test.d.ts

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