@north-light/crouter 0.3.318 → 0.3.320

package/dist/core/__tests__/kickoff.test.d.ts

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

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

@@ -1,196 +0,0 @@
-// Run with: node --import tsx/esm --test src/core/__tests__/kickoff.test.ts
-//
-// The fresh-revive kickoff split (runtime/kickoff.ts). drainBearings reads the
-// durable yield note, feed, and pending persona framing; buildReviveKickoff is a
-// pure assembler. session_start commits the note and persona handoffs.
-import { test, before, after, beforeEach } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, rmSync, existsSync, mkdirSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { createNode, getNode, subscribe } from '../canvas/canvas.js';
-import { reportsDir } from '../canvas/paths.js';
-import { closeDb, migrate, openDb } from '../canvas/db.js';
-import { acknowledgeNodeMail, claimNodeMail } from '../canvas/deliveries.js';
-import { beginExecution } from '../canvas/executions.js';
-import { buildReviveKickoff, clearYieldMessage, drainBearings, readYieldMessage, writeYieldMessage, yieldMessagePath, } from '../runtime/kickoff.js';
-import { enqueueNodeMail } from '../feed/messages.js';
-import { appendSituationalContext } from '../runtime/situational-context.js';
-import { buildContextBearings as buildContextIntro } from '../runtime/bearings.js';
-let home;
-function node(id, over = {}) {
-    return {
-        node_id: id,
-        name: id,
-        created: new Date().toISOString(),
-        cwd: '/tmp/work',
-        kind: 'general',
-        mode: 'base',
-        lifecycle: 'terminal',
-        status: 'active',
-        ...over,
-    };
-}
-before(() => {
-    home = mkdtempSync(join(tmpdir(), 'crtr-kickoff-'));
-    process.env['CRTR_HOME'] = home;
-});
-beforeEach(() => {
-    closeDb();
-    rmSync(home, { recursive: true, force: true });
-    migrate(openDb());
-});
-after(() => {
-    closeDb();
-    rmSync(home, { recursive: true, force: true });
-    delete process.env['CRTR_HOME'];
-});
-test('drainBearings preserves the yield note until explicit boot confirmation', () => {
-    const id = 'n1';
-    const meta = createNode(node(id));
-    const executionId = beginExecution(id, { daemonEpoch: 'test' });
-    writeYieldMessage(id, 'on wake, finish step 3');
-    enqueueNodeMail(id, { senderNodeId: 'w1', kind: 'update', label: 'first', bodyRef: '/tmp/a.md', urgency: 'normal', wake: 1 });
-    enqueueNodeMail(id, { senderNodeId: 'w1', kind: 'update', label: 'second', bodyRef: '/tmp/b.md', urgency: 'normal', wake: 1 });
-    const b1 = drainBearings(meta, executionId);
-    assert.equal(b1.yieldMsg?.trim(), 'on wake, finish step 3');
-    assert.ok(b1.unreadDigest !== null && b1.unreadDigest.length > 0);
-    assert.equal(existsSync(yieldMessagePath(id)), true, 'yield note remains pending before confirmation');
-    assert.equal(readYieldMessage(id), 'on wake, finish step 3', 'reader sees the same persisted note');
-    const claim = claimNodeMail(id, executionId, 'wake');
-    const receipt = acknowledgeNodeMail(id, executionId, claim.deliveries.map((delivery) => ({
-        deliveryId: delivery.deliveryId, attempts: delivery.attempts, disposition: 'acknowledged',
-    })));
-    assert.deepEqual(receipt.results.map((result) => result.outcome), ['acknowledged', 'acknowledged']);
-    const b2 = drainBearings(meta, executionId);
-    assert.equal(b2.yieldMsg, 'on wake, finish step 3', 'a failed launch can read the same note again');
-    assert.equal(b2.unreadDigest, null, 'settled deliveries do not return to the next launch');
-    clearYieldMessage(id);
-    clearYieldMessage(id);
-    assert.equal(readYieldMessage(id), null, 'confirmation clear is idempotent');
-    assert.equal(existsSync(yieldMessagePath(id)), false, 'confirmed handoff removes the note');
-});
-test('fresh kickoff keeps each inbox card directly before its own message', () => {
-    const id = 'ordered-cards';
-    const meta = createNode(node(id));
-    const executionId = beginExecution(id, { daemonEpoch: 'test' });
-    enqueueNodeMail(id, {
-        senderNodeId: 'sender', kind: 'message', label: 'FIRST-BODY',
-        bodyJson: { body: 'FIRST-BODY', cards: ['<runtime kind="test-card">FIRST-CARD</runtime>'] }, urgency: 'normal', wake: 1,
-    });
-    enqueueNodeMail(id, {
-        senderNodeId: 'sender', kind: 'message', label: 'SECOND-BODY',
-        bodyJson: { body: 'SECOND-BODY', cards: ['<runtime kind="test-card">SECOND-CARD</runtime>'] }, urgency: 'normal', wake: 1,
-    });
-    for (const body of ['GROUPED-BODY-1', 'GROUPED-BODY-2', 'GROUPED-BODY-3']) {
-        enqueueNodeMail(id, { senderNodeId: 'card-free-sender', kind: 'message', label: body, bodyJson: { body }, urgency: 'normal', wake: 1 });
-    }
-    const kickoff = buildReviveKickoff(meta, drainBearings(meta, executionId));
-    const firstCard = kickoff.indexOf('FIRST-CARD');
-    const firstBody = kickoff.indexOf('FIRST-BODY');
-    const secondCard = kickoff.indexOf('SECOND-CARD');
-    const secondBody = kickoff.indexOf('SECOND-BODY');
-    assert.ok(firstCard >= 0 && firstCard < firstBody, 'the first card stays ahead of its own message');
-    assert.ok(firstBody < secondCard, 'the second card cannot leap ahead of the first message');
-    assert.ok(secondCard < secondBody, 'the second card stays ahead of its own message');
-    const groupedSections = kickoff.match(/<from id="card-free-sender">([\s\S]*?)<\/from>/g) ?? [];
-    assert.equal(groupedSections.length, 1, 'card-free entries from one sender remain one delivery');
-    for (const body of ['GROUPED-BODY-1', 'GROUPED-BODY-2', 'GROUPED-BODY-3']) {
-        assert.ok(groupedSections[0].includes(body), `${body} remains in the sender's single delivery`);
-    }
-});
-test('drainBearings leaves persona drift pending until the replacement context exists', () => {
-    const oldPersona = { kind: 'developer', mode: 'base', lifecycle: 'terminal' };
-    const meta = createNode(node('pending-persona', {
-        kind: 'developer',
-        mode: 'orchestrator',
-        persona_ack: oldPersona,
-    }));
-    const bearings = drainBearings(meta, beginExecution(meta.node_id, { daemonEpoch: 'test' }));
-    assert.match(bearings.driftGuidance ?? '', /ORCHESTRATOR/);
-    assert.deepEqual(getNode(meta.node_id)?.persona_ack, oldPersona, 'pre-session_start launch work cannot acknowledge the drift');
-});
-test('the feed block frames awaiting workers as alive + auto-waking, so a fresh revive has no reason to poll', () => {
-    const parent = createNode(node('p1'));
-    const child = createNode(node('c1')); // status 'active' by default
-    subscribe(parent.node_id, child.node_id); // parent awaits child
-    const msg = buildReviveKickoff(parent, drainBearings(parent, beginExecution(parent.node_id, { daemonEpoch: 'test' })));
-    // The roster names the live child...
-    assert.ok(msg.includes(child.node_id), 'awaiting roster lists the live child');
-    // ...and asserts aliveness + the automatic wake at the source, so the node
-    // has nothing to check, poll, or verify separately.
-    assert.ok(/alive and running/.test(msg), 'states the worker is alive and running');
-    assert.ok(/wake you the moment/.test(msg), 'states the wake is automatic on push');
-    assert.ok(/still working, not stalled/.test(msg), 'frames the empty feed as expected, not a problem');
-});
-test('a fresh revive is pointed at its subscriptions\' on-disk report history (catch-up bug)', () => {
-    // Regression for the fresh-revive catch-up bug: on a refresh-yield
-    // (resume:false) the old conversation is gone AND the inbox cursor has already
-    // advanced past everything drained pre-yield, so the revived node needs a
-    // durable catch-up breadcrumb for reports its subscriptions pushed BEFORE the
-    // yield. The bodies persist forever at reports/<ts>-<kind>.md; the kickoff
-    // surfaces a collapsed index with the newest ref and expansion commands.
-    const parent = createNode(node('p1'));
-    const worker = createNode(node('w1'));
-    subscribe(parent.node_id, worker.node_id);
-    // The worker pushed two reports BEFORE the parent's refresh-yield.
-    const dir = reportsDir(worker.node_id);
-    mkdirSync(dir, { recursive: true });
-    const older = join(dir, '20260608T120000-update.md');
-    const newer = join(dir, '20260608T130000-final.md');
-    writeFileSync(older, '---\n---\nearly progress', 'utf8');
-    writeFileSync(newer, '---\n---\nthe result', 'utf8');
-    const msg = buildReviveKickoff(parent, drainBearings(parent, beginExecution(parent.node_id, { daemonEpoch: 'test' })));
-    // The feed block stays condensed: it reports that history exists and surfaces
-    // the newest report ref for immediate dereference, while older refs stay one
-    // command away instead of being preloaded into the revive prompt.
-    const olderRef = `${worker.node_id}:reports/20260608T120000-update.md`;
-    const newerRef = `${worker.node_id}:reports/20260608T130000-final.md`;
-    assert.ok(/Report history on disk \(collapsed\): 2 reports across 1 subscribed node/.test(msg));
-    assert.ok(msg.includes(`latest final: ${newerRef}`), 'newest report ref surfaced');
-    assert.ok(!msg.includes(olderRef), 'older report ref omitted from collapsed kickoff');
-    assert.ok(!msg.includes(older), 'absolute report paths not rendered');
-    assert.ok(!msg.includes(newer), 'absolute report paths not rendered');
-    assert.ok(/canvas history read <ref>/.test(msg), 'points at one-report expansion');
-    assert.ok(/node inspect artifacts <node-id> --type report/.test(msg), 'points at full per-node expansion');
-    assert.ok(/node inspect artifacts <node-id> --type inbox/.test(msg), 'points at the cursor-independent full-history replay');
-});
-test('a fresh revive kickoff never carries situational context — it rides the hidden bearings seam instead', () => {
-    // Hiddenness regression: situational context must stay OUT of the visible
-    // fresh/cycling revive kickoff prompt. It is still delivered on this path, but
-    // hidden — canvas-context-intro's session_start handler re-fires on every
-    // fresh/cycling revive (a new pi process boot rooting a fresh branch) and
-    // re-injects buildContextIntro(), which already carries the sidecar's stored
-    // situational card alongside <crtr-bearings> (see context-intro.test.ts for
-    // that seam's own coverage). buildReviveKickoff must never duplicate it into
-    // the visible prompt.
-    const id = 'n3';
-    const meta = createNode(node(id));
-    appendSituationalContext(id, 'user is mid-checkout on the store applet');
-    const kickoff = buildReviveKickoff(meta, drainBearings(meta, beginExecution(meta.node_id, { daemonEpoch: 'test' })));
-    assert.doesNotMatch(kickoff, /kind="situational"/, 'visible kickoff never carries the ambient card');
-    assert.doesNotMatch(kickoff, /mid-checkout on the store applet/, 'visible kickoff never carries the ambient text');
-    const hidden = buildContextIntro(id);
-    assert.match(hidden, /<runtime kind="situational">/, 'delivered instead via the hidden bearings/context-intro seam');
-    assert.match(hidden, /mid-checkout on the store applet/, 'hidden delivery carries the ambient text');
-});
-test('buildReviveKickoff is pure — building twice eats nothing', () => {
-    const id = 'n2';
-    const meta = createNode(node(id));
-    const executionId = beginExecution(id, { daemonEpoch: 'test' });
-    writeYieldMessage(id, 'remember the invariant');
-    enqueueNodeMail(id, { senderNodeId: 'w', kind: 'update', label: 'r', bodyRef: '/tmp/r.md', urgency: 'normal', wake: 1 });
-    // Claim once, then build twice from the same immutable bearings.
-    const bearings = drainBearings(meta, executionId);
-    const s1 = buildReviveKickoff(meta, bearings);
-    const s2 = buildReviveKickoff(meta, bearings);
-    // Identical output, and the build mutates neither delivery receipts nor note.
-    assert.equal(s1, s2);
-    assert.match(s1, /<yield-message>\nremember the invariant\n<\/yield-message>/, 'yield note is delivered inline');
-    const contextInventory = s1.match(/<context-dir path="[^"]+">[\s\S]*?<\/context-dir>/)?.[0];
-    assert.ok(contextInventory, 'context inventory is present');
-    assert.doesNotMatch(contextInventory, /yield-message\.md/, 'ephemeral yield note is not addressable from inventory');
-    const claim = claimNodeMail(id, executionId, 'wake');
-    assert.equal(claim.deliveries.length, 1, 'build does not settle its claimed delivery');
-    assert.equal(readYieldMessage(id), 'remember the invariant', 'build does not mutate the persisted note');
-});

