@north-light/crouter 0.3.318 → 0.3.319

package/dist/core/__tests__/integration/live-mutation-verbs.test.js

@@ -1,180 +0,0 @@
-// Run with: node --import tsx/esm --test src/core/__tests__/live-mutation-verbs.test.ts
-//
-// HEADLESS RETARGET (foundation-spec §C.11 + §E). AXIS: LIVE MUTATION, part 2 —
-// the demote/recycle verb split and the A4 yield-mode boundary, driven
-// against FABRICATED broker-hosted (paneless) nodes — no real tmux session, no
-// pane chrome, and NO real broker boot. Split out of live-mutation.test.ts for
-// node:test file-level parallelism; each test holds its OWN isolated harness.
-//
-// THREE-PART LOCK HEADER ──────────────────────────────────────────────────
-// (1) BUG LOCKED — the demote/recycle SPLIT and the A4 yield-mode boundary:
-//     • `node lifecycle demote` flips lifecycle→TERMINAL IN PLACE — keeps MODE, parentage,
-//       and a live (active) status; NOT finalized. It is NOT a mode flip.
-//     • `node lifecycle recycle` is FINISH+RECYCLE — pushes a final → done (mode KEPT), and
-//       mints a DIFFERENT fresh general/base/resident root.
-//     • A4: a PLAIN `node yield` on a base node is MODE-PRESERVING — no auto-
-//       promote, no roadmap seeded, no persona_ack drift — it just sets
-//       intent=refresh. `node yield --promote` is the explicit opt-in that
-//       rides the promote() path (mode→orchestrator + roadmap seeded), and
-//       leaves persona_ack pending until the fresh-context baseline persists.
-// (2) WHY MODEL-LEVEL, NOT PANE/WINDOW — demote writes lifecycle on the row
-//     (setLifecycle→updateNode); recycle's FINISH+MINT half is pushFinal +
-//     spawnNode (pure model) — only its pane-respawn is tmux (a deliberately-
-//     skipped artifact here, recycled:false). yield's mode flip (or lack of
-//     one) + intent set are row writes; persona_ack/personaDrift are pure. No
-//     pane is read for any assertion.
-// (3) HOW THE HEADLESS DRIVE STILL FAILS IF THE FIX REGRESSES — if demote also
-//     flipped MODE, the 'mode stays orchestrator' assert goes RED; if recycle
-//     re-roled instead of finishing, 'recycled node → done' / 'fresh root born
-//     base×resident' go RED; if a plain yield auto-promoted, the A4 'plain
-//     yield preserves mode' assert goes RED; if `--promote` failed to flip mode
-//     or seed a roadmap, or if it committed the ack itself, the A4 'yield
-//     --promote' asserts go RED.
-//
-// HOST-HOOK CAVEAT — fabrication cannot run the replacement context intro.
-// recycleNode still exercises its finish-and-mint model path; these A4 cases pin
-// the pre-refresh state. canvas-context-intro.test.ts proves the fresh baseline
-// persists before persona_ack advances.
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { createHeadlessHarness } from '../helpers/harness.js';
-import { subscribe } from '../../canvas/canvas.js';
-import { recycleNode } from '../../runtime/recycle.js';
-import { commitPersonaAck, personaDrift } from '../../runtime/persona.js';
-import { hasRoadmap } from '../../runtime/roadmap.js';
-/** Normalize the two persona axes off a NodeMeta for deepEqual. */
-function persona(m) {
-    return { mode: m.mode, lifecycle: m.lifecycle };
-}
-const FULL_CLI_TEST_TIMEOUT_MS = 180_000;
-// (b) THE demote / recycle SPLIT — two DISTINCT verbs:
-//   • `node lifecycle demote`  flips a LIVE node's lifecycle→TERMINAL IN PLACE — it keeps
-//     its MODE and parentage, keeps running (active), is NOT finalized; it now
-//     merely owes a final up the spine (vision F5). MODE is untouched.
-//   • `node lifecycle recycle` is FINISH+RECYCLE — push final → done, then recycle the pane
-//     into a FRESH general/base/resident root (a DIFFERENT node). The recycled
-//     node keeps mode=orchestrator (it is merely `done`).
-// This test drives demote via the real CLI verb and recycle via the real
-// recycleNode, pinning each behavior at the model layer.
-test('node lifecycle demote flips lifecycle→terminal IN PLACE; node lifecycle recycle is FINISH+RECYCLE', 
-// Drives several full-CLI subprocess spawns (each a cold tsx compile of the
-// whole CLI) + recycleNode; this is a subprocess-heavy regression and gets a
-// CI-safe per-test budget while the npm script isolates it at file concurrency 1.
-{ timeout: FULL_CLI_TEST_TIMEOUT_MS }, async () => {
-    const h = await createHeadlessHarness({ sessionPrefix: 'crtr-live-demote' });
-    try {
-        const A = h.spawnRoot('resident root');
-        const B = h.fabricateBrokerNode({ parent: A, kind: 'developer', mode: 'base', lifecycle: 'terminal', status: 'active' });
-        subscribe(A, B, true);
-        // Make B resident + orchestrator so the demote's flip→terminal is visible
-        // and we can prove MODE/parentage survive it.
-        assert.equal(h.cli(B, ['node', 'config', '--lifecycle', 'resident', '--node', B]).code, 0, 'B → resident');
-        assert.equal(h.cli(B, ['node', 'promote', '--kind', 'developer']).code, 0, 'promote B');
-        {
-            const b = h.node(B);
-            assert.equal(b.lifecycle, 'resident', 'B resident before demote');
-            assert.equal(b.mode, 'orchestrator', 'B orchestrator before demote');
-        }
-        const bParent = h.node(B).parent;
-        // --- node lifecycle demote: flip-to-terminal IN PLACE. Keeps B alive, MODE/parentage
-        //     untouched, NOT finalized.
-        const dem = h.cli(B, ['node', 'lifecycle', 'demote', '--node', B]);
-        assert.equal(dem.code, 0, `node lifecycle demote exit 0\n${dem.stderr}`);
-        assert.match(dem.stdout, /^Demoted /, `demote rendered\n${dem.stdout}`);
-        {
-            const b = h.node(B);
-            assert.equal(b.lifecycle, 'terminal', 'demote flips lifecycle→terminal IN PLACE');
-            assert.equal(b.mode, 'orchestrator', 'demote leaves MODE untouched (not an orchestrator→base flip)');
-            assert.equal(b.parent, bParent, 'demote leaves parentage unchanged');
-            assert.equal(b.status, 'active', 'demote does NOT finish B — it keeps running in place');
-            assert.notEqual(b.intent ?? null, 'done', 'demote does NOT finalize B');
-        }
-        // --- node lifecycle recycle: FINISH + RECYCLE. Driven through the real recycleNode.
-        //     Its FINISH+MINT model half runs fully; the pane respawn is the only
-        //     tmux artifact (no pane for a broker node), so recycled:false while
-        //     finalized:true and a fresh root IS minted — the bug-lock (recycle ≠
-        //     demote) is entirely in that model half.
-        const res = await recycleNode(B, '%recycle-headless');
-        assert.equal(res.finalized, true, 'recycle pushed a final for the node (FINISH half ran)');
-        assert.ok(typeof res.newRoot === 'string' && res.newRoot !== B, 'a fresh root (≠ B) was minted');
-        // The recycled node is FINISHED, not mode-flipped.
-        {
-            const b = h.node(B);
-            assert.equal(b.status, 'done', 'recycled node → done (finished), NOT re-roled');
-            assert.equal(b.intent, 'done', 'intent=done (finalize), per the push-final path');
-            assert.equal(b.mode, 'orchestrator', 'recycled node KEEPS mode=orchestrator — recycle is NOT a mode flip');
-        }
-        // The fresh root is a DIFFERENT, BASE×RESIDENT node.
-        {
-            const fresh = h.node(res.newRoot);
-            assert.deepEqual(persona(fresh), { mode: 'base', lifecycle: 'resident' }, 'recycled root is born base×resident (general)');
-            assert.deepEqual(fresh.persona_ack, { kind: 'general', mode: 'base', lifecycle: 'resident' }, 'fresh root born acked general×base×resident');
-            assert.equal(fresh.parent ?? null, null, 'the fresh root is a root (no parent)');
-        }
-    }
-    finally {
-        await h.dispose();
-    }
-});
-// (b) A4 BOUNDARY — plain yield is mode-preserving; `yield --promote` is the
-//     explicit one-step promotion + refresh. A plain yield sets intent=refresh
-//     only, leaves the base persona acknowledged, and does NOT seed a roadmap.
-//     With `--promote`, the mode flips and a roadmap is seeded; persona drift
-//     remains pending until the replacement context persists its baseline.
-test('A4: a plain yield preserves base mode and does not seed a roadmap', 
-// Full-CLI subprocess spawn under load — see the sibling test's budget note.
-{ timeout: FULL_CLI_TEST_TIMEOUT_MS }, async () => {
-    const h = await createHeadlessHarness({ sessionPrefix: 'crtr-live-a4-plain' });
-    try {
-        const A = h.spawnRoot('resident root');
-        const B = h.fabricateBrokerNode({ parent: A, kind: 'developer', mode: 'base', lifecycle: 'terminal', status: 'active' });
-        subscribe(A, B, true);
-        commitPersonaAck(B, { kind: 'developer', mode: 'base', lifecycle: 'terminal' });
-        assert.equal(hasRoadmap(B), false, 'B has no roadmap before a plain yield');
-        const y = h.cli(B, ['node', 'yield', 'refresh against the original goal']);
-        assert.equal(y.code, 0, `node yield exit 0\n${y.stderr}`);
-        {
-            const b = h.node(B);
-            assert.equal(b.mode, 'base', 'plain yield preserves base mode');
-            assert.equal(b.intent, 'refresh', 'intent=refresh set by the yield');
-            assert.deepEqual(b.persona_ack, { kind: 'developer', mode: 'base', lifecycle: 'terminal' }, 'plain yield leaves the acknowledged base persona unchanged');
-        }
-        assert.equal(hasRoadmap(B), false, 'plain yield does not seed a roadmap');
-        assert.equal(personaDrift(B), null, 'plain yield leaves no persona transition pending');
-    }
-    finally {
-        await h.dispose();
-    }
-});
-test('A4: yield --promote flips base→orchestrator, seeds a roadmap, and leaves persona_ack pending', 
-// Full-CLI subprocess spawn under load — see the sibling test's budget note.
-{ timeout: FULL_CLI_TEST_TIMEOUT_MS }, async () => {
-    const h = await createHeadlessHarness({ sessionPrefix: 'crtr-live-a4-promote' });
-    try {
-        const A = h.spawnRoot('resident root');
-        const B = h.fabricateBrokerNode({ parent: A, kind: 'developer', mode: 'base', lifecycle: 'terminal', status: 'active' });
-        subscribe(A, B, true);
-        commitPersonaAck(B, { kind: 'developer', mode: 'base', lifecycle: 'terminal' });
-        assert.equal(hasRoadmap(B), false, 'B has no roadmap before yield --promote');
-        const y = h.cli(B, ['node', 'yield', '--promote', 'refresh as an orchestrator']);
-        assert.equal(y.code, 0, `node yield --promote exit 0\n${y.stderr}`);
-        {
-            const b = h.node(B);
-            assert.equal(b.mode, 'orchestrator', 'yield --promote flips base→orchestrator');
-            assert.equal(b.intent, 'refresh', 'intent=refresh set by the yield');
-            assert.deepEqual(b.persona_ack, { kind: 'developer', mode: 'base', lifecycle: 'terminal' }, 'ack stays base until provider-gated delivery or the fresh-context baseline completes');
-        }
-        assert.equal(hasRoadmap(B), true, 'yield --promote seeds a roadmap');
-        // The refresh kickoff carries this framing into the replacement context;
-        // persona_ack stays pending until that context's snapshots persist.
-        {
-            const drift = personaDrift(B);
-            assert.ok(drift !== null, 'the orchestration guidance is PENDING after yield --promote (drift detected)');
-            assert.deepEqual(drift?.to, { kind: 'developer', mode: 'orchestrator', lifecycle: 'terminal' }, 'pending drift → orchestrator×terminal');
-            assert.match(drift?.guidance ?? '', /ORCHESTRATOR/i, 'the pending fresh-revive framing carries the orchestration guidance');
-        }
-    }
-    finally {
-        await h.dispose();
-    }
-});

