@crouton-kit/crouter 0.3.33 → 0.3.35

package/dist/core/__tests__/on-read-dedup-resume.test.js

@@ -20,6 +20,7 @@ import { mkdtempSync, mkdirSync, rmSync, writeFileSync, existsSync } from 'node:
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { closeDb } from '../canvas/db.js';
+import { resetScopeCache } from '../scope.js';
 import { injectedDocsPath } from '../canvas/paths.js';
 import { spawnNode } from '../runtime/nodes.js';
 import { renderOnReadDocs } from '../substrate/on-read.js';
@@ -27,20 +28,32 @@ import { loadInjectedDocs, saveInjectedDocs, clearInjectedDocs, } from '../subst
 const FIXTURE_BODY = 'Fixture body that must surface exactly once.';
 let home;
 let work;
+let prevHomeEnv;
 before(() => {
     home = mkdtempSync(join(tmpdir(), 'crtr-onread-home-'));
     process.env['CRTR_HOME'] = home;
+    prevHomeEnv = process.env['HOME'];
 });
 beforeEach(() => {
     closeDb();
+    resetScopeCache();
     rmSync(home, { recursive: true, force: true });
+    if (prevHomeEnv === undefined)
+        delete process.env['HOME'];
+    else
+        process.env['HOME'] = prevHomeEnv;
     work = mkdtempSync(join(tmpdir(), 'crtr-onread-work-'));
 });
 after(() => {
     closeDb();
+    resetScopeCache();
     rmSync(home, { recursive: true, force: true });
     rmSync(work, { recursive: true, force: true });
     delete process.env['CRTR_HOME'];
+    if (prevHomeEnv === undefined)
+        delete process.env['HOME'];
+    else
+        process.env['HOME'] = prevHomeEnv;
 });
 test('injected-store round-trips and clears', () => {
     const node = spawnNode({ kind: 'general', cwd: work, parent: null }).node_id;
@@ -51,6 +64,33 @@ test('injected-store round-trips and clears', () => {
     assert.ok(!existsSync(injectedDocsPath(node)), 'clear removes the file');
     assert.deepEqual([...loadInjectedDocs(node)], [], 'load after clear is empty');
 });
+test('user-global memory docs do not fire positionally for every file under home', () => {
+    const fakeHome = mkdtempSync(join(tmpdir(), 'crtr-onread-user-home-'));
+    process.env['HOME'] = fakeHome;
+    resetScopeCache();
+    const node = spawnNode({ kind: 'general', cwd: join(fakeHome, 'work'), parent: null }).node_id;
+    const userMemDir = join(fakeHome, '.crouter', 'memory');
+    mkdirSync(userMemDir, { recursive: true });
+    writeFileSync(join(userMemDir, 'noisy-global.md'), '---\nkind: preference\n' +
+        'when-and-why-to-read: When reading any file, this preference should be read because this fixture must not fire positionally\n' +
+        'file-read-visibility: content\n---\n' +
+        'NOISY USER BODY\n');
+    const projectMemDir = join(fakeHome, 'work', '.crouter', 'memory');
+    mkdirSync(projectMemDir, { recursive: true });
+    writeFileSync(join(projectMemDir, 'local.md'), '---\nkind: knowledge\n' +
+        'when-and-why-to-read: When reading project files, this reference should be read because local project memories remain positional\n' +
+        'file-read-visibility: content\n---\n' +
+        'LOCAL PROJECT BODY\n');
+    const readFile = join(fakeHome, 'work', 'ideas.md');
+    writeFileSync(readFile, 'turn off xml closer\n');
+    const rendered = renderOnReadDocs(node, readFile, new Set());
+    assert.ok(!rendered.includes('NOISY USER BODY'), 'user-global doc is not positional');
+    assert.ok(rendered.includes('LOCAL PROJECT BODY'), 'project doc still fires positionally');
+    assert.ok(rendered.includes('<memory kind="knowledge" name="local"'), 'memory docs render as memory tags');
+    assert.ok(!rendered.includes('triggered-by='), 'read target is not repeated on child items');
+    assert.ok(!rendered.includes('<auto-loaded-context file='), 'read target is not repeated on the wrapper');
+    rmSync(fakeHome, { recursive: true, force: true });
+});
 test('on-read doc surfaces once, stays deduped across a revive(resume), re-surfaces after a fresh launch', () => {
     const node = spawnNode({ kind: 'general', cwd: work, parent: null }).node_id;
     // A positional substrate doc in a `.crouter/memory/` ancestor of the read file.

package/dist/core/__tests__/preview-registry-sync.test.js

@@ -0,0 +1,36 @@
+// Drift guard for the attach-viewer's bundle-safe preview registry.
+// Run with: node --import tsx/esm --test src/core/__tests__/preview-registry-sync.test.ts
+//
+// src/core/preview-registry.ts is a hand-maintained, zero-import mirror of
+// every leaf's `help.preview.suppressOutput` — it has to be hand-maintained
+// (not computed) because the attach viewer can never import the live command
+// tree (build-root.ts pulls in every subtree, including the web client's
+// Tailwind native binary — see command-preview-implementation.md). This test
+// is the only thing that keeps the mirror honest: it walks the real,
+// buildRoot()-assembled tree (safe here — this is a test, not the attach
+// bundle) and asserts the set of leaves declaring `suppressOutput: true`
+// matches the registry exactly.
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { buildRoot } from '../../build-root.js';
+import { SUPPRESS_OUTPUT_LEAVES } from '../preview-registry.js';
+test('preview-registry.ts matches every leaf declaring help.preview.suppressOutput', async () => {
+    const root = await buildRoot();
+    const declared = new Set();
+    const walk = (branch) => {
+        for (const child of branch.children) {
+            if (child.kind === 'branch') {
+                walk(child);
+            }
+            else {
+                const leaf = child;
+                if (leaf.help.preview?.suppressOutput === true)
+                    declared.add(leaf.help.name);
+            }
+        }
+    };
+    for (const subtree of root.subtrees)
+        walk(subtree);
+    assert.deepEqual([...declared].sort(), [...SUPPRESS_OUTPUT_LEAVES].sort(), 'src/core/preview-registry.ts is out of sync with the leaves that declare ' +
+        'help.preview.suppressOutput — update SUPPRESS_OUTPUT_LEAVES to match.');
+});

package/dist/core/__tests__/prune-to-limit.test.js

@@ -0,0 +1,91 @@
+import { test, before, after, beforeEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync, existsSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { createNode, getRow, recordPid, pruneToLimit, } from '../canvas/canvas.js';
+import { closeDb } from '../canvas/db.js';
+import { nodeDir } from '../canvas/paths.js';
+let home;
+// A timestamp `secondsAgo` before now — created order doubles as recency order
+// here (no telemetry.json is written, so recencyMs falls back to created epoch).
+const at = (secondsAgo) => new Date(Date.now() - secondsAgo * 1000).toISOString();
+function node(id, over = {}) {
+    return {
+        node_id: id,
+        name: id,
+        created: at(0),
+        cwd: '/tmp/work',
+        kind: 'general',
+        mode: 'base',
+        lifecycle: 'terminal',
+        status: 'dead',
+        ...over,
+    };
+}
+before(() => {
+    home = mkdtempSync(join(tmpdir(), 'crtr-prune-limit-'));
+    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('keeps all live nodes even when liveCount exceeds the cap', () => {
+    // 5 live (active/idle with a running pi) + 2 old terminal; cap of 3.
+    // target = max(3, 5) = 5, so NO live node is ever deleted; the 2 terminal
+    // fall beyond rank 5 and are pruned.
+    for (let i = 0; i < 5; i++) {
+        createNode(node(`live-${i}`, { status: 'active', created: at(i) }));
+        recordPid(`live-${i}`, process.pid); // process.pid is alive → isPidAlive true
+    }
+    createNode(node('old-a', { status: 'dead', created: at(100) }));
+    createNode(node('old-b', { status: 'done', created: at(101) }));
+    const result = pruneToLimit({ maxNodes: 3 });
+    assert.equal(result.dryRun, false);
+    assert.deepEqual(result.pruned.map((p) => p.node_id).sort(), ['old-a', 'old-b']);
+    for (let i = 0; i < 5; i++) {
+        assert.ok(getRow(`live-${i}`) !== null, `live-${i} must survive past the cap`);
+    }
+});
+test('deletes the oldest terminal nodes beyond max(cap, liveCount)', () => {
+    // 1 live + 5 terminal of descending recency; cap of 3 → target = max(3,1) = 3.
+    // Ranked by recency DESC: live-0, term-0, term-1 (top 3, kept), then
+    // term-2, term-3, term-4 (rank >= 3, pruned).
+    createNode(node('live-0', { status: 'idle', created: at(0) }));
+    recordPid('live-0', process.pid);
+    for (let i = 0; i < 5; i++) {
+        createNode(node(`term-${i}`, { status: 'dead', created: at(10 + i) }));
+    }
+    const result = pruneToLimit({ maxNodes: 3 });
+    assert.deepEqual(result.pruned.map((p) => p.node_id).sort(), ['term-2', 'term-3', 'term-4']);
+    // The kept set: the live node + the two newest terminal.
+    for (const id of ['live-0', 'term-0', 'term-1']) {
+        assert.ok(getRow(id) !== null, `${id} must survive`);
+        assert.ok(existsSync(nodeDir(id)), `${id} dir must survive`);
+    }
+    // The pruned set: rows AND dirs gone.
+    for (const id of ['term-2', 'term-3', 'term-4']) {
+        assert.equal(getRow(id), null, `${id} row should be pruned`);
+        assert.ok(!existsSync(nodeDir(id)), `${id} dir should be removed`);
+    }
+});
+test('--dry-run reports candidates but deletes nothing', () => {
+    for (let i = 0; i < 5; i++) {
+        createNode(node(`term-${i}`, { status: 'dead', created: at(i) }));
+    }
+    const result = pruneToLimit({ maxNodes: 3, dryRun: true });
+    assert.equal(result.dryRun, true);
+    assert.deepEqual(result.pruned.map((p) => p.node_id).sort(), ['term-3', 'term-4']);
+    // Nothing deleted — all rows + dirs intact.
+    for (let i = 0; i < 5; i++) {
+        assert.ok(getRow(`term-${i}`) !== null, `term-${i} must survive a dry run`);
+        assert.ok(existsSync(nodeDir(`term-${i}`)), `term-${i} dir must survive a dry run`);
+    }
+});

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

@@ -93,41 +93,54 @@ after(() => {
 // ---------------------------------------------------------------------------
 // resumeArgs — the pure resume-source selection
 // ---------------------------------------------------------------------------
-test('resumeArgs prefers the absolute file path and keeps the id as fallback', () => {
-    const m = node('n', { pi_session_id: 'uuid-123', pi_session_file: '/abs/sess.jsonl' });
-    assert.deepEqual(resumeArgs(m, true), {
-        resumeSessionId: 'uuid-123',
-        resumeSessionPath: '/abs/sess.jsonl',
-    });
+test('resumeArgs resumes by the absolute file path when it exists on disk', () => {
+    mkdirSync(home, { recursive: true });
+    const sessionFile = join(home, 'resume-args-exists.jsonl');
+    writeFileSync(sessionFile, '{}\n', 'utf8');
+    const m = node('n', { pi_session_id: 'uuid-123', pi_session_file: sessionFile });
+    assert.deepEqual(resumeArgs(m, true), { resumeSessionPath: sessionFile });
 });
-test('resumeArgs falls back to the bare id when no file was captured (older node)', () => {
+test('resumeArgs selects nothing (falls through to fresh) when no file was ever captured (older node)', () => {
     const m = node('n', { pi_session_id: 'uuid-123', pi_session_file: null });
-    assert.deepEqual(resumeArgs(m, true), {
-        resumeSessionId: 'uuid-123',
-        resumeSessionPath: undefined,
+    assert.deepEqual(resumeArgs(m, true), {});
+});
+test('resumeArgs selects nothing (falls through to fresh) when the recorded file does not exist on disk', () => {
+    // The related P6 finding: pi_session_file can be recorded in meta with
+    // nothing ever written there (the first-boot engine died before
+    // session_start). A bare id is NOT a safe fallback either —
+    // headlessBrokerHost's preflight fatally rejects it — so this must select
+    // NEITHER source, not silently hand pi a path that isn't there.
+    const m = node('n', {
+        pi_session_id: 'uuid-123',
+        pi_session_file: join(home, 'never-written.jsonl'),
     });
+    assert.deepEqual(resumeArgs(m, true), {});
 });
 test('resumeArgs selects neither source on a no-resume (refresh) revive', () => {
-    const m = node('n', { pi_session_id: 'uuid-123', pi_session_file: '/abs/sess.jsonl' });
+    mkdirSync(home, { recursive: true });
+    const sessionFile = join(home, 'resume-args-refresh.jsonl');
+    writeFileSync(sessionFile, '{}\n', 'utf8');
+    const m = node('n', { pi_session_id: 'uuid-123', pi_session_file: sessionFile });
     assert.deepEqual(resumeArgs(m, false), {});
 });
 // ---------------------------------------------------------------------------
 // buildPiArgv — the `--session` argument the revive builds
 // ---------------------------------------------------------------------------
-test('buildPiArgv resumes by ABSOLUTE path when pi_session_file is set (not the uuid)', () => {
-    const m = node('n', { pi_session_id: 'uuid-123', pi_session_file: '/abs/sess.jsonl' });
+test('buildPiArgv resumes by ABSOLUTE path when pi_session_file exists on disk', () => {
+    mkdirSync(home, { recursive: true });
+    const sessionFile = join(home, 'build-argv-exists.jsonl');
+    writeFileSync(sessionFile, '{}\n', 'utf8');
+    const m = node('n', { pi_session_id: 'uuid-123', pi_session_file: sessionFile });
     const { argv } = buildPiArgv(m, resumeArgs(m, true));
     const i = argv.indexOf('--session');
     assert.ok(i >= 0, 'argv carries --session');
-    assert.equal(argv[i + 1], '/abs/sess.jsonl', 'resumes by absolute file path');
-    assert.ok(!argv.includes('uuid-123'), 'the bare uuid is NOT used when a path exists');
+    assert.equal(argv[i + 1], sessionFile, 'resumes by absolute file path');
+    assert.ok(!argv.includes('uuid-123'), 'the bare uuid is never used to resume');
 });
-test('buildPiArgv falls back to --session <uuid> when no path is stored', () => {
+test('buildPiArgv passes no --session when no path is stored (falls through to fresh)', () => {
     const m = node('n', { pi_session_id: 'uuid-123', pi_session_file: null });
     const { argv } = buildPiArgv(m, resumeArgs(m, true));
-    const i = argv.indexOf('--session');
-    assert.ok(i >= 0, 'argv carries --session');
-    assert.equal(argv[i + 1], 'uuid-123', 'resumes by bare uuid (older node)');
+    assert.ok(!argv.includes('--session'), 'no bare-uuid resume — a bare id is fatally rejected by broker preflight');
 });
 test('buildPiArgv passes no --session on a fresh (no-resume) launch', () => {
     const m = node('n', { pi_session_id: 'uuid-123', pi_session_file: '/abs/sess.jsonl' });
@@ -140,11 +153,14 @@ test('buildPiArgv passes no --session on a fresh (no-resume) launch', () => {
 // (kind/mode/lifecycle come back as the node's *current* self).
 // ---------------------------------------------------------------------------
 test('a resumed revive replays the persisted LaunchSpec (model, tools, extensions, prompt, env)', () => {
+    mkdirSync(home, { recursive: true });
+    const sessionFile = join(home, 'launchspec-replay.jsonl');
+    writeFileSync(sessionFile, '{}\n', 'utf8');
     const m = node('n', {
         kind: 'developer',
         mode: 'orchestrator',
         pi_session_id: 'uuid-9',
-        pi_session_file: '/abs/sess.jsonl',
+        pi_session_file: sessionFile,
         launch: {
             model: 'anthropic/sonnet',
             tools: ['bash', 'read'],
@@ -167,7 +183,7 @@ test('a resumed revive replays the persisted LaunchSpec (model, tools, extension
     assert.equal(argv[ti + 1], 'bash,read');
     assert.ok(argv.includes('--append-system-prompt'), 'system prompt replayed');
     const si = argv.indexOf('--session');
-    assert.equal(argv[si + 1], '/abs/sess.jsonl', 'still resumes by file path');
+    assert.equal(argv[si + 1], sessionFile, 'still resumes by file path');
     // Env contract: launch-spec env merged over the node identity env.
     assert.equal(env['FOO'], 'bar');
     assert.equal(env['CRTR_NODE_ID'], 'n');
@@ -230,6 +246,33 @@ test('reviveNode PROCEEDS when the broker engine is DOWN (dead pid) — cycle co
         await h.dispose();
     }
 });
+test('reviveNode fresh-fallback clears the stale session identity (Major-3: no phantom stranded-relaunch)', async () => {
+    const h = await createHarness({ headless: true, sessionPrefix: 'crtr-revive-freshfb' });
+    try {
+        // resume=true was ASKED, but the recorded .jsonl is gone from disk, so
+        // resumeArgs falls through to a FRESH launch. The stale pi_session_id /
+        // pi_session_file must be cleared BEFORE launch: if this fresh broker then
+        // dies before session_start (no new pid, no new session), the daemon keys on
+        // pi_session_id — a leftover id would be misread as a stranded relaunch and
+        // retried forever instead of surfaced as a boot failure.
+        const missingFile = join(home, 'sessions', 'never-written.jsonl');
+        const M = h.fabricateBrokerNode({
+            status: 'active',
+            intent: null,
+            pi_pid: deadPid(),
+            pi_session_id: 'uuid-stale',
+            pi_session_file: missingFile,
+        });
+        const res = reviveNode(M, { resume: true });
+        assert.equal(res.resumed, false, 'a missing .jsonl forces a fresh (non-resuming) launch');
+        const after = h.node(M);
+        assert.equal(after.pi_session_id, null, 'stale pi_session_id cleared before the fresh launch');
+        assert.equal(after.pi_session_file, null, 'stale pi_session_file cleared before the fresh launch');
+    }
+    finally {
+        await h.dispose();
+    }
+});
 test('reviveNode crashes and clears pid when launch/preflight throws', async () => {
     const h = await createHarness({ headless: true, sessionPrefix: 'crtr-revive-fail' });
     const originalLaunch = headlessBrokerHost.launch;

package/dist/core/__tests__/trigger-migration.test.js

@@ -0,0 +1,48 @@
+// Regression for final-integrated-verdict finding #3: the v7 (`wakeups`) →
+// v9 (`triggers`) migration must preserve a deadline wakeup's `fire_at`
+// exactly, not just its `trigger_type`/`node_id`. Drives the real migration
+// steps (`MIGRATIONS[6]` = appendWakeupsTable/v7, `MIGRATIONS[8]` =
+// migrateWakeupsToTriggers/v9) directly against a bare `DatabaseSync`, seeding
+// a v7-shaped `wakeups` row by hand — see `src/core/canvas/db.ts`.
+import { test, before, after } 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 { DatabaseSync } from 'node:sqlite';
+import { MIGRATIONS } from '../canvas/db.js';
+let home;
+before(() => {
+    home = mkdtempSync(join(tmpdir(), 'crtr-trigger-migration-'));
+});
+after(() => {
+    rmSync(home, { recursive: true, force: true });
+});
+test('v7->v9 migration preserves a deadline wakeup\'s fire_at exactly', () => {
+    const db = new DatabaseSync(join(home, 'migration.db'));
+    try {
+        db.exec('PRAGMA foreign_keys = ON;');
+        // v1 — nodes/edges baseline (MIGRATIONS[0]); triggers.node_id's FK needs a
+        // real nodes row to reference.
+        MIGRATIONS[0](db);
+        const created = new Date().toISOString();
+        db.prepare(`INSERT INTO nodes (node_id, name, kind, cwd, created) VALUES (?, ?, ?, ?, ?)`).run('target-node', 'target-node', 'general', '/tmp/work', created);
+        // v7 — the wakeups table (MIGRATIONS[6]).
+        MIGRATIONS[6](db);
+        const fireAt = '2026-01-01T12:34:56.000Z';
+        db.prepare(`INSERT INTO wakeups (wakeup_id, node_id, owner_id, fire_at, kind, recur, payload, created)
+       VALUES (?, ?, ?, ?, 'deadline', NULL, ?, ?)`).run('wk-1', 'target-node', 'target-node', fireAt, JSON.stringify({ body: 'time is up', timeout: true, label: 'deadline' }), created);
+        // v9 — generalize wakeups into triggers (MIGRATIONS[8]).
+        MIGRATIONS[8](db);
+        const row = db.prepare('SELECT * FROM triggers WHERE trigger_id = ?').get('wk-1');
+        assert.ok(row, 'migrated trigger row should exist under the preserved wakeup_id');
+        assert.equal(row['trigger_type'], 'until');
+        assert.equal(row['action_mode'], 'deadline_message');
+        // The literal required assertion (verdict finding #3): fire_at must survive
+        // the migration byte-for-byte, not just the trigger_type/action_mode shape.
+        assert.equal(row['fire_at'], fireAt);
+    }
+    finally {
+        db.close();
+    }
+});

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

@@ -1,12 +1,13 @@
 // Run with: node --import tsx/esm --test src/core/__tests__/wake-bearings.test.ts
 //
-// Wake-origin self-knowledge (the <crtr-wake> provenance block). Regression
+// Trigger-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
+// not tell it came from a timer — a fired trigger 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
+//   • buildWakeBearings renders the right decision-first block per trigger
+//     kind / cadence, and never crashes when the armer was reaped (no resolved
+//     name);
+//   • the fresh-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.
@@ -47,9 +48,9 @@ after(() => {
     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', () => {
+test('node_birth one-shot: names a deferred birth + the armer, and says it does not recur', () => {
     const o = {
-        kind: 'spawn',
+        kind: 'node_birth',
         ownerId: 'arm-1',
         ownerName: 'release-orch',
         armedAt: ARMED,
@@ -64,9 +65,9 @@ test('spawn one-shot: names a deferred birth + the armer, and says it does not r
     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', () => {
+test('node_birth cron: surfaces the cadence + frames it as one run of a standing job', () => {
     const o = {
-        kind: 'spawn',
+        kind: 'node_birth',
         ownerId: 'arm-1',
         ownerName: 'nightly',
         armedAt: ARMED,
@@ -79,9 +80,9 @@ test('spawn cron: surfaces the cadence + frames it as one run of a standing job'
     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', () => {
+test('node_birth interval cron: renders the every-N cadence', () => {
     const o = {
-        kind: 'spawn',
+        kind: 'node_birth',
         ownerId: 'arm-1',
         ownerName: 'poller',
         armedAt: ARMED,
@@ -89,9 +90,9 @@ test('spawn interval cron: renders the every-N cadence', () => {
     };
     assert.match(buildWakeBearings(o), /firing every 6h/);
 });
-test('spawn with a reaped armer: renders the bare id, no name, never crashes', () => {
+test('node_birth with a reaped armer: renders the bare id, no name, never crashes', () => {
     const o = {
-        kind: 'spawn',
+        kind: 'node_birth',
         ownerId: 'gone-9',
         ownerName: undefined, // armer no longer exists → no resolved name
         armedAt: ARMED,
@@ -101,20 +102,21 @@ test('spawn with a reaped armer: renders the bare id, no name, never crashes', (
     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 };
+test('fresh_revive one-shot: frames a timed re-check, NOT a new request', () => {
+    const o = { kind: 'fresh_revive', 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.
+    // No armer attribution on a bare revive (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', () => {
+test('fresh_revive recurring: frames one tick of a standing re-check + the cadence', () => {
     const o = {
-        kind: 'bare',
+        kind: 'fresh_revive',
         ownerId: 'n1',
         ownerName: 'n1',
         armedAt: ARMED,
@@ -124,12 +126,12 @@ test('bare recurring: frames one tick of a standing re-check + the cadence', ()
     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', () => {
+// --- the fresh-revive kickoff seam -------------------------------------
+test('a fresh_revive trigger makes the fresh-revive kickoff distinguishable from a refresh', () => {
     const id = 'b1';
     const meta = createNode(node(id));
     const wakeReason = {
-        kind: 'bare',
+        kind: 'fresh_revive',
         ownerId: id,
         ownerName: id,
         armedAt: ARMED,

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

@@ -1,37 +1,37 @@
 // Run with: node --import tsx/esm --test src/core/__tests__/wake-origin.test.ts
 //
-// HEADLESS RETARGET (foundation-spec §C.16 + §E). Wake-origin self-knowledge at
-// the DAEMON FIRING seams (the other half of the regression — wake-bearings.test.ts
-// covers the pure block in isolation). The observed gap: a scheduled wake arrived
-// indistinguishable from an ordinary message/spawn (Invariant D). Both seams are
-// now driven model-only — ZERO tmux, ZERO boot:
+// HEADLESS RETARGET (foundation-spec §C.16 + §E). Trigger-origin self-knowledge
+// at the DAEMON FIRING seams (the other half of the regression — wake-bearings.
+// test.ts covers the pure block in isolation). The observed gap: a node woken
+// or born by a scheduled trigger arrived indistinguishable from an ordinary
+// message/spawn (Invariant D). Both seams are driven model-only — ZERO tmux,
+// ZERO boot:
 //
-// (1) BUG LOCKED — a node woken or BORN by a TIMER must, by construction, learn a
-//     CLOCK (not an event) caused it: a noted wake rides a ⏰-marked inbox label
-//     (distinct from a plain `node msg`), and a spawn wake prepends the
-//     <crtr-wake> birth block (armer + cadence) to the newborn's kickoff while an
-//     ordinary `node new` carries none.
+// (1) BUG LOCKED — a node woken or BORN by a TIMER must, by construction, learn
+//     a CLOCK (not an event) caused it: an inbox_message trigger rides a
+//     ⏰-marked inbox label (distinct from a plain `node msg`), and a node_birth
+//     trigger prepends the <crtr-wake> birth block (armer + cadence) to the
+//     newborn's kickoff while an ordinary `node new` carries none.
 //
-// (2) WHY MODEL-LEVEL, NOT TMUX CHROME — the noted seam is pure data layer
-//     (superviseTick's third pass → appendInbox; readInboxSince reads it back).
-//     The spawn-birth seam (spawn.ts) assembles the kickoff as
+// (2) WHY MODEL-LEVEL, NOT TMUX CHROME — the inbox_message seam is pure data
+//     layer (superviseTick's third pass → appendInbox; readInboxSince reads it
+//     back). The spawn-birth seam (spawn.ts) assembles the kickoff as
 //     `${buildWakeBearings(wakeOrigin)}\n\n${idBlock}${prompt}` ONLY when a
 //     wakeOrigin is present; `node new` passes none → no block. The load-bearing
-//     fact is the PURE rendering of buildWakeBearings for a spawn origin (and its
-//     absence without one) — reading it off a real booted pi's prompt was pure
-//     tmux/SDK overhead for a string a pure call already returns.
+//     fact is the PURE rendering of buildWakeBearings for a node_birth origin
+//     (and its absence without one) — reading it off a real booted pi's prompt
+//     was pure tmux/SDK overhead for a string a pure call already returns.
 //
 // (3) HOW THE DRIVE STILL FAILS IF THE BUG REGRESSES — drop the ⏰ label marker
-//     and the noted assert goes RED; drop the spawn-kind <crtr-wake> rendering
-//     and the spawn assert goes RED (the block / armer / cadence vanish).
+//     and the inbox_message assert goes RED; drop the node_birth <crtr-wake>
+//     rendering and the spawn assert goes RED (the block / armer / cadence
+//     vanish).
 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 { armWake } from '../canvas/wakeups.js';
-import { closeDb } from '../canvas/db.js';
+import { createNode, armTrigger, closeDb } from '../canvas/index.js';
 import { readInboxSince } from '../feed/inbox.js';
 import { superviseTick } from '../../daemon/crtrd.js';
 import { buildWakeBearings } from '../runtime/bearings.js';
@@ -62,16 +62,18 @@ after(() => {
     rmSync(home, { recursive: true, force: true });
     delete process.env['CRTR_HOME'];
 });
-// --- noted seam (the daemon's third pass → inbox) ---------------------------
-test('a noted scheduled wake delivers a ⏰-marked inbox label, distinct from a plain message', async () => {
+// --- inbox_message seam (the daemon's third pass → inbox) -------------------
+test('a due inbox_message trigger 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',
+    armTrigger({
+        trigger_id: 'trg-noted-1',
         node_id: target.node_id,
         owner_id: armer.node_id,
+        action: 'msg',
+        action_mode: 'inbox_message',
+        trigger_type: 'at',
         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' },
     });
@@ -79,22 +81,23 @@ test('a noted scheduled wake delivers a ⏰-marked inbox label, distinct from a
     await superviseTick(Date.now());
     closeDb();
     const entries = readInboxSince(target.node_id);
-    assert.equal(entries.length, 1, 'the noted wake delivered exactly one inbox entry');
+    assert.equal(entries.length, 1, 'the due trigger 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-birth seam (the headline; spawn.ts kickoff assembly) -------------
-test('a spawn scheduled wake renders a <crtr-wake> birth block (armer + cadence); a plain node new renders none', async () => {
+// --- node_birth seam (the headline; spawn.ts kickoff assembly) --------------
+test('a node_birth trigger renders a <crtr-wake> birth block (armer + cadence); a plain node new renders none', async () => {
     const armer = createNode(node('armer'));
     // The spawn-birth seam (spawn.ts): the newborn's pi kickoff is
     //   `${buildWakeBearings(wakeOrigin)}\n\n${idBlock}${prompt}`
     // when a wakeOrigin is present, and just `${idBlock}${prompt}` (no block)
-    // when it is not. The daemon's third pass builds the WakeOrigin from the fired
-    // recurring `spawn` row via wakeOriginFrom; here we assert the block it yields.
+    // when it is not. The daemon's third pass builds the WakeOrigin from the
+    // fired recurring node_birth trigger row via wakeOriginFrom; here we assert
+    // the block it yields.
     const origin = {
-        kind: 'spawn',
+        kind: 'node_birth',
         ownerId: armer.node_id,
         ownerName: 'armer',
         armedAt: new Date(Date.now() - 1000).toISOString(),
@@ -110,5 +113,5 @@ test('a spawn scheduled wake renders a <crtr-wake> birth block (armer + cadence)
     // prepends nothing — no <crtr-wake> in the newborn's kickoff.
     const wakeBlock = (o) => (o !== undefined ? `${buildWakeBearings(o)}\n\n` : '');
     assert.equal(wakeBlock(undefined), '', 'node new (no wakeOrigin) prepends no wake block');
-    assert.match(wakeBlock(origin), /<crtr-wake>/, 'a spawn wake prepends the block');
+    assert.match(wakeBlock(origin), /<crtr-wake>/, 'a node_birth trigger prepends the block');
 });