package/dist/core/__tests__/lifecycle-terminal-reasons.test.d.ts

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

package/dist/core/__tests__/lifecycle-terminal-reasons.test.js

@@ -1,62 +0,0 @@
-import { after, before, beforeEach, test } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { createNode, getNode } from '../canvas/canvas.js';
-import { closeDb, migrate, openDb } from '../canvas/db.js';
-import { transition } from '../runtime/lifecycle.js';
-let home;
-function seed(nodeId) {
-    const node = {
-        node_id: nodeId,
-        name: nodeId,
-        created: new Date().toISOString(),
-        cwd: '/tmp/work',
-        kind: 'general',
-        mode: 'base',
-        lifecycle: 'terminal',
-        status: 'active',
-    };
-    createNode(node);
-}
-function reason(nodeId) {
-    return getNode(nodeId)?.terminal_reason;
-}
-before(() => {
-    home = mkdtempSync(join(tmpdir(), 'crtr-lifecycle-reasons-'));
-    process.env['CRTR_HOME'] = home;
-});
-beforeEach(() => {
-    closeDb();
-    rmSync(home, { recursive: true, force: true });
-    migrate(openDb());
-});
-after(() => {
-    closeDb();
-    rmSync(home, { recursive: true, force: true });
-    delete process.env['CRTR_HOME'];
-});
-test('transition records terminal reasons and clears them on terminal-to-live transitions', () => {
-    for (const [event, expected] of [
-        ['finish', 'finished'],
-        ['park', 'parked'],
-        ['cancel', 'stranded'],
-        ['crash', 'crashed'],
-        ['yield', null],
-        ['release', null],
-    ]) {
-        const nodeId = `event-${event}`;
-        seed(nodeId);
-        transition(nodeId, event);
-        assert.equal(reason(nodeId), expected, `${event} records its terminal reason`);
-    }
-    seed('refresh-launch');
-    transition('refresh-launch', 'cancel');
-    transition('refresh-launch', 'refresh-launch');
-    assert.equal(reason('refresh-launch'), null, 'refresh-launch clears a terminal reason');
-    seed('revive');
-    transition('revive', 'finish');
-    transition('revive', 'revive');
-    assert.equal(reason('revive'), null, 'revive clears a terminal reason');
-});

