@north-light/crouter 0.3.318 → 0.3.319

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

@@ -1,184 +0,0 @@
-// Run with: node --conditions=crtr-src --import tsx/esm --test src/core/__tests__/revive-capacity.test.ts
-//
-// The broker cap is a real admission gate, and `reviveNode` is where every
-// launcher meets it. A caller declares what it wants when the ledger is full —
-// `freeze` (its reason to run survives waiting) or `refuse` (it needs an engine
-// now) — and this file pins the whole disposition matrix: the refusal names the
-// cap and the live count instead of failing silently, the freeze marks the row
-// once per episode without touching its session identity, an already-live node
-// is admitted at the cap because it consumes no new slot, and the launch that
-// finally happens retires the mark.
-import { test, before, beforeEach, after } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdirSync, mkdtempSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { createNode, getNode } from '../canvas/canvas.js';
-import { jobDir } from '../canvas/paths.js';
-import { closeDb, migrate, openDb } from '../canvas/db.js';
-import { resetSession } from '../canvas/sessions.js';
-import { resetScopeCache } from '../scope.js';
-import { closeScopedStores } from '../scoped-state/db.js';
-import { initializeFreshScopedStore } from '../scoped-state/migrate.js';
-import { bindDaemonEventSource, resetEventSourceForTests } from '../events/source.js';
-import { resetFleetForTests } from '../runtime/fleet.js';
-import { CANVAS_EXTENSIONS } from '../runtime/canvas-extensions.js';
-import { headlessBrokerHost } from '../runtime/host.js';
-import { reviveNode } from '../runtime/revive.js';
-import { deliverNodeMessage } from '../../daemon/messaging/node-message.js';
-import { bindTestFleet } from './helpers/fleet.js';
-let home;
-let tf;
-const previousHome = process.env['HOME'];
-let seq = 0;
-const originalLaunch = headlessBrokerHost.launch;
-/** The real host contract, minus the process: register at the launch seam, so
- *  the ledger consumes the reservation exactly as production does. */
-function stubLaunch() {
-    headlessBrokerHost.launch = (nodeId) => {
-        const handle = { pid: 500_000 + seq++, exited: new Promise(() => { }) };
-        tf.fleet.register(nodeId, handle);
-        return handle;
-    };
-}
-function node(id, over = {}) {
-    const meta = {
-        node_id: id,
-        name: id,
-        created: new Date().toISOString(),
-        cwd: home,
-        kind: 'developer',
-        mode: 'base',
-        lifecycle: 'terminal',
-        status: 'active',
-        host_kind: 'broker',
-        ...over,
-    };
-    createNode(meta);
-    if (meta.pi_session_id != null) {
-        resetSession(id, { sessionId: meta.pi_session_id, transcriptPath: meta.pi_session_file ?? null });
-    }
-    return id;
-}
-/** Fill the ledger to the cap with live brokers. */
-async function saturate() {
-    await reviveNode(node(`filler-a-${seq}`), { resume: false, capacity: 'refuse' });
-    await reviveNode(node(`filler-b-${seq}`), { resume: false, capacity: 'refuse' });
-    assert.equal(tf.fleet.size(), 2, 'precondition: the ledger is at its cap of 2');
-}
-before(() => {
-    home = mkdtempSync(join(tmpdir(), 'crtr-revive-capacity-'));
-    process.env['HOME'] = home;
-    process.env['CRTR_HOME'] = join(home, 'canvas');
-    process.env['CRTR_MAX_LIVE_BROKERS'] = '2';
-    resetEventSourceForTests();
-    bindDaemonEventSource();
-});
-beforeEach(() => {
-    closeDb();
-    closeScopedStores();
-    rmSync(home, { recursive: true, force: true });
-    resetScopeCache();
-    initializeFreshScopedStore({ kind: 'user', root: join(home, '.crouter') });
-    migrate(openDb());
-    tf = bindTestFleet();
-    stubLaunch();
-});
-after(() => {
-    headlessBrokerHost.launch = originalLaunch;
-    tf.fleet.dispose();
-    resetFleetForTests();
-    resetEventSourceForTests();
-    closeDb();
-    closeScopedStores();
-    delete process.env['CRTR_MAX_LIVE_BROKERS'];
-    delete process.env['CRTR_HOME'];
-    if (previousHome === undefined)
-        delete process.env['HOME'];
-    else
-        process.env['HOME'] = previousHome;
-    rmSync(home, { recursive: true, force: true });
-    resetScopeCache();
-});
-test('a refusing caller gets an error naming the cap and the live count, never a silent no-op', async () => {
-    await saturate();
-    const turned = node('refused', { pi_session_id: 'sess-refused' });
-    await assert.rejects(() => reviveNode(turned, { resume: true, capacity: 'refuse' }), (err) => {
-        const details = err.details ?? {};
-        assert.equal(details['error'], 'broker_cap_reached', 'the refusal is a typed InputError, so it survives the /v1 error body');
-        assert.match(String(details['message']), /2 live brokers at the cap of 2/, 'the message names both the live count and the cap');
-        return true;
-    });
-    const meta = getNode(turned);
-    assert.equal(meta.frozen_at ?? null, null, 'a refusal is not a freeze — nothing waits for this row');
-    assert.equal(meta.pi_session_id, 'sess-refused', 'the refusal happens before any mutation of the session identity');
-    assert.equal(meta.cycles ?? 0, 0, 'a node turned away never spent a cycle');
-});
-test('a pre-spawn launch failure releases the reservation', () => {
-    const id = node('pre-spawn-failure');
-    mkdirSync(join(jobDir(id), 'broker.log'));
-    headlessBrokerHost.launch = originalLaunch;
-    try {
-        assert.throws(() => headlessBrokerHost.launch(id, {
-            argv: CANVAS_EXTENSIONS.flatMap((path) => ['-e', path]),
-            env: {},
-        }, { cwd: home, name: id, resuming: false }), /EISDIR/);
-        assert.equal(tf.fleet.occupancy(), 0, 'the failed launch leaves no slot reserved');
-        assert.equal(tf.fleet.reserveSlot(id), true, 'the same node can claim the released slot immediately');
-        tf.fleet.releaseReservation(id);
-        assert.equal(tf.fleet.occupancy(), 0);
-    }
-    finally {
-        stubLaunch();
-    }
-});
-test('a freezing caller gets a frozen row, marked once and left otherwise untouched', async () => {
-    await saturate();
-    const waiting = node('frozen', { pi_session_id: 'sess-frozen' });
-    const first = await reviveNode(waiting, { resume: true, capacity: 'freeze' });
-    assert.equal(first.outcome, 'frozen', 'the caller learns it got no engine');
-    const marked = getNode(waiting);
-    assert.ok(marked.frozen_at != null, 'the row carries the durable wait mark the thaw order reads');
-    assert.equal(marked.pi_pid ?? null, null, 'a frozen row holds no pid — every status surface reads it as frozen, not stale-active');
-    assert.equal(marked.cycles ?? 0, 0, 'a frozen node never spent a cycle');
-    const second = await reviveNode(waiting, { resume: true, capacity: 'freeze' });
-    assert.equal(second.outcome, 'frozen');
-    assert.equal(getNode(waiting).frozen_at, marked.frozen_at, 'freezing is once-per-episode: a second saturated tick keeps the original wait timestamp');
-});
-test('a durable daemon message reports capacity_frozen when its wake cannot launch', async () => {
-    await saturate();
-    const waiting = node('message-frozen');
-    const delivery = await deliverNodeMessage({
-        node_id: waiting,
-        body: 'capacity-delayed notice',
-        label: 'notice',
-        mode: 'wake',
-    });
-    assert.equal(delivery.via, 'inbox');
-    assert.ok(delivery.entry_id !== null, 'the message stays durable while the broker waits');
-    assert.equal(delivery.revived, false);
-    assert.equal(delivery.reason, 'capacity_frozen');
-});
-test('an already-live node is admitted at the cap — it consumes no new slot', async () => {
-    const live = node('already-live');
-    await reviveNode(live, { resume: false, capacity: 'refuse' });
-    await reviveNode(node('already-live-filler'), { resume: false, capacity: 'refuse' });
-    assert.equal(tf.fleet.size(), 2, 'precondition: this node holds one of the two slots, and the ledger is full');
-    // Both dispositions agree: liveness is answered before capacity ever is.
-    assert.equal((await reviveNode(live, { resume: true, capacity: 'refuse' })).outcome, 'already-live');
-    assert.equal((await reviveNode(live, { resume: true, capacity: 'freeze' })).outcome, 'already-live');
-    assert.equal(getNode(live).frozen_at ?? null, null, 'a live node is never marked as waiting for a slot');
-});
-test('a freed slot lets the frozen row launch, and the launch retires the mark', async () => {
-    const filler = node('filler-exits');
-    await reviveNode(filler, { resume: false, capacity: 'refuse' });
-    await reviveNode(node('filler-stays'), { resume: false, capacity: 'refuse' });
-    const waiting = node('thaws', { pi_session_id: 'sess-thaws' });
-    assert.equal((await reviveNode(waiting, { resume: true, capacity: 'freeze' })).outcome, 'frozen');
-    // A real exit frees the slot; its policy job runs on the lane like production.
-    tf.fleet.deliverExit(filler, { code: 0, signal: null });
-    await tf.drain();
-    assert.equal((await reviveNode(waiting, { resume: true, capacity: 'freeze' })).outcome, 'launched');
-    assert.equal(getNode(waiting).frozen_at ?? null, null, 'a launch is the definition of not-frozen');
-    assert.equal(tf.fleet.has(waiting), true, 'the thawed node owns the freed slot');
-});

