@crouton-kit/crouter 0.3.14 → 0.3.15

package/dist/core/__tests__/context-intro.test.js

@@ -0,0 +1,196 @@
+// Tests for the <crtr-context> bearings preamble + scoped memory:
+//   1. A plain spawned node gets NO MEMORY.md; promotion seeds it (the template).
+//   2. seedMemory is idempotent (never clobbers an evolved memory).
+//   3. Worker bearings = shared-doc framing only (no <memory> block);
+//      orchestrator bearings add the across-cycles framing + a <memory> block
+//      that MERGES the applicable stores, each a `label · dir` header over its
+//      live index POINTER LINES only (the how-to boilerplate is dropped — it
+//      lives once in the kernel); promotion delivers that same orchestrator
+//      context-dir framing to a node that spawned base.
+//   4. canvas-context-intro injects the block as its own session message at
+//      session_start (before the first prompt), idempotent across resumes.
+//
+// Run: node --import tsx/esm --test src/core/__tests__/context-intro.test.ts
+import { test, before, beforeEach, after } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { existsSync } from 'node:fs';
+import { closeDb } from '../canvas/db.js';
+import { contextDir } from '../canvas/paths.js';
+import { spawnNode } from '../runtime/nodes.js';
+import { promote } from '../runtime/promote.js';
+import { personaDrift } from '../runtime/persona.js';
+import { memoryPath, memoryDir, readMemory, seedMemory, hasMemory, MEMORY_TEMPLATE, userMemoryDir, userMemoryPath, projectMemoryDir, projectMemoryPath, } from '../runtime/memory.js';
+import registerCanvasContextIntro, { buildContextIntro, renderContextMessage, CONTEXT_INTRO_CUSTOM_TYPE, } from '../../pi-extensions/canvas-context-intro.js';
+let home;
+before(() => {
+    home = mkdtempSync(join(tmpdir(), 'crtr-ctxintro-'));
+    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'];
+    delete process.env['CRTR_NODE_ID'];
+});
+test('a plain spawned node gets NO memory; promotion seeds the index + dir', () => {
+    const meta = spawnNode({ kind: 'general', cwd: '/tmp/work', parent: null });
+    assert.equal(hasMemory(meta.node_id), false, 'no memory before promotion');
+    promote(meta.node_id);
+    assert.ok(hasMemory(meta.node_id), 'MEMORY.md index exists after promotion');
+    assert.ok(existsSync(memoryDir(meta.node_id)), 'memory dir created for direct writes');
+    assert.ok(memoryPath(meta.node_id).endsWith('/memory/MEMORY.md'), 'index lives inside the memory dir');
+    assert.equal(readMemory(meta.node_id), MEMORY_TEMPLATE);
+});
+test('seedMemory is idempotent — never clobbers an evolved memory', () => {
+    const meta = spawnNode({ kind: 'general', cwd: '/tmp/work', parent: null });
+    seedMemory(meta.node_id);
+    const evolved = '# Memory\n\n## Lessons\n- never trust the cache\n';
+    writeFileSync(memoryPath(meta.node_id), evolved);
+    assert.equal(seedMemory(meta.node_id), false, 'returns false when one exists');
+    assert.equal(readMemory(meta.node_id), evolved, 'left untouched');
+});
+test('worker bearings: shared-doc framing only, no orchestrator/memory framing', () => {
+    const meta = spawnNode({ kind: 'general', cwd: '/tmp/work', parent: null });
+    const block = buildContextIntro(meta.node_id);
+    assert.match(block, new RegExp(`<crtr-context dir="${contextDir(meta.node_id)}">`));
+    assert.match(block, /shared document store, not a task tracker/, 'base = shared docs, not tasks');
+    assert.doesNotMatch(block, /MEMORY\.md/, 'no memory pointer for a memory-less worker');
+    assert.doesNotMatch(block, /<memory>/, 'no memory block for a memory-less worker');
+    assert.doesNotMatch(block, /refresh cycles/, 'no across-cycles framing for a terminal worker');
+    assert.match(block, /<\/crtr-context>/);
+});
+test('orchestrator bearings: across-cycles framing + a <memory> block whose body is the live pointer lines under `label · dir`', () => {
+    const meta = spawnNode({ kind: 'general', cwd: '/tmp/work', parent: null });
+    seedMemory(meta.node_id);
+    // The seeded index carries the how-to comment + the empty marker; an evolved
+    // index adds a pointer line. The block must render ONLY the pointer line.
+    writeFileSync(memoryPath(meta.node_id), '# memory index — one pointer line per memory; how-to in "Your long-term memory".\n\n- [Flaky build](flaky-build.md) — first run fails\n');
+    const block = buildContextIntro(meta.node_id);
+    assert.match(block, /shared document store, not a task tracker/, 'still carries the base framing');
+    assert.match(block, /refresh cycles/, 'orchestrator gets the across-cycles framing');
+    assert.match(block, /<memory>/, 'has a memory block');
+    // (a) the store renders just its pointer line under a `label · dir` header.
+    assert.ok(block.includes(`node-local · ${memoryDir(meta.node_id)}`), 'compact `label · dir` header');
+    assert.match(block, /- \[Flaky build\]\(flaky-build\.md\) — first run fails/, 'the live pointer line is inlined');
+    // (c) no `index:` line, no absolute index path, no inlined how-to boilerplate.
+    assert.ok(!block.includes('index:'), 'no index: substring');
+    assert.ok(!block.includes(memoryPath(meta.node_id)), 'no absolute index (MEMORY.md) path');
+    assert.ok(!block.includes('how-to in'), 'the index how-to boilerplate is NOT inlined');
+    assert.ok(!block.includes('# memory index'), 'the index header comment is NOT inlined');
+    assert.match(block, /<\/crtr-context>/);
+});
+test('orchestrator bearings: a promoted node merges all THREE stores; template-only stores render (empty)', () => {
+    const meta = spawnNode({ kind: 'general', cwd: '/tmp/work', parent: null });
+    promote(meta.node_id); // seeds user-global + project + node-local (all template-only)
+    const block = buildContextIntro(meta.node_id);
+    // Each scope present as a `label · dir` header.
+    assert.ok(block.includes(`user-global · ${userMemoryDir()}`), 'merges the user-global store');
+    assert.ok(block.includes(`project · ${projectMemoryDir('/tmp/work')}`), 'merges the project store');
+    assert.ok(block.includes(`node-local · ${memoryDir(meta.node_id)}`), 'merges the node-local store');
+    // (b) a template-only / not-yet-written store renders the (empty) marker.
+    assert.match(block, /user-global · .*\n\(empty\)/, 'template-only user store renders (empty)');
+    assert.equal(block.match(/\(empty\)/g)?.length, 3, 'all three template-only stores render (empty)');
+    // (c) no absolute index paths leak in.
+    assert.ok(!block.includes(userMemoryPath()), 'no user-global MEMORY.md path');
+    assert.ok(!block.includes(projectMemoryPath('/tmp/work')), 'no project MEMORY.md path');
+    // The type→store mapping is taught by the kernel; the block points at it.
+    assert.match(block, /type/, 'the block references the type that decides the store');
+});
+test('promotion guidance delivers the orchestrator context-dir framing', () => {
+    // A node spawns as a base worker (no orchestrator bearings). On promotion the
+    // persona injector must build the across-cycles context-dir framing it never
+    // got at spawn (delivered at the next turn boundary, not returned by promote).
+    const meta = spawnNode({ kind: 'general', cwd: '/tmp/work', parent: null });
+    promote(meta.node_id);
+    const drift = personaDrift(meta.node_id);
+    const guidance = drift?.guidance ?? '';
+    assert.ok(drift !== null, 'promotion drifts the persona (base→orchestrator)');
+    assert.match(guidance, /refresh cycles/, 'promotion guidance carries the across-cycles framing');
+    assert.ok(guidance.includes(contextDir(meta.node_id)), 'and names the context dir path');
+});
+function makeFakePi() {
+    return {
+        sent: [],
+        renderers: {},
+        on(e, h) { if (e === 'session_start')
+            this.handler = h; },
+        sendMessage(m) { this.sent.push(m); },
+        registerMessageRenderer(t, r) { this.renderers[t] = r; },
+    };
+}
+function fakeCtx(entries = []) {
+    return { sessionManager: { getEntries: () => entries } };
+}
+test('session_start injects the block as the first message of an empty session', () => {
+    const meta = spawnNode({ kind: 'general', cwd: '/tmp/work', parent: null });
+    process.env['CRTR_NODE_ID'] = meta.node_id;
+    const pi = makeFakePi();
+    registerCanvasContextIntro(pi);
+    assert.ok(pi.handler, 'session_start handler registered');
+    // Empty session → inject the block as its own custom message (no delivery
+    // options → it precedes the first prompt).
+    pi.handler({ reason: 'startup' }, fakeCtx());
+    assert.equal(pi.sent.length, 1, 'one message injected');
+    assert.equal(pi.sent[0].customType, CONTEXT_INTRO_CUSTOM_TYPE);
+    assert.equal(pi.sent[0].display, true);
+    assert.match(pi.sent[0].content, /<crtr-context dir=/);
+});
+test('session_start is idempotent across resume (skips if already in history)', () => {
+    const meta = spawnNode({ kind: 'general', cwd: '/tmp/work', parent: null });
+    process.env['CRTR_NODE_ID'] = meta.node_id;
+    // Restored session already carries the block → no duplicate injection.
+    const pi = makeFakePi();
+    registerCanvasContextIntro(pi);
+    const entries = [{ type: 'custom_message', customType: CONTEXT_INTRO_CUSTOM_TYPE }];
+    pi.handler({ reason: 'resume' }, fakeCtx(entries));
+    assert.equal(pi.sent.length, 0, 'block already in history → skip');
+});
+test('session_start is inert when CRTR_NODE_ID is absent', () => {
+    delete process.env['CRTR_NODE_ID'];
+    const pi = makeFakePi();
+    registerCanvasContextIntro(pi);
+    pi.handler({ reason: 'startup' }, fakeCtx());
+    assert.equal(pi.sent.length, 0);
+});
+test('renderer registered for the customType; collapsed hides body, ctrl+o expand reveals it', () => {
+    const pi = makeFakePi();
+    registerCanvasContextIntro(pi);
+    const renderer = pi.renderers[CONTEXT_INTRO_CUSTOM_TYPE];
+    assert.ok(renderer, 'message renderer registered for crtr-context');
+    const body = '<crtr-context dir="/x">\nshared document store\n</crtr-context>';
+    const message = { customType: CONTEXT_INTRO_CUSTOM_TYPE, content: body };
+    const theme = {}; // no fg → plain text, easy to assert
+    // Collapsed (default): a single stub line, NONE of the body.
+    const collapsed = renderContextMessage(message, { expanded: false }, theme).render(80);
+    assert.equal(collapsed.length, 1, 'collapsed is one line');
+    assert.match(collapsed[0], /ctrl\+o to expand/);
+    assert.ok(!collapsed.join('\n').includes('shared document store'), 'body hidden when collapsed');
+    // Expanded (Ctrl+O): label + full body.
+    const expanded = renderContextMessage(message, { expanded: true }, theme).render(80);
+    const joined = expanded.join('\n');
+    assert.ok(joined.includes('shared document store'), 'body shown when expanded');
+    assert.ok(joined.includes(`[${CONTEXT_INTRO_CUSTOM_TYPE}]`), 'expanded shows the label');
+});
+test('renderer never emits a line wider than the terminal (truncates the collapsed stub)', () => {
+    // Regression: a fixed-width stub crashed pi's TUI at narrow widths
+    // ("Rendered line 1 exceeds terminal width"). Every emitted line — collapsed
+    // or expanded — must fit within the width handed to render().
+    const body = Array.from({ length: 6 }, () => 'x'.repeat(200)).join('\n');
+    const message = { customType: CONTEXT_INTRO_CUSTOM_TYPE, content: body };
+    const theme = {}; // no fg → plain text, so .length == visible width
+    for (const w of [1, 2, 5, 10, 20, 42, 80]) {
+        for (const expanded of [false, true]) {
+            const lines = renderContextMessage(message, { expanded }, theme).render(w);
+            for (const line of lines) {
+                assert.ok([...line].length <= w, `width=${w} expanded=${expanded}: line ${[...line].length} cols exceeds ${w}: ${JSON.stringify(line)}`);
+            }
+        }
+    }
+});