package/dist/core/__tests__/lifecycle.test.d.ts

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

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

@@ -1,176 +0,0 @@
-// Run with: node --import tsx/esm --test src/core/__tests__/lifecycle.test.ts
-//
-// The status×intent state machine (runtime/lifecycle.ts). Every LEGAL event
-// from every valid from-status lands the documented (status, intent), and every
-// ILLEGAL move throws — illegal states are unrepresentable. This IS the old
-// markCleanExitDone guard + the dozen scattered setStatus/setIntent pairs, now
-// table-driven. All assertions read back through getNode() (the hydrated view).
-import { test, before, after, beforeEach } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { createNode, getNode, setStatus, setIntent } from '../canvas/canvas.js';
-import { closeDb, migrate, openDb } from '../canvas/db.js';
-import { isParked, transition } from '../runtime/lifecycle.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',
-    };
-}
-/** Create a node forced into a precise (status, intent) start state. */
-function mk(id, status, intent = null) {
-    createNode(node(id));
-    setStatus(id, status);
-    setIntent(id, intent);
-}
-before(() => {
-    home = mkdtempSync(join(tmpdir(), 'crtr-lifecycle-'));
-    process.env['CRTR_HOME'] = home;
-});
-beforeEach(() => {
-    closeDb();
-    rmSync(home, { recursive: true, force: true });
-    migrate(openDb());
-});
-after(() => {
-    closeDb();
-    rmSync(home, { recursive: true, force: true });
-    delete process.env['CRTR_HOME'];
-});
-const ALL = ['active', 'idle', 'done', 'dead', 'canceled'];
-const LIVE = ['active', 'idle'];
-const TERMINAL = ['done', 'dead', 'canceled'];
-// finalize → done + intent='done', legal only from active|idle
-test('finalize: active|idle → done + intent=done', () => {
-    for (const from of LIVE) {
-        mk(`n_${from}`, from, 'refresh');
-        const m = transition(`n_${from}`, 'finish');
-        assert.equal(m.status, 'done', `finalize from ${from}`);
-        assert.equal(m.intent, 'done', `finalize from ${from} sets intent=done`);
-    }
-});
-test('finalize: illegal from done|dead|canceled → throws, status untouched', () => {
-    for (const from of TERMINAL) {
-        mk(`n_${from}`, from);
-        assert.throws(() => transition(`n_${from}`, 'finish'), /illegal lifecycle transition/);
-        assert.equal(getNode(`n_${from}`)?.status, from, `${from} unchanged on illegal finalize`);
-    }
-});
-// park → done + intent='parked', legal only from active|idle. The intent IS the
-// durable park marker: it must land atomically with the `done` it qualifies,
-// read only through isParked, and be cleared by revival.
-test('park: active|idle → done + intent=parked, and isParked reads exactly that pair', () => {
-    for (const from of LIVE) {
-        mk(`n_${from}`, from);
-        const m = transition(`n_${from}`, 'park');
-        assert.equal(m.status, 'done', `park from ${from}`);
-        assert.equal(m.intent, 'parked', `park from ${from} sets intent=parked`);
-        assert.equal(isParked(m), true, `park from ${from} is readable as parked`);
-        assert.equal(m.final_report ?? null, null, `park from ${from} leaves the finalization latch unset`);
-    }
-});
-test('park: illegal from done|dead|canceled → throws', () => {
-    for (const from of TERMINAL) {
-        mk(`n_${from}`, from);
-        assert.throws(() => transition(`n_${from}`, 'park'), /illegal lifecycle transition/);
-    }
-});
-test('park: revival clears the marker, and no other done is parked', () => {
-    mk('reopened', 'active');
-    transition('reopened', 'park');
-    assert.equal(isParked(transition('reopened', 'revive')), false, 'revive clears intent=parked');
-    mk('finished', 'active');
-    assert.equal(isParked(transition('finished', 'finish')), false, 'a finished done is not a park');
-});
-// cancel → canceled + intent cleared, legal from ANY status (forced teardown).
-// A5 (human-confirmed 2026-06-06): the `reap` event was COLLAPSED into `cancel`
-// — they were identical (status differed only; both intent=null, from=ANY, no
-// side effects in transition()). Every external reap (close cascade AND
-// reset/relaunch) now routes through `cancel`; `done` is reserved for finalize.
-test('cancel: any status → canceled + intent cleared', () => {
-    for (const from of ALL) {
-        mk(`n_${from}`, from, 'idle-release');
-        const m = transition(`n_${from}`, 'cancel');
-        assert.equal(m.status, 'canceled', `cancel from ${from}`);
-        assert.equal(m.intent, null, `cancel from ${from} clears intent`);
-    }
-});
-// crash → dead, intent UNCHANGED, legal only from active|idle
-test('crash: active|idle → dead, intent preserved', () => {
-    for (const from of LIVE) {
-        mk(`n_${from}`, from, 'refresh');
-        const m = transition(`n_${from}`, 'crash');
-        assert.equal(m.status, 'dead', `crash from ${from}`);
-        assert.equal(m.intent, 'refresh', `crash from ${from} leaves intent untouched`);
-    }
-});
-test('crash: illegal from done|dead|canceled → throws', () => {
-    for (const from of TERMINAL) {
-        mk(`n_${from}`, from);
-        assert.throws(() => transition(`n_${from}`, 'crash'), /illegal lifecycle transition/);
-    }
-});
-// yield → intent='refresh', status UNCHANGED, legal only from active|idle
-test('yield: active|idle → intent=refresh, status preserved', () => {
-    for (const from of LIVE) {
-        mk(`n_${from}`, from);
-        const m = transition(`n_${from}`, 'yield');
-        assert.equal(m.status, from, `yield from ${from} keeps status`);
-        assert.equal(m.intent, 'refresh', `yield from ${from} sets intent=refresh`);
-    }
-});
-test('yield: illegal from done|dead|canceled → throws', () => {
-    for (const from of TERMINAL) {
-        mk(`n_${from}`, from);
-        assert.throws(() => transition(`n_${from}`, 'yield'), /illegal lifecycle transition/);
-    }
-});
-// release → idle + intent='idle-release', legal from active|idle|done
-test('release: active|idle|done → idle + intent=idle-release', () => {
-    for (const from of [...LIVE, 'done']) {
-        mk(`n_${from}`, from);
-        const m = transition(`n_${from}`, 'release');
-        assert.equal(m.status, 'idle', `release from ${from}`);
-        assert.equal(m.intent, 'idle-release', `release from ${from} sets intent=idle-release`);
-    }
-});
-test('release: illegal from dead|canceled → throws', () => {
-    for (const from of ['dead', 'canceled']) {
-        mk(`n_${from}`, from);
-        assert.throws(() => transition(`n_${from}`, 'release'), /illegal lifecycle transition/);
-    }
-});
-// refresh-launch → active + intent=refresh, legal from ANY status. This is the
-// provisional launch transition; session_start commits through revive below.
-test('refresh-launch: any status → active + intent=refresh', () => {
-    for (const from of ALL) {
-        mk(`n_${from}`, from, 'idle-release');
-        const m = transition(`n_${from}`, 'refresh-launch');
-        assert.equal(m.status, 'active', `refresh-launch from ${from}`);
-        assert.equal(m.intent, 'refresh', `refresh-launch from ${from} preserves refresh authority`);
-    }
-});
-// revive → active + intent cleared, legal from ANY status (the universal "back")
-test('revive: any status → active + intent cleared', () => {
-    for (const from of ALL) {
-        mk(`n_${from}`, from, 'idle-release');
-        const m = transition(`n_${from}`, 'revive');
-        assert.equal(m.status, 'active', `revive from ${from}`);
-        assert.equal(m.intent, null, `revive from ${from} clears intent`);
-    }
-});
-// unknown node → throws for every event
-test('transition on an unknown node throws', () => {
-    for (const ev of ['finish', 'park', 'cancel', 'crash', 'yield', 'release', 'refresh-launch', 'revive']) {
-        assert.throws(() => transition('ghost', ev), /unknown node/);
-    }
-});

