@north-light/crouter 0.3.318 → 0.3.319

package/dist/core/__tests__/integration/plugin-revalidate.test.js

@@ -1,359 +0,0 @@
-// Contract-seam tests for bundle-plugin revalidation against a stub endpoint.
-// Run with: npm run test:integration
-//
-// Two behaviors whose absence would be SILENT — the package on disk would still
-// be a complete, valid command tree, so nothing fails loudly while the client
-// dispatches against a description the server retired:
-//
-//  1. Round trip — an install stores the served validator; a later check sends
-//     it conditionally, leaves the package untouched on 304, and swaps it on a
-//     200 that carries different bytes.
-//  2. Refetch on miss — the forced refetch a `manifest_stale` answer triggers
-//     reports whether the package actually CHANGED. That boolean is the whole
-//     branch: false means the operation is genuinely gone and the server's own
-//     error stands, true means the retry has a fresher tree to parse against.
-//  3. Recovery from a RENAMED op, end to end and entirely off the wire: the
-//     stub answers the v1 op with a real 400 error envelope carrying
-//     `manifest_stale`, so the flag is parsed by the transport rather than
-//     hand-built. `runCli` renders every other failure itself, so recovery is
-//     unreachable unless this one class escapes it — and from the outside a
-//     rendered error looks identical to a recovered one. Its three legs: the
-//     escape, the refetch-and-replay, and exactly-once.
-//
-// All run against an isolated HOME and a startDir with no `.crouter` ancestor,
-// so no ambient plugin or scope of the developer's machine is reachable.
-import { test, describe, before, beforeEach, afterEach, after } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, writeFileSync, rmSync, readFileSync, realpathSync } from 'node:fs';
-import { createServer } from 'node:http';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import * as tar from 'tar';
-import { resetScopeCache, userScopeRoot } from '../../scope.js';
-import { readState, readConfig } from '../../config.js';
-import { closeScopedStores } from '../../scoped-state/db.js';
-import { initializeFreshScopedStore } from '../../scoped-state/migrate.js';
-import { revalidateBundlePlugins, forceRevalidateBundlePlugin } from '../../command-plugins/revalidate.js';
-import { pluginInstall } from '../../../commands/pkg/plugin-manage.js';
-import { runCli } from '../../command.js';
-import { buildRoot } from '../../../build-root.js';
-import { dispatchWithStaleRecovery } from '../../manifest-recovery.js';
-import { CrtrError } from '../../errors.js';
-const PLUGIN = 'revalidate-fixture';
-const ARGV = ['node', 'crtr', 'demo', 'show'];
-/** The positional the fixture leaf echoes back. */
-const FIXTURE_ID = 'fixture-1';
-let isolatedHome;
-let isolatedCwd;
-let prevHome;
-let prevTtl;
-let prevCwd;
-let server;
-let endpoint;
-/** What the stub serves right now, and what every BUNDLE request asked for. */
-let served;
-let requests;
-/** Which generations of the `demo show` op this backend has retired. A call
- *  against a retired one gets the 400 + `manifest_stale` envelope that drives
- *  client recovery; any other generation is served normally. */
-let retiredOps;
-/** Every generation the leaf was actually invoked at, in order — `['v1','v2']`
- *  is one recovery: the stale call, then the replay against the fresh tree. */
-let opCalls;
-before(() => {
-    prevHome = process.env.HOME;
-    prevTtl = process.env.CRTR_PLUGIN_REVALIDATE_TTL_MS;
-    prevCwd = process.cwd();
-});
-beforeEach(async () => {
-    isolatedHome = realpathSync(mkdtempSync(join(tmpdir(), 'crtr-revalidate-home-')));
-    isolatedCwd = realpathSync(mkdtempSync(join(tmpdir(), 'crtr-revalidate-cwd-')));
-    process.env.HOME = isolatedHome;
-    process.chdir(isolatedCwd);
-    initializeFreshScopedStore({ kind: 'user', root: join(isolatedHome, '.crouter') });
-    resetScopeCache();
-    served = { archive: makeArchive('v1'), etag: '"sha256-v1"' };
-    requests = [];
-    retiredOps = new Set();
-    opCalls = [];
-    server = createServer((req, res) => {
-        const path = (req.url ?? '/').split('?')[0] ?? '/';
-        const op = /^\/(v\d+)\/demo\/(.+)$/.exec(path);
-        if (op !== null) {
-            serveOp(res, op[1], op[2]);
-            return;
-        }
-        if (path !== '/v1/cli/bundle') {
-            res.writeHead(404, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ error: { code: 'not_found', message: `no route for ${path}` } }));
-            return;
-        }
-        const ifNoneMatch = typeof req.headers['if-none-match'] === 'string' ? req.headers['if-none-match'] : undefined;
-        if (ifNoneMatch === served.etag) {
-            requests.push({ ifNoneMatch, status: 304 });
-            res.writeHead(304, { ETag: served.etag, 'Cache-Control': 'private, no-cache' });
-            res.end();
-            return;
-        }
-        requests.push({ ifNoneMatch, status: 200 });
-        res.writeHead(200, { 'Content-Type': 'application/x-tar', ETag: served.etag, 'Cache-Control': 'private, no-cache' });
-        res.end(Buffer.from(served.archive));
-    });
-    await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
-    const address = server.address();
-    if (address === null || typeof address === 'string')
-        throw new Error('stub server has no TCP address');
-    endpoint = `http://127.0.0.1:${address.port}/v1/cli/bundle`;
-});
-afterEach(async () => {
-    await new Promise((resolve) => server.close(() => resolve()));
-    process.chdir(prevCwd);
-    closeScopedStores();
-    rmSync(isolatedHome, { recursive: true, force: true });
-    rmSync(isolatedCwd, { recursive: true, force: true });
-});
-after(() => {
-    process.chdir(prevCwd);
-    process.env.HOME = prevHome;
-    if (prevTtl === undefined)
-        delete process.env.CRTR_PLUGIN_REVALIDATE_TTL_MS;
-    else
-        process.env.CRTR_PLUGIN_REVALIDATE_TTL_MS = prevTtl;
-    resetScopeCache();
-});
-/** The `demo show` leaf, answered at whichever generation the caller's tree
- *  parsed the path from. A retired generation gets a real error envelope with
- *  `manifest_stale` set, so the flag reaches the client through the transport's
- *  own JSON parse rather than being constructed in the test. */
-function serveOp(res, generation, id) {
-    opCalls.push(generation);
-    if (retiredOps.has(generation)) {
-        res.writeHead(400, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({
-            error: {
-                code: 'cli_op_unknown',
-                message: `this backend no longer serves "demo show" at ${generation}`,
-                manifest_stale: true,
-                next: 'Refetch the plugin package and re-run.',
-            },
-        }));
-        return;
-    }
-    res.writeHead(200, { 'Content-Type': 'application/json' });
-    res.end(JSON.stringify({ id }));
-}
-/** One archive per generation. `marker` rides the leaf description AND the REST
- *  path its leaf calls, so the tree unpacked on disk says which generation
- *  produced it, the two generations are different bytes with different
- *  validators, and a call made from the OLD tree is distinguishable on the wire
- *  from the same call made after a swap — which is exactly what a renamed op
- *  looks like to a backend. */
-function makeArchive(marker) {
-    const commands = {
-        schemaVersion: 1,
-        mounts: [
-            {
-                parent: [],
-                node: {
-                    kind: 'branch',
-                    name: 'demo',
-                    description: `demo commands (${marker})`,
-                    whenToUse: 'you are exercising the revalidation seam',
-                    rootEntry: {
-                        concept: 'a fixture command tree served by the stub endpoint',
-                        description: `demo commands (${marker})`,
-                        whenToUse: 'you are exercising the revalidation seam',
-                    },
-                    summary: `demo commands (${marker})`,
-                    model: 'A fixture tree with one read-only leaf.',
-                    children: [
-                        {
-                            kind: 'leaf',
-                            name: 'show',
-                            description: `show the fixture (${marker})`,
-                            whenToUse: 'inspect the fixture record',
-                            tier: 'important',
-                            summary: `show the fixture record (${marker})`,
-                            params: [{ kind: 'positional', name: 'id', required: true, constraint: 'the fixture id' }],
-                            output: [{ name: 'id', type: 'string', required: true, constraint: 'the echoed fixture id' }],
-                            effects: ['None. Read-only.'],
-                            rest: { method: 'GET', path: `/${marker}/demo/{id}`, params: { id: { in: 'path' } } },
-                        },
-                    ],
-                },
-            },
-        ],
-    };
-    const dir = mkdtempSync(join(tmpdir(), 'crtr-revalidate-tar-'));
-    try {
-        writeFileSync(join(dir, 'bundle.json'), JSON.stringify({ bundleVersion: 1 }));
-        writeFileSync(join(dir, 'commands.json'), JSON.stringify(commands));
-        const pack = tar.create({ sync: true, cwd: dir, portable: true }, ['bundle.json', 'commands.json']);
-        const chunks = [];
-        let chunk;
-        while ((chunk = pack.read()) !== null)
-            chunks.push(chunk);
-        return new Uint8Array(Buffer.concat(chunks));
-    }
-    finally {
-        rmSync(dir, { recursive: true, force: true });
-    }
-}
-async function install() {
-    await pluginInstall.run({ endpoint, name: PLUGIN, scope: 'user' });
-}
-/** The generation of the tree actually unpacked under the user scope. */
-function installedMarker() {
-    const path = join(userScopeRoot(), 'plugins', PLUGIN, 'commands.json');
-    const parsed = JSON.parse(readFileSync(path, 'utf8'));
-    const description = parsed.mounts[0].node.description;
-    return description.slice(description.indexOf('(') + 1, description.indexOf(')'));
-}
-function pluginState() {
-    return readState('user').plugins[PLUGIN] ?? {};
-}
-function installedVersion() {
-    return readConfig('user').plugins[PLUGIN]?.version;
-}
-/** Age out the TTL without waiting one out: the pass measures freshness from
- *  `checked_at`, so a one-millisecond TTL plus a real pause is due. */
-async function makeDue() {
-    process.env.CRTR_PLUGIN_REVALIDATE_TTL_MS = '1';
-    await new Promise((resolve) => setTimeout(resolve, 5));
-}
-/** Run a dispatch and collect what the caller would actually have observed:
- *  what reached stdout (both rendered results and rendered errors go there) and
- *  whether anything escaped the frame. `process.exitCode` is restored, since a
- *  rendered error sets it and would otherwise fail the whole test process. */
-async function captured(run) {
-    const chunks = [];
-    const realWrite = process.stdout.write.bind(process.stdout);
-    const realExitCode = process.exitCode;
-    process.stdout.write = ((chunk) => {
-        chunks.push(String(chunk));
-        return true;
-    });
-    let thrown;
-    try {
-        await run();
-    }
-    catch (error) {
-        thrown = error;
-    }
-    finally {
-        process.stdout.write = realWrite;
-        process.exitCode = realExitCode;
-    }
-    return { stdout: chunks.join(''), thrown };
-}
-describe('bundle plugin revalidation', () => {
-    test('an install fills the cache; an unchanged bundle 304s and a changed one swaps the package', async () => {
-        await install();
-        // The install IS the first cache fill: unconditional, and it stores what
-        // the server named for the bytes it unpacked.
-        assert.deepEqual(requests, [{ ifNoneMatch: undefined, status: 200 }]);
-        assert.equal(pluginState().etag, '"sha256-v1"');
-        assert.ok(pluginState().checked_at !== undefined);
-        assert.equal(installedMarker(), 'v1');
-        const firstVersion = installedVersion();
-        // Inside the TTL there is nothing to do, and nothing is asked.
-        process.env.CRTR_PLUGIN_REVALIDATE_TTL_MS = '600000';
-        await revalidateBundlePlugins(ARGV);
-        assert.equal(requests.length, 1);
-        // Due, unchanged: the request carries the stored validator, the server
-        // answers 304, and the package on disk is left exactly as it was.
-        await makeDue();
-        const beforeCheck = pluginState().checked_at;
-        await revalidateBundlePlugins(ARGV);
-        assert.deepEqual(requests[1], { ifNoneMatch: '"sha256-v1"', status: 304 });
-        assert.equal(installedMarker(), 'v1');
-        assert.equal(installedVersion(), firstVersion);
-        assert.equal(pluginState().etag, '"sha256-v1"');
-        assert.notEqual(pluginState().checked_at, beforeCheck);
-        // Due, changed: the 200 swaps the package, and the new validator replaces
-        // the old one so the next check is conditional on what is now on disk.
-        served = { archive: makeArchive('v2'), etag: '"sha256-v2"' };
-        await makeDue();
-        await revalidateBundlePlugins(ARGV);
-        assert.deepEqual(requests[2], { ifNoneMatch: '"sha256-v1"', status: 200 });
-        assert.equal(installedMarker(), 'v2');
-        assert.notEqual(installedVersion(), firstVersion);
-        assert.equal(pluginState().etag, '"sha256-v2"');
-    });
-    test('a forced refetch reports whether the package changed, ignoring a fresh TTL', async () => {
-        await install();
-        // A TTL the ordinary pass would honor. The forced path must not.
-        process.env.CRTR_PLUGIN_REVALIDATE_TTL_MS = '600000';
-        // Nothing newer is served: the operation the caller invoked is genuinely
-        // gone, so the refetch reports no change and the server's error stands.
-        assert.equal(await forceRevalidateBundlePlugin(PLUGIN), false);
-        assert.deepEqual(requests[1], { ifNoneMatch: undefined, status: 200 });
-        assert.equal(installedMarker(), 'v1');
-        // A changed package: the retry has a fresher tree to re-parse against.
-        served = { archive: makeArchive('v2'), etag: '"sha256-v2"' };
-        assert.equal(await forceRevalidateBundlePlugin(PLUGIN), true);
-        assert.equal(installedMarker(), 'v2');
-        assert.equal(pluginState().etag, '"sha256-v2"');
-        // A plugin that is not installed is not a recovery path.
-        assert.equal(await forceRevalidateBundlePlugin('absent-plugin'), false);
-    });
-    test('the dispatcher lets a manifest_stale answer off the wire escape, and renders every other failure', async () => {
-        await install();
-        // The pass must not fire underneath these legs: every fetch below is one a
-        // test asked for.
-        process.env.CRTR_PLUGIN_REVALIDATE_TTL_MS = '600000';
-        retiredOps.add('v1');
-        const root = await buildRoot();
-        const stale = await captured(() => runCli(root, [...ARGV, FIXTURE_ID]));
-        // Rethrown, not rendered: nothing printed, and the frame above holds the
-        // error with the two details recovery needs.
-        assert.equal(stale.stdout, '');
-        const thrown = stale.thrown;
-        assert.ok(thrown instanceof CrtrError, String(thrown));
-        assert.equal(thrown.details?.['manifest_stale'], true);
-        assert.equal(thrown.details?.['plugin'], PLUGIN);
-        assert.deepEqual(opCalls, ['v1']);
-        // Every other failure stays the dispatcher's to report. The same leaf,
-        // missing its required positional, is rendered rather than thrown.
-        const usage = await captured(() => runCli(root, ARGV));
-        assert.equal(usage.thrown, undefined);
-        assert.ok(usage.stdout.includes('id'), usage.stdout);
-    });
-    test('a stale answer refetches the package and re-runs the ORIGINAL argv against the refreshed tree', async () => {
-        await install();
-        process.env.CRTR_PLUGIN_REVALIDATE_TTL_MS = '600000';
-        // The backend has moved the op on: it retired the generation this client
-        // installed, and now serves a package whose leaf calls the new path.
-        retiredOps.add('v1');
-        served = { archive: makeArchive('v2'), etag: '"sha256-v2"' };
-        const root = await buildRoot();
-        const run = await captured(() => dispatchWithStaleRecovery(root, [...ARGV, FIXTURE_ID]));
-        assert.equal(run.thrown, undefined);
-        // The stale call, one forced bundle fetch, then the replay at the NEW
-        // generation — which only the refreshed tree could have addressed.
-        assert.deepEqual(opCalls, ['v1', 'v2']);
-        assert.deepEqual(requests, [
-            { ifNoneMatch: undefined, status: 200 }, // the install
-            { ifNoneMatch: undefined, status: 200 }, // the forced refetch
-        ]);
-        assert.equal(installedMarker(), 'v2');
-        assert.ok(run.stdout.includes(FIXTURE_ID), run.stdout);
-    });
-    test('a second stale answer is rendered rather than refetched again', async () => {
-        await install();
-        process.env.CRTR_PLUGIN_REVALIDATE_TTL_MS = '600000';
-        // A backend that keeps answering `manifest_stale` however fresh the package
-        // is. The refetch genuinely changes the tree, so the retry does happen —
-        // and its own stale answer must end the cycle, not restart it.
-        retiredOps = new Set(['v1', 'v2']);
-        served = { archive: makeArchive('v2'), etag: '"sha256-v2"' };
-        const root = await buildRoot();
-        const run = await captured(() => dispatchWithStaleRecovery(root, [...ARGV, FIXTURE_ID]));
-        assert.equal(run.thrown, undefined);
-        assert.deepEqual(opCalls, ['v1', 'v2']);
-        assert.equal(requests.length, 2, 'the install plus exactly ONE forced refetch');
-        assert.equal(installedMarker(), 'v2');
-        // The backend's own second complaint is the answer the caller gets.
-        assert.ok(run.stdout.includes('no longer serves'), run.stdout);
-    });
-});