package/dist/core/__tests__/daemon-boot.test.d.ts

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

package/dist/core/__tests__/daemon-boot.test.js

@@ -0,0 +1,93 @@
+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 { createNode, getNode, subscribe } from '../canvas/canvas.js';
+import { closeDb } from '../canvas/db.js';
+import { readInboxSince } from '../feed/inbox.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,
+    };
+}
+/** Wire `parent subscribes_to child` — the spawn-time edge (parent wakes on the
+ *  child's pushes), so the daemon's boot-failure push reaches the parent. */
+function spawnEdge(parent, child) {
+    subscribe(parent, child, true);
+}
+before(() => {
+    home = mkdtempSync(join(tmpdir(), 'crtr-daemon-boot-'));
+    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'];
+});
+// A node whose window is gone while pi_session_id was NEVER set: the vehicle
+// died before pi ever booted. The spawner already returned status="active", so
+// the parent must be told — the daemon marks it dead AND pushes urgent up.
+test('never-booted node is marked dead and surfaced to the parent as urgent', async () => {
+    createNode(node('P', { kind: 'developer', lifecycle: 'resident' }));
+    createNode(node('C', {
+        parent: 'P',
+        kind: 'explore',
+        // Points at a session/window that does not exist → windowAlive() is false,
+        // so the daemon treats the window as gone.
+        tmux_session: 'crtr-test-absent-session',
+        window: '@999991',
+        pi_session_id: null, // never booted
+        intent: null,
+    }));
+    spawnEdge('P', 'C');
+    await superviseTick();
+    assert.equal(getNode('C').status, 'dead', 'never-booted child is dead');
+    const inbox = readInboxSince('P');
+    assert.equal(inbox.length, 1, 'parent received exactly one pointer');
+    assert.equal(inbox[0].tier, 'urgent', 'boot failure is delivered as urgent');
+    assert.equal(inbox[0].from, 'C');
+    assert.match(inbox[0].label, /Spawn failed/);
+});
+// A node that HAD booted (pi_session_id set) then lost its window is a genuine
+// crash, not a boot failure — it is marked dead but NOT surfaced as a spawn
+// failure (no false alarm to the parent).
+test('a crash after boot is marked dead without a boot-failure push', async () => {
+    createNode(node('P2', { kind: 'developer', lifecycle: 'resident' }));
+    createNode(node('C2', {
+        parent: 'P2',
+        kind: 'explore',
+        tmux_session: 'crtr-test-absent-session',
+        window: '@999992',
+        pi_session_id: '019e8f00-booted-once', // it booted before dying
+        intent: null,
+    }));
+    spawnEdge('P2', 'C2');
+    await superviseTick();
+    assert.equal(getNode('C2').status, 'dead', 'crashed child is dead');
+    assert.equal(readInboxSince('P2').length, 0, 'a real crash does not push a boot-failure pointer');
+});
+// A still-booting node whose window is alive must be left untouched — boot is
+// slow, and an alive window means pi may still be coming up.
+test('a node with a live window is left alone even before it boots', async () => {
+    // No tmux_session/window → treated as an inline root and skipped entirely,
+    // which exercises the "no placement → not daemon-managed" guard rather than a
+    // false reap. (We avoid depending on a real live tmux window in the test env.)
+    createNode(node('S', { status: 'active', pi_session_id: null }));
+    await superviseTick();
+    assert.equal(getNode('S').status, 'active', 'unplaced active node is not reaped');
+});

