@north-light/crouter 0.3.172 → 0.3.174

package/dist/core/__tests__/full/broker-model-changed-broadcast.test.js

@@ -1,57 +0,0 @@
-// Run with: node --import tsx/esm --test src/core/__tests__/full/broker-model-changed-broadcast.test.ts
-//
-// FULL TIER (real-boot-bound): tmux-free, but it boots a REAL broker process,
-// so it lives in full/ (CI), not the fast local loop.
-//
-// BUG-REGRESSION (real, observed 2026-06-11 in `crtr surface attach`): switching the
-// model (/model <provider/id> or the picker) visibly did nothing — the viewer's
-// status bar kept showing the OLD model until some unrelated event happened to
-// arrive.
-//
-// 3-PART HEADER:
-//  (1) BUG IT LOCKS — pi emits no AgentSessionEvent for a model switch, and the
-//      broker's `set_model`/`cycle_model` handlers replied with only a bare ack
-//      to the REQUESTING client. The new model reached no viewer at all: the
-//      broker now broadcasts a `model_changed` frame (mirroring
-//      snapshot.state.model) to every client after the engine accepts the switch.
-//  (2) WHY BROKER/SOCKET-LEVEL, NOT PANE — the regression is pure frame-plumbing
-//      on view.sock: a controller `set_model` in, an ack + `model_changed`
-//      fan-out. No tmux pane or TUI is involved, so the lock holds headlessly
-//      (createHeadlessHarness + the fake engine, whose registry stub resolves
-//      any `provider/id` and whose setModel stores what it is handed).
-//  (3) HOW IT FAILS ON REGRESSION — pre-fix, NO `model_changed` frame ever
-//      arrives at either the controller or the observer (both waits time out);
-//      the ack alone still passing would not satisfy the broadcast asserts.
-import { test, before, after, afterEach } from 'node:test';
-import assert from 'node:assert/strict';
-import { createHeadlessHarness } from '../helpers/harness.js';
-import { createAttachKit } from '../helpers/broker-clients.js';
-let h;
-let id;
-const kit = createAttachKit(() => h);
-const { attachUntil } = kit;
-before(async () => {
-    h = await createHeadlessHarness({ sessionPrefix: 'crtr-brkmodel' });
-    const root = h.spawnRoot('model-changed-broadcast suite root');
-    id = await h.spawnHeadlessChild(root, 'headless worker — model_changed broadcast gate');
-});
-after(async () => {
-    if (h !== undefined)
-        await h.dispose();
-});
-afterEach(() => {
-    kit.closeAll();
-});
-test('set_model acks the requester and broadcasts model_changed to every viewer', async () => {
-    const c = await attachUntil(id, 'controller', 'model-ctrl', (a) => a.welcome.role === 'controller', 'model-ctrl admitted controller');
-    const o = await attachUntil(id, 'observer', 'model-obs', (a) => a.welcome.role === 'observer', 'model-obs admitted observer');
-    c.send({ type: 'set_model', model: 'anthropic/fake-fable' });
-    const ack = await c.waitFrame((f) => f.type === 'ack' && f.for === 'set_model', 'set_model ack');
-    assert.ok(ack.type === 'ack' && ack.ok, 'set_model acked ok');
-    // BOTH the requester and the observer hear the switch. Pre-fix: no
-    // model_changed frame exists, so neither wait ever resolves.
-    const cm = await c.waitFrame((f) => f.type === 'model_changed', 'controller receives model_changed');
-    assert.ok(cm.type === 'model_changed' && cm.model?.id === 'fake-fable', 'controller sees the new model id');
-    const om = await o.waitFrame((f) => f.type === 'model_changed', 'observer receives model_changed');
-    assert.ok(om.type === 'model_changed' && om.model?.id === 'fake-fable', 'observer sees the new model id');
-});

package/dist/core/__tests__/full/broker-navigate-tree-rewelcome.test.d.ts

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

package/dist/core/__tests__/full/broker-navigate-tree-rewelcome.test.js

