@crouton-kit/crouter 0.3.28 → 0.3.29

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

@@ -1,212 +0,0 @@
-// Run with: node --import tsx/esm --test src/core/__tests__/placement-reconcile.test.ts
-//
-// STEP 3 of the placement/focus migration: pane-anchored reconciliation (Q6) —
-// the robustness step. A manual move-pane/join-pane/break-pane must NEVER read
-// as a node death; liveness becomes pane-existence, and reconcile makes crtr
-// FOLLOW a move instead of fighting it. Covers:
-//   - reconcileDecision (PURE, no tmux): pane moved → cache FOLLOWS; pane gone →
-//     LOCATION nulled; never returns a stale window; legacy no-pane + live window
-//     → backfills the pane from paneOfWindow.
-//   - reconcile (impure shell over a real temp-db row, tmux absent): exercises
-//     the gone / no-op paths through setPresence.
-//   - isNodePaneAlive: pane present → paneExists path; pane null + window →
-//     windowAlive fallback (with a real, live tmux window when available).
-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, getRow } from '../../canvas/canvas.js';
-import { closeDb } from '../../canvas/db.js';
-import { reconcileDecision, reconcile, isNodePaneAlive, } from '../../runtime/placement.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;
-}
-before(() => {
-    home = mkdtempSync(join(tmpdir(), 'crtr-placement-'));
-    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'];
-});
-// ---------------------------------------------------------------------------
-// reconcileDecision — the PURE robustness core (§2.4, Q6). No tmux.
-// ---------------------------------------------------------------------------
-const cached = (over = {}) => ({
-    pane: '%5',
-    tmux_session: 'crtr',
-    window: '@1',
-    ...over,
-});
-const probe = (over = {}) => ({
-    paneLoc: null,
-    windowPane: null,
-    ...over,
-});
-test('reconcileDecision: pane MOVED → cache FOLLOWS to the new session/window (same pane id)', () => {
-    const d = reconcileDecision(cached({ pane: '%5', tmux_session: 'crtr', window: '@1' }), probe({ paneLoc: { session: 'user-sess', window: '@9' } }));
-    assert.deepEqual(d, { kind: 'follow', pane: '%5', tmux_session: 'user-sess', window: '@9' });
-});
-test('reconcileDecision: pane GONE (paneLocation null) → LOCATION nulled', () => {
-    const d = reconcileDecision(cached({ pane: '%5' }), probe({ paneLoc: null }));
-    assert.deepEqual(d, { kind: 'gone' });
-});
-test('reconcileDecision: pane present + cache already current → no-op (never a stale write)', () => {
-    const d = reconcileDecision(cached({ pane: '%5', tmux_session: 'crtr', window: '@1' }), probe({ paneLoc: { session: 'crtr', window: '@1' } }));
-    assert.deepEqual(d, { kind: 'none' });
-});
-test('reconcileDecision: NEVER returns a stale window — a follow always carries the LIVE location', () => {
-    // Window renumbered under the same pane (@1 → @4); follow must report @4, the
-    // live value, not the cached @1.
-    const d = reconcileDecision(cached({ pane: '%5', tmux_session: 'crtr', window: '@1' }), probe({ paneLoc: { session: 'crtr', window: '@4' } }));
-    assert.equal(d.kind, 'follow');
-    assert.equal(d.window, '@4', 'follow carries the live window, never the stale cache');
-});
-test('reconcileDecision: legacy no-pane + live window → BACKFILLS the pane from paneOfWindow', () => {
-    const d = reconcileDecision(cached({ pane: null, tmux_session: 'crtr', window: '@1' }), probe({ windowPane: '%7' }));
-    assert.deepEqual(d, { kind: 'backfill', pane: '%7', tmux_session: 'crtr', window: '@1' });
-});
-test('reconcileDecision: no pane + no live window pane → no-op (nothing to anchor on)', () => {
-    assert.deepEqual(reconcileDecision(cached({ pane: null, tmux_session: 'crtr', window: '@1' }), probe({ windowPane: null })), { kind: 'none' }, 'window has no resolvable active pane → nothing to backfill');
-});
-test('reconcileDecision: no pane + no window at all → no-op (a dormant/inline-root row)', () => {
-    assert.deepEqual(reconcileDecision(cached({ pane: null, tmux_session: null, window: null }), probe({ windowPane: '%7' })), { kind: 'none' }, 'no window to anchor a backfill on → no-op even if a stray windowPane was read');
-});
-// ---------------------------------------------------------------------------
-// reconcile / isNodePaneAlive — the impure shells. These call the real tmux
-// driver, so the machine may have a live tmux server with arbitrary panes; we
-// must never assume a hardcoded pane/session id is dead. Two robust strategies:
-//   • "absent" assertions use a UNIQUELY-named session that cannot exist
-//     (windowAlive/paneOfWindow on it are deterministically empty — robust
-//     whether or not a server is running).
-//   • "present/dead-pane" assertions create a real session and a real pane,
-//     killing it to get a guaranteed-dead `%id`. Gated on hasTmux().
-// ---------------------------------------------------------------------------
-/** A session name guaranteed not to exist on any server. */
-const ghostSession = `crtr-ghost-${process.pid}`;
-/** Run `fn` with a fresh detached session; tear it down after. */
-async function withSession(tag, fn) {
-    const session = `crtr-placement-${process.pid}-${tag}`;
-    spawnSync('tmux', ['new-session', '-d', '-s', session, '-c', '/tmp', 'sleep 600']);
-    try {
-        await fn(session);
-    }
-    finally {
-        spawnSync('tmux', ['kill-session', '-t', session], { stdio: 'ignore' });
-    }
-}
-function tmuxOut(args) {
-    return (spawnSync('tmux', args, { encoding: 'utf8' }).stdout ?? '').trim();
-}
-/** A guaranteed-DEAD `%pane_id` inside a still-live `window` of `session`: split
- *  a fresh pane, capture its id, kill it. The window survives via its original
- *  pane, so the id is dead while its old window is alive. */
-function makeDeadPane(session, window) {
-    const dead = tmuxOut(['split-window', '-d', '-P', '-F', '#{pane_id}', '-t', `${session}:${window}`, 'sleep 600']);
-    spawnSync('tmux', ['kill-pane', '-t', dead], { stdio: 'ignore' });
-    return dead;
-}
-test('reconcile: an unknown node is a silent no-op', () => {
-    assert.doesNotThrow(() => reconcile('ghost'));
-});
-test('reconcile: no pane + a non-existent window → no-op (cache left intact, not nulled)', () => {
-    // A ghost session can never resolve an active pane → backfill cannot fire and
-    // reconcile leaves the (already pane-less) cache exactly as it was.
-    createNode(node('n', { pane: null, tmux_session: ghostSession, window: '@1' }));
-    reconcile('n');
-    const r = getRow('n');
-    assert.equal(r?.pane, null, 'still no pane');
-    assert.equal(r?.tmux_session, ghostSession, 'session left intact (no-op, not nulled)');
-    assert.equal(r?.window, '@1', 'window left intact');
-});
-test('reconcile: a DEAD pane → LOCATION nulled (gone branch)', { skip: !hasTmux() }, async () => {
-    await withSession('gone', async (session) => {
-        const window = tmuxOut(['display-message', '-p', '-t', `${session}:`, '#{window_id}']);
-        const dead = makeDeadPane(session, window);
-        createNode(node('n', { pane: dead, tmux_session: session, window }));
-        reconcile('n');
-        const r = getRow('n');
-        assert.equal(r?.pane, null, 'pane nulled');
-        assert.equal(r?.tmux_session, null, 'session nulled');
-        assert.equal(r?.window, null, 'window nulled');
-    });
-});
-// ---------------------------------------------------------------------------
-// isNodePaneAlive — pane-existence primary, windowAlive fallback.
-// ---------------------------------------------------------------------------
-test('isNodePaneAlive: an unknown node id is not alive', () => {
-    assert.equal(isNodePaneAlive('ghost'), false);
-});
-test('isNodePaneAlive: pane null + a non-existent window → not alive (windowAlive fallback false)', () => {
-    createNode(node('legacy', { pane: null, tmux_session: ghostSession, window: '@1' }));
-    assert.equal(isNodePaneAlive('legacy'), false, 'no pane + dead window → fallback false');
-});
-test('isNodePaneAlive: a DEAD pane is NOT alive (paneExists path), id or row alike', { skip: !hasTmux() }, async () => {
-    await withSession('dead', async (session) => {
-        const window = tmuxOut(['display-message', '-p', '-t', `${session}:`, '#{window_id}']);
-        const dead = makeDeadPane(session, window);
-        createNode(node('n', { pane: dead, tmux_session: session, window }));
-        assert.equal(isNodePaneAlive('n'), false, 'a killed pane → not alive (by id)');
-        assert.equal(isNodePaneAlive(getRow('n')), false, 'same verdict passed a NodeRow directly');
-    });
-});
-// ---------------------------------------------------------------------------
-// Real-tmux behavior (gated): the windowAlive fallback + lazy backfill, and a
-// live pane FOLLOWING a manual move (the Q6 robustness core).
-// ---------------------------------------------------------------------------
-test('isNodePaneAlive: pane null + a LIVE window → alive via the windowAlive fallback (+ lazy backfill)', { skip: !hasTmux() }, async () => {
-    await withSession('alive', async (session) => {
-        const window = tmuxOut(['list-windows', '-t', session, '-F', '#{window_id}']).split('\n')[0];
-        createNode(node('legacy', { pane: null, tmux_session: session, window }));
-        assert.equal(isNodePaneAlive('legacy'), true, 'no pane but a live window → alive (legacy fallback)');
-        // reconcile lazily backfills that legacy row's pane from the live window.
-        reconcile('legacy');
-        const got = getNode('legacy');
-        assert.ok(got?.pane != null && got.pane.startsWith('%'), 'reconcile backfilled the pane from paneOfWindow');
-        assert.equal(got?.tmux_session, session, 'session preserved through the backfill');
-        assert.equal(got?.window, window, 'window preserved through the backfill');
-    });
-});
-test('isNodePaneAlive + reconcile: a LIVE pane is alive and FOLLOWS a join-pane move to another window', { skip: !hasTmux() }, async () => {
-    await withSession('move', async (session) => {
-        // Original window W0 and its active pane P.
-        const w0 = tmuxOut(['display-message', '-p', '-t', `${session}:`, '#{window_id}']);
-        const pane = tmuxOut(['display-message', '-p', '-t', `${session}:${w0}`, '#{pane_id}']);
-        // A second window W1 to move P into.
-        const w1 = tmuxOut(['new-window', '-d', '-P', '-F', '#{window_id}', '-t', `${session}:`, 'sleep 600']);
-        assert.ok(pane.startsWith('%') && w0.startsWith('@') && w1.startsWith('@') && w0 !== w1);
-        createNode(node('m', { pane, tmux_session: session, window: w0 }));
-        assert.equal(isNodePaneAlive('m'), true, 'a live pane reads alive');
-        // Manually join P into W1 — the Q6 robustness scenario. P's id survives; W0
-        // (now empty) closes. This must NOT read as a death.
-        spawnSync('tmux', ['join-pane', '-s', pane, '-t', `${session}:${w1}`], { stdio: 'ignore' });
-        assert.equal(isNodePaneAlive('m'), true, 'a manual join-pane is NOT a death — the pane still exists');
-        // reconcile FOLLOWS the move: same pane id, new window.
-        reconcile('m');
-        const got = getNode('m');
-        assert.equal(got?.pane, pane, 'pane id is invariant across the move');
-        assert.equal(got?.window, w1, 'window FOLLOWED the join-pane to W1');
-        assert.equal(got?.tmux_session, session, 'still the same session');
-    });
-});

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