package/dist/core/__tests__/integration/profile-pause.test.d.ts

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

package/dist/core/__tests__/integration/profile-pause.test.js

@@ -1,115 +0,0 @@
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { existsSync, readFileSync, readdirSync } from 'node:fs';
-import { contextDir } from '../../canvas/paths.js';
-import { getRow } from '../../canvas/canvas.js';
-import { bashJobPaths, bashJobsDir } from '../../bash-jobs.js';
-import { acknowledgedNodeMailCount } from '../../canvas/deliveries.js';
-import { transition } from '../../runtime/lifecycle.js';
-import { ensureRootProfile, pauseProfile } from '../../profiles/manifest.js';
-import { createHeadlessHarness } from '../helpers/harness.js';
-function runningJob(nodeId) {
-    const dir = bashJobsDir(contextDir(nodeId));
-    try {
-        for (const jobId of readdirSync(dir)) {
-            const paths = bashJobPaths(contextDir(nodeId), jobId);
-            if (existsSync(paths.jobRun))
-                return paths;
-        }
-    }
-    catch {
-        // The valve has not created its job directory yet.
-    }
-    return undefined;
-}
-test('profile pause backgrounds real bash, retains its queued SQL delivery, and recovers after a quick resume without failure', { timeout: 120_000 }, async () => {
-    const h = await createHeadlessHarness({ sessionPrefix: 'crtr-profile-pause' });
-    try {
-        const profile = ensureRootProfile();
-        const parent = h.fabricateBrokerNode({ lifecycle: 'resident' });
-        const child = await h.spawnHeadlessChild(parent, 'stay available while the profile pauses', { profile: profile.profileId });
-        h.fakeCmd(child, { cmd: 'bash', command: "sh -c 'sleep 2; printf preserved'" });
-        const job = await h.waitFor(() => runningJob(child), { label: 'valve job.run' });
-        assert.ok(existsSync(job.jobRun), 'the bash valve owns the foreground command before pause');
-        const paused = h.cli(null, ['profile', 'pause', profile.profileId]);
-        assert.equal(paused.code, 0, paused.stderr);
-        await h.tick();
-        assert.equal(h.bootCount(child), 1, 'the lifecycle pass while paused launches no replacement');
-        const retained = h.cli(null, ['node', 'message', 'send', '--to', child, 'mail retained while profile is paused']);
-        assert.equal(retained.code, 0, retained.stderr);
-        const retainedEntry = h.inbox(child).find((entry) => entry.data?.['body'] === 'mail retained while profile is paused');
-        assert.ok(retainedEntry, 'the message was durably appended');
-        assert.equal(acknowledgedNodeMailCount(child), 0, 'pause leaves the queued SQL delivery unacknowledged');
-        const resumed = h.cli(null, ['profile', 'resume', profile.profileId]);
-        assert.equal(resumed.code, 0, resumed.stderr);
-        await h.awaitFleetExit(child);
-        assert.ok(existsSync(job.jobBg), 'SIGTERM atomically handed job.run to job.bg');
-        assert.equal(existsSync(job.jobRun), false, 'the foreground valve ownership is gone');
-        await h.waitFor(() => existsSync(job.jobExit), { label: 'background bash completion' });
-        assert.equal(readFileSync(job.jobExit, 'utf8').trim(), '0', 'the handoff command completed after its broker exited');
-        assert.equal(acknowledgedNodeMailCount(child), 0, 'neither retained message nor background completion acknowledges the stopped broker delivery');
-        await h.tick();
-        assert.equal(h.bootCount(child), 1, 'the first resumed policy pass only consumes the pause interruption');
-        assert.equal(getRow(child)?.respawn_failures, 0, 'the intentional SIGTERM never counts as a crash');
-        await h.tick();
-        // `#respawn`'s backoff-assessment defers this exact relaunch on its first
-        // assessment: this node's original spawn (`spawnChild`'s direct
-        // `headlessBrokerHost.launch`) never records `launched_at`, so
-        // `decideRespawnAttempt` can never see `last_settled_at > launched_at` on
-        // this first-ever `#respawn` call for the row and always takes the
-        // `respawn_not_before` backoff branch (fleet.ts's RESPAWN_BACKOFF_BASE_MS,
-        // currently 5s) instead of launching. A THIRD tick, issued once real time
-        // has passed that window, finds `respawn_not_before` already set (so
-        // `#respawn` skips reassessment this time) and actually calls `reviveNode`.
-        // Real-time sleep, not a fake clock: `now()` here is the daemon's real
-        // `Date.now`, so only the wall clock — not another tick — advances it.
-        await new Promise((r) => setTimeout(r, 5_500));
-        await h.tick();
-        await h.awaitBoot(child, { minCount: 2, timeoutMs: 30_000 });
-        const deliveries = await h.awaitWake(child, { match: /mail retained while profile is paused/ });
-        assert.ok(deliveries.some((content) => /mail retained while profile is paused/.test(content)), 'the resumed watcher delivers the retained backlog');
-    }
-    finally {
-        await h.dispose();
-    }
-});
-test('profile pause preserves an idle-release row so mail queued during pause wakes it', { timeout: 120_000 }, async () => {
-    const h = await createHeadlessHarness({ sessionPrefix: 'crtr-profile-pause-idle' });
-    try {
-        const profile = ensureRootProfile();
-        const parent = h.fabricateBrokerNode({ lifecycle: 'resident' });
-        const child = await h.spawnHeadlessChild(parent, 'await ordinary mail', { profile: profile.profileId, lifecycle: 'resident' });
-        transition(child, 'release');
-        const paused = h.cli(null, ['profile', 'pause', profile.profileId]);
-        assert.equal(paused.code, 0, paused.stderr);
-        const queued = h.cli(null, ['node', 'message', 'send', '--to', child, 'ordinary mail queued during pause']);
-        assert.equal(queued.code, 0, queued.stderr);
-        await h.awaitFleetExit(child);
-        const resumed = h.cli(null, ['profile', 'resume', profile.profileId]);
-        assert.equal(resumed.code, 0, resumed.stderr);
-        await h.tick();
-        await h.tick();
-        await h.awaitBoot(child, { minCount: 2, timeoutMs: 60_000 });
-        const deliveries = await h.awaitWake(child, { match: /ordinary mail queued during pause/ });
-        assert.ok(deliveries.some((content) => /ordinary mail queued during pause/.test(content)), 'the idle-release wake is not stranded behind the pause marker');
-    }
-    finally {
-        await h.dispose();
-    }
-});
-test('lifecycle catches a broker that became live after the pause command fast scan', { timeout: 60_000 }, async () => {
-    const h = await createHeadlessHarness({ sessionPrefix: 'crtr-profile-pause-race' });
-    try {
-        const profile = ensureRootProfile();
-        const parent = h.fabricateBrokerNode({ lifecycle: 'resident' });
-        const child = await h.spawnHeadlessChild(parent, 'broker launched after pause scan', { profile: profile.profileId });
-        pauseProfile(profile.profileId);
-        await h.tick();
-        await h.awaitFleetExit(child);
-        assert.equal(h.bootCount(child), 1, 'the paused lifecycle tick terminates the late live broker instead of leaving it running');
-        assert.equal(getRow(child)?.respawn_failures, 0, 'the late broker interruption has no failure cost');
-    }
-    finally {
-        await h.dispose();
-    }
-});