package/dist/core/__tests__/revive-parked-fresh.test.d.ts

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

package/dist/core/__tests__/revive-parked-fresh.test.js

@@ -1,176 +0,0 @@
-// Run with: node --conditions=crtr-src --import tsx/esm --test src/core/__tests__/revive-parked-fresh.test.ts
-//
-// Re-entering a parked node resumes its main transcript: the isolated parking
-// turn never wrote to it. Wake-worthy mail remains durable for the inbox watcher
-// to deliver after boot; it does not create a fresh-cycle kickoff. An input-less
-// revival likewise resumes quietly. The rule is a property of the node,
-// evaluated once inside reviveNode, so every doorway gets it uniformly.
-import { after, afterEach, before, beforeEach, test } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { createNode, getNode } from '../canvas/canvas.js';
-import { ensureScopeInitialized } from '../config.js';
-import { closeScopedStores } from '../scoped-state/db.js';
-import { contextDir } from '../canvas/paths.js';
-import { closeDb, migrate, openDb } from '../canvas/db.js';
-import { enqueueNodeMail } from '../feed/messages.js';
-import { acknowledgeNodeMail, acknowledgedNodeMailCount, claimNodeMail } from '../canvas/deliveries.js';
-import { beginExecution, endExecution } from '../canvas/executions.js';
-import { bindSession } from '../canvas/sessions.js';
-import { transition } from '../runtime/lifecycle.js';
-import { reviveNode } from '../runtime/revive.js';
-import { headlessBrokerHost } from '../runtime/host.js';
-import { resetFleetForTests } from '../runtime/fleet.js';
-import { bindTestFleet } from './helpers/fleet.js';
-let home;
-let priorHome;
-let priorUserHome;
-let fleet;
-let launches;
-let originalLaunch;
-/** A parked resident with a real `.jsonl` on disk, so the choice between
- *  resuming that transcript and cycling it is genuinely open. */
-function parkResident(id, ground = {}) {
-    const sessionFile = join(home, `${id}.jsonl`);
-    writeFileSync(sessionFile, '{}\n');
-    const meta = {
-        node_id: id,
-        name: id,
-        created: new Date().toISOString(),
-        cwd: home,
-        kind: 'general',
-        mode: 'base',
-        lifecycle: 'resident',
-        status: 'active',
-        pi_session_id: `${id}-session`,
-        pi_session_file: sessionFile,
-    };
-    createNode(meta);
-    const executionId = beginExecution(id, { daemonEpoch: 'test' });
-    assert.equal(bindSession(id, { executionId, sessionId: meta.pi_session_id, transcriptPath: sessionFile }), 'bound');
-    endExecution(executionId, { reason: 'parked test setup' });
-    mkdirSync(contextDir(id), { recursive: true });
-    if (ground.roadmap !== undefined)
-        writeFileSync(join(contextDir(id), 'roadmap.md'), ground.roadmap);
-    if (ground.goal !== undefined)
-        writeFileSync(join(contextDir(id), 'initial-prompt.md'), ground.goal);
-    transition(id, 'park');
-}
-/** Durable wake-worthy mail, appended exactly as every message doorway appends
- *  it before calling reviveNode. */
-function deliverMail(id, tier = 'normal') {
-    return enqueueNodeMail(id, { kind: 'message', label: 'work', bodyJson: { body: 'work' }, urgency: tier, wake: 1 });
-}
-/** Did this launch carry the fresh-revive kickoff? `buildReviveKickoff` always
- *  opens its card body with this sentence (src/core/runtime/kickoff.ts:325). */
-function kickedOff(entry) {
-    return entry.argv.some((arg) => arg.includes('You have been revived fresh'));
-}
-/** The two facts every row below asserts together: a fresh row is
- *  `resuming:false` + kickoff, a quiet row is `resuming:true` + none. */
-function placements() {
-    return launches.map(({ nodeId, resuming }) => ({ nodeId, resuming }));
-}
-before(() => {
-    home = mkdtempSync(join(tmpdir(), 'crtr-revive-parked-'));
-    priorHome = process.env['CRTR_HOME'];
-    priorUserHome = process.env['HOME'];
-    process.env['CRTR_HOME'] = home;
-    process.env['HOME'] = home;
-});
-beforeEach(() => {
-    closeDb();
-    rmSync(home, { recursive: true, force: true });
-    mkdirSync(home, { recursive: true });
-    ensureScopeInitialized('user', join(home, '.crouter'));
-    migrate(openDb());
-    resetFleetForTests();
-    fleet = bindTestFleet();
-    launches = [];
-    originalLaunch = headlessBrokerHost.launch;
-    headlessBrokerHost.launch = ((nodeId, inv, opts) => {
-        launches.push({ nodeId, resuming: opts.resuming, argv: inv.argv });
-        const handle = { pid: 0x7ffffffe, exited: new Promise(() => { }) };
-        fleet.fleet.register(nodeId, handle);
-        return handle;
-    });
-});
-afterEach(() => {
-    headlessBrokerHost.launch = originalLaunch;
-    closeDb();
-    closeScopedStores();
-    resetFleetForTests();
-});
-after(() => {
-    rmSync(home, { recursive: true, force: true });
-    if (priorHome === undefined)
-        delete process.env['CRTR_HOME'];
-    else
-        process.env['CRTR_HOME'] = priorHome;
-    if (priorUserHome === undefined)
-        delete process.env['HOME'];
-    else
-        process.env['HOME'] = priorUserHome;
-});
-test('a parked node with mail waiting resumes its main transcript and clears the marker', async () => {
-    parkResident('parked', { roadmap: '# Roadmap\n\n- one open item\n' });
-    deliverMail('parked');
-    const result = await reviveNode('parked', { resume: true, capacity: 'freeze' });
-    assert.equal(result.resumed, true, 'the isolated parking turn never concluded the main transcript');
-    assert.deepEqual(placements(), [{ nodeId: 'parked', resuming: true }]);
-    assert.equal(kickedOff(launches[0]), false, 'the inbox watcher delivers the mail after the resumed boot');
-    const reopened = getNode('parked');
-    assert.equal(reopened.status, 'active');
-    assert.equal(reopened.intent ?? null, null, 'the park marker clears on revival');
-    assert.equal(reopened.cycle_pending, false, 'a strict resume does not open a new cycle');
-});
-test('a parked node grounded only by a goal still resumes when mail rides the revive', async () => {
-    parkResident('goal-only', { goal: 'Watch the deploy lane.' });
-    deliverMail('goal-only');
-    assert.equal((await reviveNode('goal-only', { resume: true, capacity: 'freeze' })).resumed, true);
-    assert.equal(kickedOff(launches[0]), false);
-});
-test('an input-less revival of a parked node quietly resumes and injects no kickoff', async () => {
-    parkResident('quiet', { roadmap: '# Roadmap\n\n- one open item\n' });
-    const result = await reviveNode('quiet', { resume: true, capacity: 'freeze' });
-    assert.equal(result.resumed, true, 'nothing arrived, so there is nothing a fresh window would answer');
-    assert.deepEqual(placements(), [{ nodeId: 'quiet', resuming: true }]);
-    assert.equal(kickedOff(launches[0]), false, 'a quiet resume generates nothing');
-    assert.equal(acknowledgedNodeMailCount('quiet'), 0, 'a quiet resume does not acknowledge mail');
-    const reopened = getNode('quiet');
-    assert.equal(reopened.status, 'active');
-    assert.equal(reopened.intent ?? null, null, 'the park marker clears on a quiet resume too');
-});
-test('deferred mail alone is not input, so the revival still resumes quietly', async () => {
-    parkResident('deferred', { roadmap: '# Roadmap\n\n- one open item\n' });
-    deliverMail('deferred', 'deferred');
-    assert.equal((await reviveNode('deferred', { resume: true, capacity: 'freeze' })).resumed, true);
-    assert.equal(kickedOff(launches[0]), false);
-    assert.equal(acknowledgedNodeMailCount('deferred'), 0, 'the deferred delivery rides the next natural cycle, unacknowledged');
-});
-test('mail already acknowledged by an earlier execution is not input, so the revival still resumes quietly', async () => {
-    parkResident('stale', { roadmap: '# Roadmap\n\n- one open item\n' });
-    const delivery = deliverMail('stale');
-    const executionId = beginExecution('stale', { daemonEpoch: 'test' });
-    const claim = claimNodeMail('stale', executionId, 'wake');
-    assert.equal(claim.deliveries.length, 1, 'the earlier execution claims the delivery');
-    assert.deepEqual(acknowledgeNodeMail('stale', executionId, [{ deliveryId: delivery.deliveryId, attempts: claim.deliveries[0].attempts, disposition: 'acknowledged' }]).results, [{ deliveryId: delivery.deliveryId, outcome: 'acknowledged' }], 'the prior handoff has an explicit SQL acknowledgement');
-    endExecution(executionId, { reason: 'test complete' });
-    assert.equal((await reviveNode('stale', { resume: true, capacity: 'freeze' })).resumed, true, 'only pending wake deliveries count as input');
-    assert.equal(kickedOff(launches[0]), false);
-});
-test('a parked node with no goal and no roadmap resumes its transcript rather than waking amnesiac', async () => {
-    parkResident('bare');
-    deliverMail('bare');
-    const result = await reviveNode('bare', { resume: true, capacity: 'freeze' });
-    assert.equal(result.resumed, true, 'the degraded park has nothing on disk to ground a fresh window');
-    assert.deepEqual(placements(), [{ nodeId: 'bare', resuming: true }]);
-});
-test('an ordinary done node with a roadmap still resumes — only the park marker vetoes', async () => {
-    parkResident('finished', { roadmap: '# Roadmap\n\n- one open item\n' });
-    transition('finished', 'revive');
-    transition('finished', 'finish');
-    assert.equal((await reviveNode('finished', { resume: true, capacity: 'freeze' })).resumed, true);
-});

