@north-light/crouter 0.3.318 → 0.3.320

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

@@ -1,946 +0,0 @@
-import { test, before, beforeEach, after } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync, existsSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { DatabaseSync } from 'node:sqlite';
-import { openDb, closeDb, migrate, MIGRATIONS } from '../canvas/db.js';
-import { canvasDbPath, ensureHome } from '../canvas/paths.js';
-import { customExtensionPaths } from '../canvas/extensions.js';
-import { assertMandatoryCanvasExtensions, CANVAS_EXTENSIONS, mergeCanvasExtensions } from '../runtime/canvas-extensions.js';
-import { updateNode } from '../canvas/canvas.js';
-import { parsePage, parsePageDelivery } from '../human/page.js';
-import { spawn, spawnSync } from 'node:child_process';
-const HERE = dirname(fileURLToPath(import.meta.url));
-const RUNTIME_COLUMNS = ['intent', 'window', 'tmux_session'];
-const RACE_FIXTURE = join(HERE, 'fixtures', 'metadata-migration-race.ts');
-const PRE_TOOL_GUIDE_CANVAS_EXTENSION_NAMES = [
-    'canvas-inbox-watcher', 'canvas-stophook', 'canvas-recap',
-    'canvas-goal-capture', 'canvas-passive-context', 'canvas-context-intro',
-    'canvas-doc-substrate', 'canvas-structured-output', 'canvas-bash-valve',
-];
-const REVIEW_BOUNDARY_CANVAS_EXTENSION_NAMES = [
-    'canvas-inbox-watcher', 'canvas-stophook', 'canvas-recap',
-    'canvas-goal-capture', 'canvas-passive-context', 'canvas-review-boundary',
-    'canvas-context-intro', 'canvas-tool-guide', 'canvas-doc-substrate',
-    'canvas-structured-output', 'canvas-bash-valve',
-];
-let home;
-async function waitForPath(path) {
-    for (;;) {
-        if (existsSync(path))
-            return;
-        await new Promise((resolve) => setTimeout(resolve, 10));
-    }
-}
-async function spawnMigrationRace(path, marker) {
-    const child = spawn(process.execPath, ['--import', 'tsx/esm', RACE_FIXTURE, path, marker], { env: { ...process.env, CRTR_HOME: home } });
-    return {
-        done: new Promise((resolve, reject) => {
-            child.on('error', reject);
-            child.on('exit', (code, signal) => {
-                if (code === 0) {
-                    resolve();
-                    return;
-                }
-                const detail = signal === null ? `exit ${code}` : `signal ${signal}`;
-                reject(new Error(`migration race fixture failed (${detail})`));
-            });
-        }),
-    };
-}
-function userVersion(db) {
-    return db.prepare('PRAGMA user_version').get()
-        .user_version;
-}
-function openMigratedDb() {
-    const db = openDb();
-    migrate(db);
-    return db;
-}
-function nodeColumns(db) {
-    return db.prepare('PRAGMA table_info(nodes)').all().map((r) => r.name);
-}
-function migrateToVersion(db, targetVersion) {
-    const current = userVersion(db);
-    for (let version = current; version < targetVersion; version++) {
-        MIGRATIONS[version](db);
-        db.exec(`PRAGMA user_version = ${version + 1}`);
-    }
-}
-before(() => {
-    home = mkdtempSync(join(tmpdir(), 'crtr-migration-'));
-    process.env['CRTR_HOME'] = home;
-});
-beforeEach(() => {
-    // Fresh db + dirs per test for isolation.
-    closeDb();
-    rmSync(home, { recursive: true, force: true });
-});
-after(() => {
-    closeDb();
-    rmSync(home, { recursive: true, force: true });
-    delete process.env['CRTR_HOME'];
-});
-test('opening a fresh home leaves schema initialization explicit', () => {
-    const db = openDb();
-    assert.equal(userVersion(db), 0);
-    assert.equal(db.prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'nodes'").get(), undefined);
-    migrate(db);
-    assert.equal(userVersion(db), MIGRATIONS.length);
-});
-test('a persisted review-boundary canvas prefix is not treated as custom extensions', () => {
-    const persisted = REVIEW_BOUNDARY_CANVAS_EXTENSION_NAMES.map((name) => `/old-generation/pi-extensions/${name}.js`);
-    assert.deepEqual(customExtensionPaths(persisted), []);
-});
-test('stale generation hooks are retired structurally without dropping user extensions', () => {
-    const stale = [
-        'canvas-inbox-watcher', 'canvas-stophook', 'canvas-recap', 'canvas-goal-capture',
-        'canvas-passive-context', 'canvas-context-intro', 'canvas-tool-guide',
-        'canvas-doc-substrate', 'canvas-structured-output', 'canvas-bash-valve',
-    ].map((name) => `/Users/silasrhyneer/.crouter/runtime/generations/d3ff9346e6df88f88c44af898a028a8fd6f03466eb216d7cd3b70a734f71a11b/dist/pi-extensions/${name}.js`);
-    assert.deepEqual(customExtensionPaths(stale), []);
-    assert.deepEqual(customExtensionPaths([...stale, '/Users/silasrhyneer/extensions/canvas-foo.js']), ['/Users/silasrhyneer/extensions/canvas-foo.js']);
-});
-test('a retained custom extension sharing a canvas-hook basename still launches', () => {
-    const custom = '/Users/silasrhyneer/extensions/canvas-recap.js';
-    assert.deepEqual(customExtensionPaths([custom]), [custom]);
-    assert.doesNotThrow(() => assertMandatoryCanvasExtensions(mergeCanvasExtensions([custom])));
-    assert.throws(() => assertMandatoryCanvasExtensions([...CANVAS_EXTENSIONS, '/stale-root/pi-extensions/canvas-recap.js']), /duplicate mandatory canvas extension basename canvas-recap/);
-});
-test('a v14 canvas normalizes historical canvas paths while retaining custom launch extras', () => {
-    const metaPath = join(home, 'nodes', 'saved', 'meta.json');
-    mkdirSync(join(home, 'nodes', 'saved'), { recursive: true });
-    writeFileSync(metaPath, JSON.stringify({
-        node_id: 'saved', name: 'saved', created: '2026-01-01T00:00:00.000Z', cwd: '/tmp',
-        kind: 'developer', mode: 'base', lifecycle: 'terminal', status: 'idle',
-        launch: { extensions: [
-                ...PRE_TOOL_GUIDE_CANVAS_EXTENSION_NAMES.map((name) => `/old-generation/pi-extensions/${name}.js`),
-                '/plugins/canvas-inbox-watcher.js',
-            ] },
-    }));
-    ensureHome();
-    const raw = new DatabaseSync(canvasDbPath());
-    migrateToVersion(raw, 14);
-    migrate(raw);
-    assert.equal(userVersion(raw), MIGRATIONS.length, 'the retired v14 version advances safely without its runtime');
-    raw.close();
-    const saved = JSON.parse(readFileSync(metaPath, 'utf8'));
-    assert.deepEqual(saved.launch.extensions, ['/plugins/canvas-inbox-watcher.js']);
-});
-test('an explicit v14 migration preserves legacy metadata while node updates use SQL state', async () => {
-    const metaPath = join(home, 'nodes', 'saved', 'meta.json');
-    mkdirSync(join(home, 'nodes', 'saved'), { recursive: true });
-    writeFileSync(metaPath, JSON.stringify({
-        node_id: 'saved',
-        name: 'saved',
-        created: '2026-01-01T00:00:00.000Z',
-        cwd: '/tmp',
-        kind: 'developer',
-        mode: 'base',
-        lifecycle: 'terminal',
-        status: 'idle',
-        launch: {
-            extensions: [...PRE_TOOL_GUIDE_CANVAS_EXTENSION_NAMES.map((name) => `/old-generation/pi-extensions/${name}.js`), '/plugins/canvas-inbox-watcher.js'],
-        },
-    }));
-    ensureHome();
-    const raw = new DatabaseSync(canvasDbPath());
-    migrateToVersion(raw, 14);
-    const marker = `${metaPath}.ready`;
-    rmSync(marker, { force: true });
-    const { done } = await spawnMigrationRace(metaPath, marker);
-    await waitForPath(marker);
-    migrate(raw);
-    await done;
-    raw.close();
-    const update = updateNode('saved', { name: 'saved-raced' });
-    assert.equal(update.name, 'saved-raced');
-    const settled = JSON.parse(readFileSync(metaPath, 'utf8'));
-    assert.equal(customExtensionPaths(settled.launch.extensions).length, settled.launch.extensions.length);
-    assert.deepEqual(settled.launch.extensions, ['/plugins/canvas-inbox-watcher.js'], 'migration writeback cannot restore retired hook prefixes');
-    assert.equal(settled.name, 'saved', 'the legacy conversion input remains unchanged after a SQL node update');
-});
-test('a v0 db retains its runtime fields while process state moves to executions', () => {
-    // Build a v0 db by hand: the baseline tables only, user_version 0, no runtime
-    // columns — exactly the shape of the live fleet before this phase.
-    ensureHome();
-    const raw = new DatabaseSync(canvasDbPath());
-    raw.exec(`
-    CREATE TABLE nodes (
-      node_id    TEXT PRIMARY KEY,
-      name       TEXT NOT NULL,
-      kind       TEXT NOT NULL,
-      mode       TEXT NOT NULL DEFAULT 'base',
-      lifecycle  TEXT NOT NULL DEFAULT 'terminal',
-      status     TEXT NOT NULL DEFAULT 'active',
-      cwd        TEXT NOT NULL,
-      parent     TEXT,
-      created    TEXT NOT NULL
-    );
-    CREATE TABLE edges (
-      type     TEXT NOT NULL,
-      from_id  TEXT NOT NULL,
-      to_id    TEXT NOT NULL,
-      active   INTEGER NOT NULL DEFAULT 1,
-      created  TEXT NOT NULL,
-      PRIMARY KEY (type, from_id, to_id)
-    );
-  `);
-    raw.exec('PRAGMA user_version = 0;');
-    raw
-        .prepare('INSERT INTO nodes (node_id, name, kind, status, cwd, created) VALUES (?,?,?,?,?,?)')
-        .run('n1', 'N1', 'general', 'done', '/tmp/work', '2020-01-01T00:00:00Z');
-    raw
-        .prepare('INSERT INTO edges (type, from_id, to_id, created) VALUES (?,?,?,?)')
-        .run('subscribes_to', 'n1', 'n1', '2020-01-01T00:00:00Z');
-    // Precondition: genuinely a v0 db with no runtime columns.
-    assert.equal(userVersion(raw), 0);
-    assert.ok(!nodeColumns(raw).includes('intent'));
-    raw.close();
-    const db = openMigratedDb();
-    assert.equal(userVersion(db), MIGRATIONS.length);
-    // Node runtime columns now exist; process state is projected from executions.
-    const cols = nodeColumns(db);
-    for (const c of RUNTIME_COLUMNS) {
-        assert.ok(cols.includes(c), `expected nodes.${c} after migration`);
-    }
-    assert.ok(!cols.includes('pi_pid'), 'nodes no longer stores process state');
-    // Pre-existing data is intact — no loss, no mutation of existing columns.
-    const row = db
-        .prepare('SELECT node_id, status, cwd FROM nodes WHERE node_id = ?')
-        .get('n1');
-    assert.equal(row.node_id, 'n1');
-    assert.equal(row.status, 'done');
-    assert.equal(row.cwd, '/tmp/work');
-    const edgeCount = db.prepare('SELECT COUNT(*) AS n FROM edges').get().n;
-    assert.equal(edgeCount, 1);
-    // The new columns are seeded NULL for the migrated row — nothing observed.
-    const rt = db
-        .prepare('SELECT intent, "window", tmux_session FROM nodes WHERE node_id = ?')
-        .get('n1');
-    assert.equal(rt['intent'], null);
-    assert.equal(rt['window'], null);
-    assert.equal(rt['tmux_session'], null);
-});
-test('session-file ownership migration reconciles authoritative metas before clearing duplicate claimants', () => {
-    ensureHome();
-    const raw = new DatabaseSync(canvasDbPath());
-    migrateToVersion(raw, 35);
-    const sessionFile = '/tmp/preexisting-duplicate.jsonl';
-    const aliasedSessionFile = '/tmp/./preexisting-duplicate.jsonl';
-    const recoveredSessionFile = '/tmp/recovered-session.jsonl';
-    const metas = [
-        ['first-owner', '2026-01-01T00:00:00.000Z', sessionFile],
-        ['later-claimant', '2026-01-02T00:00:00.000Z', aliasedSessionFile],
-        // The durable meta write survived, but the derived row below is stale.
-        ['recovered-claimant', '2026-01-03T00:00:00.000Z', recoveredSessionFile],
-    ];
-    for (const [id, created, pi_session_file] of metas) {
-        const nodeDir = join(home, 'nodes', id);
-        mkdirSync(nodeDir, { recursive: true });
-        writeFileSync(join(nodeDir, 'meta.json'), JSON.stringify({
-            node_id: id, name: id, created, cwd: '/tmp', kind: 'developer', mode: 'base', lifecycle: 'terminal', pi_session_id: `${id}-session`, pi_session_file,
-        }));
-    }
-    const insert = raw.prepare('INSERT INTO nodes (node_id, name, kind, mode, lifecycle, status, cwd, created, pi_session_file) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)');
-    insert.run('first-owner', 'first-owner', 'developer', 'base', 'terminal', 'active', '/tmp', '2026-01-01T00:00:00.000Z', sessionFile);
-    insert.run('later-claimant', 'later-claimant', 'developer', 'base', 'terminal', 'active', '/tmp', '2026-01-02T00:00:00.000Z', aliasedSessionFile);
-    insert.run('recovered-claimant', 'recovered-claimant', 'developer', 'base', 'terminal', 'active', '/tmp', '2026-01-03T00:00:00.000Z', sessionFile);
-    assert.doesNotThrow(() => migrate(raw), 'a real canvas with pre-existing duplicates must migrate');
-    const rows = raw.prepare('SELECT node_id, pi_session_file FROM node_rows ORDER BY created, node_id').all();
-    assert.deepEqual(rows.map((row) => [row.node_id, row.pi_session_file]), [
-        ['first-owner', sessionFile],
-        ['later-claimant', null],
-        ['recovered-claimant', recoveredSessionFile],
-    ], 'the oldest duplicate is retained while a stale row is reconciled from its authoritative meta');
-    const loser = JSON.parse(readFileSync(join(home, 'nodes', 'later-claimant', 'meta.json'), 'utf8'));
-    assert.equal(loser.pi_session_id, null, 'the duplicate loser meta cannot reindex its stale session id');
-    assert.equal(loser.pi_session_file, null, 'the duplicate loser meta cannot restore the duplicate projection');
-    const recovered = JSON.parse(readFileSync(join(home, 'nodes', 'recovered-claimant', 'meta.json'), 'utf8'));
-    assert.equal(recovered.pi_session_id, 'recovered-claimant-session', 'a stale row cannot clear the authoritative session id');
-    assert.equal(recovered.pi_session_file, recoveredSessionFile, 'a stale row cannot clear the authoritative session file');
-    assert.throws(() => raw.prepare("INSERT INTO sessions (binding_id, session_id, node_id, transcript_path, source_session_id, fork_entry_id, created_at, bound_at, unbound_at) VALUES ('later-duplicate', 'later-duplicate-session', 'later-claimant', ?, NULL, NULL, '2026-01-02T00:00:00.000Z', '2026-01-02T00:00:00.000Z', NULL)").run(sessionFile), /UNIQUE/, 'the SQL session table enforces the repaired invariant');
-    raw.close();
-});
-test('forward session-file repair reprojects a surviving v36 meta coordinate before restoring its UNIQUE index', () => {
-    ensureHome();
-    const raw = new DatabaseSync(canvasDbPath());
-    migrateToVersion(raw, 35);
-    const recoveredSessionFile = '/tmp/surviving-meta-coordinate.jsonl';
-    const staleSessionFile = '/tmp/stale-v36-coordinate.jsonl';
-    for (const [id, pi_session_id, pi_session_file] of [
-        ['surviving-owner', 'surviving-session', recoveredSessionFile],
-        ['stale-row', null, null],
-    ]) {
-        const nodeDir = join(home, 'nodes', id);
-        mkdirSync(nodeDir, { recursive: true });
-        writeFileSync(join(nodeDir, 'meta.json'), JSON.stringify({
-            node_id: id, name: id, created: id === 'surviving-owner' ? '2026-01-01T00:00:00.000Z' : '2026-01-02T00:00:00.000Z',
-            cwd: '/tmp', kind: 'developer', mode: 'base', lifecycle: 'terminal', pi_session_id, pi_session_file,
-        }));
-    }
-    const insert = raw.prepare('INSERT INTO nodes (node_id, name, kind, mode, lifecycle, status, cwd, created, pi_session_file) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)');
-    // This is the v0.3.250 shape after v36: the owner’s surviving meta coordinate
-    // disagrees with its indexed row, while the row carrying it has no meta claim.
-    insert.run('surviving-owner', 'surviving-owner', 'developer', 'base', 'terminal', 'active', '/tmp', '2026-01-01T00:00:00.000Z', staleSessionFile);
-    insert.run('stale-row', 'stale-row', 'developer', 'base', 'terminal', 'active', '/tmp', '2026-01-02T00:00:00.000Z', recoveredSessionFile);
-    raw.exec('DROP INDEX IF EXISTS idx_nodes_pi_session_file; CREATE UNIQUE INDEX idx_nodes_pi_session_file ON nodes(pi_session_file); PRAGMA user_version = 36;');
-    assert.doesNotThrow(() => migrate(raw));
-    assert.equal(userVersion(raw), MIGRATIONS.length);
-    const rows = raw.prepare('SELECT node_id, pi_session_file FROM node_rows ORDER BY created, node_id').all();
-    assert.deepEqual(rows.map((row) => [row.node_id, row.pi_session_file]), [
-        ['surviving-owner', recoveredSessionFile],
-        ['stale-row', null],
-    ]);
-    const survivor = JSON.parse(readFileSync(join(home, 'nodes', 'surviving-owner', 'meta.json'), 'utf8'));
-    assert.equal(survivor.pi_session_id, 'surviving-session');
-    assert.equal(survivor.pi_session_file, recoveredSessionFile);
-    assert.throws(() => raw.prepare("INSERT INTO sessions (binding_id, session_id, node_id, transcript_path, source_session_id, fork_entry_id, created_at, bound_at, unbound_at) VALUES ('stale-duplicate', NULL, 'stale-row', ?, NULL, NULL, '2026-01-02T00:00:00.000Z', '2026-01-02T00:00:00.000Z', NULL)").run(recoveredSessionFile), /UNIQUE/);
-    raw.close();
-});
-test('node lifecycle substrate migration adds six columns and backfills terminal reasons', () => {
-    ensureHome();
-    const raw = new DatabaseSync(canvasDbPath());
-    migrateToVersion(raw, 34);
-    const lifecycleColumns = [
-        'frozen_at',
-        'respawn_failures',
-        'respawn_not_before',
-        'launched_at',
-        'last_settled_at',
-        'terminal_reason',
-    ];
-    for (const column of lifecycleColumns)
-        assert.ok(!nodeColumns(raw).includes(column));
-    const insert = raw.prepare('INSERT INTO nodes (node_id, name, kind, status, intent, final_report, cwd, created) VALUES (?, ?, ?, ?, ?, ?, ?, ?)');
-    const created = '2020-01-01T00:00:00Z';
-    insert.run('finalized', 'finalized', 'general', 'done', 'done', 'final.md', '/tmp', created);
-    insert.run('parked', 'parked', 'general', 'done', 'parked', null, '/tmp', created);
-    insert.run('finished', 'finished', 'general', 'done', 'done', null, '/tmp', created);
-    insert.run('stranded', 'stranded', 'general', 'canceled', null, null, '/tmp', created);
-    insert.run('crashed', 'crashed', 'general', 'dead', null, null, '/tmp', created);
-    insert.run('active', 'active', 'general', 'active', null, null, '/tmp', created);
-    raw.close();
-    const db = openMigratedDb();
-    assert.equal(userVersion(db), MIGRATIONS.length);
-    for (const column of lifecycleColumns)
-        assert.ok(nodeColumns(db).includes(column));
-    const reasons = Object.fromEntries(db.prepare('SELECT node_id, terminal_reason FROM nodes ORDER BY node_id').all().map((row) => [row.node_id, row.terminal_reason]));
-    assert.deepEqual(reasons, {
-        active: null,
-        crashed: 'crashed',
-        finalized: 'finalized',
-        finished: 'finished',
-        parked: 'parked',
-        stranded: 'stranded',
-    });
-});
-// v4: edges FK ON DELETE CASCADE (the one irreversible rebuild)
-/** Build a hand-rolled db at exactly v3 (baseline tables + the four runtime
- *  columns, edges with NO foreign key, `user_version = 3`) — the shape the live
- *  fleet reaches just before v4. Caller seeds it, then explicitly runs v4 and
- *  later steps. */
-function buildV3Db() {
-    ensureHome();
-    const raw = new DatabaseSync(canvasDbPath());
-    raw.exec(`
-    CREATE TABLE nodes (
-      node_id    TEXT PRIMARY KEY,
-      name       TEXT NOT NULL,
-      kind       TEXT NOT NULL,
-      mode       TEXT NOT NULL DEFAULT 'base',
-      lifecycle  TEXT NOT NULL DEFAULT 'terminal',
-      status     TEXT NOT NULL DEFAULT 'active',
-      cwd        TEXT NOT NULL,
-      parent     TEXT,
-      created    TEXT NOT NULL,
-      intent       TEXT,
-      pi_pid       INTEGER,
-      window       TEXT,
-      tmux_session TEXT
-    );
-    CREATE TABLE edges (
-      type     TEXT NOT NULL,
-      from_id  TEXT NOT NULL,
-      to_id    TEXT NOT NULL,
-      active   INTEGER NOT NULL DEFAULT 1,
-      created  TEXT NOT NULL,
-      PRIMARY KEY (type, from_id, to_id)
-    );
-    PRAGMA user_version = 3;
-  `);
-    return raw;
-}
-function insertNode(db, id) {
-    db.prepare('INSERT INTO nodes (node_id, name, kind, status, cwd, created) VALUES (?,?,?,?,?,?)').run(id, id, 'general', 'active', '/tmp/work', '2020-01-01T00:00:00Z');
-}
-function insertEdge(db, type, from, to) {
-    db.prepare('INSERT INTO edges (type, from_id, to_id, created) VALUES (?,?,?,?)').run(type, from, to, '2020-01-01T00:00:00Z');
-}
-function edgeCount(db) {
-    return db.prepare('SELECT COUNT(*) AS n FROM edges').get().n;
-}
-test('v4 migrates a db with a pre-existing orphan edge without throwing', () => {
-    const raw = buildV3Db();
-    insertNode(raw, 'n1');
-    insertNode(raw, 'n2');
-    insertEdge(raw, 'subscribes_to', 'n1', 'n2'); // non-orphan: both endpoints exist
-    insertEdge(raw, 'spawned_by', 'n1', 'ghost'); // ORPHAN: 'ghost' has no node row
-    assert.equal(userVersion(raw), 3);
-    assert.equal(edgeCount(raw), 2);
-    raw.close();
-    // Explicit migration must not throw on the orphan, and must drop it.
-    const db = openMigratedDb();
-    assert.equal(userVersion(db), MIGRATIONS.length); // migrated forward to the head
-    // The orphan edge is filtered; the non-orphan edge + its count are preserved.
-    assert.equal(edgeCount(db), 1);
-    const surviving = db
-        .prepare('SELECT type, from_id, to_id FROM edges')
-        .get();
-    assert.equal(surviving.type, 'subscribes_to');
-    assert.equal(surviving.from_id, 'n1');
-    assert.equal(surviving.to_id, 'n2');
-});
-function buildV4DbWithLaterColumns() {
-    ensureHome();
-    const raw = new DatabaseSync(canvasDbPath());
-    raw.exec(`
-    CREATE TABLE nodes (
-      node_id    TEXT PRIMARY KEY,
-      name       TEXT NOT NULL,
-      kind       TEXT NOT NULL,
-      mode       TEXT NOT NULL DEFAULT 'base',
-      lifecycle  TEXT NOT NULL DEFAULT 'terminal',
-      status     TEXT NOT NULL DEFAULT 'active',
-      cwd        TEXT NOT NULL,
-      parent     TEXT,
-      created    TEXT NOT NULL,
-      intent       TEXT,
-      pi_pid       INTEGER,
-      window       TEXT,
-      tmux_session TEXT,
-      pane         TEXT,
-      host_kind    TEXT
-    );
-    CREATE TABLE edges (
-      type     TEXT NOT NULL,
-      from_id  TEXT NOT NULL,
-      to_id    TEXT NOT NULL,
-      active   INTEGER NOT NULL DEFAULT 1,
-      created  TEXT NOT NULL,
-      PRIMARY KEY (type, from_id, to_id)
-    );
-    PRAGMA user_version = 4;
-  `);
-    raw
-        .prepare('INSERT INTO nodes (node_id, name, kind, status, cwd, created, pane, host_kind) VALUES (?,?,?,?,?,?,?,?)')
-        .run('stale', 'Stale', 'general', 'idle', '/tmp/work', '2020-01-01T00:00:00Z', '%9', 'broker');
-    return raw;
-}
-test('bug #99: a stale v4 db with later columns already present migrates cleanly', () => {
-    const raw = buildV4DbWithLaterColumns();
-    assert.equal(userVersion(raw), 4);
-    assert.equal(nodeColumns(raw).includes('pane'), true, 'precondition: pane already exists even though user_version is stale');
-    raw.close();
-    const db = openMigratedDb();
-    assert.equal(userVersion(db), MIGRATIONS.length);
-    const cols = nodeColumns(db);
-    assert.ok(cols.includes('pane'), 'pane survives the migration');
-    assert.ok(cols.includes('host_kind'), 'host_kind survives the migration');
-    const row = db
-        .prepare('SELECT pane, host_kind FROM nodes WHERE node_id = ?')
-        .get('stale');
-    assert.equal(row.pane, '%9');
-    assert.equal(row.host_kind, 'broker');
-});
-test('v16 repairs a v15 database missing canonical finalization columns', () => {
-    ensureHome();
-    const db = new DatabaseSync(join(home, 'finalization.db'));
-    try {
-        migrateToVersion(db, 13);
-        db.exec('PRAGMA user_version = 15');
-        migrate(db);
-        const columns = nodeColumns(db);
-        assert.ok(columns.includes('final_report'));
-        assert.ok(columns.includes('finalized_at'));
-        // migrate() always brings a db to the latest schema, not just v16 — assert
-        // against the live migration count rather than a version snapshot that will
-        // go stale every time a new migration is appended.
-        assert.equal(userVersion(db), MIGRATIONS.length);
-    }
-    finally {
-        db.close();
-    }
-});
-// v22: legacy schedules → crons
-function buildV21Db() {
-    ensureHome();
-    const raw = new DatabaseSync(canvasDbPath());
-    migrateToVersion(raw, 21);
-    insertNode(raw, 'owner');
-    insertNode(raw, 'target');
-    raw.prepare('UPDATE nodes SET profile_id = ? WHERE node_id = ?').run('work', 'owner');
-    return raw;
-}
-function insertLegacySchedule(db, row) {
-    db.prepare(`
-    INSERT INTO triggers (
-      trigger_id, owner_id, node_id, action, action_mode, trigger_type,
-      fire_at, recur, payload, when_script, eval_every, next_eval_at,
-      timeout_at, eval_state, created
-    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'idle', '2020-01-01T00:00:00Z')
-  `).run(row.id, row.ownerId ?? 'owner', row.nodeId, row.action, row.actionMode, row.timing, row.fireAt ?? null, row.recur ?? null, row.payload === null ? null : JSON.stringify(row.payload), row.whenScript ?? null, row.evalEvery ?? null, row.nextEvalAt ?? null, row.timeoutAt ?? null);
-}
-test('v22 converts existing schedules into self-contained crons and removes the retired table', () => {
-    const raw = buildV21Db();
-    insertLegacySchedule(raw, {
-        id: 'scheduled-message',
-        nodeId: 'target',
-        action: 'msg',
-        actionMode: 'inbox_message',
-        timing: 'at',
-        fireAt: '2026-01-01T00:00:00.000Z',
-        payload: { body: 'check CI', label: 'CI check', tier: 'urgent' },
-    });
-    insertLegacySchedule(raw, {
-        id: 'fresh-revive',
-        nodeId: 'target',
-        action: 'msg',
-        actionMode: 'fresh_revive',
-        timing: 'at',
-        fireAt: '2026-01-02T00:00:00.000Z',
-        payload: null,
-    });
-    insertLegacySchedule(raw, {
-        id: 'conditional-message',
-        nodeId: 'target',
-        action: 'msg',
-        actionMode: 'inbox_message',
-        timing: 'when',
-        payload: { body: 'ready at last', label: 'ci watch' },
-        whenScript: 'test -f ready',
-        evalEvery: JSON.stringify({ every: '5m' }),
-        nextEvalAt: '2026-01-03T00:00:00.000Z',
-        timeoutAt: '2026-01-04T00:00:00.000Z',
-    });
-    insertLegacySchedule(raw, {
-        id: 'armed-deadline',
-        nodeId: 'target',
-        action: 'msg',
-        actionMode: 'deadline_message',
-        timing: 'at',
-        fireAt: '2026-01-06T00:00:00.000Z',
-        payload: { body: 'timed out — decide without me' },
-    });
-    insertLegacySchedule(raw, {
-        id: 'recurring-birth',
-        nodeId: null,
-        action: 'new',
-        actionMode: 'node_birth',
-        timing: 'every',
-        fireAt: '2026-01-05T00:00:00.000Z',
-        recur: JSON.stringify({ every: '6h' }),
-        payload: { kind: 'general', mode: 'base', cwd: '/tmp/work', prompt: 'go', parent: 'owner' },
-    });
-    raw.close();
-    const db = openMigratedDb();
-    assert.equal(userVersion(db), MIGRATIONS.length);
-    const tables = db.prepare("SELECT name FROM sqlite_master WHERE type = 'table'").all().map((row) => row.name);
-    assert.ok(!tables.includes('triggers'));
-    const cron = (id) => db.prepare('SELECT * FROM crons WHERE cron_id = ?').get(id);
-    const message = cron('scheduled-message');
-    assert.equal(message.name, 'CI check');
-    assert.equal(message.anchor_node, 'target');
-    assert.equal(message.cwd, '/tmp/work');
-    assert.equal(message.profile, 'work');
-    assert.equal(message.tier, 'urgent');
-    assert.match(message.command, /crtr node message send --to 'target' --tier 'urgent'/);
-    assert.match(message.command, /check CI/);
-    const revive = cron('fresh-revive');
-    assert.equal(revive.command, "crtr node lifecycle revive 'target' --fresh");
-    const conditional = cron('conditional-message');
-    assert.equal(conditional.cancel_on_wake, 0, 'only a deadline message is cancel-on-wake');
-    assert.equal(conditional.recur, JSON.stringify({ every: '5m' }));
-    assert.equal(conditional.expires_at, '2026-01-04T00:00:00.000Z');
-    assert.match(conditional.command, /test -f ready/);
-    // The action's exit status must reach the cron, so the self-cancel is CHAINED
-    // off it rather than run unconditionally on its own line. (What the chain
-    // actually DOES when run is proved by execution below, not by this shape.)
-    assert.match(conditional.command, /\n} && crtr cron cancel "\$CRTR_CRON_ID"/);
-    const deadline = cron('armed-deadline');
-    assert.equal(deadline.cancel_on_wake, 1, 'a deadline message is cancelled by any wake');
-    assert.equal(deadline.tier, 'urgent', 'a deadline message is forced urgent');
-    assert.equal(deadline.anchor_node, 'target');
-    assert.match(deadline.command, /--tier 'urgent'/);
-    const birth = cron('recurring-birth');
-    assert.equal(birth.anchor_node, null);
-    assert.equal(birth.recur, JSON.stringify({ every: '6h' }));
-    assert.match(birth.command, /crtr node new --kind 'general'/);
-    assert.match(birth.command, /go/);
-});
-// The explicit v22 migration must handle every declared-legal data shape. These
-// cases are all shapes the retired schema declared legal.
-function insertNodeAt(db, id, cwd, created, parent) {
-    db.prepare('INSERT INTO nodes (node_id, name, kind, status, cwd, parent, created) VALUES (?,?,?,?,?,?,?)').run(id, id, 'general', 'active', cwd, parent, created);
-}
-test('v22 converts the legal edge rows and records the ones it cannot express', () => {
-    ensureHome();
-    const raw = new DatabaseSync(canvasDbPath());
-    migrateToVersion(raw, 21);
-    insertNodeAt(raw, 'ambient', '/tmp/ambient', '2019-01-01T00:00:00Z', null);
-    insertNodeAt(raw, 'owner', '/tmp/work', '2020-01-01T00:00:00Z', 'ambient');
-    insertNodeAt(raw, 'target', '/tmp/work', '2020-01-01T00:00:00Z', 'ambient');
-    // A crashed-then-pruned armer: `owner_id` deliberately carries no FK, so this
-    // detached row is expected, not corrupt.
-    insertLegacySchedule(raw, {
-        id: 'pruned-owner',
-        ownerId: 'ghost',
-        nodeId: 'target',
-        action: 'msg',
-        actionMode: 'inbox_message',
-        timing: 'at',
-        fireAt: '2026-02-01T00:00:00.000Z',
-        payload: { body: 'still due' },
-    });
-    // Already past its fire time: converts, then the cron expiry pass reaps it.
-    insertLegacySchedule(raw, {
-        id: 'expired',
-        nodeId: 'target',
-        action: 'msg',
-        actionMode: 'inbox_message',
-        timing: 'at',
-        fireAt: '2020-06-01T00:00:00.000Z',
-        payload: { body: 'long overdue' },
-    });
-    // `until` is one-shot: a fire time and no recurrence.
-    insertLegacySchedule(raw, {
-        id: 'one-shot-until',
-        nodeId: 'target',
-        action: 'msg',
-        actionMode: 'inbox_message',
-        timing: 'until',
-        fireAt: '2026-03-01T00:00:00.000Z',
-        payload: { body: 'deadline policy' },
-    });
-    // A body-less predicate: the retired daemon sent the gate's stdout as the body.
-    insertLegacySchedule(raw, {
-        id: 'gate-stdout-body',
-        nodeId: 'target',
-        action: 'msg',
-        actionMode: 'inbox_message',
-        timing: 'when',
-        payload: { label: 'ci watch' },
-        whenScript: 'gh run view --json status',
-        evalEvery: JSON.stringify({ every: '5m' }),
-        nextEvalAt: '2026-01-03T00:00:00.000Z',
-        timeoutAt: '2026-01-04T00:00:00.000Z',
-    });
-    // `payload` was nullable: a NULL payload must not fail the open.
-    insertLegacySchedule(raw, {
-        id: 'null-payload',
-        nodeId: 'target',
-        action: 'msg',
-        actionMode: 'inbox_message',
-        timing: 'at',
-        fireAt: '2026-04-01T00:00:00.000Z',
-        payload: null,
-    });
-    // Two deadlines for one node: illegal under the retired unique index (dropped
-    // here to seed the drifted shape), so only drifted data reaches here. INSERT OR REPLACE would silently evict the first;
-    // the loser must be recorded instead.
-    raw.exec('DROP INDEX idx_triggers_deadline');
-    insertLegacySchedule(raw, {
-        id: 'deadline-first',
-        nodeId: 'target',
-        action: 'msg',
-        actionMode: 'deadline_message',
-        timing: 'at',
-        fireAt: '2026-05-01T00:00:00.000Z',
-        payload: { body: 'first deadline' },
-    });
-    insertLegacySchedule(raw, {
-        id: 'deadline-rival',
-        nodeId: 'target',
-        action: 'msg',
-        actionMode: 'deadline_message',
-        timing: 'at',
-        fireAt: '2026-05-02T00:00:00.000Z',
-        payload: { body: 'rival deadline' },
-    });
-    // Genuinely unconvertible: skipped and recorded, never fatal.
-    insertLegacySchedule(raw, {
-        id: 'unknown-timing',
-        nodeId: 'target',
-        action: 'msg',
-        actionMode: 'inbox_message',
-        timing: 'whenever',
-        payload: { body: 'nope' },
-    });
-    raw.close();
-    const db = openMigratedDb();
-    assert.equal(userVersion(db), MIGRATIONS.length, 'the schema advances despite the unconvertible row');
-    const cron = (id) => db.prepare('SELECT * FROM crons WHERE cron_id = ?').get(id);
-    const pruned = cron('pruned-owner');
-    assert.equal(pruned.cwd, '/tmp/ambient', 'a pruned armer falls back to the ambient root cwd');
-    assert.equal(pruned.profile, null);
-    assert.equal(cron('expired').fire_at, '2020-06-01T00:00:00.000Z');
-    assert.equal(cron('one-shot-until').recur, null);
-    const gated = cron('gate-stdout-body');
-    assert.match(gated.command, /CRTR_GATE_STDOUT="\$\(/);
-    assert.match(gated.command, /printf '%s\\n' "\$CRTR_GATE_STDOUT" \| crtr node message send --to 'target'/);
-    assert.match(cron('null-payload').command, /no body was recorded/);
-    assert.equal(cron('unknown-timing'), undefined, 'the unconvertible row is dropped, not fatal');
-    const ledger = db.prepare('SELECT value FROM canvas_meta WHERE key = ?').get('migration.v22.skipped');
-    assert.deepEqual(JSON.parse(ledger.value).map((entry) => entry.trigger_id).sort(), ['deadline-rival', 'unknown-timing'], 'both the unconvertible row and the evicted duplicate deadline are named');
-    assert.notEqual(cron('deadline-first'), undefined, 'the first deadline survives the duplicate');
-});
-test('v22 re-run over already-converted crons converges instead of colliding on the primary key', () => {
-    const raw = buildV21Db();
-    insertLegacySchedule(raw, {
-        id: 'scheduled-message',
-        nodeId: 'target',
-        action: 'msg',
-        actionMode: 'inbox_message',
-        timing: 'at',
-        fireAt: '2026-01-01T00:00:00.000Z',
-        payload: { body: 'check CI' },
-    });
-    // What an interrupted pre-fix run left behind: the cron row committed while
-    // `user_version` stayed at 21, so the next open re-runs the step.
-    raw.prepare(`
-    INSERT INTO crons (cron_id, name, created_by, command, fire_at, cwd, sink, created, updated)
-    VALUES ('scheduled-message', 'stale', 'owner', 'echo stale', '2026-01-01T00:00:00.000Z', '/tmp/work', '{}', '2020-01-01T00:00:00Z', '2020-01-01T00:00:00Z')
-  `).run();
-    raw.close();
-    const db = openMigratedDb();
-    assert.equal(userVersion(db), MIGRATIONS.length);
-    const row = db.prepare('SELECT command FROM crons WHERE cron_id = ?').get('scheduled-message');
-    assert.match(row.command, /crtr node message send --to 'target'/, 'the re-run replaces the half-written row');
-    // Opening again is a plain no-op at the latest version.
-    closeDb();
-    assert.equal(userVersion(openDb()), MIGRATIONS.length);
-});
-test('a failing migration step rolls back its writes and leaves user_version untouched', () => {
-    const raw = buildV21Db();
-    insertLegacySchedule(raw, {
-        id: 'scheduled-message',
-        nodeId: 'target',
-        action: 'msg',
-        actionMode: 'inbox_message',
-        timing: 'at',
-        fireAt: '2026-01-01T00:00:00.000Z',
-        payload: { body: 'check CI' },
-    });
-    insertLegacySchedule(raw, {
-        id: 'unknown-timing',
-        nodeId: 'target',
-        action: 'msg',
-        actionMode: 'inbox_message',
-        timing: 'whenever',
-        payload: { body: 'nope' },
-    });
-    // Break the step mid-flight: the skip ledger has nowhere to land, so v22
-    // throws AFTER it has already inserted the convertible row.
-    raw.exec('DROP TABLE canvas_meta');
-    assert.throws(() => migrate(raw));
-    assert.equal(userVersion(raw), 21, 'the version stays at the last fully-applied step');
-    const crons = raw.prepare('SELECT COUNT(*) AS n FROM crons').get().n;
-    assert.equal(crons, 0, 'every write from the failed step rolled back');
-    const triggers = raw.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name='triggers'").get();
-    assert.notEqual(triggers, undefined, 'the retired table survives so the step can be retried');
-    raw.close();
-});
-test('v22 recovers a db wedged by an interrupted pre-atomicity run', () => {
-    const raw = buildV21Db();
-    // The wedge the old bare-migration path could produce: crons committed, the
-    // retired table already dropped, `user_version` never bumped past 21.
-    raw.prepare(`
-    INSERT INTO crons (cron_id, name, created_by, command, fire_at, cwd, sink, created, updated)
-    VALUES ('half-written', 'half', 'owner', 'echo hi', '2026-01-01T00:00:00.000Z', '/tmp/work', '{}', '2020-01-01T00:00:00Z', '2020-01-01T00:00:00Z')
-  `).run();
-    raw.exec('DROP TABLE triggers');
-    raw.close();
-    const db = openMigratedDb();
-    assert.equal(userVersion(db), MIGRATIONS.length, 'the schema advances rather than failing every explicit migration');
-    assert.notEqual(db.prepare('SELECT 1 FROM crons WHERE cron_id = ?').get('half-written'), undefined);
-});
-// The generated cron scripts are the migration's real product, so the M4
-// contract (a failed action must NOT self-cancel and must exit nonzero) is
-// proved by RUNNING them under bash with a stub `crtr` on PATH. A string match
-// cannot see a heredoc that swallows the chained cancel; `bash -n` cannot either.
-function runMigratedScript(script, opts) {
-    const dir = mkdtempSync(join(tmpdir(), 'crtr-cron-script-'));
-    const bin = join(dir, 'bin');
-    mkdirSync(bin);
-    const log = join(dir, 'crtr.log');
-    writeFileSync(join(bin, 'crtr'), `#!/bin/sh\nprintf 'ARGS: %s\\n' "$*" >> "${log}"\nif [ "$1" = 'node' ]; then { printf 'BODY<'; cat; printf '>\\n'; } >> "${log}"; fi\nexit \${CRTR_STUB_EXIT:-0}\n`, { mode: 0o755 });
-    if (opts.gateReady === true)
-        writeFileSync(join(dir, 'ready'), '');
-    const result = spawnSync('bash', ['-c', script], {
-        cwd: dir,
-        stdio: ['ignore', 'pipe', 'pipe'],
-        env: {
-            ...process.env,
-            PATH: `${bin}:${process.env['PATH'] ?? ''}`,
-            CRTR_CRON_ID: 'conditional-message',
-            CRTR_STUB_EXIT: String(opts.crtrExit ?? 0),
-        },
-    });
-    const written = existsSync(log) ? readFileSync(log, 'utf8') : '';
-    rmSync(dir, { recursive: true, force: true });
-    return { code: result.status ?? -1, log: written };
-}
-function buildV39Db() {
-    ensureHome();
-    const raw = new DatabaseSync(canvasDbPath());
-    migrateToVersion(raw, 39);
-    return raw;
-}
-function resetV39Home() {
-    closeDb();
-    rmSync(home, { recursive: true, force: true });
-    return buildV39Db();
-}
-function writeLegacyPage(id, source, dialect = 'jsx') {
-    const dir = join(home, 'nodes', id);
-    mkdirSync(dir, { recursive: true });
-    const document = dialect === 'jsx'
-        ? 'export default function LegacyPage() { return <Page title="The gate is gone" subtitle="This page was sent with page_surface off — the refusal that used to block it no longer exists. Nothing to answer; it is here to prove delivery." placement="panel" />; }\n'
-        : '---\ntitle: The gate is gone\n---\nThis is the stored Markdown page.\n';
-    writeFileSync(join(dir, dialect === 'jsx' ? 'page.tsx' : 'page.md'), document);
-    writeFileSync(join(dir, 'page.json'), JSON.stringify({
-        schema: 'crtr.page/v1', dialect, title: 'The gate is gone',
-        subtitle: 'This page was sent with page_surface off — the refusal that used to block it no longer exists. Nothing to answer; it is here to prove delivery.',
-        placement: 'panel', document: dialect === 'jsx' ? 'page.tsx' : 'page.md', steps: 1, slots: [], source,
-    }));
-    return dir;
-}
-test('v40 imports pre-envelope v1 pages and still rejects invalid v2 delivery envelopes', () => {
-    const raw = buildV39Db();
-    const blocked = writeLegacyPage('page-bba481b2', {
-        sessionName: 'general', blockedSince: '2026-08-11T17:32:21.979Z', profileName: 'crouter', nodeId: '3zl47w7d-msowsany-ee8e2bba',
-    });
-    const emitted = writeLegacyPage('nfy-3b21bc8a', {
-        sessionName: 'notify', nodeId: '3zl47w7d-msmeye7h-cb3ff1da',
-    }, 'md');
-    const legacyBytes = readFileSync(join(blocked, 'page.json'));
-    migrate(raw);
-    for (const [dir, id, delivery] of [[blocked, 'page-bba481b2', { placement: 'panel', inbox: true, reply: true }], [emitted, 'nfy-3b21bc8a', { placement: 'panel', inbox: true, reply: false }]]) {
-        const stored = raw.prepare('SELECT presentation_dir, specification_json FROM human_requests WHERE request_id = ?').get(id);
-        const manifest = parsePage(stored.presentation_dir);
-        assert.deepEqual(manifest.delivery, delivery);
-        assert.deepEqual(parsePageDelivery(stored.presentation_dir), delivery);
-        assert.deepEqual(JSON.parse(stored.specification_json), manifest);
-    }
-    assert.deepEqual(readFileSync(join(blocked, 'page.json')), legacyBytes, 'the source manifest remains untouched');
-    raw.close();
-    const invalid = resetV39Home();
-    const valid = writeLegacyPage('valid-v1-page', { blockedSince: '2026-08-11T17:32:21.979Z' });
-    const validBytes = readFileSync(join(valid, 'page.json'));
-    const dir = writeLegacyPage('broken-v2-page', { blockedSince: '2026-08-11T17:32:21.979Z' });
-    writeFileSync(join(dir, 'page.json'), JSON.stringify({ schema: 'crtr.page/v2', title: 'Broken', delivery: { placement: 'panel', inbox: true, reply: false, extra: true } }));
-    assert.throws(() => migrate(invalid), (error) => error instanceof Error && error.message.includes(join(dir, 'page.json')));
-    assert.equal(userVersion(invalid), 39, 'the failed migration rolls back');
-    assert.deepEqual(readFileSync(join(valid, 'page.json')), validBytes, 'a failed migration does not alter an earlier v1 input');
-    invalid.close();
-    const malformedV2 = resetV39Home();
-    const malformedV2Dir = writeLegacyPage('malformed-v2-page', { blockedSince: '2026-08-11T17:32:21.979Z' });
-    writeFileSync(join(malformedV2Dir, 'page.json'), JSON.stringify({ schema: 'crtr.page/v2', title: 'Broken', delivery: { placement: 'panel', inbox: true, reply: false } }));
-    assert.throws(() => migrate(malformedV2), (error) => error instanceof Error && error.message.includes(join(malformedV2Dir, 'page.json')));
-    malformedV2.close();
-    const malformedV1 = resetV39Home();
-    const malformedV1Dir = writeLegacyPage('malformed-v1-page', { blockedSince: '2026-08-11T17:32:21.979Z' });
-    writeFileSync(join(malformedV1Dir, 'page.json'), JSON.stringify({
-        schema: 'crtr.page/v1', dialect: 'jsx', title: 'Broken', placement: 'panel', document: 'page.tsx', steps: 1,
-        slots: [{ id: 'out-of-range', kind: 'options', step: 1, config: {} }], source: { blockedSince: '2026-08-11T17:32:21.979Z' },
-    }));
-    assert.throws(() => migrate(malformedV1), (error) => error instanceof Error && error.message.includes(join(malformedV1Dir, 'page.json')));
-    malformedV1.close();
-    const malformedMarkdown = resetV39Home();
-    const malformedMarkdownDir = writeLegacyPage('malformed-markdown-page', {}, 'md');
-    const malformedMarkdownManifest = JSON.parse(readFileSync(join(malformedMarkdownDir, 'page.json'), 'utf8'));
-    malformedMarkdownManifest.steps = 2;
-    writeFileSync(join(malformedMarkdownDir, 'page.json'), JSON.stringify(malformedMarkdownManifest));
-    assert.throws(() => migrate(malformedMarkdown), (error) => error instanceof Error && error.message.includes(join(malformedMarkdownDir, 'page.json')));
-    malformedMarkdown.close();
-});
-test('v40 skips recovery witnesses without identity while retaining failures for indexed nodes', () => {
-    const raw = buildV39Db();
-    const faultDir = join(home, 'nodes', 'orphan-fault', 'job');
-    const retryDir = join(home, 'nodes', 'orphan-retry', 'job');
-    mkdirSync(faultDir, { recursive: true });
-    mkdirSync(retryDir, { recursive: true });
-    writeFileSync(join(faultDir, 'fault'), JSON.stringify({
-        link: 'viewer↔broker', op: 'connect', kind: 'connection', message: 'ENOENT', since: '2026-09-10T00:00:00.000Z', operation_id: '11111111111111111111111111111111', retry: { disposition: 'fatal' },
-    }));
-    writeFileSync(join(retryDir, 'provider-retry'), JSON.stringify({
-        state: 'pending', sessionFile: '/tmp/orphan-retry.jsonl', anchorEntryId: null,
-        fault: { link: 'pi→provider', op: 'request', kind: 'connection', message: 'ECONNRESET', since: '2026-09-10T00:00:00.000Z', operation_id: '22222222222222222222222222222222', retry: { disposition: 'auto', by: 'daemon' } },
-    }));
-    const resident = join(home, 'nodes', 'metadata-node');
-    mkdirSync(join(resident, 'job'), { recursive: true });
-    writeFileSync(join(resident, 'meta.json'), JSON.stringify({
-        node_id: 'metadata-node', name: 'metadata-node', created: '2026-09-10T00:00:00.000Z', cwd: '/tmp', kind: 'developer', mode: 'base', lifecycle: 'terminal',
-    }));
-    writeFileSync(join(resident, 'job', 'busy'), '');
-    migrate(raw);
-    assert.notEqual(raw.prepare('SELECT 1 FROM nodes WHERE node_id = ?').get('metadata-node'), undefined);
-    assert.equal(raw.prepare('SELECT COUNT(*) AS count FROM executions WHERE node_id = ?').get('metadata-node').count, 1);
-    assert.equal(raw.prepare("SELECT 1 FROM nodes WHERE node_id IN ('orphan-fault', 'orphan-retry')").get(), undefined);
-    raw.close();
-    const invalid = resetV39Home();
-    insertNode(invalid, 'indexed-node');
-    const invalidPath = join(home, 'nodes', 'indexed-node', 'job', 'fault');
-    mkdirSync(dirname(invalidPath), { recursive: true });
-    writeFileSync(invalidPath, 'not json');
-    assert.throws(() => migrate(invalid), (error) => error instanceof Error && error.message.includes(invalidPath));
-    invalid.close();
-});
-test('a migrated predicate script delivers its exact body and self-cancels only when the action succeeds', () => {
-    const raw = buildV21Db();
-    insertLegacySchedule(raw, {
-        id: 'conditional-message',
-        nodeId: 'target',
-        action: 'msg',
-        actionMode: 'inbox_message',
-        timing: 'when',
-        payload: { body: 'ready at last' },
-        whenScript: 'test -f ready',
-        evalEvery: JSON.stringify({ every: '5m' }),
-        nextEvalAt: '2026-01-03T00:00:00.000Z',
-        timeoutAt: '2026-01-04T00:00:00.000Z',
-    });
-    insertLegacySchedule(raw, {
-        id: 'gate-stdout-body',
-        nodeId: 'target',
-        action: 'msg',
-        actionMode: 'inbox_message',
-        timing: 'when',
-        payload: {},
-        whenScript: 'test -f ready && echo "build 1234 is green"',
-        evalEvery: JSON.stringify({ every: '5m' }),
-        nextEvalAt: '2026-01-03T00:00:00.000Z',
-        timeoutAt: '2026-01-04T00:00:00.000Z',
-    });
-    raw.close();
-    const db = openMigratedDb();
-    const script = (id) => db.prepare('SELECT command FROM crons WHERE cron_id = ?').get(id).command;
-    const stored = script('conditional-message');
-    const satisfied = runMigratedScript(stored, { gateReady: true });
-    assert.equal(satisfied.code, 0);
-    assert.match(satisfied.log, /BODY<ready at last\n>/, 'the heredoc body is delivered verbatim');
-    assert.doesNotMatch(satisfied.log, /CRTR_MIGRATED/, 'no heredoc delimiter leaks into the body');
-    assert.match(satisfied.log, /ARGS: cron cancel conditional-message/, 'a successful action self-cancels');
-    const failed = runMigratedScript(stored, { gateReady: true, crtrExit: 3 });
-    assert.notEqual(failed.code, 0, 'a failed action propagates a nonzero exit to the on-failure path');
-    assert.doesNotMatch(failed.log, /cron cancel/, 'a failed action leaves the cron armed');
-    const unsatisfied = runMigratedScript(stored, { gateReady: false });
-    assert.equal(unsatisfied.code, 0, 'an unsatisfied gate is a clean no-op');
-    assert.equal(unsatisfied.log, '', 'nothing is enacted while the gate is closed');
-    const fromGate = runMigratedScript(script('gate-stdout-body'), { gateReady: true });
-    assert.equal(fromGate.code, 0);
-    assert.match(fromGate.log, /BODY<build 1234 is green\n>/, "a body-less predicate sends the gate's stdout");
-    assert.match(fromGate.log, /ARGS: cron cancel/);
-});