@crouton-kit/crouter 0.3.17 → 0.3.19

package/dist/core/__tests__/placement-teardown.test.js

@@ -5,9 +5,11 @@
 // never realized, so closePane no-ops and only the DB effects are asserted):
 //
 //   • handFocusToManager(focusId, managerId) — the §1.6 manager-takeover, a PURE
-//     DB occupant swap. Returns true (TAKEOVER) only when there is a distinct,
-//     not-already-focused manager; false (caller closes the focus) in each of the
-//     three guard cases. Each guard is asserted distinctly.
+//     DB occupant swap. Returns true (TAKEOVER) only when a successor will
+//     GENUINELY claim the frozen pane — a live manager (swapped in) or a dormant
+//     manager the daemon will revive (status='idle' && intent='idle-release').
+//     Returns false (caller disarms the freeze + closes the focus) for every
+//     other case; each guard is asserted distinctly.
 //   • tearDownNode(nodeId) — close/reset teardown: close the focus row it
 //     occupies and null its LOCATION.
 import { test, before, after, beforeEach } from 'node:test';
@@ -62,10 +64,13 @@ after(() => {
 // ---------------------------------------------------------------------------
 // handFocusToManager (pure DB) — §1.6 manager-takeover + its three false-guards.
 // ---------------------------------------------------------------------------
-test('handFocusToManager: distinct, free manager → TAKEOVER (repoints the row, returns true)', () => {
+test('handFocusToManager: dormant idle-release manager → TAKEOVER (repoints the row, returns true)', () => {
     openFocusRow('f', '%m', 'Sa', 'M');
-    createNode(node('mgr'));
-    assert.equal(handFocusToManager('f', 'mgr'), true, 'a valid manager takes the focus');
+    // The daemon's superviseTick second pass revives a node ONLY when it is idle +
+    // idle-release (crtrd.ts ~309) — that is the ONLY dormant manager that will be
+    // brought into the frozen %m, so it is the ONLY dormant takeover that returns true.
+    createNode(node('mgr', { status: 'idle', intent: 'idle-release' }));
+    assert.equal(handFocusToManager('f', 'mgr'), true, 'a manager the daemon WILL revive takes the focus');
     assert.equal(getFocusByNode('mgr')?.focus_id, 'f', 'the row now shows the manager');
     assert.equal(getFocusByNode('M'), null, 'the finished node no longer occupies it');
     // Non-vacuous: a no-op impl returns false / leaves M as occupant → both the
@@ -140,12 +145,14 @@ test('handFocusToManager: LIVE backstage manager → swaps its pane INTO the foc
         spawnSync('tmux', ['kill-session', '-t', back], { stdio: 'ignore' });
     }
 });
-test('handFocusToManager: DORMANT manager (dead pane) → occupant repointed, NO swap, focus pane UNCHANGED', () => {
+test('handFocusToManager: DORMANT idle-release manager (dead pane) → occupant repointed, NO swap, focus pane UNCHANGED', () => {
     openFocusRow('f', '%focus', 'Suser', 'M');
-    // The manager has a pane recorded but it is NOT a live tmux pane (its dead-pi
-    // window collapsed). isNodePaneAlive(mgr) is therefore false, so the live-swap
-    // is skipped — the external daemon later respawns it into the frozen %focus.
-    createNode(node('mgr', { pane: '%mgr-dead', tmux_session: 'back', window: '@wb', pi_pid: process.pid }));
+    // The manager is dormant + idle-release (the ONLY dormant manager the daemon
+    // revives): its pane is recorded but NOT a live tmux pane (its dead-pi window
+    // collapsed) and its pi is dead. isNodePaneAlive(mgr) is therefore false, so the
+    // live-swap is skipped — the external daemon later respawns it into the frozen
+    // %focus, exactly because status='idle' && intent='idle-release'.
+    createNode(node('mgr', { pane: '%mgr-dead', tmux_session: 'back', window: '@wb', pi_pid: null, status: 'idle', intent: 'idle-release' }));
     assert.equal(handFocusToManager('f', 'mgr'), true, 'still a takeover (occupant repointed)');
     assert.equal(getFocusByNode('mgr')?.focus_id, 'f', 'the manager occupies the focus row (DB repoint)');
     assert.equal(getFocusByNode('M'), null, 'the finished node no longer occupies it');
@@ -162,6 +169,42 @@ test('handFocusToManager: DORMANT manager (dead pane) → occupant repointed, NO
     // manager having a pane.
 });
 // ---------------------------------------------------------------------------
+// BUG REGRESSION (dead-focus-pane): handFocusToManager must return FALSE — so
+// the stophook caller runs closeFocusToShell to DISARM remain-on-exit and the
+// pane REAPS on exit — whenever NO successor will actually claim the frozen pane.
+// Pre-fix it repointed the occupant and returned true for ANY non-null,
+// not-already-focused manager (even done/dead/canceled, idle-but-not-idle-
+// release, or a live-but-paneless inline root). The daemon revives NONE of those
+// into the frozen pane, so closeFocusToShell was skipped, remain-on-exit stayed
+// ON, and the focus pane FROZE forever as a dead pane with no reaper.
+// Diagnosis: nodes/mq32wjve-68de0c31/context/dead-focus-pane-fix.md
+// ---------------------------------------------------------------------------
+test('handFocusToManager (BUG REGRESSION): a manager the daemon will NEVER revive → false, occupant UNCHANGED (caller disarms + reaps)', () => {
+    openFocusRow('f', '%focus', 'Suser', 'M'); // M occupies the frozen focus pane
+    // (a) DONE manager — the daemon ignores done nodes entirely (the most common
+    //     trigger: demoting a child to terminal whose manager already finished).
+    createNode(node('mgrDone', { status: 'done', pane: '%d', tmux_session: 'back', window: '@wd' }));
+    assert.equal(handFocusToManager('f', 'mgrDone'), false, 'a DONE manager will never be revived → caller must disarm + reap');
+    assert.equal(getFocusByNode('mgrDone'), null, 'a DONE manager is NOT repointed into the focus row');
+    // (b) DORMANT but NOT idle-release — idle with a different intent; crtrd's
+    //     second pass (idle && idle-release) skips it, so it never enters the pane.
+    createNode(node('mgrIdleDone', { status: 'idle', intent: 'done', pane: '%i', tmux_session: 'back', window: '@wi' }));
+    assert.equal(handFocusToManager('f', 'mgrIdleDone'), false, 'idle but NOT idle-release → daemon never revives it → false');
+    assert.equal(getFocusByNode('mgrIdleDone'), null, 'a non-idle-release manager is NOT repointed');
+    // (c) LIVE-but-PANELESS manager (an inline root, pane == null) — the live-swap
+    //     branch is skipped (no pane to swap) and, being active not idle-release,
+    //     the daemon never revives it either.
+    createNode(node('mgrPaneless', { status: 'active', pi_pid: process.pid, pane: null }));
+    assert.equal(handFocusToManager('f', 'mgrPaneless'), false, 'a live-but-paneless inline root cannot claim the pane → false');
+    assert.equal(getFocusByNode('mgrPaneless'), null, 'a paneless manager is NOT repointed');
+    // The occupant is untouched across all three → the caller (canvas-stophook
+    // agent_end done-branch) runs closeFocusToShell, disarming the freeze.
+    assert.equal(getFocusById('f')?.node_id, 'M', 'M still occupies its focus → caller disarms remain-on-exit + closes the row');
+    // Non-vacuous: the pre-fix impl repointed the occupant + returned true for each
+    // of (a)/(b)/(c), so every false return AND every "NOT repointed" assert fails
+    // against it — and that stray true would have stranded the pane frozen forever.
+});
+// ---------------------------------------------------------------------------
 // tearDownNode (pure DB; no tmux — pane is null so closePane never runs).
 // ---------------------------------------------------------------------------
 test('tearDownNode: closes the focus row M occupied and nulls its LOCATION', () => {

package/dist/core/__tests__/relaunch.test.js

@@ -109,8 +109,9 @@ test('relaunchRoot parks the old root (canceled, edges intact, no wipe) and mint
     assert.equal(existsSync(roadmapPath('root')), true, 'roadmap preserved');
     assert.equal(existsSync(inboxPath('root')), true, 'inbox preserved');
     assert.equal(existsSync(join(reportsDir('root'), '20260101T000000-update.md')), true, 'report preserved');
-    // New root: fresh base resident, active, intent=refresh, empty context dir,
-    // spawned_by=old, focused.
+    // New root: fresh base resident, active, intent=refresh, a clean-slate context
+    // dir (only the born-with memory store, nothing inherited), spawned_by=old,
+    // focused.
     const fresh = getNode(newId);
     assert.equal(fresh?.parent, null, 'new node is a root');
     assert.equal(fresh?.mode, 'base');
@@ -122,7 +123,7 @@ test('relaunchRoot parks the old root (canceled, edges intact, no wipe) and mint
     assert.equal(fresh?.tmux_session, 'crtr', 'adopted the old root window location');
     assert.equal(fresh?.window, '@7');
     assert.ok(fresh?.launch, 'a fresh base launch spec was written');
-    assert.equal(readdirSync(contextDir(newId)).length, 0, 'fresh empty context dir');
+    assert.deepEqual(readdirSync(contextDir(newId)).sort(), ['memory'], 'fresh context dir holds only the born-with node-local memory store — nothing inherited from the old root');
     // Focus follows content: the focus row the old root held now shows the new root.
     assert.equal(getFocusByNode(newId)?.focus_id, 'fRoot', 'focus row repointed to the new root');
     assert.equal(getFocusByNode('root'), null, 'old root no longer occupies the focus');

package/dist/core/__tests__/review-render-pane-regression.test.d.ts

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

package/dist/core/__tests__/review-render-pane-regression.test.js

@@ -0,0 +1,133 @@
+// Run with: node --import tsx/esm --test src/core/__tests__/review-render-pane-regression.test.ts
+//
+// BUG REGRESSION: `crtr human review` showed the human RAW markdown — literal
+// `:::callout{...}` / `#` / `**bold**` source — instead of the termrender-
+// rendered document the leaf help promises ("directive-flavored markdown
+// rendered by termrender (panels, columns, trees, callouts, mermaid)").
+//
+// Root cause: the review surface was ONLY the read-only nvim buffer. nvim must
+// show the raw source (anchored comments hang off source line/col numbers), and
+// `-u NONE` treesitter/render-markdown styling never interprets ::: directives —
+// so nothing anywhere rendered the doc. There was no termrender invocation in
+// the entire review path (crouter `_run` review branch + humanloop
+// launchReview): the managed venv binary was healthy and never asked.
+//
+// THE FIX (src/commands/human/queue.ts, `_run` review branch): open a live
+// termrender watch pane via humanloop `display()` BESIDE the editor, record its
+// pane id as `render_pane_id` on run.json (so `human cancel` can clear it), and
+// kill it in a `finally` when the editor exits. The editor keeps the raw
+// source; the human reads the rendered pane.
+//
+// This test drives the REAL `crtr human _run` worker (review mode) in a REAL
+// but isolated tmux session — no mocks — and asserts:
+//   (a) a second pane appears beside the editor running termrender on the file,
+//   (b) that pane's content is RENDERED ANSI (box-drawing panels), not raw `:::`,
+//   (c) run.json carries render_pane_id for the cancel path,
+//   (d) the render pane is torn down when the editor exits.
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { spawnSync } from 'node:child_process';
+import { mkdtempSync, rmSync, writeFileSync, readFileSync, existsSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createRequire } from 'node:module';
+import { hasTmux } from './helpers/harness.js';
+const CROUTER = join(dirname(fileURLToPath(import.meta.url)), '..', '..', '..');
+const CLI_SRC = join(CROUTER, 'src', 'cli.ts');
+const TSX_ESM = createRequire(import.meta.url).resolve('tsx/esm');
+function tmux(args) {
+    const r = spawnSync('tmux', args, { encoding: 'utf8' });
+    return { code: r.status ?? -1, out: (r.stdout ?? '').trim(), err: (r.stderr ?? '').trim() };
+}
+function sessionPanes(session) {
+    const r = tmux(['list-panes', '-s', '-t', session, '-F', '#{pane_id}\t#{pane_current_command}']);
+    if (r.code !== 0)
+        return [];
+    return r.out
+        .split('\n')
+        .filter((l) => l.trim() !== '')
+        .map((l) => {
+        const [id, cmd] = l.split('\t');
+        return { id: id ?? '', cmd: cmd ?? '' };
+    });
+}
+function paneContent(paneId) {
+    return tmux(['capture-pane', '-p', '-t', paneId]).out;
+}
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+async function waitFor(fn, timeoutMs, label) {
+    const deadline = Date.now() + timeoutMs;
+    for (;;) {
+        const v = fn();
+        if (v !== undefined)
+            return v;
+        if (Date.now() > deadline)
+            throw new Error(`timeout waiting for ${label}`);
+        await sleep(300);
+    }
+}
+const SKIP = !hasTmux();
+test('review-render-pane regression: `human _run` (review) opens a live termrender pane showing RENDERED panels, not raw ::: source', { skip: SKIP ? 'tmux unavailable' : false, timeout: 90_000 }, async () => {
+    const dir = mkdtempSync(join(tmpdir(), 'crtr-review-render-'));
+    const session = `crtr-revrender-${process.pid}-${Date.now().toString(36)}`;
+    const mdPath = join(dir, 'doc.md');
+    // A directive doc: rendered output has box-drawing panels; raw output has `:::`.
+    writeFileSync(mdPath, '# Render check\n\n:::callout{type="info"}\nRENDER-MARKER body\n:::\n');
+    writeFileSync(join(dir, 'run.json'), JSON.stringify({ mode: 'review', job_id: '', file: mdPath, output: join(dir, 'feedback.json') }));
+    try {
+        // The worker runs the real `crtr human _run` from src via tsx, exactly the
+        // command shape detachHumanTui bakes into the spawned pane. job_id is ''
+        // so pushFinal is skipped (no canvas home needed) — the surface under
+        // test is the panes, not the report fan-out.
+        const workerCmd = `CRTR_HUMAN_DIR='${dir}' '${process.execPath}' --import '${TSX_ESM}' '${CLI_SRC}' human _run; sleep 120`;
+        const created = tmux(['new-session', '-d', '-s', session, '-x', '200', '-y', '50', workerCmd]);
+        assert.equal(created.code, 0, `create isolated session failed: ${created.err}`);
+        // (a) a SECOND pane appears: the termrender watch pane beside the editor.
+        const renderPane = await waitFor(() => {
+            const panes = sessionPanes(session);
+            if (panes.length < 2)
+                return undefined;
+            // The render pane is the one NOT hosting the editor/worker shell.
+            const candidates = panes.filter((p) => !/zsh|bash|sh|node|nvim|vim/i.test(p.cmd));
+            return candidates[0]?.id;
+        }, 30_000, 'termrender render pane to open');
+        // (b) its content is RENDERED: panel box-drawing present, raw ::: absent.
+        const rendered = await waitFor(() => {
+            const c = paneContent(renderPane);
+            return c.includes('RENDER-MARKER') ? c : undefined;
+        }, 30_000, 'rendered body to paint');
+        assert.ok(/[┌│└]/.test(rendered), `render pane draws panels (box chars): ${rendered.slice(0, 200)}`);
+        assert.ok(!rendered.includes(':::'), 'render pane does NOT show raw ::: directive source');
+        // (c) run.json carries render_pane_id so `human cancel` can clear the pane.
+        const rc = JSON.parse(readFileSync(join(dir, 'run.json'), 'utf8'));
+        assert.equal(rc.render_pane_id, renderPane, 'run.json records the render pane id');
+        // (d) editor exit (any quit submits) tears the render pane down. The
+        // editor pane is the OTHER pane (nvim runs as a child of the worker, so
+        // #{pane_current_command} may report node/zsh — match on its content:
+        // the read-only buffer shows the RAW ::: source).
+        const editorPane = await waitFor(() => {
+            const other = sessionPanes(session).find((p) => p.id !== renderPane);
+            if (other === undefined)
+                return undefined;
+            return paneContent(other.id).includes(':::') ? other.id : undefined;
+        }, 30_000, 'editor pane showing the raw source buffer');
+        tmux(['send-keys', '-t', editorPane, 'Space', 's']);
+        await waitFor(() => (existsSync(join(dir, 'feedback.json')) ? true : undefined), 30_000, 'feedback.json after submit');
+        await waitFor(() => (sessionPanes(session).some((p) => p.id === renderPane) ? undefined : true), 15_000, 'render pane to be killed after editor exit');
+    }
+    finally {
+        tmux(['kill-session', '-t', session]);
+        // The worker may still be flushing job files as it exits; retry the rm
+        // briefly so a write racing the first attempt can't fail the test.
+        for (let i = 0; i < 10; i++) {
+            try {
+                rmSync(dir, { recursive: true, force: true });
+                break;
+            }
+            catch {
+                await sleep(300);
+            }
+        }
+    }
+});

package/dist/core/__tests__/spawn-root.test.js

@@ -10,6 +10,7 @@ import { createNode, getNode, getRow, subscribersOf } from '../canvas/canvas.js'
 import { closeDb } from '../canvas/db.js';
 import { nodeDir } from '../canvas/paths.js';
 import { spawnNode } from '../runtime/nodes.js';
+import { resolveSpawner } from '../runtime/spawn.js';
 let home;
 function spawner(id) {
     return {
@@ -62,6 +63,15 @@ test('independent root: provenance only, no parent, no subscription', () => {
     assert.equal(meta.lifecycle, 'resident', 'a root is resident');
     assert.equal(subscribersOf(root.node_id).length, 0, 'nobody is subscribed to an independent root — the spawner is not woken by it');
 });
+test('resolveSpawner: a --root spawn needs no caller; a managed child does (regression)', () => {
+    // Bug-regression: `crtr node new --root` from a human shell (no CRTR_NODE_ID,
+    // no --parent) threw "spawnChild requires a calling node" even though a root
+    // has no spine parent and the spawner id is provenance only.
+    assert.equal(resolveSpawner(undefined, null, true), null, 'human root spawn: no caller is fine');
+    assert.equal(resolveSpawner(undefined, 'A', true), 'A', 'node root spawn: provenance recorded');
+    assert.equal(resolveSpawner('A', null, false), 'A', 'explicit parent satisfies a child spawn');
+    assert.throws(() => resolveSpawner(undefined, null, false), /requires a calling node/, 'a managed child with no caller still throws');
+});
 test('unknown parent: spawnNode throws and mints NO node dir / row (validate before create)', () => {
     // Pre-allocate the would-be id so we can prove nothing was scaffolded for it.
     const orphanId = 'orphan-under-ghost';

package/dist/core/__tests__/spike-harness.test.js

@@ -46,6 +46,7 @@ const CANVAS_ENV_KEYS = [
     'CRTR_NODE_ID',
     'CRTR_HOME',
     'CRTR_ROOT_SESSION',
+    'CRTR_SUBTREE',
     'CRTR_NODE_SESSION',
     'CRTR_PARENT_NODE_ID',
     'CRTR_FRONT_DOOR',

package/dist/core/__tests__/wake-bearings.test.d.ts

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

package/dist/core/__tests__/wake-bearings.test.js

@@ -0,0 +1,156 @@
+// Run with: node --import tsx/esm --test src/core/__tests__/wake-bearings.test.ts
+//
+// Wake-origin self-knowledge (the <crtr-wake> provenance block). Regression
+// guard for the observed gap: a node woken or BORN by a scheduled TIMER could
+// not tell it came from a timer — a scheduled wake arrived indistinguishable
+// from an ordinary refresh/message (the Invariant B/D anti-goal). These lock:
+//   • buildWakeBearings renders the right decision-first block per wake kind /
+//     cadence, and never crashes when the armer was reaped (no resolved name);
+//   • the bare-wake revive kickoff carries that block (so a scheduled alarm is
+//     distinguishable from a generic context-refresh), placed AFTER the kickoff
+//     sentinel (goal-capture keys on it) and BEFORE the roadmap/disk bearings;
+//   • an ordinary fresh revive (no wakeReason) carries NO block.
+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 } from '../canvas/canvas.js';
+import { closeDb } from '../canvas/db.js';
+import { buildWakeBearings } from '../runtime/bearings.js';
+import { buildReviveKickoff, drainBearings, REVIVE_KICKOFF_SENTINEL, } from '../runtime/kickoff.js';
+let home;
+function node(id) {
+    return {
+        node_id: id,
+        name: id,
+        created: new Date().toISOString(),
+        cwd: '/tmp/work',
+        kind: 'general',
+        mode: 'base',
+        lifecycle: 'terminal',
+        status: 'active',
+    };
+}
+const ARMED = '2026-06-08T13:30:00.000Z';
+before(() => {
+    home = mkdtempSync(join(tmpdir(), 'crtr-wake-bearings-'));
+    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'];
+});
+// --- buildWakeBearings: one per kind / cadence variant ----------------------
+test('spawn one-shot: names a deferred birth + the armer, and says it does not recur', () => {
+    const o = {
+        kind: 'spawn',
+        ownerId: 'arm-1',
+        ownerName: 'release-orch',
+        armedAt: ARMED,
+        recur: null,
+    };
+    const b = buildWakeBearings(o);
+    assert.ok(b.startsWith('<crtr-wake>') && b.endsWith('</crtr-wake>'));
+    assert.match(b, /BORN by a scheduled wake/);
+    assert.match(b, /deferred birth/);
+    // Armer named ROLE-explicitly so the newborn never reads the id as its own.
+    assert.match(b, /armed by node arm-1 \("release-orch"\)/);
+    assert.match(b, /only run, not a recurring job/);
+    assert.match(b, /Your task follows\./);
+});
+test('spawn cron: surfaces the cadence + frames it as one run of a standing job', () => {
+    const o = {
+        kind: 'spawn',
+        ownerId: 'arm-1',
+        ownerName: 'nightly',
+        armedAt: ARMED,
+        recur: JSON.stringify({ cron: '0 9 * * *', tz: 'America/New_York' }),
+    };
+    const b = buildWakeBearings(o);
+    assert.match(b, /recurring spawn-cron armed by node arm-1 \("nightly"\)/);
+    // The cadence renders via the shared cadenceDisplay (matches `wake list`).
+    assert.match(b, /firing cron `0 9 \* \* \*` \(America\/New_York\)/);
+    assert.match(b, /one run of a standing job, not a one-off/);
+    assert.match(b, /inherit nothing from prior runs but this task/);
+});
+test('spawn interval cron: renders the every-N cadence', () => {
+    const o = {
+        kind: 'spawn',
+        ownerId: 'arm-1',
+        ownerName: 'poller',
+        armedAt: ARMED,
+        recur: JSON.stringify({ every: '6h' }),
+    };
+    assert.match(buildWakeBearings(o), /firing every 6h/);
+});
+test('spawn with a reaped armer: renders the bare id, no name, never crashes', () => {
+    const o = {
+        kind: 'spawn',
+        ownerId: 'gone-9',
+        ownerName: undefined, // armer no longer exists → no resolved name
+        armedAt: ARMED,
+        recur: JSON.stringify({ every: '12h' }),
+    };
+    const b = buildWakeBearings(o);
+    assert.match(b, /armed by node gone-9 \(now gone\)/); // bare id, flagged reaped
+    assert.doesNotMatch(b, /\("/); // never an empty/dangling name
+});
+test('bare one-shot: frames a timed re-check, NOT a new request', () => {
+    const o = { kind: 'bare', ownerId: 'n1', ownerName: 'n1', armedAt: ARMED, recur: null };
+    const b = buildWakeBearings(o);
+    assert.match(b, /a scheduled alarm fired/);
+    assert.match(b, /a timer, NOT a new message or request/);
+    assert.match(b, /timed re-check, not a new task/);
+    assert.match(b, /re-read your roadmap/);
+    // No armer attribution on bare (could be `--node`-armed by another), no ISO.
+    assert.doesNotMatch(b, /you set/);
+    assert.doesNotMatch(b, new RegExp(ARMED));
+});
+test('bare recurring: frames one tick of a standing re-check + the cadence', () => {
+    const o = {
+        kind: 'bare',
+        ownerId: 'n1',
+        ownerName: 'n1',
+        armedAt: ARMED,
+        recur: JSON.stringify({ every: '6h' }),
+    };
+    const b = buildWakeBearings(o);
+    assert.match(b, /recurring scheduled alarm fired \(every 6h\)/);
+    assert.match(b, /one tick of a standing re-check/);
+});
+// --- the bare-wake revive seam (Seam 2) -------------------------------------
+test('a bare scheduled wake makes the fresh-revive kickoff distinguishable from a refresh', () => {
+    const id = 'b1';
+    const meta = createNode(node(id));
+    const wakeReason = {
+        kind: 'bare',
+        ownerId: id,
+        ownerName: id,
+        armedAt: ARMED,
+        recur: null,
+    };
+    const msg = buildReviveKickoff(meta, drainBearings(meta), wakeReason);
+    // The block is present, and the kickoff STILL starts with the sentinel that
+    // goal-capture keys on (so the prompt is never mistaken for a user mandate).
+    assert.ok(msg.startsWith(REVIVE_KICKOFF_SENTINEL), 'kickoff still leads with the sentinel');
+    assert.match(msg, /<crtr-wake>/);
+    assert.match(msg, /a scheduled alarm fired/);
+    // Placement: sentinel < <crtr-wake> < <roadmap> — "why you woke" precedes
+    // "what to rebuild from".
+    const iSentinel = msg.indexOf(REVIVE_KICKOFF_SENTINEL);
+    const iWake = msg.indexOf('<crtr-wake>');
+    const iRoadmap = msg.indexOf('<roadmap');
+    assert.ok(iSentinel === 0 && iSentinel < iWake && iWake < iRoadmap, 'block sits after sentinel, before roadmap');
+});
+test('an ordinary fresh revive (no wakeReason) carries NO wake block', () => {
+    const id = 'b2';
+    const meta = createNode(node(id));
+    const msg = buildReviveKickoff(meta, drainBearings(meta));
+    assert.doesNotMatch(msg, /<crtr-wake>/);
+});

package/dist/core/__tests__/wake-origin.test.d.ts

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

package/dist/core/__tests__/wake-origin.test.js

@@ -0,0 +1,110 @@
+// Run with: node --import tsx/esm --test src/core/__tests__/wake-origin.test.ts
+//
+// Wake-origin self-knowledge at the DAEMON FIRING seams (the other half of the
+// regression — wake-bearings.test.ts covers the pure block + the bare-revive
+// kickoff). The observed gap: a scheduled wake arrived indistinguishable from an
+// ordinary message/spawn (Invariant D). These lock the daemon's third pass:
+//   • noted  — the delivered inbox label carries the ⏰ scheduled-wake marker, so
+//     a timed note is distinguishable from a plain `node msg` (no tmux needed).
+//   • spawn  — a node BORN by a spawn wake gets the <crtr-wake> block prepended
+//     to its kickoff prompt (naming the armer + cadence); an ordinary `node new`
+//     spawn does NOT. The headline. (tmux-gated integration via the harness.)
+import { test, before, after, beforeEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync, readdirSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createNode } from '../canvas/canvas.js';
+import { armWake } from '../canvas/wakeups.js';
+import { closeDb } from '../canvas/db.js';
+import { readInboxSince } from '../feed/inbox.js';
+import { superviseTick } from '../../daemon/crtrd.js';
+import { hasTmux, createHarness } from './helpers/harness.js';
+const CROUTER = join(dirname(fileURLToPath(import.meta.url)), '..', '..', '..');
+function node(id) {
+    return {
+        node_id: id,
+        name: id,
+        created: new Date().toISOString(),
+        cwd: '/tmp/work',
+        kind: 'general',
+        mode: 'base',
+        lifecycle: 'terminal',
+        status: 'active',
+        parent: null,
+    };
+}
+// --- noted seam (no tmux) ---------------------------------------------------
+let home;
+before(() => {
+    home = mkdtempSync(join(tmpdir(), 'crtr-wake-origin-'));
+    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'];
+});
+test('a noted scheduled wake delivers a ⏰-marked inbox label, distinct from a plain message', async () => {
+    const armer = createNode(node('armer'));
+    const target = createNode(node('tgt')); // no tmux placement → pass 1 skips it
+    armWake({
+        wakeup_id: 'wk-noted-1',
+        node_id: target.node_id,
+        owner_id: armer.node_id,
+        fire_at: new Date(Date.now() - 1000).toISOString(),
+        kind: 'noted',
+        recur: null,
+        payload: { body: 'CI should be green by now — check it', label: 'check CI' },
+    });
+    closeDb();
+    await superviseTick(Date.now());
+    closeDb();
+    const entries = readInboxSince(target.node_id);
+    assert.equal(entries.length, 1, 'the noted wake delivered exactly one inbox entry');
+    // Invariant D: the timer signal rides the VISIBLE label (digests never surface
+    // arbitrary data keys), so this is distinguishable from a plain `node msg`.
+    assert.equal(entries[0].label, '⏰ scheduled wake — check CI');
+    assert.notEqual(entries[0].label, 'check CI', 'a plain message would carry the bare label');
+});
+// --- spawn seam (the headline; tmux-gated integration) ----------------------
+test('a spawn scheduled wake births a node whose kickoff carries <crtr-wake>; node new does NOT', { skip: hasTmux() ? false : 'tmux unavailable' }, async () => {
+    const h = await createHarness();
+    try {
+        const armer = h.spawnRoot('armer');
+        // Contrast: an ordinary `node new` spawn — its kickoff has NO wake block.
+        const plainChild = await h.spawnChild(armer, 'plain task');
+        const plainBoot = await h.awaitBoot(plainChild);
+        assert.doesNotMatch(plainBoot.prompt ?? '', /<crtr-wake>/, 'node new carries no wake block');
+        // Arm a recurring spawn-cron (detached), fire one tick, inspect the BORN
+        // node's kickoff prompt (the message it actually wakes on).
+        const before = new Set(readdirSync(join(h.home, 'nodes')));
+        armWake({
+            wakeup_id: 'wk-spawn-1',
+            node_id: null, // canvas-detached deferred birth
+            owner_id: armer,
+            fire_at: new Date(Date.now() - 1000).toISOString(),
+            kind: 'spawn',
+            recur: JSON.stringify({ every: '6h' }),
+            payload: { kind: 'general', cwd: CROUTER, prompt: 'do the recurring job', parent: armer },
+        });
+        await h.tick(Date.now());
+        const born = readdirSync(join(h.home, 'nodes')).filter((d) => !before.has(d));
+        assert.equal(born.length, 1, 'exactly one node born from the spawn wake');
+        const bornBoot = await h.awaitBoot(born[0]);
+        const prompt = bornBoot.prompt ?? '';
+        assert.match(prompt, /<crtr-wake>/, 'the born node learns a timer birthed it');
+        assert.match(prompt, /recurring spawn-cron armed by node /, 'names the armer role-explicitly');
+        assert.match(prompt, /firing every 6h/, 'surfaces the cadence');
+        assert.match(prompt, new RegExp(armer), 'the still-alive armer is named');
+        assert.match(prompt, /do the recurring job/, 'the real task follows the block');
+    }
+    finally {
+        await h.dispose();
+    }
+});

package/dist/core/bootstrap.js

@@ -30,7 +30,7 @@ const BOOT_SKILL_MARKER_PREFIX = '<!-- crtr-boot-skill v';
 function bootSkillBody() {
     return `---
 name: crtr-skills
-description: Capture, list, search, and load skills via the crtr CLI. Skills are durable agent memory — markdown future LLM sessions load on demand. Use when the user wants to remember/save knowledge, build a context primer, or recall a previously saved skill. Triggers: "save", "remember", "build context for", "what skills do we have", "skill for X".
+description: 'Capture, list, search, and load skills via the crtr CLI. Skills are durable agent memory — markdown future LLM sessions load on demand. Use when the user wants to remember/save knowledge, build a context primer, or recall a previously saved skill. Triggers: "save", "remember", "build context for", "what skills do we have", "skill for X".'
 argument-hint: [topic or verb]
 ---
 

package/dist/core/canvas/browse/__tests__/render.test.js

@@ -36,6 +36,7 @@ function state(over = {}) {
         cwdScope: null,
         sort: 'tree',
         preview: false,
+        residentsOnly: false,
         ...over,
     };
 }