@@ -1,80 +0,0 @@
-// Run with: node --import tsx/esm --test src/core/__tests__/full/broker-navigate-tree-rewelcome.test.ts
-//
-// FULL TIER (real-boot-bound): tmux-free, but it boots a REAL broker process,
-// so it lives in full/ (CI), not the fast local loop.
-//
-// BUG-REGRESSION (real, observed 2026-06-11 in `crtr surface attach`): double-Esc (or
-// /tree) opened the session-tree picker, but SELECTING an entry visibly did
-// nothing — the viewer stayed on the old transcript instead of traveling back
-// to the chosen point in time.
-//
-// 3-PART HEADER:
-//  (1) BUG IT LOCKS — the broker's `navigate_tree` handler called
-//      session.navigateTree() (which rewinds IN-PLACE: same session file, new
-//      leaf, NO relayed AgentSessionEvent) and then only acked. Unlike the
-//      session-replacing ops (new_session/switch_session/fork → runReplacement
-//      → reWelcomeAll), it never re-snapshotted the viewers, so every attached
-//      client kept rendering the abandoned branch. The navigated-to user
-//      message's `editorText` (pi parity: the tree navigator restores it to the
-//      editor) was dropped on the floor too.
-//  (2) WHY BROKER/SOCKET-LEVEL, NOT PANE — the regression is pure frame-plumbing
-//      on view.sock: a controller `navigate_tree` in, a re-`welcome` fan-out +
-//      ack.detail out. No tmux pane or TUI is involved, so the lock holds
-//      headlessly (createHeadlessHarness + the fake engine, whose navigateTree
-//      pops the last accrued turn and returns `rewound-to:<targetId>`).
-//  (3) HOW IT FAILS ON REGRESSION — pre-fix, NO second welcome ever arrives
-//      (the re-welcome waits time out) and the navigate_tree ack carries no
-//      detail; the rewound-history assert (the turn token gone from the new
-//      snapshot) also goes red if the re-welcome serves a stale snapshot.
-import { test, before, after, afterEach } from 'node:test';
-import assert from 'node:assert/strict';
-import { createHeadlessHarness } from '../helpers/harness.js';
-import { createAttachKit, frameHas, tok } from '../helpers/broker-clients.js';
-let h;
-let id;
-const kit = createAttachKit(() => h);
-const { attachUntil } = kit;
-before(async () => {
-    h = await createHeadlessHarness({ sessionPrefix: 'crtr-brknav' });
-    const root = h.spawnRoot('navigate-tree-rewelcome suite root');
-    id = await h.spawnHeadlessChild(root, 'headless worker — navigate-tree rewelcome gate');
-});
-after(async () => {
-    if (h !== undefined)
-        await h.dispose();
-});
-afterEach(() => {
-    kit.closeAll();
-});
-const welcomes = (frames) => frames.filter((f) => f.type === 'welcome');
-test('navigate_tree re-welcomes every viewer onto the rewound transcript and acks the editor text', async () => {
-    const c = await attachUntil(id, 'controller', 'nav-ctrl', (a) => a.welcome.role === 'controller', 'nav-ctrl admitted controller');
-    // Accrue one observable turn so the rewind has something to drop.
-    const token = tok('NAV-TURN');
-    c.send({ type: 'prompt', text: token });
-    await c.waitFrame((f) => f.type === 'agent_end' && frameHas(f, token), 'turn relayed before navigate');
-    // The observer attaches AFTER the turn so its first welcome deterministically
-    // holds the token (the pre-navigate baseline) — same accrual trick as G3.
-    const o = await attachUntil(id, 'observer', 'nav-obs', (a) => frameHas(a.welcome, token), 'observer welcome holds the pre-navigate turn');
-    c.send({ type: 'navigate_tree', targetId: 'entry-x' });
-    // The ack carries the navigated-to user message's text in detail (the viewer
-    // restores it to the editor). Pre-fix: ack had no detail.
-    const ack = await c.waitFrame((f) => f.type === 'ack' && f.for === 'navigate_tree', 'navigate_tree ack');
-    assert.ok(ack.type === 'ack' && ack.ok, 'navigate_tree acked ok');
-    assert.equal(ack.type === 'ack' ? ack.detail : undefined, 'rewound-to:entry-x', 'ack.detail carries the rewound-to editor text');
-    // BOTH viewers get re-welcomed onto the rewound history. Pre-fix: no second
-    // welcome ever arrives (navigate_tree only acked).
-    await h.waitFor(() => (welcomes(c.frames).length >= 2 ? true : null), {
-        label: 'controller re-welcomed after navigate_tree',
-    });
-    await h.waitFor(() => (welcomes(o.frames).length >= 2 ? true : null), {
-        label: 'observer re-welcomed after navigate_tree',
-    });
-    // The re-welcome serves the REWOUND transcript: the fake's navigateTree popped
-    // the last accrued turn, so the token present in the observer's first welcome
-    // must be gone from its second.
-    const [first, second] = welcomes(o.frames);
-    assert.ok(frameHas(first, token), 'pre-navigate welcome holds the turn');
-    assert.ok(!frameHas(second, token), 're-welcome serves the rewound transcript (turn dropped)');
-    assert.equal(second.snapshot.messages.length, first.snapshot.messages.length - 2, 're-welcome history is exactly one turn shorter (a turn = user + assistant = 2 tree messages)');
-});

package/dist/core/__tests__/full/cascade-close.test.d.ts

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

package/dist/core/__tests__/full/cascade-close.test.js