package/dist/core/__tests__/integration/refresh-stall-recycle.test.d.ts

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

package/dist/core/__tests__/integration/refresh-stall-recycle.test.js

@@ -1,151 +0,0 @@
-// Run with: npm run test:integration
-//
-// BUG-REGRESSION (broker-universal-host cut, design §H refresh-authority; U7
-// report mq8gq8we-4cadd8e6; stuck-refresh, parent mq7s5o93). A `node yield` /
-// refresh records intent='refresh' and relies on the in-process stophook to call
-// shutdown at stop. But the engine can be left ALIVE forever — it hangs at a huge
-// context, OR a STALE in-process stophook (pi extensions never reload, so a
-// days-old resident carries an old hook) ignores intent='refresh' and never calls
-// shutdown. Engine alive + turn over + intent pending forever. The daemon only
-// recovers DEAD engines, so without §H the node is permanently stuck. The DAEMON
-// is the authority: when intent='refresh' persists on a LIVE engine whose turn is
-// over, past YIELD_STALL_GRACE_MS, it force-kills the engine (SIGTERM). The kill
-// then lands as a real exit event whose policy job classifies intent='refresh'
-// as respawn-fresh (policy table row 3) — the fresh roadmap-revive the yield
-// asked for.
-//
-// Two legs: the pure truth table (D4a — yieldStallVerdict) and the daemon
-// integration over a real live pid the daemon must SIGTERM (D4b — superviseTick
-// with an injected clock). Regression check: drop §H and D4b's "engine killed"
-// assert goes RED (the live refresh pid lives forever, never recycled).
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { spawn } from 'node:child_process';
-import { createHeadlessHarness } from '../helpers/harness.js';
-import { getRow } from '../../canvas/canvas.js';
-import { abortExecution, beginExecution, recordExecutionPid } from '../../canvas/executions.js';
-import { isPidAlive } from '../../canvas/pid.js';
-import { BrokerSupervisionReconciler, yieldStallVerdict, YIELD_STALL_GRACE_MS } from '../../../daemon/reconcilers/broker-supervision.js';
-// D4a — the pure refresh-stall truth table.
-test('D4a yieldStallVerdict: kill ONLY a live, not-busy, refresh engine past the grace', () => {
-    const G = YIELD_STALL_GRACE_MS;
-    // The one 'kill' case: engine alive, intent=refresh, turn over (not busy), past grace.
-    assert.equal(yieldStallVerdict(true, 'refresh', false, G), 'kill', 'alive+refresh+!busy+>=grace → kill');
-    // A working engine is NEVER killed, even past the grace.
-    assert.equal(yieldStallVerdict(true, 'refresh', true, G + 60_000), 'leave', 'busy (mid-turn) → leave');
-});
-// D4b — daemon integration: a stuck refresh on a LIVE engine is force-recycled.
-const T0 = 7_000_000;
-const T_KILL = T0 + YIELD_STALL_GRACE_MS + 1; // one ms past the grace from t0
-const KILL_ESCALATE_MS = 20_000;
-test('D4b daemon force-recycles a stuck refresh: a live, not-busy refresh engine past the grace is SIGTERM\'d', { timeout: 30_000 }, async () => {
-    const h = await createHeadlessHarness({ sessionPrefix: 'crtr-d4b' });
-    // A real live subprocess standing in for the hung/stale-hook engine. `sleep`
-    // dies on SIGTERM, so the daemon's force-kill is directly observable.
-    const child = spawn('sleep', ['300'], { stdio: 'ignore' });
-    const enginePid = child.pid;
-    try {
-        assert.equal(isPidAlive(enginePid), true, 'precondition: the refresh engine is alive');
-        // intent='refresh' + LIVE pid + turn over (no busy marker by default) →
-        // the §H stall state the daemon must break.
-        const id = h.fabricateBrokerNode({
-            kind: 'developer',
-            status: 'active',
-            intent: 'refresh',
-            pi_pid: enginePid,
-            pi_session_id: 'sess-d4b',
-        });
-        // A live broker records its launch-time identity with its pid. The force
-        // signal re-verifies that identity, so this fixture must model the
-        // production record rather than a legacy identity-less row.
-        const executionId = beginExecution(id, { daemonEpoch: h.fleet.epoch() });
-        recordExecutionPid(executionId, id, enginePid);
-        // Post-cutover the live-fleet pass iterates fleet ENTRIES, not rows: a
-        // live broker IS a fleet entry (design D-1). Model the launch-time
-        // registration the production host performs, with a never-resolving
-        // exited promise — this test observes the SIGTERM, not the exit policy.
-        h.fleet.register(id, { pid: enginePid, exited: new Promise(() => { }) });
-        assert.equal(h.node(id).intent, 'refresh', 'precondition: intent=refresh pending');
-        assert.notEqual(h.node(id).pi_pid_identity, null, 'precondition: live engine has a recorded identity');
-        // TICK @ t0: arms the stall clock (yieldStallSince). No kill yet.
-        await h.tick(T0);
-        assert.equal(isPidAlive(enginePid), true, 'within grace: the engine is NOT killed (clock just armed)');
-        // --- TICK past the grace: the daemon concludes the refresh stalled and
-        //     SIGTERMs the engine itself (§H force-recycle). ---
-        await h.tick(T_KILL);
-        await h.waitFor(() => (isPidAlive(enginePid) ? null : true), {
-            label: 'daemon SIGTERM killed the stuck refresh engine',
-            timeoutMs: 10_000,
-        });
-        assert.equal(isPidAlive(enginePid), false, 'past grace: the daemon force-killed the stuck refresh engine (§H)');
-    }
-    finally {
-        try {
-            child.kill('SIGKILL');
-        }
-        catch {
-            /* already gone */
-        }
-        await h.dispose();
-    }
-});
-test('D4c yield escalation is scoped to the broker that received SIGTERM', { timeout: 30_000 }, async () => {
-    const h = await createHeadlessHarness({ sessionPrefix: 'crtr-d4c' });
-    const original = spawn('sleep', ['300'], { stdio: 'ignore' });
-    let replacement;
-    try {
-        const id = h.fabricateBrokerNode({
-            kind: 'developer',
-            status: 'active',
-            intent: 'refresh',
-            pi_pid: original.pid,
-            pi_session_id: 'sess-d4c',
-        });
-        const originalExecution = beginExecution(id, { daemonEpoch: h.fleet.epoch() });
-        recordExecutionPid(originalExecution, id, original.pid);
-        h.fleet.register(id, { pid: original.pid, exited: new Promise(() => { }) });
-        const supervisor = new BrokerSupervisionReconciler();
-        const context = () => ({
-            rows: [getRow(id)],
-            fleet: h.fleet,
-            lifecycle: { acceptsDetachedWork: () => false, registerDetached: () => { } },
-        });
-        await supervisor.run(T0, context());
-        await supervisor.run(T_KILL, context());
-        await h.waitFor(() => (isPidAlive(original.pid) ? null : true), {
-            label: 'original refresh broker received SIGTERM',
-            timeoutMs: 10_000,
-        });
-        h.fleet.forget(id);
-        abortExecution(originalExecution, { reason: 'test replacement' });
-        replacement = spawn(process.execPath, ['-e', 'process.on("SIGTERM", () => {}); console.log("ready"); setInterval(() => {}, 1000)'], { stdio: ['ignore', 'pipe', 'ignore'] });
-        await new Promise((resolve, reject) => {
-            replacement.stdout.once('data', () => resolve());
-            replacement.once('error', reject);
-        });
-        const replacementExecution = beginExecution(id, { daemonEpoch: h.fleet.epoch() });
-        recordExecutionPid(replacementExecution, id, replacement.pid);
-        h.fleet.register(id, { pid: replacement.pid, exited: new Promise(() => { }) });
-        const replacementStarted = T_KILL + KILL_ESCALATE_MS + 1;
-        await supervisor.run(replacementStarted, context());
-        assert.equal(isPidAlive(replacement.pid), true, 'the old SIGKILL deadline does not target the replacement');
-        await supervisor.run(replacementStarted + YIELD_STALL_GRACE_MS + 1, context());
-        assert.equal(isPidAlive(replacement.pid), true, 'the replacement survives its own SIGTERM when still stalled');
-        await supervisor.run(replacementStarted + YIELD_STALL_GRACE_MS + KILL_ESCALATE_MS + 1, context());
-        await h.waitFor(() => (isPidAlive(replacement.pid) ? null : true), {
-            label: 'replacement refresh broker received its own SIGKILL',
-            timeoutMs: 10_000,
-        });
-    }
-    finally {
-        for (const child of [original, replacement]) {
-            if (child?.pid === undefined)
-                continue;
-            try {
-                child.kill('SIGKILL');
-            }
-            catch { /* already gone */ }
-        }
-        await h.dispose();
-    }
-});

package/dist/core/__tests__/integration/revive.test.d.ts

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