@@ -1,238 +0,0 @@
-// Run with: node --import tsx/esm --test src/core/__tests__/placement-revive.test.ts
-//
-// STEP 5 of the placement/focus migration: placement-aware revive (§1.4) — THE
-// step that kills the "unbidden windows in my session" bug. Two proofs:
-//
-//   1. The PURE bug-death test (§5.1, the crown jewel): reviveTarget(focus,
-//      focusPaneAlive, homeSession) — the target decision in isolation, no tmux.
-//      The load-bearing assertion is the once-focused-now-unfocused CHILD: its
-//      focus is gone (focusOf == null) and home_session = 'crtr' even though the
-//      OLD meta.tmux_session was tainted to a user session → backstage 'crtr',
-//      NOT the user session. That is the audit §F/H1 defect, structurally dead.
-//
-//   2. The gated real-tmux swap-out-skipped regression (§5.2, the definitive
-//      proof): focus a node into a user session, terminate its pi (the focus
-//      pane collapses — Step 5 has no remain-on-exit yet), wake it via
-//      reviveIntoPlacement → assert ZERO new windows appear in the user session
-//      across the whole sequence; the revived node lands in home_session.
-//
-//   Plus: backstage-into-home_session (the taint is IGNORED), respawn-into-focus
-//   (F3 resume in place, no new window), and reconcileFocus following a manual
-//   move of the focus pane (Q4). The gated tests drive a benign `sleep` command,
-//   never a real pi — reviveNode delegates the placement decision to exactly the
-//   reviveIntoPlacement exercised here.
-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 } from '../../canvas/canvas.js';
-import { openFocusRow, getFocusByNode, getFocusById } from '../../canvas/focuses.js';
-import { closeDb } from '../../canvas/db.js';
-import { reviveTarget, reviveIntoPlacement, reconcileFocus } from '../../runtime/placement.js';
-import { reviveInPlace } from '../../runtime/revive.js';
-let home;
-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 focus(over = {}) {
-    return { focus_id: 'f1', pane: '%a', session: 'Suser', node_id: 'M', ...over };
-}
-function hasTmux() {
-    return spawnSync('tmux', ['-V'], { stdio: 'ignore' }).status === 0;
-}
-before(() => {
-    home = mkdtempSync(join(tmpdir(), 'crtr-placement-revive-'));
-    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'];
-});
-// ---------------------------------------------------------------------------
-// 1. The PURE bug-death test (§5.1) — reviveTarget in isolation. No tmux.
-// ---------------------------------------------------------------------------
-test('reviveTarget: a node on a LIVE focus → resume IN PLACE in that focus pane', () => {
-    const d = reviveTarget(focus({ pane: '%a', session: 'Suser', node_id: 'M' }), true, 'crtr');
-    assert.deepEqual(d, { kind: 'focus-pane', pane: '%a', session: 'Suser' });
-});
-test('reviveTarget: a non-focused CHILD (home_session=crtr) → BACKSTAGE crtr (never a user session)', () => {
-    assert.deepEqual(reviveTarget(null, false, 'crtr'), { kind: 'backstage', session: 'crtr' });
-});
-test('reviveTarget: a ROOT (home_session = its own user session) → backstage THAT session (NOT the bug)', () => {
-    // A root legitimately lives in its own adopted user session; reviving it there
-    // is correct. The bug is a non-focused CHILD landing in a user session — not a
-    // root reviving into its own.
-    assert.deepEqual(reviveTarget(null, false, 'Suser-root'), { kind: 'backstage', session: 'Suser-root' });
-});
-test('THE BUG, structurally dead: a once-focused-now-unfocused CHILD → BACKSTAGE crtr, NOT the tainted user session', () => {
-    // The exact audit §F/H1 scenario. The child WAS focused, so its OLD
-    // meta.tmux_session was tainted to the user session — but the focus is gone
-    // (focusOf == null) and reviveTarget keys on home_session ('crtr'), NEVER on
-    // the tainted tmux_session. So the revive lands backstage in 'crtr'. THIS is
-    // the assertion that proves the "unbidden windows" bug cannot recur: even with
-    // a tainted tmux_session sitting in the row, the target is home_session only.
-    const d = reviveTarget(null, false, 'crtr');
-    assert.equal(d.kind, 'backstage');
-    assert.equal(d.session, 'crtr');
-    assert.notEqual(d.session, 'Suser', 'NOT the tainted user session');
-});
-test('A-MAJOR-1 dead (refresh-yield twin): a focused (tainted) child reviveInPlace propagates CRTR_ROOT_SESSION = home_session (backstage), so any child it spawns lands backstage — NOT the user session', () => {
-    // The reviveInPlace (refresh-yield) counterpart to the reviveTarget crown
-    // jewel above. A focused child M was tainted: meta.tmux_session = the USER
-    // session (focus taints it), home_session = the backstage `crtr`. Pre-fix,
-    // reviveInPlace re-execed M's pi with CRTR_ROOT_SESSION = meta.tmux_session =
-    // the user session, so any child M then spawned opened its window in the user's
-    // session (and re-tainted that grandchild's home_session). The fix sources
-    // CRTR_ROOT_SESSION from home_session — the taint-immune backstage. We capture
-    // the env reviveInPlace dispatches to the pane respawn and assert it carries
-    // the backstage, never the tainted session. Fails against the pre-fix code.
-    const back = `crtr-back-${process.pid}`;
-    const user = `crtr-user-${process.pid}`; // the focus taint that must be ignored
-    createNode(node('M', { home_session: back, tmux_session: user, window: '@7', pane: '%5' }));
-    let captured;
-    const spy = (opts) => {
-        captured = opts.env;
-        return true;
-    };
-    reviveInPlace('M', '%5', spy);
-    assert.equal(captured?.['CRTR_ROOT_SESSION'], back, 'children spawn into the backstage home_session');
-    assert.notEqual(captured?.['CRTR_ROOT_SESSION'], user, 'NEVER the tainted user session (A-MAJOR-1 dead)');
-    // The node's own LOCATION is unchanged — the re-exec is in place, the pane
-    // never moved, so it still sits in the (still-tainted) user session.
-    assert.equal(getNode('M').tmux_session, user, 'LOCATION preserved (in-place re-exec); only the child env is hardened');
-});
-test('reviveTarget: a focus whose pane has COLLAPSED (focusPaneAlive=false) → backstage, not a dead pane', () => {
-    // Step-5 limitation: a focused node that fully terminates has no remain-on-exit
-    // yet, so its focus pane collapses. focusPaneAlive=false → backstage (home),
-    // never the gone focus pane. Still SAFE: home_session, never a user session.
-    const d = reviveTarget(focus({ pane: '%gone', session: 'Suser', node_id: 'M' }), false, 'crtr');
-    assert.deepEqual(d, { kind: 'backstage', session: 'crtr' });
-});
-// ---------------------------------------------------------------------------
-// 2. Gated real-tmux placement (skip when tmux is absent). Each test isolates
-// two real sessions: `user` (the user's terminal) and `back` (the backstage that
-// stands in for `crtr`). We drive reviveIntoPlacement with a benign `sleep`
-// command, never a real pi.
-// ---------------------------------------------------------------------------
-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 !== '');
-}
-/** Hold two real, isolated sessions (`user` + `back`) open for `fn`, exposing the
- *  user session's first window + active pane, then tear both down. */
-async function withUserAndBackstage(tag, fn) {
-    const user = `crtr-rev-user-${process.pid}-${tag}`;
-    const back = `crtr-rev-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 {
-        const userWindow = windowIds(user)[0];
-        await fn({ user, back, userWindow });
-    }
-    finally {
-        spawnSync('tmux', ['kill-session', '-t', user], { stdio: 'ignore' });
-        spawnSync('tmux', ['kill-session', '-t', back], { stdio: 'ignore' });
-    }
-}
-/** Open a real, live extra pane inside `session:window` (a stand-in focus pane)
- *  running `sleep`, and return its durable `%pane_id`. */
-function liveFocusPane(session, window) {
-    return tmuxOut(['split-window', '-d', '-P', '-F', '#{pane_id}', '-t', `${session}:${window}`, 'sleep 600']);
-}
-const launch = (over = {}) => ({
-    command: 'sleep 600',
-    env: {},
-    cwd: '/tmp',
-    name: 'm',
-    resuming: false,
-    ...over,
-});
-test('reviveIntoPlacement (backstage): a non-focused node opens in home_session, IGNORING its tainted tmux_session', { skip: !hasTmux() }, async () => {
-    await withUserAndBackstage('backstage', async ({ user, back }) => {
-        // A child whose tmux_session was TAINTED to the user session (as focus would
-        // have done) but which is NOT focused now. home_session = the backstage.
-        createNode(node('M', { home_session: back, tmux_session: user, window: null, pane: null }));
-        const userBefore = windowIds(user).length;
-        const backBefore = windowIds(back).length;
-        const placed = reviveIntoPlacement('M', launch());
-        assert.equal(windowIds(user).length, userBefore, 'ZERO new windows in the user session');
-        assert.equal(windowIds(back).length, backBefore + 1, 'exactly one new window in home_session (backstage)');
-        assert.equal(placed.session, back, 'placed into home_session, not the tainted user session');
-        assert.ok(placed.pane?.startsWith('%'), 'a durable pane id was recorded');
-        const m = getNode('M');
-        assert.equal(m.tmux_session, back, 'LOCATION repointed to the backstage; the taint is overwritten');
-        assert.equal(m.pane, placed.pane, 'the row pane matches the opened pane');
-    });
-});
-test('§5.2 swap-out-skipped regression: focus→terminate→wake puts ZERO new windows in the user session', { skip: !hasTmux() }, async () => {
-    await withUserAndBackstage('regress', async ({ user, back, userWindow }) => {
-        // The bug scenario, end to end:
-        //   1. M is a child focused into the user session: a real focus pane in
-        //      `user`, a focus row on it, and (the taint) tmux_session=user.
-        //   2. Its pi terminates → the focus pane COLLAPSES (Step 5 has no
-        //      remain-on-exit yet) — modelled by killing the focus pane.
-        //   3. The daemon/reviveNode wakes M → reviveIntoPlacement.
-        // The fix: M lands in home_session (backstage), NOT a new window in `user`.
-        const focusPane = liveFocusPane(user, userWindow);
-        createNode(node('M', { home_session: back, tmux_session: user, window: userWindow, pane: focusPane }));
-        openFocusRow('f1', focusPane, user, 'M');
-        const userBefore = windowIds(user).length;
-        const backBefore = windowIds(back).length;
-        // Terminate: the focus pane collapses (no remain-on-exit in Step 5).
-        spawnSync('tmux', ['kill-pane', '-t', focusPane], { stdio: 'ignore' });
-        const placed = reviveIntoPlacement('M', launch({ resuming: true }));
-        assert.equal(windowIds(user).length, userBefore, 'ZERO new windows opened in the user session across the sequence');
-        assert.equal(windowIds(back).length, backBefore + 1, 'the revived node landed in home_session (backstage)');
-        assert.equal(placed.session, back, 'reviveIntoPlacement targeted home_session, not the tainted user session');
-        assert.equal(getNode('M').tmux_session, back, 'LOCATION repointed to the backstage');
-    });
-});
-test('reviveIntoPlacement (focus-pane): a node on a LIVE focus resumes IN PLACE — no new window anywhere', { skip: !hasTmux() }, async () => {
-    await withUserAndBackstage('inplace', async ({ user, back, userWindow }) => {
-        const focusPane = liveFocusPane(user, userWindow);
-        createNode(node('M', { home_session: back, tmux_session: user, window: userWindow, pane: focusPane }));
-        openFocusRow('f1', focusPane, user, 'M');
-        const userBefore = windowIds(user).length;
-        const backBefore = windowIds(back).length;
-        const placed = reviveIntoPlacement('M', launch({ resuming: true }));
-        assert.equal(placed.pane, focusPane, 'resumed into the SAME focus pane id (respawn-pane -k, no new pane)');
-        assert.equal(windowIds(user).length, userBefore, 'no new window in the user session (resume in place)');
-        assert.equal(windowIds(back).length, backBefore, 'no new window in the backstage either');
-        assert.equal(placed.session, user, 'the focus pane lives in the user session — the F3 resume stays there (desired)');
-        assert.equal(getFocusByNode('M')?.pane, focusPane, 'the focus row still anchors the same pane');
-    });
-});
-test('reconcileFocus: follows a manual move of the focus pane to another session (Q4)', { skip: !hasTmux() }, async () => {
-    await withUserAndBackstage('recfocus', async ({ user, back, userWindow }) => {
-        // Focus pane starts in `user`; the row caches session=user.
-        const focusPane = liveFocusPane(user, userWindow);
-        openFocusRow('f1', focusPane, user, 'M');
-        // The user moves the focus pane into the backstage session (join-pane). The
-        // pane id survives; the row's cached session is now stale.
-        const backWindow = windowIds(back)[0];
-        spawnSync('tmux', ['join-pane', '-s', focusPane, '-t', `${back}:${backWindow}`], { stdio: 'ignore' });
-        reconcileFocus('f1');
-        const f = getFocusById('f1');
-        assert.equal(f?.pane, focusPane, 'pane id is invariant across the move');
-        assert.equal(f?.session, back, 'reconcileFocus FOLLOWED the move to the backstage session');
-    });
-});