package/dist/core/__tests__/daemon-liveness.test.d.ts

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

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

@@ -0,0 +1,223 @@
+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 { closeDb } from '../canvas/db.js';
+import { appendInbox } from '../feed/inbox.js';
+import { superviseTick, isPidAlive, livenessVerdict, } 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' });
+    // spawnSync has reaped it by the time it returns; pid may be on r.pid.
+    return r.pid ?? 0x7ffffffe; // fall back to an implausibly-high pid
+}
+before(() => {
+    home = mkdtempSync(join(tmpdir(), 'crtr-daemon-liveness-'));
+    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'];
+});
+// ---------------------------------------------------------------------------
+// livenessVerdict — the pure grace-window decision
+// ---------------------------------------------------------------------------
+test('livenessVerdict: a live (or unknown) pi is left alone', () => {
+    assert.equal(livenessVerdict(true, 0), 'leave', 'alive pid → leave');
+    assert.equal(livenessVerdict(true, 10_000_000), 'leave');
+    assert.equal(livenessVerdict(null, 10_000_000), 'leave', 'no recorded pid → leave (legacy / in-flight)');
+});
+test('livenessVerdict: a dead pi pends through the grace window, then revives', () => {
+    assert.equal(livenessVerdict(false, null), 'pending', 'first observation → pending');
+    assert.equal(livenessVerdict(false, 0), 'pending', 'just-observed-dead → pending');
+    assert.equal(livenessVerdict(false, 1_000), 'pending', 'still inside grace → pending');
+    assert.equal(livenessVerdict(false, 10_000_000), 'revive', 'dead past grace → revive');
+});
+// ---------------------------------------------------------------------------
+// isPidAlive
+// ---------------------------------------------------------------------------
+test('isPidAlive: this process is alive; a reaped pid is dead', () => {
+    assert.equal(isPidAlive(process.pid), true, 'self is alive');
+    assert.equal(isPidAlive(deadPid()), false, 'a reaped/implausible pid is dead');
+});
+// ---------------------------------------------------------------------------
+// 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 crash branch fires. pi_session_id
+        // is set so it's a clean crash, not a boot-failure push.
+        createNode(node('G', {
+            pane: dead,
+            tmux_session: session,
+            window,
+            pi_pid: process.pid, // alive — irrelevant once the pane reads gone
+            pi_session_id: 'booted',
+            intent: null,
+        }));
+        await superviseTick();
+        assert.equal(getNode('G').status, 'dead', 'a gone pane fires the gone-branch even with a live window + pid');
+    });
+});
+// ---------------------------------------------------------------------------
+// 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__/focuses.test.d.ts

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