@north-light/crouter 0.3.318 → 0.3.320

package/dist/core/__tests__/cron-held-settlement.test.js

@@ -1,240 +0,0 @@
-// Run with: node --import tsx/esm --test src/core/__tests__/cron-held-settlement.test.ts
-//
-// The owed-gate (exit 75) settlement branch: a scheduled run exiting
-// EX_TEMPFAIL declares "this occurrence is owed but not currently eligible."
-// The row is PARKED (held=1, occurrence not spent) instead of disposed — no
-// failure, no escalation, no delivery, no on-change hash, no one-shot
-// consumption — and a poke (`pokeHeldCrons`) re-dues every held active row
-// now. These pin the branch's truth table: the exact class of scheduling
-// defect that otherwise fails silently weeks later.
-import { after, afterEach, before, beforeEach, test } 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 { setTimeout as delay } from 'node:timers/promises';
-import { closeDb, migrate, openDb } from '../canvas/db.js';
-import { ensureScopeInitialized } from '../config.js';
-import { closeScopedStores } from '../scoped-state/db.js';
-import { armCron, cancelCron, getCron, listCronRuns, pokeHeldCrons, setCronState, } from '../canvas/crons.js';
-import { executeCron, runDueCrons } from '../../daemon/cron-run.js';
-const HELD_DELIVERED = 'deferred (exit 75) — held for poke';
-const HELD_FAR_FUTURE = '9999-12-31T23:59:59.999Z';
-let home;
-let realHome;
-let realUserHome;
-function arm(overrides) {
-    armCron({
-        name: overrides.cron_id,
-        created_by: null,
-        fire_at: new Date(Date.now() - 1_000).toISOString(),
-        recur: null,
-        tz: null,
-        expires_at: null,
-        anchor_node: null,
-        cancel_on_wake: false,
-        cwd: home,
-        env_json: null,
-        profile: null,
-        scope: 'profile',
-        run_timeout_s: 30,
-        overlap: 'skip',
-        on_output: 'silent',
-        sink: '{}',
-        tier: 'normal',
-        ...overrides,
-    });
-}
-before(() => {
-    home = mkdtempSync(join(tmpdir(), 'crtr-cron-held-'));
-    realHome = process.env['CRTR_HOME'];
-    realUserHome = process.env['HOME'];
-    process.env['HOME'] = home;
-    process.env['CRTR_HOME'] = home;
-});
-beforeEach(() => {
-    closeDb();
-    closeScopedStores();
-    rmSync(home, { recursive: true, force: true });
-    mkdirSync(home, { recursive: true });
-    ensureScopeInitialized('user', join(home, '.crouter'));
-    migrate(openDb());
-});
-afterEach(() => {
-    closeDb();
-    closeScopedStores();
-});
-after(() => {
-    closeDb();
-    rmSync(home, { recursive: true, force: true });
-    if (realHome === undefined)
-        delete process.env['CRTR_HOME'];
-    else
-        process.env['CRTR_HOME'] = realHome;
-    if (realUserHome === undefined)
-        delete process.env['HOME'];
-    else
-        process.env['HOME'] = realUserHome;
-});
-test('a recurring exit-75 run parks: held, backstop untouched, no disposition', async () => {
-    // on-change makes the skipped disposition observable: were the branch to
-    // fall through, a failed run would escalate (pause + node) and the hash
-    // bookkeeping would write last_output_hash.
-    arm({
-        cron_id: 'gate-recurring',
-        command: 'exit 75',
-        recur: JSON.stringify({ every: '1h' }),
-        on_output: 'on-change',
-    });
-    const settlements = runDueCrons(Date.now());
-    assert.equal(settlements.length, 1, 'the due gated run was admitted');
-    // The pre-run advance already wrote the natural next slot — the backstop.
-    const backstop = getCron('gate-recurring').fire_at;
-    await Promise.all(settlements);
-    const row = getCron('gate-recurring');
-    assert.equal(row.held, true);
-    assert.equal(row.fire_at, backstop, 'settlement must not touch the pre-advanced slot');
-    assert.equal(row.state, 'active', 'held is not a failure — no pause, no escalation');
-    assert.equal(row.run_state, 'idle');
-    assert.equal(row.last_output_hash, null, 'on-change bookkeeping is skipped for a held run');
-    const runs = listCronRuns('gate-recurring');
-    assert.equal(runs.length, 1);
-    assert.equal(runs[0].exit_code, 75);
-    assert.equal(runs[0].delivered, HELD_DELIVERED);
-    cancelCron('gate-recurring');
-});
-test('a held one-shot without expires is retained at the far-future backstop', async () => {
-    arm({ cron_id: 'gate-oneshot', command: 'exit 75' });
-    await Promise.all(runDueCrons(Date.now()));
-    const row = getCron('gate-oneshot');
-    assert.notEqual(row, null, 'the occurrence is not spent — the one-shot is not consumed');
-    assert.equal(row.held, true);
-    assert.equal(row.fire_at, HELD_FAR_FUTURE, 'poke-only: never due on the clock');
-    cancelCron('gate-oneshot');
-});
-test('a held one-shot with --expires waits at expiry, then is deleted unfired', async () => {
-    const expiresAt = new Date(Date.now() + 1_000).toISOString();
-    arm({ cron_id: 'gate-oneshot-expires', command: 'exit 75', expires_at: expiresAt });
-    await Promise.all(runDueCrons(Date.now()));
-    const row = getCron('gate-oneshot-expires');
-    assert.equal(row.held, true);
-    assert.equal(row.fire_at, expiresAt, 'expiry bounds the wait');
-    // Past the bound: expiry runs before due processing, so the row is deleted
-    // without ever firing blind at its expiry instant.
-    const afterExpiry = runDueCrons(new Date(expiresAt).getTime() + 1_000);
-    assert.equal(afterExpiry.length, 0, 'the expired row never fired');
-    await Promise.all(afterExpiry);
-    assert.equal(getCron('gate-oneshot-expires'), null, 'deleted unfired at expiry');
-});
-test('a poke re-dues held active rows, skips paused ones, stamps every row', async () => {
-    arm({ cron_id: 'poke-active', command: 'exit 75', recur: JSON.stringify({ every: '1h' }) });
-    await Promise.all(runDueCrons(Date.now()));
-    arm({ cron_id: 'poke-paused', command: 'exit 75', recur: JSON.stringify({ every: '1h' }) });
-    await Promise.all(runDueCrons(Date.now()));
-    setCronState('poke-paused', 'paused');
-    const pausedBackstop = getCron('poke-paused').fire_at;
-    arm({ cron_id: 'poke-ordinary', command: 'exit 0', fire_at: new Date(Date.now() + 3_600_000).toISOString() });
-    const nowIso = new Date().toISOString();
-    assert.equal(pokeHeldCrons(nowIso), 1, 'only the held ACTIVE row unparks');
-    const active = getCron('poke-active');
-    assert.equal(active.held, false);
-    assert.equal(active.fire_at, nowIso, 'unparked: due now');
-    const paused = getCron('poke-paused');
-    assert.equal(paused.held, true, 'pause is user-owned — a poke never unparks a paused row');
-    assert.equal(paused.fire_at, pausedBackstop);
-    for (const id of ['poke-active', 'poke-paused', 'poke-ordinary']) {
-        assert.equal(getCron(id).last_poke_at, nowIso, `last_poke_at stamps every row (${id})`);
-        cancelCron(id);
-    }
-});
-test('a poke never unparks a row whose gate check is in flight', async () => {
-    // A held recurring row at its backstop slot: due selection pre-advances
-    // fire_at, then leases the run. A poke landing mid-run must not touch the
-    // row — unparking would overwrite the advanced slot with `now`, and a
-    // PASSING gate (ordinary settlement only clears `held`) would then fire a
-    // second time on the next tick.
-    arm({ cron_id: 'poke-inflight', command: 'sleep 0.3; exit 0', recur: JSON.stringify({ every: '1h' }) });
-    openDb().prepare('UPDATE crons SET held = 1 WHERE cron_id = ?').run('poke-inflight');
-    const settlements = runDueCrons(Date.now());
-    assert.equal(settlements.length, 1, 'the held row past its backstop is due');
-    const advanced = getCron('poke-inflight').fire_at;
-    await delay(50);
-    const nowIso = new Date().toISOString();
-    assert.equal(pokeHeldCrons(nowIso), 0, 'a leased row is stamped, never unparked');
-    await Promise.all(settlements);
-    const row = getCron('poke-inflight');
-    assert.equal(row.held, false, 'the passing gate resolved — ordinary settlement clears held');
-    assert.equal(row.fire_at, advanced, 'the pre-advanced slot survives the poke — no double fire');
-    assert.equal(row.last_poke_at, nowIso);
-    cancelCron('poke-inflight');
-});
-test('a row paused mid-run parks on exit 75 even when a poke stamped it', async () => {
-    // Pause lands while the gate check is in flight, then a poke stamps every
-    // row (skipping the paused row's unpark). The settling 75 must PARK, not
-    // re-due: a re-due would leave a past-due unheld row that `cron resume`
-    // fires blind even though its gate never passed.
-    arm({ cron_id: 'paused-midrun', command: 'sleep 0.3; exit 75', recur: JSON.stringify({ every: '1h' }) });
-    const settlements = runDueCrons(Date.now());
-    assert.equal(settlements.length, 1);
-    const backstop = getCron('paused-midrun').fire_at;
-    await delay(50);
-    setCronState('paused-midrun', 'paused');
-    pokeHeldCrons(new Date().toISOString());
-    await Promise.all(settlements);
-    const row = getCron('paused-midrun');
-    assert.equal(row.state, 'paused');
-    assert.equal(row.held, true, 'paused mid-run parks — resume re-checks the gate, never fires it blind');
-    assert.equal(row.fire_at, backstop, 'the pre-advanced backstop survives');
-    cancelCron('paused-midrun');
-});
-test('a poke landing mid-run re-dues the settling row instead of parking it (F2)', async () => {
-    arm({ cron_id: 'gate-midrun-poke', command: 'sleep 0.3; exit 75' });
-    const settlement = executeCron(getCron('gate-midrun-poke'), { outOfBand: false });
-    await delay(50);
-    // The gate check is in flight: the poke's WHERE held=1 misses it.
-    assert.equal(pokeHeldCrons(new Date().toISOString()), 0);
-    const record = await settlement;
-    assert.equal(record?.exit_code, 75);
-    const row = getCron('gate-midrun-poke');
-    assert.equal(row.held, false, 're-dued, not parked — the poke is not lost');
-    assert.notEqual(row.fire_at, HELD_FAR_FUTURE);
-    assert.ok(Math.abs(new Date(row.fire_at).getTime() - Date.now()) < 5_000, `re-dued to settle time, got ${row.fire_at}`);
-    cancelCron('gate-midrun-poke');
-});
-test('an out-of-band exit 75 reports the result and never touches scheduling state (F3)', async () => {
-    const futureFire = new Date(Date.now() + 3_600_000).toISOString();
-    arm({ cron_id: 'oob-75', command: 'exit 75', recur: JSON.stringify({ every: '1h' }), fire_at: futureFire });
-    const record = await executeCron(getCron('oob-75'), { outOfBand: true });
-    assert.equal(record?.exit_code, 75);
-    assert.notEqual(record?.delivered, HELD_DELIVERED, 'a manual verification is not an owed gate');
-    const row = getCron('oob-75');
-    assert.equal(row.held, false);
-    assert.equal(row.fire_at, futureFire);
-    cancelCron('oob-75');
-});
-test('a timeout kill is a real failure even when the command would exit 75 (F3)', async () => {
-    arm({
-        cron_id: 'timeout-75',
-        command: 'sleep 3; exit 75',
-        recur: JSON.stringify({ every: '1h' }),
-        run_timeout_s: 1,
-    });
-    await Promise.all(runDueCrons(Date.now()));
-    const row = getCron('timeout-75');
-    assert.equal(row.held, false, 'a timed-out run takes the failure path, never the held branch');
-    const runs = listCronRuns('timeout-75');
-    assert.equal(runs[0].exit_code, -1);
-    assert.notEqual(runs[0].delivered, HELD_DELIVERED);
-    cancelCron('timeout-75');
-});
-test('an ordinary scheduled settlement clears held (the backstop run resolves the gate)', async () => {
-    arm({ cron_id: 'clear-held', command: 'exit 0', recur: JSON.stringify({ every: '1h' }) });
-    // Simulate a parked row whose backstop slot has arrived: held rows are
-    // deliberately NOT filtered out of the due query.
-    openDb().prepare('UPDATE crons SET held = 1 WHERE cron_id = ?').run('clear-held');
-    const settlements = runDueCrons(Date.now());
-    assert.equal(settlements.length, 1, 'a held row past its backstop is due');
-    await Promise.all(settlements);
-    assert.equal(getCron('clear-held').held, false, 'the resolved gate unparks the row');
-    cancelCron('clear-held');
-});