@@ -1,240 +0,0 @@
-// Run with: node --import tsx/esm --test src/core/__tests__/cascade-close.test.ts
-//
-// CASCADE CLOSE + exclusive-subtree ownership — a FAITHFUL integration test of
-// `crtr node lifecycle close` on a MIDDLE node, driven through the REAL CLI against a REAL
-// isolated tmux session with REAL fake-pi vehicles in REAL panes, asserting off
-// the canvas data layer and checked against the state-model ORACLE
-// (state-model.md §4 `node lifecycle close`, §5 cascade-close ownership, invariant 3,
-// ambiguity A5).
-//
-// WHY this exists alongside the unit `close.test.ts`: that test exercises
-// `closeNode()` in-process against the data layer with FABRICATED pane strings
-// (`pane:'%x'`) — it proves the closing-set fixpoint and the status flip, but it
-// never kills a real tmux pane, never boots a real vehicle, and never closes a
-// MIDDLE node with a live sideways-sibling subtree. This test fills exactly that
-// gap: it builds a real tree, closes the middle, and proves the reap is EXACTLY
-// the closed node's own subtree — nothing above (the ancestor) or sideways (a
-// sibling subtree) is touched, and the real broker engines actually die.
-//
-// VIEWER MODEL (a09b71f): a managed child boots as a detached headless BROKER
-// with NO viewer pane on spawn (a viewer is opened on demand via `surface node focus`).
-// So "the node is up" is broker-engine liveness — its recorded `pi_pid` is alive
-// — NOT pane presence. close tears that broker engine down (headlessBrokerHost
-// .teardown over view.sock), so we assert pid liveness, not panes.
-//
-// The tree (covers BOTH required shapes in one topology):
-//
-//     A (resident root, in-process)
-//     ├── B   ◄── CLOSE TARGET (the middle node)
-//     │   ├── C
-//     │   │   └── E        depth  : A→B→C→E  (deep chain)
-//     │   └── D            breadth: B has two children {C, D}
-//     └── S                sideways sibling subtree — MUST survive
-//         └── G
-//
-//   close(B) ⇒ exclusive subtree {B,C,D,E} canceled; A,S,G untouched.
-//
-// CRITICAL DELIVERABLE (ambiguity A5): the EXACT terminal status a cascade-
-// closed descendant receives under `node lifecycle close`. With the fixtures made
-// non-empty below: status === 'canceled', intent === null (cleared) — for the
-// cascade ROOT and EVERY descendant alike (`transition(id,'cancel')`,
-// close.ts → lifecycle.ts cancel row: status='canceled', intent=null, from '*').
-// This differs from the ancestor-RESET path (`reapDescendants` → `reap` → 'done')
-// — same act, different terminal status: A5's open question. We assert the close
-// side and report the confirmed fact; we do NOT change it.
-//
-// FLAG vs the task brief: the brief expected "subscription+parent edges removed"
-// on close. CURRENT behavior + the ORACLE (§4: "Nothing is deleted: pi sessions +
-// edges persist → revivable") + the CLI help ("their pi sessions and canvas edges
-// persist for a later revive") all say edges PERSIST. This test asserts the
-// CURRENT (persist) behavior and the report flags the contradiction; production
-// is NOT changed.
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { spawnSync } from 'node:child_process';
-import { mkdirSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { createHarness, hasTmux, TMUX_TIMEOUT_MS } from '../helpers/harness.js';
-import { isPidAlive } from '../../canvas/pid.js';
-function sessionExists(session) {
-    return (spawnSync('tmux', ['has-session', '-t', session], {
-        stdio: 'ignore',
-        timeout: TMUX_TIMEOUT_MS,
-    }).status === 0);
-}
-function seedAssistantSession(sessionFile) {
-    mkdirSync(join(sessionFile, '..'), { recursive: true });
-    writeFileSync(sessionFile, JSON.stringify({ type: 'message', message: { role: 'assistant', content: [{ type: 'text', text: 'hi' }] } }) + '\n');
-}
-test('cascade close: middle-node lifecycle close cancels EXACTLY its subtree, ancestor + sideways untouched, edges persist', { skip: !hasTmux() ? 'tmux unavailable' : false, timeout: 180_000 }, async () => {
-    const h = await createHarness({ sessionPrefix: 'crtr-cascade' });
-    try {
-        // ===================================================================
-        // BUILD — the real tree. A is the in-process resident root (no pane);
-        // B,C,D,E,S,G are real managed children, each a real fake-pi in a real
-        // backstage pane (spawnChild awaits each boot). Every `node new` seeds the
-        // spine edge parent→child (active) + the spawned_by/parent provenance.
-        // ===================================================================
-        const A = h.spawnRoot('cascade-close root');
-        const B = await h.spawnChild(A, 'middle node — the close target', { kind: 'developer' });
-        const C = await h.spawnChild(B, 'B child one');
-        const E = await h.spawnChild(C, 'deep leaf under C'); // depth: A→B→C→E
-        const D = await h.spawnChild(B, 'B child two'); // breadth: B has {C, D}
-        const S = await h.spawnChild(A, 'sideways sibling of B'); // sideways subtree
-        const G = await h.spawnChild(S, 'child of the sideways sibling');
-        const subtree = [B, C, D, E]; // B's exclusive subtree (the expected cancel set)
-        const sideways = [S, G]; // a sibling subtree — must be wholly untouched
-        // Make the close-path fixtures NON-EMPTY so close exercises cancel+notice
-        // semantics instead of the new reap-empty path.
-        for (const id of subtree) {
-            const sessionFile = h.node(id).pi_session_file;
-            assert.ok(sessionFile !== null && sessionFile !== undefined, `${id} has a session file`);
-            seedAssistantSession(sessionFile);
-        }
-        // Pre-close sanity: every node live + present, spine wired as drawn.
-        {
-            for (const id of [B, C, D, E, S, G]) {
-                assert.ok(h.status(id) === 'active' || h.status(id) === 'idle', `${id} live before close`);
-                const pid = h.node(id).pi_pid;
-                assert.ok(pid != null && isPidAlive(pid), `${id} broker engine alive before close`);
-            }
-            assert.ok(h.status(A) === 'active' || h.status(A) === 'idle', 'A (root) live before close');
-            // Spine: A→{B,S}, B→{C,D}, C→{E}, S→{G} (all active spawn-seed edges).
-            const subIds = (n) => h.subscriptions(n).map((s) => s.node_id).sort();
-            assert.deepEqual(subIds(A), [B, S].sort(), 'A subscribes_to B and S');
-            assert.deepEqual(subIds(B), [C, D].sort(), 'B subscribes_to C and D');
-            assert.deepEqual(subIds(C), [E], 'C subscribes_to E');
-            assert.deepEqual(subIds(S), [G], 'S subscribes_to G');
-            // provenance edges (spawned_by / parent)
-            for (const [child, parent] of [[B, A], [C, B], [E, C], [D, B], [S, A], [G, S]]) {
-                assert.equal(h.node(child).parent, parent, `${child}.parent = ${parent}`);
-            }
-        }
-        // Make A's inbox NON-EMPTY before the close so "ancestor inbox intact" is a
-        // non-vacuous assertion: B pushes a routine update up its spine → A (B's
-        // sole active subscriber). A is the in-process root with no live watcher,
-        // so the pointer simply accumulates and must survive the close untouched.
-        {
-            const res = h.cli(B, ['push', 'update', 'progress from B before close']);
-            assert.equal(res.code, 0, `B push update exit 0\n${res.stderr}`);
-        }
-        const aInboxBefore = h.inbox(A);
-        assert.ok(aInboxBefore.some((e) => e.from === B && e.kind === 'update'), "A's inbox holds B's pre-close update (non-vacuous 'intact' baseline)");
-        // ===================================================================
-        // CLOSE the MIDDLE node B, through the REAL CLI (`crtr node lifecycle close --node B`,
-        // run AS the root A). closeNode is synchronous in the subprocess: by the
-        // time it returns, rows are flipped and panes are killed.
-        // ===================================================================
-        const closeRes = h.cli(A, ['node', 'lifecycle', 'close', '--node', B]);
-        assert.equal(closeRes.code, 0, `node lifecycle close exit 0\n${closeRes.stderr}`);
-        // The CLI's own rendered report (plain markdown): cascade root B, exactly
-        // 4 closed, 0 spared (no spared clause is emitted when none were spared).
-        assert.match(closeRes.stdout, new RegExp(`^Closed ${B} and its exclusive subtree — 4 node\\(s\\) closed\\.`), `close report names B as root, count=4, spared=0\n${closeRes.stdout}`);
-        // ===================================================================
-        // ASSERT 1 — the A5 DELIVERABLE: the EXACT terminal status of every
-        // cascade-closed node. With the fixtures now non-empty, close exercises
-        // cancel+notice semantics and the rows remain present as canceled husks.
-        // ===================================================================
-        for (const id of subtree) {
-            const n = h.node(id);
-            assert.equal(n.status, 'canceled', `${id} terminal status === 'canceled' (cancel event)`);
-            assert.strictEqual(n.intent ?? null, null, `${id} intent cleared to null on cancel`);
-        }
-        // Pin the exact field tuple once more, explicitly, for the human decision:
-        // a cascade-closed descendant under `node lifecycle close` reads (canceled, null) —
-        // NOT (done, done) and NOT (done, null). This is the confirmed A5 fact.
-        {
-            const e = h.node(E); // the deepest descendant
-            assert.deepEqual({ status: e.status, intent: e.intent ?? null }, { status: 'canceled', intent: null }, "deepest closed descendant E: (status,intent) === ('canceled', null)");
-        }
-        // ===================================================================
-        // ASSERT 2 — broker ENGINE torn down for the ENTIRE subtree (the real
-        // "node is up" invariant now: a closed node owns no live broker process).
-        // close → headlessBrokerHost.teardown shut each broker down over view.sock.
-        // ===================================================================
-        for (const id of subtree) {
-            await h.waitFor(() => {
-                const pid = h.node(id)?.pi_pid ?? null;
-                return pid === null || !isPidAlive(pid);
-            }, { label: `${id} broker engine torn down by close` });
-            const pid = h.node(id)?.pi_pid ?? null;
-            assert.ok(pid === null || !isPidAlive(pid), `${id} broker engine destroyed by close`);
-        }
-        // ===================================================================
-        // ASSERT 3 — EXCLUSIVE-SUBTREE OWNERSHIP: nothing ABOVE (A) and nothing
-        // SIDEWAYS (S, G) was reaped. close(B) canceled EXACTLY B's own subtree.
-        // ===================================================================
-        // Ancestor A — lifecycle untouched (still the live resident root), but A is
-        // the SURVIVING manager of the close-root B, so the wake doctrine fix WAKES
-        // it: a "child closed" notice is fanned to a manager OUTSIDE the closing set
-        // (D-1 — previously A heard nothing and a dormant A could hang forever).
-        {
-            const a = h.node(A);
-            assert.equal(a.status, 'active', 'A (ancestor) still active — untouched by the cascade');
-            assert.equal(a.lifecycle, 'resident', 'A still resident');
-            assert.equal(a.intent ?? null, null, 'A intent untouched');
-            // A's PRIOR entries are preserved; exactly ONE new child-closed entry
-            // from the closed child B is appended (the doctrine wake).
-            const aInbox = h.inbox(A);
-            assert.deepEqual(aInbox.slice(0, aInboxBefore.length), aInboxBefore, "A's prior inbox entries are preserved across the close");
-            const added = aInbox.slice(aInboxBefore.length);
-            assert.equal(added.length, 1, 'exactly one new entry appended to the surviving manager A');
-            assert.equal(added[0].from, B, 'the new entry is from the closed child B');
-            assert.match(added[0].label, /closed/i, 'the new entry tells A its child B was closed');
-        }
-        // Sideways subtree S→G — wholly alive: status active AND broker engine alive.
-        for (const id of sideways) {
-            assert.equal(h.status(id), 'active', `${id} (sideways) still active — not canceled`);
-            const pid = h.node(id).pi_pid;
-            assert.ok(pid != null && isPidAlive(pid), `${id} (sideways) broker engine still alive`);
-        }
-        // The strong "EXACTLY its own subtree" closure: every node in the graph is
-        // either in B's subtree (canceled) or untouched (active) — no over-reach.
-        {
-            const reaped = new Set(subtree);
-            for (const id of [A, B, C, D, E, S, G]) {
-                const want = reaped.has(id) ? 'canceled' : 'active';
-                assert.equal(h.status(id), want, `${id} status === '${want}' (no over-/under-reach)`);
-            }
-        }
-        // ===================================================================
-        // ASSERT 4 — EDGES PERSIST (CURRENT behavior + ORACLE §4). close is a pause,
-        // not a delete: a closed node keeps its spine + provenance edges so it can
-        // be revived. (FLAGGED in the report: the task brief expected "edges
-        // removed" — that contradicts current behavior; we assert persistence.)
-        // ===================================================================
-        {
-            const subIds = (n) => h.subscriptions(n).map((s) => s.node_id).sort();
-            // Ancestor's spine edge to the closed middle node survives.
-            assert.ok(h.subscriptions(A).some((s) => s.node_id === B && s.active), 'A→B subscription edge PERSISTS after close (revivable)');
-            // Intra-subtree spine edges survive too.
-            assert.deepEqual(subIds(B), [C, D].sort(), 'B→{C,D} edges persist');
-            assert.deepEqual(subIds(C), [E], 'C→E edge persists');
-            // Provenance (spawned_by / parent) survives.
-            for (const [child, parent] of [[B, A], [C, B], [E, C], [D, B]]) {
-                assert.equal(h.node(child).parent, parent, `${child}.parent = ${parent} persists`);
-            }
-            // Sideways edges obviously untouched.
-            assert.deepEqual(subIds(S), [G], 'S→G edge untouched');
-        }
-        // ===================================================================
-        // ASSERT 5 — each closed node got its cancellation notice (the resume
-        // breadcrumb), appended AFTER its watcher died (close.ts step 3). The root
-        // B reads "CLOSED by the user"; descendants read "CANCELED — an ancestor…".
-        // ===================================================================
-        {
-            const bNotice = h.inbox(B).at(-1);
-            assert.equal(bNotice.from, null, "B's cancel notice is a system message");
-            assert.match(bNotice.label, /CLOSED by the user/, 'B (cascade root) reads the CLOSED notice');
-            assert.equal(bNotice.data?.['cascade_root'], B, "B notice records the cascade root");
-            const eNotice = h.inbox(E).at(-1);
-            assert.match(eNotice.label, /CANCELED/, 'E (descendant) reads the CANCELED notice');
-            assert.equal(eNotice.data?.['cascade_root'], B, "E notice records B as the cascade root");
-        }
-    }
-    finally {
-        const session = h.session;
-        await h.dispose();
-        assert.equal(sessionExists(session), false, 'isolated session killed — no stray');
-    }
-});

package/dist/core/__tests__/full/detach-focus.test.d.ts

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

package/dist/core/__tests__/full/detach-focus.test.js

@@ -1,126 +0,0 @@
-// Run with: node --import tsx/esm --test src/core/__tests__/full/detach-focus.test.ts
-//
-// `crtr node demote --detach` on a node with a live viewer (Alt+C → D).
-//
-// BROKER-CUT ADAPTATION (insights/runtime/broker-is-the-host, 2026-06-10): every node is a
-// detached headless broker. After a09b71f a managed child opens NO viewer on
-// spawn — a viewer is opened on demand via `surface node focus`, registering
-// its `crtr surface attach` VIEWER pane in the focuses table. The engine is NOT in a pane, so the
-// pre-cut "relocate the still-running pi pane to the backstage" behavior —
-// detachToBackground's engine break-pane/release path, and its isGenerating()
-// gate that released a non-generating node to dormant — is DELETED. The Bug-1
-// non-generating-release test that locked that gate is deleted with it (the
-// behavior no longer exists; nothing to invent coverage for).
-//
-// What SURVIVES and is locked here: `node demote --detach` flips the node
-// terminal IN PLACE and CLOSES its viewer pane + focus row, leaving the broker
-// ENGINE running untouched (reconnectable by a later `focus`). This drives the
-// REAL verb (subprocess, AS the node) — the actual Alt+C → D menu path — against
-// a live broker node genuinely focused in a viewer pane, and proves:
-//   (a) lifecycle flips terminal in place,
-//   (b) the broker engine keeps running (pi_pid alive, unchanged — NOT killed),
-//   (c) the viewer pane is closed + its focus row dropped (no orphaned/phantom
-//       viewport row — Invariant P / F5).
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { spawnSync } from 'node:child_process';
-import { mkdirSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { createHarness, hasTmux, TMUX_TIMEOUT_MS } from '../helpers/harness.js';
-import { paneTag, taggedViewerPanes, waitForOneTaggedViewer } from '../helpers/viewer-panes.js';
-import { getNode } from '../../canvas/canvas.js';
-import { closeDb } from '../../canvas/db.js';
-import { isPidAlive } from '../../canvas/pid.js';
-const SKIP = !hasTmux() ? 'tmux unavailable' : false;
-function sessionExists(session) {
-    return (spawnSync('tmux', ['has-session', '-t', session], {
-        stdio: 'ignore',
-        timeout: TMUX_TIMEOUT_MS,
-    }).status === 0);
-}
-function paneExistsReal(pane) {
-    return ((spawnSync('tmux', ['display-message', '-p', '-t', pane, '#{pane_id}'], {
-        encoding: 'utf8',
-        timeout: TMUX_TIMEOUT_MS,
-    }).stdout ?? '').trim() === pane);
-}
-// P1 moved the `surface node focus` viewer registry off the `focuses` DB table (the CLI
-// can no longer write canvas.db) onto the tmux `@crtr_node` pane tag a
-// `crtr surface attach` viewer self-sets on connect. These helpers read that
-// pane-tag registry — the ground truth for "which pane is a node's viewer".
-// `paneTag` / `taggedViewerPanes` / `waitForOneTaggedViewer` live in
-// helpers/viewer-panes.ts, shared with the other full-tier viewer tests.
-// Split a throwaway pane in the harness session; return its %id. The caller pane
-// `surface node focus` opens the viewer beside (a09b71f: spawn no longer auto-opens one).
-// Write an assistant message into a node's pi session so it is NOT an empty
-// shell — reapIfEmpty (0515e8d) tears output-less nodes down on detach, which
-// would defeat the "broker survives" contract this test locks.
-function seedAssistantSession(sessionFile) {
-    mkdirSync(join(sessionFile, '..'), { recursive: true });
-    writeFileSync(sessionFile, JSON.stringify({ type: 'message', message: { role: 'assistant', content: [{ type: 'text', text: 'hi' }] } }) + '\n');
-}
-function makePane(session) {
-    const r = spawnSync('tmux', ['split-window', '-d', '-t', session, '-P', '-F', '#{pane_id}', 'sleep 100000'], { encoding: 'utf8', timeout: TMUX_TIMEOUT_MS });
-    const pane = (r.stdout ?? '').trim();
-    assert.ok(pane.startsWith('%'), `expected a %pane_id, got "${pane}" (stderr: ${r.stderr})`);
-    return pane;
-}
-// ===========================================================================
-// `crtr node demote --detach` on a node with a live viewer (Alt+C → D).
-// ===========================================================================
-test('node demote --detach: flips terminal in place, CLOSES the viewer pane + focus row, broker engine keeps running', { skip: SKIP, timeout: 120_000 }, async () => {
-    const h = await createHarness({ sessionPrefix: 'crtr-detach-focus' });
-    try {
-        // A resident root + a live terminal child B. spawnChild launches B's broker
-        // but opens NO viewer (a09b71f) — so B has no focus row yet.
-        const A = h.spawnRoot('resident root');
-        const B = await h.spawnChild(A, 'do the work', { kind: 'developer' });
-        const b0 = h.node(B);
-        assert.equal(b0.lifecycle, 'terminal', 'B born terminal');
-        assert.equal(b0.status, 'active', 'B active after boot');
-        const brokerPid = b0.pi_pid;
-        assert.ok(brokerPid != null && isPidAlive(brokerPid), 'B broker engine alive before detach');
-        // Make B NON-EMPTY (it produced an assistant message) so `--detach`
-        // exercises the "close the viewer, broker survives" contract and NOT the
-        // reap-empty path (0515e8d), which would tear an output-less shell down.
-        assert.ok(b0.pi_session_file != null, 'B has a session file');
-        seedAssistantSession(b0.pi_session_file);
-        // Put B genuinely "on screen": `surface node focus` opens its one `crtr surface attach`
-        // VIEWER pane beside a caller pane in the harness session — the on-demand
-        // viewer the detach then tears down.
-        const caller = makePane(h.session);
-        const focusRes = h.cli(B, ['surface', 'node', 'focus', B, '--pane', caller]);
-        assert.equal(focusRes.code, 0, `surface node focus B exit 0\n${focusRes.stderr}`);
-        // The viewer pane is the node's on-screen presence, registered by the
-        // `@crtr_node` pane tag the attach client self-sets on connect (P1: the CLI
-        // no longer writes the focuses DB table) — NOT a node-row pane (a broker
-        // carries null placement). Wait for the tag so the real registry is live.
-        const viewerPane = await waitForOneTaggedViewer(h.session, B);
-        assert.equal(paneExistsReal(viewerPane), true, 'B viewer pane is live on screen');
-        // --- Drive the REAL verb on the focused node (the Alt+C → D menu path). ---
-        const res = h.cli(B, ['node', 'lifecycle', 'demote', '--node', B, '--pane', viewerPane, '--detach']);
-        assert.equal(res.code, 0, `node demote --detach exit 0\n${res.stderr}`);
-        assert.match(res.stdout, /viewer closed \(broker still running off-screen\)/, `the viewer was closed\n${res.stdout}`);
-        closeDb();
-        const b = getNode(B);
-        // (a) lifecycle flipped to terminal IN PLACE (it was already terminal; the
-        //     demote is idempotent on lifecycle — the point is it does not end B).
-        assert.equal(b.lifecycle, 'terminal', '(a) B lifecycle=terminal after the flip');
-        assert.equal(b.status, 'active', '(a) detach does NOT end the node — B stays active');
-        // (b) the broker ENGINE keeps running — detach closes only the viewer, never
-        //     the engine (the one-host invariant: the engine was never in a pane).
-        assert.equal(b.pi_pid, brokerPid, "(b) B's broker pid is UNCHANGED (engine not killed/respawned)");
-        assert.equal(isPidAlive(brokerPid), true, '(b) B broker engine still alive off-screen');
-        // (c) the viewer pane is CLOSED and its focus row dropped — no orphaned /
-        //     phantom viewport (A3 hazard / Invariant P).
-        await h.waitForPaneGone(B);
-        assert.equal(paneExistsReal(viewerPane), false, '(c) B viewer pane closed');
-        assert.deepEqual(taggedViewerPanes(h.session, B), [], '(c) B no longer occupies any viewer (untagged — Invariant P)');
-        assert.equal(paneTag(viewerPane), '', '(c) NO phantom @crtr_node tag resolves on the closed viewer %id');
-    }
-    finally {
-        const session = h.session;
-        await h.dispose();
-        assert.equal(sessionExists(session), false, 'isolated session killed — no stray');
-    }
-});

package/dist/core/__tests__/full/idle-release-settlement.test.d.ts

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

package/dist/core/__tests__/full/issue-146-yield-spawn-focus.test.d.ts

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

package/dist/core/__tests__/full/issue-146-yield-spawn-focus.test.js

@@ -1,107 +0,0 @@
-// Run with: CRTR_MAX_LIVE_BROKERS=1000 node --import tsx/esm --test src/core/__tests__/full/issue-146-yield-spawn-focus.test.ts
-//
-// Issue #146 composed regression: a parent yields while a child launch is in flight,
-// its first cycling broker dies before session_start, and real `surface node focus`
-// then requests a strict resume. The locked revive arbiter must keep the durable refresh
-// authoritative, retry as a fresh cycle, and commit its intent/note only after the
-// retry reaches session_start.
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { spawnSync } from 'node:child_process';
-import { existsSync } from 'node:fs';
-import { createHarness, hasTmux, TMUX_TIMEOUT_MS, } from '../helpers/harness.js';
-import { isPidAlive } from '../../canvas/pid.js';
-import { updateNode } from '../../canvas/canvas.js';
-import { readYieldMessage, yieldMessagePath } from '../../runtime/kickoff.js';
-import { FAIL_BEFORE_SESSION_START_ONCE } from '../fixtures/fake-engine.js';
-const SKIP = !hasTmux() ? 'tmux unavailable' : false;
-function makeCallerPane(session) {
-    const result = spawnSync('tmux', ['split-window', '-d', '-t', session, '-P', '-F', '#{pane_id}', 'sleep 100000'], { encoding: 'utf8', timeout: TMUX_TIMEOUT_MS });
-    const pane = (result.stdout ?? '').trim();
-    assert.ok(pane.startsWith('%'), `expected a tmux pane id, got "${pane}" (stderr: ${result.stderr})`);
-    return pane;
-}
-function outputField(stdout, name) {
-    return stdout.match(new RegExp(`^- ${name}:\\s*(.*)$`, 'm'))?.[1]?.trim();
-}
-test('yield + concurrent child spawn + failed cycle + focus preserves fresh-refresh authority', { skip: SKIP, timeout: 180_000 }, async () => {
-    const h = await createHarness({ sessionPrefix: 'crtr-issue146' });
-    try {
-        const root = h.spawnRoot('issue 146 acting root');
-        const parent = await h.spawnHeadlessChild(root, 'issue 146 orchestrator parent', {
-            kind: 'developer',
-            mode: 'orchestrator',
-        });
-        // Keep this test-only orchestrator resident so the fake engine's automatic
-        // kickoff turn cannot legitimately idle-release it after session_start; the
-        // assertions below can then observe the confirmation commit itself.
-        updateNode(parent, { lifecycle: 'resident' });
-        const initial = h.node(parent);
-        const oldPid = initial.pi_pid;
-        const baseBoots = h.bootCount(parent);
-        const baseCycles = initial.cycles ?? 0;
-        assert.ok(initial.pi_session_file != null && existsSync(initial.pi_session_file), 'parent booted with a real session file');
-        assert.equal(isPidAlive(oldPid), true, 'parent broker is alive before yielding');
-        // spawnHeadlessChild drives real `node new` synchronously, then yields while
-        // awaiting the child broker boot. Start it without awaiting so parent yield
-        // overlaps that boot exactly as the reported issue did.
-        const childBoot = h.spawnHeadlessChild(parent, 'issue 146 concurrent child');
-        const note = `Issue #146 ${FAIL_BEFORE_SESSION_START_ONCE} retain this yield handoff`;
-        const yielded = h.cli(parent, ['node', 'yield', note]);
-        assert.equal(yielded.code, 0, `node yield should succeed\n--stderr--\n${yielded.stderr}`);
-        assert.equal(h.node(parent)?.intent, 'refresh', 'yield durably records refresh intent');
-        const child = await childBoot;
-        assert.ok(h.subscriptions(parent).some((entry) => entry.node_id === child && entry.active), 'parent remains actively subscribed to the concurrently spawned child');
-        // End the old engine turn through the real stophook. Its ChildProcess exit
-        // automatically enqueues policy row 3 (refresh → respawn-fresh); no
-        // liveness tick or grace is involved. The short-lived-exit throttle may
-        // defer the replacement briefly, so observe the new pid rather than a
-        // fixed clock.
-        await h.stop(parent);
-        await h.waitFor(() => !isPidAlive(oldPid), { label: 'yielded parent broker exited' });
-        assert.equal(h.node(parent)?.intent, 'refresh', 'refresh intent survives the old broker exit');
-        const failedCyclePid = await h.waitFor(() => {
-            const pid = h.node(parent)?.pi_pid;
-            return pid != null && pid !== oldPid ? pid : null;
-        }, { label: 'exit-event refresh launch recorded its broker pid', timeoutMs: 30_000 });
-        await h.waitFor(() => !isPidAlive(failedCyclePid), {
-            label: 'one-shot cycling broker died before session_start',
-        });
-        // Capture before focus but assert afterward. This keeps the competing real
-        // focus path non-vacuous even if one of these durable preconditions regresses.
-        const preFocus = {
-            cycles: h.node(parent)?.cycles,
-            intent: h.node(parent)?.intent ?? null,
-            cyclePending: h.node(parent)?.cycle_pending,
-            note: readYieldMessage(parent),
-            noteExists: existsSync(yieldMessagePath(parent)),
-            boots: h.bootCount(parent),
-        };
-        const callerPane = makeCallerPane(h.session);
-        const focused = h.cli(root, ['surface', 'node', 'focus', parent, '--pane', callerPane]);
-        const confirmed = await h.awaitBoot(parent, { minCount: baseBoots + 1, timeoutMs: 120_000 });
-        const final = h.node(parent);
-        assert.equal(focused.code, 0, `surface node focus should succeed\n--stderr--\n${focused.stderr}`);
-        assert.equal(outputField(focused.stdout, 'revived'), 'true', 'real focus drives the production resume=true revive entrypoint');
-        assert.equal(preFocus.boots, baseBoots, 'failed cycling launch never reached session_start');
-        assert.equal(preFocus.cycles, baseCycles + 1, 'first actual refresh launch increments cycles exactly once');
-        assert.equal(preFocus.intent, 'refresh', 'refresh intent survives the pre-session_start failure');
-        assert.equal(preFocus.cyclePending, true, 'failed cycling launch remains pending before confirmation');
-        assert.equal(preFocus.note?.trim(), note, 'failed launch leaves the complete yield handoff durable');
-        assert.equal(preFocus.noteExists, true, 'yield handoff file remains present before confirmation');
-        assert.equal(confirmed.resuming, false, 'focus cannot reopen the old session while refresh is pending');
-        assert.ok(confirmed.prompt !== null && confirmed.prompt.includes(note), 'successful cycling retry receives the original yield note');
-        assert.equal(final.cycles, baseCycles + 2, 'focus retry increments from the locked latest cycle exactly once');
-        assert.equal(final.cycle_pending, false, 'confirmed session_start clears the pending-cycle marker');
-        assert.equal(final.intent ?? null, null, 'confirmed session_start commits the refresh intent');
-        assert.equal(readYieldMessage(parent), null, 'confirmed session_start clears the one-shot yield handoff');
-        assert.equal(existsSync(yieldMessagePath(parent)), false, 'yield handoff file is gone only after confirmation');
-        const childState = h.node(child);
-        assert.equal(childState.status, 'active', 'concurrent child remains booted');
-        assert.ok(childState.pi_pid != null && isPidAlive(childState.pi_pid), 'concurrent child broker remains alive');
-        assert.ok(h.subscriptions(parent).some((entry) => entry.node_id === child && entry.active), 'parent-child subscription survives the parent refresh');
-    }
-    finally {
-        await h.dispose();
-    }
-});

package/dist/core/__tests__/full/park-clock-release.test.d.ts

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