@north-light/crouter 0.3.318 → 0.3.320

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

@@ -1,89 +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, getRow, isCollectible, setFrozen, transitionStatusIntent, } from '../canvas/canvas.js';
-import { closeDb, migrate, openDb } from '../canvas/db.js';
-let home;
-function node(id, over = {}) {
-    return {
-        node_id: id,
-        name: id,
-        created: new Date().toISOString(),
-        cwd: '/tmp/work',
-        kind: 'general',
-        mode: 'base',
-        lifecycle: 'terminal',
-        status: 'active',
-        ...over,
-    };
-}
-function terminalRow(id, reason, status = 'done') {
-    createNode(node(id));
-    transitionStatusIntent(id, { status, terminal_reason: reason });
-    return getRow(id);
-}
-before(() => {
-    home = mkdtempSync(join(tmpdir(), 'crtr-collectible-'));
-    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('isCollectible applies the terminal reason truth table and absolute retains', () => {
-    const terminalCases = [
-        ['finalized', 'done', true, true],
-        ['finished', 'done', true, true],
-        ['parked', 'done', true, true],
-        ['closed', 'dead', true, true],
-        ['retired', 'canceled', true, true],
-        ['crashed', 'dead', false, true],
-        ['stranded', 'canceled', false, true],
-        [null, 'done', false, true],
-    ];
-    for (const [reason, status, beforeTtl, pastTtl] of terminalCases) {
-        const row = terminalRow(`reason-${reason ?? 'null'}`, reason, status);
-        assert.equal(isCollectible(row), beforeTtl, `${reason ?? 'null'} before TTL`);
-        assert.equal(isCollectible(row, { pastTtl: true }), pastTtl, `${reason ?? 'null'} past TTL`);
-    }
-    const frozen = terminalRow('frozen', 'closed');
-    setFrozen(frozen.node_id, new Date().toISOString());
-    createNode(node('worktree', {
-        managed_worktree: {
-            state: 'open',
-            path: '/tmp/worktree',
-            branch: 'crtr/worktree',
-            repo_root: '/tmp/repo',
-            base_ref: 'main',
-            base_sha: 'base',
-            created: new Date().toISOString(),
-        },
-    }));
-    transitionStatusIntent('worktree', { status: 'done', terminal_reason: 'closed' });
-    const caller = terminalRow('caller', 'closed');
-    createNode(node('active'));
-    const nonTerminal = getRow('active');
-    const absoluteRows = [getRow(frozen.node_id), getRow('worktree'), caller, nonTerminal];
-    const previousNodeId = process.env['CRTR_NODE_ID'];
-    process.env['CRTR_NODE_ID'] = 'caller';
-    try {
-        for (const row of absoluteRows) {
-            assert.equal(isCollectible(row), false, `${row.node_id} before TTL`);
-            assert.equal(isCollectible(row, { pastTtl: true }), false, `${row.node_id} past TTL`);
-        }
-    }
-    finally {
-        if (previousNodeId === undefined)
-            delete process.env['CRTR_NODE_ID'];
-        else
-            process.env['CRTR_NODE_ID'] = previousNodeId;
-    }
-});

package/dist/core/__tests__/config-change-delta.test.d.ts

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

package/dist/core/__tests__/config-change-delta.test.js

@@ -1,108 +0,0 @@
-// A node whose kind/mode/lifecycle changes mid-context gets only memory newly
-// visible or raised above the context's active exposure ranks. Removals stay
-// silent because already loaded context cannot be unseen.
-//
-// The load-bearing case is the gated orchestration kernel: a base → orchestrator
-// change must select its real builtin document through the ordinary renderer.
-//
-// Run: node --conditions=crtr-src --import tsx/esm --test src/core/__tests__/config-change-delta.test.ts
-import { test, before, after } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, mkdirSync, realpathSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { ensureScopeInitialized } from '../config.js';
-import { resetScopeCache } from '../scope.js';
-import { clearSessionCache } from '../substrate/session-cache.js';
-import { renderConfigChangeDelta, renderKnowledgeForSubject, renderPreferencesForSubject, } from '../substrate/render.js';
-import { emptyContextExposureState, exposureTarget, } from '../substrate/injected-store.js';
-const NODE = 'n-delta-test';
-const DEV_PREFERENCE = 'BODY-DELTA-DEV-PREFERENCE';
-const DEV_KNOWLEDGE_WHEN = 'When the developer-only guide is routed';
-const KERNEL_MARKER = '## You are an orchestrator';
-let home;
-let work;
-let prevHome;
-let prevCanvasHome;
-let prevProfile;
-let prevCwd;
-function subject(over = {}) {
-    return {
-        kind: 'general',
-        mode: 'base',
-        lifecycle: 'terminal',
-        hasManager: true,
-        cwd: work,
-        scope: 'user',
-        orchestration: { depth: 1 },
-        profile: null,
-        ...over,
-    };
-}
-/** Everything the node's boot channels render for `s` — the baseline every
- *  later delta is diffed against. */
-function seedBoot(state, s) {
-    renderPreferencesForSubject(s, exposureTarget(state, 'system'));
-    renderKnowledgeForSubject(s, NODE, exposureTarget(state, 'transcript'));
-}
-before(() => {
-    prevHome = process.env['HOME'];
-    prevCanvasHome = process.env['CRTR_HOME'];
-    prevProfile = process.env['CRTR_PROFILE_ID'];
-    prevCwd = process.cwd();
-    home = realpathSync(mkdtempSync(join(tmpdir(), 'crtr-delta-home-')));
-    work = realpathSync(mkdtempSync(join(tmpdir(), 'crtr-delta-work-')));
-    process.env['HOME'] = home;
-    process.env['CRTR_HOME'] = realpathSync(mkdtempSync(join(tmpdir(), 'crtr-delta-canvas-')));
-    delete process.env['CRTR_PROFILE_ID'];
-    const user = join(home, '.crouter', 'memory');
-    mkdirSync(user, { recursive: true });
-    writeFileSync(join(user, 'delta-dev-preference.md'), ['---', 'kind: preference', 'gate: {kind: developer}', 'surfaces:', '  - {on: boot, at: content}', '---', '', DEV_PREFERENCE, ''].join('\n'));
-    writeFileSync(join(user, 'delta-dev-knowledge.md'), ['---', 'kind: knowledge', `when-and-why-to-read: "${DEV_KNOWLEDGE_WHEN}"`, 'gate: {kind: developer}', 'surfaces:', '  - {on: boot, at: preview}', '---', '', 'ignored body', ''].join('\n'));
-    process.chdir(work);
-    resetScopeCache();
-    ensureScopeInitialized('user', join(home, '.crouter'));
-    clearSessionCache();
-});
-after(() => {
-    process.chdir(prevCwd);
-    resetScopeCache();
-    rmSync(home, { recursive: true, force: true });
-    rmSync(work, { recursive: true, force: true });
-    rmSync(process.env['CRTR_HOME'], { recursive: true, force: true });
-    if (prevHome === undefined)
-        delete process.env['HOME'];
-    else
-        process.env['HOME'] = prevHome;
-    if (prevCanvasHome === undefined)
-        delete process.env['CRTR_HOME'];
-    else
-        process.env['CRTR_HOME'] = prevCanvasHome;
-    if (prevProfile !== undefined)
-        process.env['CRTR_PROFILE_ID'] = prevProfile;
-});
-test('a config change delivers only what the new configuration newly exposes', () => {
-    const state = emptyContextExposureState();
-    const transcript = exposureTarget(state, 'transcript');
-    const base = subject();
-    seedBoot(state, base);
-    assert.equal(renderConfigChangeDelta(base, NODE, transcript), '', 'no change → nothing to deliver; boot already showed this configuration');
-    // base → orchestrator: the builtin orchestration kernel is gated
-    // `{mode: orchestrator}`, so this transition is what unlocks it.
-    const promoted = subject({ mode: 'orchestrator' });
-    const promoteDelta = renderConfigChangeDelta(promoted, NODE, transcript);
-    assert.ok(promoteDelta.includes(KERNEL_MARKER), 'the promote delta carries the builtin orchestration kernel');
-    assert.ok(!promoteDelta.includes('Waiting is a way to end a turn'), 'a doc boot already delivered is not repeated');
-    assert.equal(renderConfigChangeDelta(promoted, NODE, transcript), '', 'the same change twice delivers nothing the second time');
-    // kind flip: a content-rung preference and a preview-rung knowledge doc, each
-    // gated on the new kind, in their own blocks.
-    const developer = subject({ mode: 'orchestrator', kind: 'developer' });
-    const kindDelta = renderConfigChangeDelta(developer, NODE, transcript);
-    assert.ok(kindDelta.includes(DEV_PREFERENCE), 'the newly-eligible preference body is delivered');
-    assert.ok(kindDelta.includes('<memory kind="preference">'), 'agent-editable preferences ride a preference block');
-    assert.ok(kindDelta.includes(`delta-dev-knowledge  # read when: ${DEV_KNOWLEDGE_WHEN}`), 'the newly-eligible knowledge doc is routed at its preview rung');
-    assert.ok(kindDelta.includes('<memory kind="knowledge">'), 'knowledge rides its own block');
-    assert.ok(!kindDelta.includes(KERNEL_MARKER), 'the kernel is not re-delivered — the promote already showed it');
-    // Removals are silent, and nothing already shown comes back.
-    assert.equal(renderConfigChangeDelta(subject({ mode: 'orchestrator' }), NODE, transcript), '', 'dropping back to the old kind announces nothing — the new prose overrides');
-});

package/dist/core/__tests__/context-intro.test.d.ts

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

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

@@ -1,123 +0,0 @@
-// Tests for the <crtr-bearings> preamble:
-//   1. Situational context rides the bearings as a sibling block, and only
-//      once something has been set.
-//   2. canvas-context-intro injects the block as its own session message at
-//      session_start (before the first prompt), idempotent across resumes, and
-//      inert without a node id.
-//
-// Run: node --import tsx/esm --test src/core/__tests__/context-intro.test.ts
-import { test, before, beforeEach, after, afterEach } from 'node:test';
-import assert from 'node:assert/strict';
-import { existsSync, mkdtempSync, mkdirSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { closeDb, migrate, openDb } from '../canvas/db.js';
-import { ensureScopeInitialized } from '../config.js';
-import { closeScopedStores } from '../scoped-state/db.js';
-import { apiSocketPath } from '../canvas/paths.js';
-import { spawnNode } from '../runtime/nodes.js';
-import { appendSituationalContext, formatSituationalProse, situationalContextEnvelope, } from '../runtime/situational-context.js';
-import registerCanvasContextIntro, { CONTEXT_INTRO_CUSTOM_TYPE, } from '../../pi-extensions/canvas-context-intro.js';
-import { buildContextBearings as buildContextIntro } from '../runtime/bearings.js';
-import { createApiServer } from '../../daemon/api/server.js';
-let home;
-let priorUserHome;
-let server;
-async function waitForSocket(path) {
-    for (let i = 0; i < 200; i++) {
-        if (existsSync(path))
-            return;
-        await new Promise((resolve) => setTimeout(resolve, 10));
-    }
-    throw new Error(`api socket never bound at ${path}`);
-}
-before(() => {
-    home = mkdtempSync(join(tmpdir(), 'crtr-ctxintro-'));
-    priorUserHome = process.env['HOME'];
-    process.env['HOME'] = home;
-    process.env['CRTR_HOME'] = home;
-});
-beforeEach(async () => {
-    closeDb();
-    rmSync(home, { recursive: true, force: true });
-    mkdirSync(home, { recursive: true });
-    ensureScopeInitialized('user', join(home, '.crouter'));
-    migrate(openDb());
-    server = createApiServer();
-    await waitForSocket(apiSocketPath());
-});
-afterEach(async () => {
-    await server.close();
-    closeScopedStores();
-});
-after(() => {
-    closeDb();
-    rmSync(home, { recursive: true, force: true });
-    delete process.env['CRTR_HOME'];
-    delete process.env['CRTR_NODE_ID'];
-    if (priorUserHome === undefined)
-        delete process.env['HOME'];
-    else
-        process.env['HOME'] = priorUserHome;
-});
-test('the stored situational card rides the bearings body; absent when unset', async () => {
-    const meta = await spawnNode({ kind: 'general', cwd: '/tmp/work', parent: null });
-    assert.equal(situationalContextEnvelope(meta.node_id), null, 'no card until something is set');
-    assert.doesNotMatch(buildContextIntro(meta.node_id), /kind="situational"/, 'bearings carry no card when unset');
-    appendSituationalContext(meta.node_id, formatSituationalProse('user is looking at the billing applet'));
-    const block = buildContextIntro(meta.node_id);
-    assert.match(block, /<runtime kind="situational">/, 'card present once situational context is set');
-    assert.match(block, /user is looking at the billing applet/, 'card carries the ambient text');
-});
-function makeFakePi(entries = []) {
-    return {
-        sent: [],
-        entries,
-        on(e, h) { if (e === 'session_start')
-            this.handler = h; },
-        sendMessage(m) {
-            this.sent.push(m);
-            this.entries.push({ type: 'custom_message', ...m });
-        },
-    };
-}
-function fakeCtx(pi) {
-    return { sessionManager: { getBranch: () => pi.entries } };
-}
-test('session_start injects the block as the first message of an empty session', async () => {
-    const meta = await spawnNode({ kind: 'general', cwd: '/tmp/work', parent: null });
-    process.env['CRTR_NODE_ID'] = meta.node_id;
-    const pi = makeFakePi();
-    registerCanvasContextIntro(pi);
-    assert.ok(pi.handler, 'session_start handler registered');
-    // Empty session → inject the block as its own custom message (no delivery
-    // options → it precedes the first prompt).
-    await pi.handler({ reason: 'startup' }, fakeCtx(pi));
-    assert.equal(pi.sent.length, 1, 'one message injected');
-    assert.equal(pi.sent[0].customType, CONTEXT_INTRO_CUSTOM_TYPE);
-    assert.equal(pi.sent[0].display, true);
-    assert.match(pi.sent[0].content, /<crtr-bearings>/);
-});
-test('session_start is idempotent across resume (skips if already in history)', async () => {
-    const meta = await spawnNode({ kind: 'general', cwd: '/tmp/work', parent: null });
-    process.env['CRTR_NODE_ID'] = meta.node_id;
-    // Restored session already carries OUR block (which names this node id) → no
-    // duplicate injection. The content matters: the guard is fork-aware and only
-    // skips when the present bearings name THIS node (a fork inherits the
-    // SOURCE's bearings, which name a different node — see canvas-context-intro
-    // tests), so a realistic resume entry must carry the real block content.
-    const entries = [
-        { type: 'custom_message', customType: CONTEXT_INTRO_CUSTOM_TYPE, content: buildContextIntro(meta.node_id) },
-    ];
-    const pi = makeFakePi(entries);
-    registerCanvasContextIntro(pi);
-    await pi.handler({ reason: 'resume' }, fakeCtx(pi));
-    assert.equal(pi.sent.length, 0, 'our own block already in history → skip');
-});
-test('session_start is inert when CRTR_NODE_ID is absent', async () => {
-    delete process.env['CRTR_NODE_ID'];
-    const pi = makeFakePi();
-    registerCanvasContextIntro(pi);
-    await pi.handler({ reason: 'startup' }, fakeCtx(pi));
-    assert.equal(pi.sent.length, 0);
-});

package/dist/core/__tests__/cron-armed-context-failure.test.d.ts

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

package/dist/core/__tests__/cron-armed-context-failure.test.js

@@ -1,150 +0,0 @@
-// Run with: npm test -- --test-name-pattern='armed'
-//
-// A cron run executes under the context it was ARMED under: the `--env`
-// snapshot and the profile stored on the row. When that stored context cannot
-// be rebuilt, the run must FAIL LOUDLY rather than execute the command under a
-// context nobody armed — the class of defect that otherwise runs wrong, every
-// tick, forever, with a clean run log.
-import { after, afterEach, before, beforeEach, test } from 'node:test';
-import assert from 'node:assert/strict';
-import { existsSync, mkdtempSync, mkdirSync, readFileSync, realpathSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { listNodes } from '../canvas/canvas.js';
-import { armCron, getCron, listCronRuns } from '../canvas/crons.js';
-import { closeDb, migrate, openDb } from '../canvas/db.js';
-import { ensureScopeInitialized } from '../config.js';
-import { closeScopedStores } from '../scoped-state/db.js';
-import { createProfile, deleteProfile, profileManifestPath } from '../profiles/manifest.js';
-import { resetScopeCache } from '../scope.js';
-import { headlessBrokerHost } from '../runtime/host.js';
-import { resetFleetForTests } from '../runtime/fleet.js';
-import { executeCron } from '../../daemon/cron-run.js';
-import { bindTestFleet } from './helpers/fleet.js';
-let userHome;
-let canvasHome;
-let priorHome;
-let priorCanvasHome;
-let fleet;
-let originalLaunch;
-/** The marker a run writes if the command actually executed. */
-function marker(id) {
-    return join(canvasHome, `${id}.ran`);
-}
-function arm({ cron_id, ...overrides }) {
-    armCron({
-        cron_id,
-        name: cron_id,
-        created_by: null,
-        // Records the profile the command actually ran under, so a root fallback is
-        // observable rather than inferred.
-        command: `printf "%s" "$CRTR_PROFILE_ID" > ${marker(cron_id)}`,
-        fire_at: new Date(Date.now() - 1_000).toISOString(),
-        recur: null, // a one-shot: retention is observable
-        tz: null,
-        expires_at: null,
-        anchor_node: null,
-        cancel_on_wake: false,
-        cwd: canvasHome,
-        env_json: null,
-        profile: null,
-        scope: 'profile',
-        run_timeout_s: 30,
-        overlap: 'skip',
-        on_output: 'on-failure',
-        sink: '{}',
-        tier: 'normal',
-        ...overrides,
-    });
-}
-before(() => {
-    // realpath: the profile store persists realpath-resolved paths, and macOS
-    // hands back a symlinked /var/folders prefix.
-    userHome = realpathSync(mkdtempSync(join(tmpdir(), 'crtr-cron-armed-user-')));
-    canvasHome = realpathSync(mkdtempSync(join(tmpdir(), 'crtr-cron-armed-canvas-')));
-    priorHome = process.env['HOME'];
-    priorCanvasHome = process.env['CRTR_HOME'];
-    process.env['HOME'] = userHome; // the profile store lives under the USER root
-    process.env['CRTR_HOME'] = canvasHome;
-    resetScopeCache();
-});
-beforeEach(() => {
-    closeDb();
-    rmSync(canvasHome, { recursive: true, force: true });
-    mkdirSync(canvasHome, { recursive: true });
-    resetFleetForTests();
-    fleet = bindTestFleet();
-    originalLaunch = headlessBrokerHost.launch;
-    headlessBrokerHost.launch = ((nodeId) => {
-        const handle = { pid: 0x7ffffffe, exited: new Promise(() => { }) };
-        fleet.fleet.register(nodeId, handle);
-        return handle;
-    });
-    ensureScopeInitialized('user', join(userHome, '.crouter'));
-    migrate(openDb());
-});
-afterEach(() => {
-    headlessBrokerHost.launch = originalLaunch;
-    closeDb();
-    closeScopedStores();
-    resetFleetForTests();
-});
-after(() => {
-    rmSync(canvasHome, { recursive: true, force: true });
-    rmSync(userHome, { recursive: true, force: true });
-    if (priorHome === undefined)
-        delete process.env['HOME'];
-    else
-        process.env['HOME'] = priorHome;
-    if (priorCanvasHome === undefined)
-        delete process.env['CRTR_HOME'];
-    else
-        process.env['CRTR_HOME'] = priorCanvasHome;
-    resetScopeCache();
-});
-/** Every way an armed context fails settles identically: no child, a record
- *  naming the cause, a paused row that keeps its one-shot, and one escalation
- *  node. */
-function assertSettledAsArmingFailure(id, record, cause, nodesBefore) {
-    assert.equal(existsSync(marker(id)), false, `${id}: the command never ran`);
-    assert.equal(record?.exit_code, null, `${id}: no process existed to exit`);
-    assert.match(record?.stderr_head ?? '', cause, `${id}: the record names the cause`);
-    assert.match(record?.delivered ?? '', /^failure: cron paused, escalation node /, `${id}: the failure is escalated`);
-    assert.equal(listNodes().length, nodesBefore + 1, `${id}: exactly one escalation node was created`);
-    const row = getCron(id);
-    assert.notEqual(row, null, `${id}: the one-shot is retained, not consumed`);
-    assert.equal(row.state, 'paused', `${id}: the row pauses, so it does not refire every tick`);
-    assert.equal(row.run_state, 'idle', `${id}: no lease was ever taken`);
-    assert.deepEqual(listCronRuns(id).map((r) => r.run_id), [record.run_id], `${id}: the failure left exactly one record`);
-}
-test('a corrupt armed env snapshot fails the run instead of silently dropping the operator variables', async () => {
-    // Both shapes the arm-time validator rejects, so neither can reach a row
-    // through the supported path: unparseable JSON, and a non-string value.
-    const corrupt = [
-        ['env-unparseable', '{"API_BASE": '],
-        ['env-nonstring', '{"API_BASE": 42}'],
-    ];
-    for (const [id, envJson] of corrupt) {
-        arm({ cron_id: id, env_json: envJson });
-        const nodesBefore = listNodes().length;
-        const record = await executeCron(getCron(id), { outOfBand: false });
-        assertSettledAsArmingFailure(id, record, /run could not be armed: the armed env snapshot/, nodesBefore);
-    }
-});
-test('a profile artifact is ignored while a deleted SQL profile runs as root', async () => {
-    const existing = createProfile('cron-existing').profileId;
-    const deleted = createProfile('cron-deleted').profileId;
-    // Profile identity is SQL-authoritative. The legacy artifact cannot change
-    // the context an already-armed run uses.
-    writeFileSync(profileManifestPath(existing), '{ not json', 'utf8');
-    arm({ cron_id: 'profile-existing', profile: existing });
-    const ranExisting = await executeCron(getCron('profile-existing'), { outOfBand: false });
-    assert.equal(ranExisting?.exit_code, 0, 'a corrupt profile artifact does not alter the SQL profile context');
-    assert.equal(readFileSync(marker('profile-existing'), 'utf8'), existing, 'the run retains the SQL-backed profile identity');
-    deleteProfile(deleted);
-    arm({ cron_id: 'profile-deleted', profile: deleted });
-    const ran = await executeCron(getCron('profile-deleted'), { outOfBand: false });
-    assert.equal(ran?.exit_code, 0, 'a deleted profile is the spec root fallback — the run proceeds');
-    assert.equal(readFileSync(marker('profile-deleted'), 'utf8'), '', 'the run carries no profile id: it ran as root');
-    assert.equal(getCron('profile-deleted'), null, 'an ordinary settled one-shot is consumed');
-});

package/dist/core/__tests__/cron-held-settlement.test.d.ts

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