package/dist/core/__tests__/integration/live-mutation.test.d.ts

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

package/dist/core/__tests__/integration/live-mutation.test.js

@@ -1,173 +0,0 @@
-// Run with: npm run test:integration
-//
-// HEADLESS RETARGET (foundation-spec §C.12 + §E). AXIS: LIVE MUTATION of the
-// 2×2 state vector (mode {base,orchestrator} × lifecycle {terminal,resident})
-// driven through the REAL `node config --lifecycle` / `node promote` CLI verbs against
-// FABRICATED broker-hosted (paneless) nodes — no real tmux session, no pane
-// chrome, and NO real broker boot. The mutation verbs and the decisions they
-// gate are host-independent model logic, so the file never pays the ~5s SDK-boot
-// cost. Every assertion reads the canvas data layer / a PURE decision function.
-//
-// THREE-PART LOCK HEADER ──────────────────────────────────────────────────
-// (1) BUG LOCKED — (a) a live lifecycle flip changes the idle-release decision:
-//     a resident node is NEVER forced dormant (suppressed), a terminal one with
-//     an active live sub IS legitimately awaiting (restored). (b) a live promote
-//     flips mode but leaves persona_ack pending for provider-gated delivery.
-// (2) WHY MODEL-LEVEL, NOT PANE/WINDOW — the flip writes lifecycle/mode on the
-//     row (updateNode) and the idle-release call is decided by the PURE
-//     evaluateStop (stop-guard.ts), which keys on lifecycle + active live subs,
-//     never on a pane. persona_ack lives in meta.json; personaDrift is pure. No
-//     pane/window is read anywhere.
-// (3) HOW THE HEADLESS DRIVE STILL FAILS IF THE FIX REGRESSES — (a) after the
-//     terminal→resident flip, evaluateStop(B) must read 'dormant' NOT 'awaiting';
-//     if the resident-suppression branch in stop-guard regresses (lifecycle
-//     ignored), B still has its active live sub to C so evaluateStop returns
-//     'awaiting' → the 'dormant' assert goes RED (verified by bug-injection
-//     below). (b) after promote, personaDrift(B) must still report base→
-//     orchestrator PENDING; if promote wrongly committed the ack, drift reads
-//     null → the pending-drift assert goes RED.
-//
-// HOST-HOOK CAVEAT — fabrication cannot run agent_end or the broker's
-// pre-provider persona gate. This test asserts evaluateStop and personaDrift;
-// canvas-stophook-agentend.test.ts pins idle-release behavior, and
-// canvas-context-intro.test.ts pins transition delivery and guarded ack.
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { createHeadlessHarness } from '../helpers/harness.js';
-import { subscribe } from '../../canvas/canvas.js';
-import { commitPersonaAck, personaDrift } from '../../runtime/persona.js';
-import { evaluateStop } from '../../runtime/stop-guard.js';
-/** Normalize the two persona axes off a NodeMeta for deepEqual. */
-function persona(m) {
-    return { mode: m.mode, lifecycle: m.lifecycle };
-}
-const SIGNALS = { pushedFinal: false, requestedHumanReply: false };
-// (a) LIFECYCLE FLIP — `crtr node config --lifecycle` on a LIVE node, both directions,
-//     observing the idle-release DECISION change. A round-trip on ONE node
-//     (terminal→resident→terminal) proves both directions: a flipped-resident
-//     node no longer idle-releases (evaluateStop → dormant); flipped-terminal it
-//     idle-releases again (evaluateStop → awaiting, on its active live sub).
-test('live lifecycle flip: terminal→resident suppresses idle-release; resident→terminal restores it', 
-// Full-CLI subprocess spawns under load — 20s blew on the slower CI runner
-// (passes fast locally); 60s = safe margin. Same class as live-mutation-verbs.
-{ timeout: 60_000 }, async () => {
-    const h = await createHeadlessHarness({ sessionPrefix: 'crtr-live-life' });
-    try {
-        // A (resident root) ─ B (base/terminal) ─ C (base/terminal). B holds an
-        // ACTIVE live sub to C → a TERMINAL B that stops is legitimately 'awaiting'
-        // and would idle-release. That live sub is the precondition that makes the
-        // resident-vs-terminal flip the ONLY variable in the stop decision.
-        const A = h.spawnRoot('resident root');
-        const B = h.fabricateBrokerNode({ parent: A, kind: 'developer', mode: 'base', lifecycle: 'terminal', status: 'active' });
-        const C = h.fabricateBrokerNode({ parent: B, mode: 'base', lifecycle: 'terminal', status: 'active' });
-        subscribe(A, B, true);
-        subscribe(B, C, true);
-        {
-            const b = h.node(B);
-            assert.deepEqual(persona(b), { mode: 'base', lifecycle: 'terminal' }, 'B born base×terminal');
-            assert.equal(b.status, 'active', 'B active');
-            assert.equal(b.intent ?? null, null, 'B no intent');
-            assert.equal(h.status(C), 'active', 'C active — B holds a live sub to it');
-            assert.ok(h.subscriptions(B).some((s) => s.node_id === C && s.active), 'B subscribes_to C (active) — the awaiting precondition');
-        }
-        // BASELINE — as a TERMINAL node with the active live sub, B's stop is
-        // 'awaiting' (it would idle-release).
-        {
-            const stop = evaluateStop(B, SIGNALS);
-            assert.equal(stop.action, 'allow', 'terminal B → allow');
-            assert.equal(stop.reason, 'awaiting', 'terminal B with an active live sub → awaiting (would idle-release)');
-        }
-        // --- FLIP 1: terminal → RESIDENT (live). Oracle §4: sets lifecycle + the
-        //     launch spec, status/intent UNTOUCHED. ---
-        {
-            const res = h.cli(B, ['node', 'config', '--lifecycle', 'resident', '--node', B]);
-            assert.equal(res.code, 0, `config --lifecycle resident exit 0\n${res.stderr}`);
-            const b = h.node(B);
-            assert.equal(b.lifecycle, 'resident', 'B → resident');
-            assert.equal(b.mode, 'base', 'mode UNCHANGED by a lifecycle flip (orthogonal axis)');
-            assert.equal(b.status, 'active', 'status UNTOUCHED by node config --lifecycle (oracle §4)');
-            assert.equal(b.intent ?? null, null, 'intent UNTOUCHED by node config --lifecycle (oracle §4)');
-        }
-        // THE SUPPRESSION LOCK — as RESIDENT, B's stop is 'dormant' (NOT awaiting):
-        // a resident node is never forced to submit a final, so it does NOT idle-
-        // release even though it still holds the SAME active live sub to C that
-        // would release a terminal node. evaluateStop is the PURE decision the
-        // stophook enacts (the actual no-release commit is locked by canvas-
-        // stophook-agentend §5.1.7). NON-VACUOUS: revert the resident branch in
-        // stop-guard and B reads 'awaiting' → this goes RED (see bug-injection).
-        {
-            const stop = evaluateStop(B, SIGNALS);
-            assert.equal(stop.action, 'allow', 'resident B → allow');
-            assert.equal(stop.reason, 'dormant', 'resident B → dormant, NOT awaiting — idle-release SUPPRESSED by the live flip');
-        }
-        // FLIP 2: resident → TERMINAL (live), on the now-resident node.
-        {
-            const res = h.cli(B, ['node', 'config', '--lifecycle', 'terminal', '--node', B]);
-            assert.equal(res.code, 0, `config --lifecycle terminal exit 0\n${res.stderr}`);
-            const b = h.node(B);
-            assert.equal(b.lifecycle, 'terminal', 'B → terminal');
-            assert.equal(b.status, 'active', 'status still UNTOUCHED by the flip');
-            assert.equal(b.intent ?? null, null, 'intent still UNTOUCHED by the flip');
-        }
-        // THE RESTORE LOCK — terminal again, B's stop is 'awaiting' once more: the
-        // exact idle-release behavior the resident flip had suppressed.
-        {
-            const stop = evaluateStop(B, SIGNALS);
-            assert.equal(stop.action, 'allow', 'terminal B → allow');
-            assert.equal(stop.reason, 'awaiting', 'terminal B with the active live sub → awaiting AGAIN (idle-release RESTORED)');
-        }
-        assert.equal(h.status(C), 'active', 'C untouched throughout the round-trip');
-    }
-    finally {
-        await h.dispose();
-    }
-});
-// (b) MODE FLIP — promote: base → orchestrator on a LIVE node. Promotion leaves
-//     persona_ack pending; the next provider request appends and persists the
-//     transition before a guarded ack. This test pins that model precondition.
-test('live mode flip: promote base→orchestrator leaves persona_ack pending for provider-gated delivery', 
-// Full-CLI subprocess spawn under load — see the sibling test's budget note.
-{ timeout: 60_000 }, async () => {
-    const h = await createHeadlessHarness({ sessionPrefix: 'crtr-live-mode' });
-    try {
-        const A = h.spawnRoot('resident root');
-        const B = h.fabricateBrokerNode({ parent: A, kind: 'developer', mode: 'base', lifecycle: 'terminal', status: 'active' });
-        subscribe(A, B, true);
-        // Born acked to its own persona (mirroring a real birth) → no spurious
-        // drift before the promote (invariant 11).
-        commitPersonaAck(B, { kind: 'developer', mode: 'base', lifecycle: 'terminal' });
-        {
-            const b = h.node(B);
-            assert.deepEqual(persona(b), { mode: 'base', lifecycle: 'terminal' }, 'B born base×terminal');
-            assert.deepEqual(b.persona_ack, { kind: 'developer', mode: 'base', lifecycle: 'terminal' }, 'persona_ack born equal to the initial persona (invariant 11)');
-            assert.equal(personaDrift(B), null, 'no drift before the promote');
-        }
-        // PROMOTE changes mode only and leaves the transition pending.
-        {
-            const res = h.cli(B, ['node', 'promote', '--kind', 'developer']);
-            assert.equal(res.code, 0, `promote exit 0\n${res.stderr}`);
-            const b = h.node(B);
-            assert.equal(b.mode, 'orchestrator', 'B → orchestrator');
-            assert.equal(b.lifecycle, 'terminal', 'lifecycle UNCHANGED (promote is mode-only)');
-            assert.equal(b.status, 'active', 'status untouched by promote');
-            assert.equal(b.intent ?? null, null, 'intent untouched by promote');
-            assert.deepEqual(b.persona_ack, { kind: 'developer', mode: 'base', lifecycle: 'terminal' }, 'promote leaves the previous persona acknowledged');
-        }
-        // If promotion committed the ack itself, personaDrift would be null and
-        // these assertions would fail. Provider delivery is pinned separately.
-        {
-            const drift = personaDrift(B);
-            assert.ok(drift !== null, 'a recompose is pending after the live promote');
-            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 orchestration guidance');
-        }
-        // Model a successful delivery ack and prove the detector clears.
-        commitPersonaAck(B, { kind: 'developer', mode: 'orchestrator', lifecycle: 'terminal' });
-        assert.deepEqual(h.node(B).persona_ack, { kind: 'developer', mode: 'orchestrator', lifecycle: 'terminal' }, 'persona_ack recomposed to the new persona');
-        assert.equal(personaDrift(B), null, 'no fresh drift after the ack commit (idempotent recompose)');
-    }
-    finally {
-        await h.dispose();
-    }
-});

package/dist/core/__tests__/integration/plugin-revalidate.test.d.ts

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