@crouton-kit/crouter 0.3.28 → 0.3.30

package/dist/core/__tests__/full/daemon-liveness-pane.full.test.js

@@ -1,292 +0,0 @@
-// Run with: node --import tsx/esm --test src/core/__tests__/full/daemon-liveness-pane.full.test.ts
-//
-// FULL-TIER (genuine tmux) half of the daemon liveness suite — split out of
-// daemon-liveness.test.ts (foundation-spec §C.8 + §E). These lock the daemon's
-// PANE-existence reconciliation: a live pane vs a stale window cache, the gone-
-// branch routing (crash / finalize / release), and the frozen-pane idle-release
-// revive. Every one of them needs a REAL live tmux window+pane to be faithful —
-// the verdict turns on `isNodePaneAlive → paneExists/paneLocation/listLivePanes`
-// probing the tmux server — so it cannot be model-fabricated; it stays CI-only.
-// (The pure decision primitives — livenessVerdict, isPidAlive — are the fast
-// half, in src/core/__tests__/daemon-liveness.test.ts.)
-import { test, before, after, beforeEach } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { spawn, spawnSync } from 'node:child_process';
-import { createNode, getNode, subscribe } from '../../canvas/canvas.js';
-import { closeDb } from '../../canvas/db.js';
-import { appendInbox } from '../../feed/inbox.js';
-import { markBusy, clearBusy } from '../../runtime/busy.js';
-import { superviseTick } from '../../../daemon/crtrd.js';
-let home;
-function node(id, over = {}) {
-    return {
-        node_id: id,
-        name: id,
-        created: new Date().toISOString(),
-        cwd: '/tmp/work',
-        kind: 'general',
-        mode: 'base',
-        lifecycle: 'terminal',
-        status: 'active',
-        ...over,
-    };
-}
-function hasTmux() {
-    return spawnSync('tmux', ['-V'], { stdio: 'ignore' }).status === 0;
-}
-/** A pid that is guaranteed dead: spawn a no-op and wait for it to exit. */
-function deadPid() {
-    const r = spawnSync('true', [], { stdio: 'ignore' });
-    return r.pid ?? 0x7ffffffe; // fall back to an implausibly-high pid
-}
-/** A pid that is ALIVE for the test's duration but expendable. Pane-gone
- *  fixtures must NEVER use process.pid for an alive pi: the gone-pane zombie
- *  sweep (b92082e) SIGKILLs a pane-gone node's live pid, which took the whole
- *  test runner down with it. The daemon (or the after hook) reaps these. */
-const livePids = [];
-function disposableLivePid() {
-    const child = spawn('sleep', ['600'], { stdio: 'ignore', detached: true });
-    child.unref();
-    livePids.push(child.pid);
-    return child.pid;
-}
-before(() => {
-    home = mkdtempSync(join(tmpdir(), 'crtr-daemon-liveness-pane-'));
-    process.env['CRTR_HOME'] = home;
-});
-beforeEach(() => {
-    closeDb();
-    rmSync(home, { recursive: true, force: true });
-});
-after(() => {
-    closeDb();
-    rmSync(home, { recursive: true, force: true });
-    delete process.env['CRTR_HOME'];
-    for (const pid of livePids) {
-        try {
-            process.kill(pid, 'SIGKILL');
-        }
-        catch {
-            /* already reaped by the daemon's zombie sweep — fine */
-        }
-    }
-});
-// ---------------------------------------------------------------------------
-// superviseTick + a REAL live tmux window (gated on tmux availability)
-// ---------------------------------------------------------------------------
-/** Run `fn` with a real, live tmux window held open for its whole duration, then
- *  tear the session down. Gives superviseTick a genuinely-alive window to judge. */
-async function withLiveWindow(tag, fn) {
-    const session = `crtr-livetest-${process.pid}-${tag}`;
-    spawnSync('tmux', ['new-session', '-d', '-s', session, '-c', '/tmp', 'sleep 600']);
-    try {
-        const r = spawnSync('tmux', ['list-windows', '-t', session, '-F', '#{window_id}'], { encoding: 'utf8' });
-        const window = (r.stdout ?? '').trim().split('\n')[0];
-        await fn(session, window);
-    }
-    finally {
-        spawnSync('tmux', ['kill-session', '-t', session], { stdio: 'ignore' });
-    }
-}
-/** Like withLiveWindow but also resolves the window's live `%pane_id` — the v3
- *  pane-anchored handle the daemon now keys liveness on. */
-async function withLivePane(tag, fn) {
-    await withLiveWindow(tag, async (session, window) => {
-        const r = spawnSync('tmux', ['display-message', '-p', '-t', `${session}:${window}`, '#{pane_id}'], { encoding: 'utf8' });
-        const pane = (r.stdout ?? '').trim();
-        await fn(session, window, pane);
-    });
-}
-test('window alive + ALIVE pi pid → healthy, untouched', { skip: !hasTmux() }, async () => {
-    await withLiveWindow('a', async (session, window) => {
-        // pi_pid = this test process: definitely alive.
-        createNode(node('A', { tmux_session: session, window, pi_pid: process.pid, pi_session_id: 'booted' }));
-        await superviseTick();
-        assert.equal(getNode('A').status, 'active', 'a node with a live pi is left active');
-    });
-});
-test('window alive + dead pi pid → pending on first observation (not reaped, not revived)', { skip: !hasTmux() }, async () => {
-    await withLiveWindow('b', async (session, window) => {
-        createNode(node('D', {
-            tmux_session: session,
-            window,
-            pi_pid: deadPid(),
-            pi_session_id: 'booted-once',
-            intent: null,
-            status: 'active',
-        }));
-        await superviseTick();
-        // First observation: inside the grace window → pending. The node must NOT be
-        // reaped to 'dead' (its window is alive) nor revived yet (no new pi spawned).
-        assert.equal(getNode('D').status, 'active', 'pending node stays active on first tick');
-    });
-});
-// ---------------------------------------------------------------------------
-// Step 3 (Q6): PANE-existence drives the daemon verdict, not window-existence.
-// A manual move-pane/join-pane/break-pane must never read as a death; and a
-// pane that is genuinely gone fires the existing gone-branch even when the
-// window it used to live in is still alive.
-// ---------------------------------------------------------------------------
-test('pane alive but window/session cache STALE → LIVE (reconciled, not revived/reaped)', { skip: !hasTmux() }, async () => {
-    await withLivePane('p1', async (session, window, pane) => {
-        // The pane is live, the pi is alive (this process) — but the row's window
-        // cache is bogus (as if a manual move desynced it). Pane-existence must win:
-        // the node stays active and reconcile FOLLOWS the pane back to its real window.
-        createNode(node('M', {
-            pane,
-            tmux_session: session,
-            window: '@99999', // stale/bogus — windowAlive() would call this gone
-            pi_pid: process.pid,
-            pi_session_id: 'booted',
-        }));
-        await superviseTick();
-        const m = getNode('M');
-        assert.equal(m.status, 'active', 'a live pane keeps the node active despite a stale window cache');
-        assert.equal(m.window, window, 'reconcile FOLLOWED the live pane back to its real window');
-        assert.equal(m.pane, pane, 'the durable pane id is unchanged');
-    });
-});
-test('pane GONE while its old window is still alive → the gone-branch fires (crash → dead)', { skip: !hasTmux() }, async () => {
-    await withLivePane('p2', async (session, window) => {
-        // Make a guaranteed-DEAD pane id inside the still-live window: split a fresh
-        // pane, then kill it (the window survives via its original pane).
-        const sp = spawnSync('tmux', ['split-window', '-d', '-P', '-F', '#{pane_id}', '-t', `${session}:${window}`, 'sleep 600'], { encoding: 'utf8' });
-        const dead = (sp.stdout ?? '').trim();
-        spawnSync('tmux', ['kill-pane', '-t', dead], { stdio: 'ignore' });
-        // The window is alive, but the node is anchored on that dead pane. Under the
-        // old window-keyed liveness this node would read healthy (window alive + live
-        // pid). Pane-keyed: the pane is gone → the gone-branch fires. The node is
-        // MID-GENERATION (busy marker present — agent_start touched it, agent_end
-        // never cleared it), so the gone-branch routes to crash → 'dead'.
-        createNode(node('G', {
-            pane: dead,
-            tmux_session: session,
-            window,
-            pi_pid: disposableLivePid(), // alive zombie — the gone-pane sweep SIGKILLs it
-            pi_session_id: 'booted',
-            intent: null,
-        }));
-        markBusy('G'); // pane killed inside a turn → genuine mid-run crash
-        await superviseTick();
-        assert.equal(getNode('G').status, 'dead', 'a gone pane mid-generation fires the gone-branch → crash (dead)');
-        clearBusy('G');
-    });
-});
-// ---------------------------------------------------------------------------
-// Gone-pane routing: a pane-gone node in the crash branch is no longer an
-// unconditional 'dead'. It routes on what the node was DOING at pane-kill time:
-//   • mid-generation (busy marker PRESENT)               → crash  ('dead')
-//   • finished its turn, awaiting nothing live           → finalize ('done')
-//   • finished its turn, still awaiting a LIVE child     → release ('idle' + idle-release), revivable
-// (The mid-generation → dead leg is covered by node 'G' above.)
-// ---------------------------------------------------------------------------
-test('pane gone + booted + busy ABSENT + no live subscription → finalize (done): the pane was closed to dismiss a finished node', { skip: !hasTmux() }, async () => {
-    await withLivePane('fin1', async (session, window) => {
-        const sp = spawnSync('tmux', ['split-window', '-d', '-P', '-F', '#{pane_id}', '-t', `${session}:${window}`, 'sleep 600'], { encoding: 'utf8' });
-        const dead = (sp.stdout ?? '').trim();
-        spawnSync('tmux', ['kill-pane', '-t', dead], { stdio: 'ignore' });
-        // Booted (pi_session_id set), no busy marker (agent_end cleared it → the turn
-        // finished), and no subscription to any live node. Closing the pane was a
-        // dismissal of a node that already did its own work → finalize to 'done'.
-        createNode(node('FIN', {
-            pane: dead,
-            tmux_session: session,
-            window,
-            pi_pid: disposableLivePid(), // alive zombie — swept before finalize routing
-            pi_session_id: 'booted',
-            intent: null,
-        }));
-        // no markBusy: the turn ended cleanly.
-        await superviseTick();
-        assert.equal(getNode('FIN').status, 'done', 'a finished, unsubscribed node whose pane was closed finalizes to done');
-    });
-});
-test('pane gone + booted + busy ABSENT but AWAITING a LIVE child → idle-release (revivable, NOT dead)', { skip: !hasTmux() }, async () => {
-    await withLivePane('fin2', async (session, window) => {
-        const sp = spawnSync('tmux', ['split-window', '-d', '-P', '-F', '#{pane_id}', '-t', `${session}:${window}`, 'sleep 600'], { encoding: 'utf8' });
-        const dead = (sp.stdout ?? '').trim();
-        spawnSync('tmux', ['kill-pane', '-t', dead], { stdio: 'ignore' });
-        // A live child the parent is subscribed to: hasActiveLiveSubscription === true.
-        createNode(node('CHILD', { status: 'active', pi_session_id: 'booted' }));
-        createNode(node('PARENT', {
-            pane: dead,
-            tmux_session: session,
-            window,
-            pi_pid: deadPid(), // the user closed the pane → pi is dead
-            pi_session_id: 'booted',
-            intent: null,
-        }));
-        subscribe('PARENT', 'CHILD', true); // active subscription to a LIVE node
-        // REGRESSION: closing the pane of a waiting orchestrator must NOT kill it.
-        // PARENT finished its turn (no busy marker) but still awaits a live child, so
-        // a hard 'dead' would orphan the child's report. It routes to idle-release
-        // (revivable); the second pass revives it on the next inbox push. No inbox
-        // entry here, so it stays dormant (idle + idle-release) — revivable, not dead.
-        await superviseTick();
-        const p = getNode('PARENT');
-        assert.equal(p.status, 'idle', 'a finished node still awaiting a live child is RELEASED, not killed');
-        assert.equal(p.intent, 'idle-release', 'routed to idle-release so a child push revives it');
-        assert.equal(p.window ?? null, null, 'the stale window ref is dropped');
-    });
-});
-// ---------------------------------------------------------------------------
-// Step 7 (§5.3, F3): a focused-dormant node frozen via remain-on-exit is
-// PANE-alive but pi-DEAD with intent='idle-release'. The daemon must NOT
-// grace-revive it on liveness (handleLiveWindow early-returns for idle-release);
-// it revives ONLY when an unseen inbox entry arrives (second pass, gated on pi
-// liveness — NOT pane existence, which would skip a frozen pane forever).
-// ---------------------------------------------------------------------------
-test('idle-release + live (frozen) pane + DEAD pi → handleLiveWindow does NOT grace-revive it', { skip: !hasTmux() }, async () => {
-    await withLivePane('idle1', async (session, window, pane) => {
-        createNode(node('F', {
-            pane,
-            tmux_session: session,
-            window,
-            pi_pid: deadPid(), // pi is DEAD; the pane is frozen (remain-on-exit stand-in)
-            pi_session_id: 'booted',
-            intent: 'idle-release',
-            status: 'idle',
-            home_session: session,
-        }));
-        // Two ticks: the SECOND is far past REVIVE_GRACE_MS (20s). Without the
-        // idle-release early-return in handleLiveWindow, tick 1 would mark the dead
-        // pi 'pending' and tick 2 (now past grace) would grace-revive it, bumping
-        // cycles. The early-return means it is never even marked pending. No inbox
-        // entry, so the second pass never revives it either.
-        await superviseTick(1_000_000);
-        await superviseTick(1_000_000 + 60_000);
-        const m = getNode('F');
-        assert.equal(m.status, 'idle', 'still idle — the frozen focused-dormant node is left alone');
-        assert.equal(m.cycles ?? 0, 0, 'cycles NOT bumped → reviveNode never fired');
-        assert.equal(m.pane, pane, 'pane unchanged');
-        assert.equal(m.window, window, 'window unchanged');
-        // Non-vacuous: drop the `intent==='idle-release'` early-return and tick 2
-        // (deadFor 60s > 20s grace) revives → cycles===1, status flips → both fail.
-    });
-});
-test('idle-release + live (frozen) pane + DEAD pi + UNSEEN inbox → REVIVED on the second pass', { skip: !hasTmux() }, async () => {
-    await withLivePane('idle2', async (session, window, pane) => {
-        createNode(node('W', {
-            pane,
-            tmux_session: session,
-            window,
-            pi_pid: deadPid(),
-            pi_session_id: 'booted',
-            intent: 'idle-release',
-            status: 'idle',
-            home_session: session, // the revive window lands here (torn down with the session)
-        }));
-        appendInbox('W', { from: 'child', tier: 'normal', kind: 'update', label: 'work for you' });
-        await superviseTick();
-        // The OLD second-pass guard `if (isNodePaneAlive(r)) continue;` would SKIP a
-        // pane-alive node forever; the new `if (r.pi_pid != null && isPidAlive(...))`
-        // gate sees the DEAD pi and revives. reviveNode bumps cycles BEFORE placing
-        // the window, so the bump is the observable even though the launch is a real
-        // (short-lived, torn-down) window. Non-vacuous: the old pane-existence gate
-        // leaves cycles unbumped.
-        assert.equal(getNode('W').cycles, 1, 'reviveNode fired on the inbox push despite a live (frozen) pane');
-    });
-});

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