package/dist/core/__tests__/live-lifecycle-prompt.test.d.ts

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

package/dist/core/__tests__/live-lifecycle-prompt.test.js

@@ -1,63 +0,0 @@
-// Regression for #244: the document corpus is session-cached, but the gate
-// subject must follow a live node lifecycle change in that same session.
-import { after, before, beforeEach, test } 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, updateNode } from '../canvas/canvas.js';
-import { closeDb, migrate, openDb } from '../canvas/db.js';
-import { ensureScopeInitialized } from '../config.js';
-import { closeScopedStores } from '../scoped-state/db.js';
-import { renderPreferencesSection } from '../substrate/render-node.js';
-import { clearSessionCache } from '../substrate/session-cache.js';
-let home;
-let priorUserHome;
-function node(id) {
-    return {
-        node_id: id,
-        name: id,
-        created: new Date().toISOString(),
-        cwd: process.cwd(),
-        kind: 'general',
-        mode: 'base',
-        lifecycle: 'resident',
-        status: 'active',
-    };
-}
-before(() => {
-    home = mkdtempSync(join(tmpdir(), 'crtr-live-lifecycle-prompt-'));
-    priorUserHome = process.env['HOME'];
-    process.env['HOME'] = home;
-    process.env['CRTR_HOME'] = home;
-});
-beforeEach(() => {
-    closeDb();
-    clearSessionCache();
-    rmSync(home, { recursive: true, force: true });
-    ensureScopeInitialized('user', join(home, '.crouter'));
-    migrate(openDb());
-});
-after(() => {
-    closeDb();
-    clearSessionCache();
-    closeScopedStores();
-    rmSync(home, { recursive: true, force: true });
-    delete process.env['CRTR_HOME'];
-    if (priorUserHome === undefined)
-        delete process.env['HOME'];
-    else
-        process.env['HOME'] = priorUserHome;
-});
-test('a cached resident prompt becomes terminal after a live lifecycle change', () => {
-    createNode(node('live'));
-    const resident = renderPreferencesSection('live');
-    assert.match(resident, /You are \*\*resident\*\* and interactable/);
-    assert.match(resident, /Do \*\*not\*\* `crtr push final`/);
-    updateNode('live', { lifecycle: 'terminal' });
-    const terminal = renderPreferencesSection('live');
-    assert.match(terminal, /You are \*\*terminal\*\*: you owe a final result/);
-    assert.match(terminal, /crtr push final/);
-    assert.doesNotMatch(terminal, /You are \*\*resident\*\* and interactable/);
-    assert.doesNotMatch(terminal, /Do \*\*not\*\* `crtr push final`/);
-});

package/dist/core/__tests__/memory-resolver-precedence.test.d.ts

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