package/dist/core/__tests__/cron-node-sink-parked-root.test.d.ts

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

package/dist/core/__tests__/cron-node-sink-parked-root.test.js

@@ -1,166 +0,0 @@
-// Run with: npm test -- --test-name-pattern='cron node sink'
-//
-// A resident root parked by the unattended clock is status=done without a
-// final-report latch. Its anchored cron is the explicit next cycle that must
-// append durably and resume the existing session; finalized and canceled rows
-// remain ordinary undeliverable node sinks.
-import { after, afterEach, before, beforeEach, test } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { createNode, getNode, listNodes } from '../canvas/canvas.js';
-import { ensureScopeInitialized } from '../config.js';
-import { closeScopedStores } from '../scoped-state/db.js';
-import { armCron, getCron } from '../canvas/crons.js';
-import { closeDb, migrate, openDb } from '../canvas/db.js';
-import { headlessBrokerHost } from '../runtime/host.js';
-import { resetFleetForTests } from '../runtime/fleet.js';
-import { applyParkEvent, parkEvent } from '../../daemon/reconcilers/live-obligation.js';
-import { executeCron } from '../../daemon/cron-run.js';
-import { bindTestFleet } from './helpers/fleet.js';
-let home;
-let priorHome;
-let priorUserHome;
-let fleet;
-let launches;
-let originalLaunch;
-function node(id, over = {}) {
-    return {
-        node_id: id,
-        name: id,
-        created: new Date().toISOString(),
-        cwd: home,
-        kind: 'general',
-        mode: 'base',
-        lifecycle: 'resident',
-        status: 'active',
-        ...over,
-    };
-}
-function nodeMail(nodeId) {
-    return openDb().prepare(`SELECT m.body_json, d.urgency FROM deliveries d JOIN messages m ON m.message_id = d.message_id
-    WHERE d.destination_kind = 'node_inbox' AND d.destination_id = ? ORDER BY m.seq`).all(nodeId).map((row) => {
-        const data = row;
-        const value = data.body_json === null ? null : JSON.parse(data.body_json);
-        return { body: typeof value?.body === 'string' ? value.body : null, urgency: data.urgency };
-    });
-}
-function arm({ cron_id, ...overrides }) {
-    armCron({
-        cron_id,
-        name: cron_id,
-        created_by: null,
-        command: "printf 'cron output'",
-        fire_at: new Date(Date.now() - 1_000).toISOString(),
-        recur: JSON.stringify({ every: '1h' }),
-        tz: null,
-        expires_at: null,
-        anchor_node: null,
-        cancel_on_wake: false,
-        cwd: home,
-        env_json: null,
-        profile: null,
-        scope: 'profile',
-        run_timeout_s: 30,
-        overlap: 'skip',
-        on_output: 'always',
-        sink: '{}',
-        tier: 'normal',
-        ...overrides,
-    });
-}
-/** Produce the exact unattended resident-root shape: `park` writes done with
- * the park marker and leaves the final-report latch empty. A real 15-minute
- * clock reaches this same transition, through a summary turn on the good path
- * and directly on the degraded one. */
-function parkResidentRoot(id) {
-    const sessionFile = join(home, `${id}.jsonl`);
-    writeFileSync(sessionFile, '{}\n');
-    createNode(node(id, { pi_session_id: `${id}-session`, pi_session_file: sessionFile }));
-    const event = parkEvent(id, 'resident');
-    assert.equal(event, 'park');
-    applyParkEvent(id, event);
-    const parked = getNode(id);
-    assert.equal(parked.status, 'done');
-    assert.equal(parked.intent, 'parked');
-    assert.equal(parked.final_report ?? null, null);
-}
-before(() => {
-    home = mkdtempSync(join(tmpdir(), 'crtr-cron-node-sink-parked-root-'));
-    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 });
-        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('cron node sink creates a durable delivery for a parked resident root without escalation', async () => {
-    parkResidentRoot('parked-root');
-    arm({ cron_id: 'parked-root-cron', sink: JSON.stringify({ node: 'parked-root' }), anchor_node: 'parked-root' });
-    const record = await executeCron(getCron('parked-root-cron'), { outOfBand: false });
-    assert.match(record?.delivered ?? '', /^delivered: /);
-    assert.equal(getCron('parked-root-cron').state, 'active', 'delivery does not pause the cron');
-    assert.deepEqual(nodeMail('parked-root').map((entry) => entry.body), ['cron output']);
-    assert.deepEqual(launches, [], 'the delivery lane wakes the destination after it claims mail');
-    assert.equal(getNode('parked-root').status, 'done', 'the parked root remains parked until delivery claims the row');
-    assert.deepEqual(listNodes().map((entry) => entry.node_id), ['parked-root'], 'no escalation node was created');
-});
-test('finalized and canceled node-sink targets still pause and escalate without delivery', async () => {
-    const targets = [
-        ['finalized-root', { status: 'done', final_report: 'final.md', finalized_at: new Date().toISOString() }],
-        ['canceled-root', { status: 'canceled' }],
-    ];
-    for (const [id, state] of targets) {
-        createNode(node(id, state));
-        arm({ cron_id: `${id}-cron`, sink: JSON.stringify({ node: id }) });
-        const before = listNodes().length;
-        const record = await executeCron(getCron(`${id}-cron`), { outOfBand: false });
-        assert.match(record?.delivered ?? '', /^failure: cron paused, escalation node /, `${id}: failure is escalated`);
-        assert.equal(getCron(`${id}-cron`).state, 'paused', `${id}: cron is paused`);
-        assert.equal(nodeMail(id).length, 0, `${id}: no message was appended`);
-        assert.equal(listNodes().length, before + 1, `${id}: exactly one escalation node was created`);
-    }
-});
-test('a deferred node-sink entry reaches the parked root durably but never revives it', async () => {
-    parkResidentRoot('deferred-root');
-    arm({ cron_id: 'deferred-root-cron', sink: JSON.stringify({ node: 'deferred-root' }), tier: 'deferred' });
-    const record = await executeCron(getCron('deferred-root-cron'), { outOfBand: false });
-    assert.match(record?.delivered ?? '', /^delivered: /);
-    assert.equal(getCron('deferred-root-cron').state, 'active');
-    assert.deepEqual(nodeMail('deferred-root').map((entry) => entry.urgency), ['deferred']);
-    assert.deepEqual(launches, [], 'deferred delivery never launches a dormant target');
-    assert.equal(getNode('deferred-root').status, 'done', 'the parked target remains parked');
-});