@@ -1,309 +0,0 @@
-// Run with: node --import tsx/esm --test src/core/__tests__/placement-focus.test.ts
-//
-// STEP 6 of the placement/focus migration: retargetFocus / openFocus / focus +
-// remain-on-exit + root-boot focus #1.
-//
-// Two proof tiers (mirrors placement-revive.test.ts):
-//   1. PURE (no tmux): outgoingDisposition (backstage-vs-kill). Provably
-//      non-vacuous (a wrong impl fails).
-//   2. Gated real-tmux: the hot-swap itself — screen position invariant (ZERO new
-//      user windows), the two post-swap LOCATIONs, outgoing backstaged (still
-//      generating) vs reaped (dormant), the Q5 vacate-old-focus path, openFocus
-//      splitting a holder viewport, and the front-door round-trip with UNIQUE
-//      node_id upheld. The swap is a real tmux op, so a faithful assertion needs
-//      a live server; gated {skip:!hasTmux()} like §5.2.
-import { test, before, after, beforeEach } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { spawnSync } from 'node:child_process';
-import { createNode, getNode, setPresence } from '../../canvas/canvas.js';
-import { openFocusRow, getFocusByNode, getFocusById, listFocuses, } from '../../canvas/focuses.js';
-import { closeDb } from '../../canvas/db.js';
-import { outgoingDisposition, retargetFocus, openFocus, focus as placementFocus, registerRootFocus, focusByPane, detachToBackground, } from '../../runtime/placement.js';
-import { markBusy, isBusy } from '../../runtime/busy.js';
-let home;
-let savedTmux;
-function node(id, over = {}) {
-    return {
-        node_id: id,
-        name: id,
-        created: new Date().toISOString(),
-        cwd: '/tmp/work',
-        kind: 'developer',
-        mode: 'base',
-        lifecycle: 'terminal',
-        status: 'active',
-        ...over,
-    };
-}
-function hasTmux() {
-    return spawnSync('tmux', ['-V'], { stdio: 'ignore' }).status === 0;
-}
-before(() => {
-    home = mkdtempSync(join(tmpdir(), 'crtr-placement-focus-'));
-    process.env['CRTR_HOME'] = home;
-    savedTmux = process.env['TMUX'];
-    delete process.env['TMUX']; // pure tests exercise the deterministic no-tmux path
-});
-beforeEach(() => {
-    closeDb();
-    rmSync(home, { recursive: true, force: true });
-});
-after(() => {
-    closeDb();
-    rmSync(home, { recursive: true, force: true });
-    delete process.env['CRTR_HOME'];
-    if (savedTmux !== undefined)
-        process.env['TMUX'] = savedTmux;
-});
-// ---------------------------------------------------------------------------
-// 1a. PURE: outgoingDisposition — the 4-field truth table (kill / backstage /
-// release). Each branch is provably non-vacuous (a wrong impl fails).
-// ---------------------------------------------------------------------------
-test('outgoingDisposition: a HOLDER / vanished node (no row) → KILL (never backstaged)', () => {
-    // A wrong impl that backstaged a holder would leak a sleep pane into crtr.
-    assert.deepEqual(outgoingDisposition({ exists: false, live: false, resident: false, generating: false }), { kind: 'kill' });
-    assert.deepEqual(outgoingDisposition({ exists: false, live: true, resident: true, generating: true }), { kind: 'kill' });
-});
-test('outgoingDisposition: a done/dead node (not live) → KILL (Invariant P: not-focused + not-live ⇒ no pane)', () => {
-    assert.deepEqual(outgoingDisposition({ exists: true, live: false, resident: false, generating: false }), { kind: 'kill' });
-});
-test('outgoingDisposition: a RESIDENT node (editor/root) → BACKSTAGE (human-driven, NEVER despawned on focus-away)', () => {
-    // Resident wins even when NOT mid-turn — a wrong impl here KILLS the user\'s editor.
-    assert.deepEqual(outgoingDisposition({ exists: true, live: true, resident: true, generating: false }), { kind: 'backstage' });
-    assert.deepEqual(outgoingDisposition({ exists: true, live: true, resident: true, generating: true }), { kind: 'backstage' });
-});
-test('outgoingDisposition: a still-generating terminal worker → BACKSTAGE (F2: keeps running off-screen)', () => {
-    assert.deepEqual(outgoingDisposition({ exists: true, live: true, resident: false, generating: true }), { kind: 'backstage' });
-});
-test('outgoingDisposition: a PARKED terminal viewer (live, not mid-turn) → RELEASE (despawn to dormant — the stuck-green fix)', () => {
-    assert.deepEqual(outgoingDisposition({ exists: true, live: true, resident: false, generating: false }), { kind: 'release' });
-});
-// ---------------------------------------------------------------------------
-// 2. Gated real-tmux: the hot-swap. Two isolated sessions: `user` (the user's
-// terminal) + `back` (stand-in for the backstage `crtr`). Panes run `sleep`,
-// never a real pi; node pi_pid is set explicitly to control "generating".
-// ---------------------------------------------------------------------------
-function tmuxOut(args) {
-    return (spawnSync('tmux', args, { encoding: 'utf8' }).stdout ?? '').trim();
-}
-function windowIds(session) {
-    return tmuxOut(['list-windows', '-t', session, '-F', '#{window_id}']).split('\n').filter((s) => s !== '');
-}
-function paneExistsReal(pane) {
-    return tmuxOut(['display-message', '-p', '-t', pane, '#{pane_id}']) === pane;
-}
-function paneSession(pane) {
-    return tmuxOut(['display-message', '-p', '-t', pane, '#{session_name}']);
-}
-/** A live extra pane in `session:window` running sleep; returns its `%pane_id`. */
-function livePane(session, window) {
-    return tmuxOut(['split-window', '-d', '-P', '-F', '#{pane_id}', '-t', `${session}:${window}`, 'sleep 600']);
-}
-const NOREVIVE = () => {
-    throw new Error('reviver should not be called when the node has a live pin pane');
-};
-/** A reviver that opens a real backstage `sleep` window for the node and points
- *  its presence at it — the stand-in for reviveIntoPlacement's backstage branch. */
-function backstageReviver(back) {
-    return (id) => {
-        const out = tmuxOut(['new-window', '-d', '-a', '-P', '-F', '#{window_id}\t#{pane_id}', '-t', `${back}:`, 'sleep 600']);
-        const [w, p] = out.split('\t');
-        setPresence(id, { pane: p, tmux_session: back, window: w });
-    };
-}
-async function withSessions(tag, fn) {
-    const user = `crtr-pf-user-${process.pid}-${tag}`;
-    const back = `crtr-pf-back-${process.pid}-${tag}`;
-    spawnSync('tmux', ['new-session', '-d', '-s', user, '-c', '/tmp', 'sleep 600']);
-    spawnSync('tmux', ['new-session', '-d', '-s', back, '-c', '/tmp', 'sleep 600']);
-    try {
-        await fn({ user, back, userWindow: windowIds(user)[0], backWindow: windowIds(back)[0] });
-    }
-    finally {
-        spawnSync('tmux', ['kill-session', '-t', user], { stdio: 'ignore' });
-        spawnSync('tmux', ['kill-session', '-t', back], { stdio: 'ignore' });
-    }
-}
-test('retargetFocus: outgoing GENERATING → backstaged; the viewport stays put (ZERO new user windows)', { skip: !hasTmux() }, async () => {
-    await withSessions('gen', async ({ user, back, userWindow, backWindow }) => {
-        const focusPane = livePane(user, userWindow); // R's focus pane (the viewport)
-        const backPane = livePane(back, backWindow); // A's live backstage pane
-        // R is the outgoing occupant, generating: a terminal worker MID-TURN (live
-        // pi_pid AND the busy marker set). A is incoming.
-        createNode(node('R', { pane: focusPane, tmux_session: user, window: userWindow, status: 'active', lifecycle: 'terminal', pi_pid: process.pid, home_session: back }));
-        createNode(node('A', { pane: backPane, tmux_session: back, window: backWindow, status: 'active', pi_pid: process.pid, home_session: back }));
-        markBusy('R'); // R is genuinely mid-turn (isGenerating = busy && pidAlive)
-        openFocusRow('f1', focusPane, user, 'R');
-        const userBefore = windowIds(user).length;
-        const res = retargetFocus('f1', 'A', NOREVIVE);
-        assert.equal(res.focused, true);
-        assert.equal(res.revived, false, 'A had a live pin pane — no revive');
-        assert.equal(windowIds(user).length, userBefore, 'ZERO new windows in the user session (screen position invariant)');
-        // A took over the viewport: it keeps its pane id, now in the user session.
-        assert.equal(getFocusByNode('A')?.focus_id, 'f1', 'A now occupies the focus');
-        assert.equal(getFocusByNode('A')?.pane, backPane, 'the focus row anchors A\'s (now-in-viewport) pane');
-        assert.equal(getNode('A').pane, backPane, 'A\'s LOCATION pane id is unchanged (swap preserves %id)');
-        assert.equal(paneSession(backPane), user, 'A\'s pane physically moved to the user viewport');
-        assert.equal(getNode('A').tmux_session, user, 'A\'s LOCATION session is the viewport');
-        // R was backstaged (still generating), keeping its pane id, now in `back`.
-        assert.equal(getFocusByNode('R'), null, 'R no longer occupies any focus');
-        assert.equal(getNode('R').pane, focusPane, 'R kept its pane id');
-        assert.equal(paneExistsReal(focusPane), true, 'R\'s pane is alive (NOT reaped — it is still generating)');
-        assert.equal(paneSession(focusPane), back, 'R\'s pane physically moved to the backstage');
-        assert.equal(getNode('R').tmux_session, back, 'R\'s LOCATION session is the backstage');
-        assert.equal(focusByPane(backPane)?.node_id, 'A', 'the focus row tracks A after the retarget');
-    });
-});
-test('retargetFocus: outgoing DONE/dead (not live) → its now-backstage pane is REAPED (Invariant P)', { skip: !hasTmux() }, async () => {
-    await withSessions('kill', async ({ user, back, userWindow, backWindow }) => {
-        const focusPane = livePane(user, userWindow);
-        const backPane = livePane(back, backWindow);
-        // R is NOT live (status done) → the KILL path: its pane must be reaped after
-        // the swap, with NO lifecycle transition.
-        createNode(node('R', { pane: focusPane, tmux_session: user, window: userWindow, status: 'done', pi_pid: null, home_session: back }));
-        createNode(node('A', { pane: backPane, tmux_session: back, window: backWindow, status: 'active', pi_pid: process.pid, home_session: back }));
-        openFocusRow('f1', focusPane, user, 'R');
-        retargetFocus('f1', 'A', NOREVIVE);
-        assert.equal(getFocusByNode('A')?.focus_id, 'f1', 'A took the viewport');
-        assert.equal(paneSession(backPane), user, 'A\'s pane is in the viewport');
-        assert.equal(paneExistsReal(focusPane), false, 'R\'s now-backstage pane was KILLED (not live ⇒ no pane)');
-        assert.equal(getNode('R').status, 'done', 'R stays done (KILL does not transition status)');
-        assert.equal(getNode('R').pane, null, 'R\'s LOCATION was nulled (Invariant P)');
-        assert.equal(getNode('R').tmux_session, null);
-    });
-});
-test('retargetFocus: outgoing PARKED terminal viewer (live pi, NOT mid-turn) → RELEASED to dormant (status idle, pane reaped) — the stuck-green fix', { skip: !hasTmux() }, async () => {
-    await withSessions('park', async ({ user, back, userWindow, backWindow }) => {
-        const focusPane = livePane(user, userWindow);
-        const backPane = livePane(back, backWindow);
-        // R is a terminal node revived only for VIEWING: live pi (pidAlive) but NOT
-        // mid-turn (no busy marker). It was the stuck-green bug: misread as
-        // generating, backstaged, and left status='active' forever. It must instead
-        // be RELEASED to dormant.
-        createNode(node('R', { pane: focusPane, tmux_session: user, window: userWindow, status: 'active', lifecycle: 'terminal', pi_pid: process.pid, home_session: back }));
-        createNode(node('A', { pane: backPane, tmux_session: back, window: backWindow, status: 'active', pi_pid: process.pid, home_session: back }));
-        assert.equal(isBusy('R'), false, 'precondition: R is parked between turns (not mid-turn)');
-        openFocusRow('f1', focusPane, user, 'R');
-        retargetFocus('f1', 'A', NOREVIVE);
-        assert.equal(getFocusByNode('A')?.focus_id, 'f1', 'A took the viewport');
-        assert.equal(paneSession(backPane), user, 'A\'s pane is in the viewport');
-        // The fix: focus-away flips R back to dormant (idle + idle-release) and reaps
-        // its pane — so the editor stops drawing it green/active.
-        assert.equal(getNode('R').status, 'idle', 'R was RELEASED back to dormant (no longer stuck active/green)');
-        assert.equal(getNode('R').intent, 'idle-release', 'R carries idle-release so the daemon revives it on its inbox');
-        assert.equal(paneExistsReal(focusPane), false, 'R\'s now-backstage pane was REAPED (parked viewer ⇒ no pane)');
-        assert.equal(getNode('R').pane, null, 'R\'s LOCATION was nulled (Invariant P)');
-        assert.equal(getNode('R').tmux_session, null);
-    });
-});
-test('retargetFocus Q5: focusing a node already focused ELSEWHERE vacates its old focus (it MOVES, no dup)', { skip: !hasTmux() }, async () => {
-    await withSessions('q5', async ({ user, back, userWindow, backWindow }) => {
-        // R sits in focus f1 (the user viewport). M is focused in f2 (a second pane).
-        const focusPane = livePane(user, userWindow);
-        const mPane = livePane(back, backWindow); // M's current focus pane (live)
-        createNode(node('R', { pane: focusPane, tmux_session: user, window: userWindow, status: 'active', pi_pid: process.pid, home_session: back }));
-        createNode(node('M', { pane: mPane, tmux_session: back, window: backWindow, status: 'active', pi_pid: process.pid, home_session: back }));
-        openFocusRow('f1', focusPane, user, 'R');
-        openFocusRow('f2', mPane, back, 'M');
-        // Focus M into f1 (the user viewport): M occupies f2 ≠ f1 → vacate f2.
-        const res = retargetFocus('f1', 'M', backstageReviver(back));
-        assert.equal(res.focused, true);
-        assert.equal(getFocusById('f2'), null, 'the OLD focus f2 was vacated (closed)');
-        assert.equal(paneExistsReal(mPane), false, 'M\'s old focus pane was killed (the node moved)');
-        const mFocus = getFocusByNode('M');
-        assert.equal(mFocus?.focus_id, 'f1', 'M now occupies ONLY f1 (UNIQUE node_id upheld)');
-        assert.equal(listFocuses().filter((f) => f.node_id === 'M').length, 1, 'exactly one focus shows M');
-        assert.equal(res.revived, true, 'M was revived into the backstage after its old pane was killed');
-    });
-});
-test('openFocus: splits a NEW viewport pane beside the caller (a holder row), NOT a new window', { skip: !hasTmux() }, async () => {
-    await withSessions('open', async ({ user, userWindow }) => {
-        const callerPane = tmuxOut(['display-message', '-p', '-t', `${user}:${userWindow}`, '#{pane_id}']);
-        const userWinBefore = windowIds(user).length;
-        const f = openFocus(callerPane, {});
-        assert.ok(f, 'openFocus returned a focus row');
-        assert.equal(windowIds(user).length, userWinBefore, 'a SPLIT, not a new window (Q3 side-by-side)');
-        assert.ok(f.pane?.startsWith('%'), 'the row anchors the new split pane');
-        assert.equal(paneExistsReal(f.pane), true, 'the holder pane is live');
-        assert.ok(f.node_id.startsWith('__hold_'), 'occupied by a holder until a node is retargeted in');
-        // remain-on-exit is armed on the viewport window (F3).
-        const win = tmuxOut(['display-message', '-p', '-t', f.pane, '#{window_id}']);
-        assert.equal(tmuxOut(['show-window-options', '-t', win, 'remain-on-exit']), 'remain-on-exit on', 'remain-on-exit armed (F3)');
-    });
-});
-test('focus front-door: round-trip open(register #1) → retarget in place → the focus follows the viewport', { skip: !hasTmux() }, async () => {
-    await withSessions('frontdoor', async ({ user, back, userWindow, backWindow }) => {
-        const rootPane = tmuxOut(['display-message', '-p', '-t', `${user}:${userWindow}`, '#{pane_id}']);
-        const aPane = livePane(back, backWindow);
-        createNode(node('R', { pane: rootPane, tmux_session: user, window: userWindow, status: 'active', pi_pid: process.pid, home_session: user }));
-        createNode(node('A', { pane: aPane, tmux_session: back, window: backWindow, status: 'active', pi_pid: process.pid, home_session: back }));
-        // Root boot registers focus #1 on the root's own pane.
-        const f1 = registerRootFocus('R', rootPane, user, userWindow);
-        assert.ok(f1, 'focus #1 registered');
-        assert.equal(focusByPane(rootPane)?.node_id, 'R');
-        // node focus A from the root's pane → retarget IN PLACE (same focus row).
-        const res = placementFocus('A', { pane: rootPane, callerNode: 'R', revive: NOREVIVE });
-        assert.equal(res.inPlace, true);
-        assert.equal(getFocusByNode('A')?.focus_id, f1.focus_id, 'the SAME focus row now shows A (no new focus)');
-        assert.equal(listFocuses().length, 1, 'still exactly one focus (retarget, not open)');
-        assert.equal(getFocusByNode('R'), null, 'R yielded the viewport');
-        // The focus followed the viewport: focusByPane on A's (now-in-viewport) pane resolves it.
-        assert.equal(focusByPane(aPane)?.node_id, 'A', 'the focus row tracks A\'s pane');
-    });
-});
-// ---------------------------------------------------------------------------
-// Regression guards (review findings on HEAD=ccc3ee2): a detach/failed-open must
-// not leave a dangling focus row or an orphan viewport pane (Invariant P / F4).
-// ---------------------------------------------------------------------------
-test('detachToBackground: a FOCUSED node sent to the backstage CLOSES its focus row (Invariant P — no phantom viewport)', { skip: !hasTmux() }, async () => {
-    await withSessions('detach', async ({ user, back, userWindow }) => {
-        const prev = process.env['CRTR_NODE_SESSION'];
-        process.env['CRTR_NODE_SESSION'] = back; // detach relocates into THIS backstage session
-        try {
-            const focusPane = livePane(user, userWindow); // the node's foreground viewport pane
-            createNode(node('N', { pane: focusPane, tmux_session: user, window: userWindow, status: 'active', pi_pid: process.pid, home_session: back }));
-            openFocusRow('f1', focusPane, user, 'N'); // N is the focus occupant
-            assert.equal(getFocusByNode('N')?.focus_id, 'f1', 'precondition: N is focused');
-            // N must read as GENERATING for the relocate-to-backstage path: detach now
-            // gates the break-pane (Bug 1 / Invariant P) on isGenerating = busy &&
-            // pidAlive. pi_pid is this (alive) process; set the busy marker so N is
-            // genuinely mid-turn (otherwise the gate would RELEASE + reap it instead).
-            markBusy('N');
-            const ok = detachToBackground('N', focusPane);
-            assert.equal(ok, true, 'the break to the backstage succeeded');
-            // The fix: N is now generating-but-UNFOCUSED, so its focus row is CLOSED.
-            assert.equal(getFocusByNode('N'), null, 'N no longer occupies any focus (row CLOSED — Invariant P)');
-            assert.equal(focusByPane(focusPane), null, 'NO phantom focus resolves on the relocated pane (%id survives the break)');
-            assert.equal(listFocuses().length, 0, 'no dangling focus rows remain');
-            // The pi keeps running — the pane is alive, just moved off-screen.
-            assert.equal(paneExistsReal(focusPane), true, 'N\'s pi keeps generating (pane alive, relocated not killed)');
-            assert.equal(paneSession(focusPane), back, 'N\'s pane physically moved to the backstage session');
-        }
-        finally {
-            if (prev === undefined)
-                delete process.env['CRTR_NODE_SESSION'];
-            else
-                process.env['CRTR_NODE_SESSION'] = prev;
-        }
-    });
-});
-test('focus --new-pane: a FAILED retarget reaps the holder pane + focus row (no orphan viewport — F4/Invariant P)', { skip: !hasTmux() }, async () => {
-    await withSessions('newpane-fail', async ({ user, userWindow }) => {
-        const callerPane = livePane(user, userWindow); // the caller's pane we split beside
-        createNode(node('D', { status: 'active', pi_pid: null })); // D is DORMANT — no live pane
-        const winBefore = windowIds(user).length;
-        const panesIn = (s, w) => tmuxOut(['list-panes', '-t', `${s}:${w}`, '-F', '#{pane_id}']).split('\n').filter((x) => x !== '').length;
-        const panesBefore = panesIn(user, userWindow);
-        // A reviver that does NOTHING → D stays dormant, retargetFocus finds no live
-        // pin and returns focused:false. The just-opened holder must be reaped.
-        const noopRevive = () => { };
-        const res = placementFocus('D', { pane: callerPane, newPane: true, revive: noopRevive });
-        assert.equal(res.focused, false, 'D could not be placed → the --new-pane focus failed');
-        assert.equal(listFocuses().length, 0, 'the just-opened focus row was REAPED (no phantom)');
-        assert.equal(panesIn(user, userWindow), panesBefore, 'the holder split pane was REAPED (no leaked sleep pane)');
-        assert.equal(windowIds(user).length, winBefore, 'no window leaked');
-    });
-});