package/dist/core/__tests__/scope-crouter-home-fence.test.d.ts

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

package/dist/core/__tests__/scope-crouter-home-fence.test.js

@@ -1,55 +0,0 @@
-// The scope ancestor walk (`collectAncestorScopeRoots` → `findProjectScopeRoots`)
-// must never climb at or above `homedir()`. When HOME is relocated and nested
-// under a directory tree that itself contains a `.crouter/` (a mock-VM home
-// under the real host home, or any relocated-HOME sandbox), the unfenced walk
-// climbs ABOVE homedir() and sweeps in the above-HOME `.crouter` as a bogus
-// "project ancestor" — leaking that host's entire user-global memory store into
-// every nested-HOME node's assembled knowledge/preference catalog. This test
-// pins the fence: an ancestor `.crouter/` sitting ABOVE the relocated HOME must
-// NOT be collected as a project scope root, while a legitimate project
-// `.crouter/` BETWEEN the cwd and HOME still is.
-//
-// Mirrors src/core/__tests__/on-read-crouter-home-fence.test.ts.
-//
-// Run: node --import tsx/esm --test src/core/__tests__/scope-crouter-home-fence.test.ts
-import { test, before, beforeEach, after } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, mkdirSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { findProjectScopeRoots, resetScopeCache } from '../scope.js';
-let sandbox;
-let prevHomeEnv;
-before(() => {
-    prevHomeEnv = process.env['HOME'];
-});
-beforeEach(() => {
-    resetScopeCache();
-    // A sandbox that CONTAINS the relocated HOME, so the ancestor walk from a cwd
-    // under HOME can (without the fence) climb above HOME into the sandbox.
-    sandbox = mkdtempSync(join(tmpdir(), 'crtr-scope-fence-'));
-});
-after(() => {
-    resetScopeCache();
-    rmSync(sandbox, { recursive: true, force: true });
-    if (prevHomeEnv === undefined)
-        delete process.env['HOME'];
-    else
-        process.env['HOME'] = prevHomeEnv;
-});
-test('an ancestor .crouter ABOVE a relocated HOME is not collected as a project scope root', () => {
-    // Simulated host user-global store, sitting ABOVE the relocated home.
-    const hostUserRoot = join(sandbox, '.crouter');
-    mkdirSync(join(hostUserRoot, 'memory'), { recursive: true });
-    // The relocated HOME, nested one level under the sandbox.
-    const home = join(sandbox, 'vm-home');
-    process.env['HOME'] = home;
-    // A legitimate project `.crouter/` between the node cwd and HOME.
-    const projectDir = join(home, 'work', 'proj');
-    const projectRoot = join(projectDir, '.crouter');
-    mkdirSync(join(projectRoot, 'memory'), { recursive: true });
-    resetScopeCache();
-    const roots = findProjectScopeRoots(projectDir, null);
-    assert.ok(!roots.includes(hostUserRoot), `above-HOME .crouter must NOT be collected as a project ancestor; got: ${JSON.stringify(roots)}`);
-    assert.ok(roots.includes(projectRoot), `legitimate project .crouter between cwd and HOME must still be collected; got: ${JSON.stringify(roots)}`);
-});

package/dist/core/__tests__/seam/broker-attach-multiclient.test.d.ts

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