package/dist/core/__tests__/cron-self-cancel-delivery.test.d.ts

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

package/dist/core/__tests__/cron-self-cancel-delivery.test.js

@@ -1,84 +0,0 @@
-// Run with: node --import tsx/esm --test src/core/__tests__/cron-self-cancel-delivery.test.ts
-//
-// A cron whose own command cancels its row mid-run must still deliver the
-// output that run produced: cancellation retires the schedule, not the run in
-// flight.
-import { after, afterEach, before, test } from 'node:test';
-import assert from 'node:assert/strict';
-import { existsSync, mkdtempSync, readFileSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { setTimeout as delay } from 'node:timers/promises';
-import { closeDb, migrate, openDb } from '../canvas/db.js';
-import { ensureScopeInitialized } from '../config.js';
-import { closeScopedStores } from '../scoped-state/db.js';
-import { armCron, cancelCron, getCron } from '../canvas/crons.js';
-import { executeCron, markSelfCanceledCronRun } from '../../daemon/cron-run.js';
-let home;
-let realHome;
-let realUserHome;
-function arm(overrides) {
-    armCron({
-        name: overrides.cron_id,
-        created_by: null,
-        fire_at: new Date(Date.now() - 1_000).toISOString(),
-        recur: null,
-        tz: null,
-        expires_at: null,
-        anchor_node: null,
-        cancel_on_wake: false,
-        cwd: home,
-        env_json: null,
-        profile: null,
-        scope: 'profile',
-        run_timeout_s: 30,
-        overlap: 'skip',
-        on_output: 'silent',
-        sink: '{}',
-        tier: 'normal',
-        ...overrides,
-    });
-}
-before(() => {
-    home = mkdtempSync(join(tmpdir(), 'crtr-cron-broker-capacity-'));
-    realHome = process.env['CRTR_HOME'];
-    realUserHome = process.env['HOME'];
-    process.env['HOME'] = home;
-    process.env['CRTR_HOME'] = home;
-    ensureScopeInitialized('user', join(home, '.crouter'));
-    migrate(openDb());
-});
-afterEach(() => {
-    closeDb();
-    closeScopedStores();
-});
-after(() => {
-    closeDb();
-    rmSync(home, { recursive: true, force: true });
-    if (realHome === undefined)
-        delete process.env['CRTR_HOME'];
-    else
-        process.env['CRTR_HOME'] = realHome;
-    if (realUserHome === undefined)
-        delete process.env['HOME'];
-    else
-        process.env['HOME'] = realUserHome;
-});
-test('an on-change cron that cancels itself still delivers its final output', async () => {
-    const runIdPath = join(home, 'self-cancel-run-id');
-    arm({
-        cron_id: 'self-cancel-delivery',
-        command: `printf '%s' "$CRTR_RUN_ID" > '${runIdPath}'; echo settled; sleep 0.1`,
-        recur: JSON.stringify({ every: '1h' }),
-        on_output: 'on-change',
-        sink: JSON.stringify({ human: true }),
-    });
-    const run = executeCron(getCron('self-cancel-delivery'), { outOfBand: false });
-    for (let i = 0; i < 50 && !existsSync(runIdPath); i++)
-        await delay(10);
-    assert.ok(existsSync(runIdPath), 'the live run exposed its id to its self-cancel command');
-    assert.equal(markSelfCanceledCronRun('self-cancel-delivery', readFileSync(runIdPath, 'utf8')), true);
-    assert.equal(cancelCron('self-cancel-delivery', { preserveRunningProcess: true }), true);
-    const record = await run;
-    assert.match(record?.delivered ?? '', /^delivered: [0-9a-f]{32}$/, 'the durable human delivery was created after self-cancel');
-});

package/dist/core/__tests__/cron-timeout-descendants.test.d.ts

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

package/dist/core/__tests__/cron-timeout-descendants.test.js

@@ -1,114 +0,0 @@
-// Run with: node --import tsx/esm --test src/core/__tests__/cron-timeout-descendants.test.ts
-//
-// #1037: a cron descendant living outside the shell's own process group held
-// the run's output pipes open, and settlement waited on those pipes. Teardown
-// signalled the group and moved on, so the timeout was recorded only when the
-// descendant finally exited by itself — 732 seconds for a 240-second timeout
-// in the field. Teardown must reap the tree it captured by ancestry, and the
-// record must wait for those processes to be dead rather than merely quiet.
-//
-// GNU `timeout` is the wrapper that produced the field report, but nothing
-// here is specific to it: a detached child reproduces the same shape on any
-// platform, so this never skips.
-import { after, before, test } from 'node:test';
-import assert from 'node:assert/strict';
-import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } 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 { armCron, getCron } from '../canvas/crons.js';
-import { isPidAlive } from '../canvas/pid.js';
-import { executeCron } from '../../daemon/cron-run.js';
-// The shell starts a live intermediate that keeps a detached grandchild in a
-// process group of its own. The grandchild inherits the cron's stdout and
-// stderr and ignores TERM, so the pipes stay open until something kills it.
-const INTERMEDIATE = `
-const { spawn } = require('node:child_process');
-spawn(process.execPath, [process.argv[2], process.argv[3]], { detached: true, stdio: 'inherit' }).unref();
-setInterval(() => {}, 1000);
-`;
-const DESCENDANT = `
-process.on('SIGTERM', () => {});
-require('node:fs').writeFileSync(process.argv[2], String(process.pid));
-setInterval(() => {}, 1000);
-`;
-let home;
-let realHome;
-let realUserHome;
-let marker;
-let command;
-function arm(overrides) {
-    armCron({
-        name: overrides.cron_id,
-        created_by: null,
-        fire_at: new Date(Date.now() - 1_000).toISOString(),
-        recur: null,
-        tz: null,
-        expires_at: null,
-        anchor_node: null,
-        cancel_on_wake: false,
-        cwd: home,
-        env_json: null,
-        profile: null,
-        scope: 'profile',
-        run_timeout_s: 1,
-        overlap: 'skip',
-        on_output: 'silent',
-        sink: '{}',
-        tier: 'normal',
-        ...overrides,
-    });
-}
-before(() => {
-    home = mkdtempSync(join(tmpdir(), 'crtr-cron-timeout-descendants-'));
-    realHome = process.env['CRTR_HOME'];
-    realUserHome = process.env['HOME'];
-    process.env['HOME'] = home;
-    process.env['CRTR_HOME'] = home;
-    ensureScopeInitialized('user', join(home, '.crouter'));
-    migrate(openDb());
-    marker = join(home, 'descendant.pid');
-    const intermediate = join(home, 'intermediate.cjs');
-    const descendant = join(home, 'descendant.cjs');
-    writeFileSync(intermediate, INTERMEDIATE);
-    writeFileSync(descendant, DESCENDANT);
-    // Two statements, so the shell stays alive as the tree's root rather than
-    // exec-replacing itself with the intermediate.
-    command = `${JSON.stringify(process.execPath)} ${JSON.stringify(intermediate)} ${JSON.stringify(descendant)} ${JSON.stringify(marker)}; printf 'shell survived\\n'`;
-});
-after(() => {
-    if (existsSync(marker)) {
-        const stranded = Number.parseInt(readFileSync(marker, 'utf8').trim(), 10);
-        if (Number.isInteger(stranded) && stranded > 0 && isPidAlive(stranded)) {
-            try {
-                process.kill(stranded, 'SIGKILL');
-            }
-            catch {
-                // It exited between the liveness probe and the signal.
-            }
-        }
-    }
-    closeDb();
-    closeScopedStores();
-    rmSync(home, { recursive: true, force: true });
-    if (realHome === undefined)
-        delete process.env['CRTR_HOME'];
-    else
-        process.env['CRTR_HOME'] = realHome;
-    if (realUserHome === undefined)
-        delete process.env['HOME'];
-    else
-        process.env['HOME'] = realUserHome;
-});
-test('a TERM-ignoring descendant outside the shell process group is reaped before the timeout is recorded', async () => {
-    arm({ cron_id: 'timeout-descendants', command });
-    const record = await executeCron(getCron('timeout-descendants'), { outOfBand: true });
-    assert.ok(record !== null, 'the run settles instead of hanging on held pipes');
-    assert.equal(record.exit_code, -1, 'the configured deadline is recorded as a timeout');
-    assert.ok(record.duration_ms < 5_000, `settlement is bounded by the deadline and teardown, got ${record.duration_ms}ms`);
-    const descendant = Number.parseInt(readFileSync(marker, 'utf8').trim(), 10);
-    assert.ok(Number.isInteger(descendant) && descendant > 0, 'the scenario actually started an out-of-group descendant');
-    assert.equal(isPidAlive(descendant), false, 'the descendant is dead, not merely detached from the pipes it was holding');
-});

package/dist/core/__tests__/daemon-boot.test.d.ts

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