@north-light/crouter 0.3.318 → 0.3.319

package/dist/core/__tests__/seam/inbox-reference-guidance.test.js

@@ -1,84 +0,0 @@
-// Run with: npm run build && node --test --test-timeout=180000 dist/core/__tests__/seam/inbox-reference-guidance.test.js
-//
-// Pins the delivered inbox text from the compiled runtime: report handles name
-// the history reader, spilled messages name their exact recipient-side file,
-// and bearings reserve context for agent-authored shared documents.
-import { after, before, test } from 'node:test';
-import assert from 'node:assert/strict';
-import { readFileSync } from 'node:fs';
-import { subscribe } from '../../canvas/index.js';
-import { claimNodeMail } from '../../canvas/deliveries.js';
-import { beginExecution } from '../../canvas/executions.js';
-import { resolveRef } from '../../canvas/history.js';
-import { coalesce, nodeMailEntry } from '../../feed/inbox.js';
-import { enqueueNodeMail } from '../../feed/messages.js';
-import { pushUpdate } from '../../feed/feed.js';
-import { contextDirNote } from '../../runtime/bearings-render.js';
-import { coalesceBrokerInbox } from '../../runtime/broker/inbox.js';
-import { createHeadlessHarness } from '../helpers/harness.js';
-let h;
-let root;
-let recipient;
-let recipientExecution;
-before(async () => {
-    h = await createHeadlessHarness({ sessionPrefix: 'crtr-inbox-reference-guidance' });
-    root = h.spawnRoot('inbox reference guidance seam root');
-    recipient = h.fabricateBrokerNode({ id: 'inbox-reference-recipient', parent: root, status: 'idle' });
-    recipientExecution = beginExecution(recipient, { daemonEpoch: h.fleet.epoch() });
-});
-after(async () => {
-    if (h !== undefined)
-        await h.dispose();
-});
-function latestEntry() {
-    const claim = claimNodeMail(recipient, recipientExecution, 'wake');
-    assert.equal(claim.action, 'claimed');
-    const delivery = claim.deliveries.at(-1);
-    assert.ok(delivery, 'the newly enqueued delivery is handed to the recipient execution');
-    return nodeMailEntry(delivery);
-}
-function onlyCard(entries) {
-    const deliveries = coalesce(entries);
-    assert.equal(deliveries.length, 1, 'one non-human inbox entry produces one card');
-    assert.equal(deliveries[0].kind, 'card');
-    return deliveries[0].text;
-}
-test('delivered report and message refs name the exact way to read their bodies', async () => {
-    const publisher = h.fabricateBrokerNode({ id: 'inbox-reference-publisher', parent: root, status: 'idle' });
-    subscribe(recipient, publisher, true);
-    const reportBody = 'published report body';
-    await pushUpdate(publisher, reportBody);
-    const reportEntry = latestEntry();
-    assert.equal(reportEntry.ref?.startsWith(`${publisher}:reports/`), true, 'delivery carries the canonical report handle');
-    const reportRef = reportEntry.ref;
-    const reportCard = onlyCard([reportEntry]);
-    const brokerReportCard = coalesceBrokerInbox([reportEntry], new Map())[0].text;
-    for (const card of [reportCard, brokerReportCard]) {
-        assert.ok(card.includes(`crtr canvas history read ${reportRef}`), 'delivery names the exact command for its handle');
-    }
-    assert.equal(resolveRef(reportRef)?.body, reportBody, 'the exact delivered handle resolves to the freshly published report');
-    for (const body of [
-        'a'.repeat(1001),
-        Array.from({ length: 13 }, (_, i) => `line ${i + 1}`).join('\n'),
-    ]) {
-        enqueueNodeMail(recipient, {
-            senderNodeId: publisher,
-            urgency: 'normal',
-            wake: 1,
-            kind: 'message',
-            label: 'long message',
-            bodyJson: { body },
-        });
-        const message = latestEntry();
-        assert.ok(message.ref?.startsWith('/'), 'a clipped message stores its full body at an absolute recipient path');
-        const messageCard = onlyCard([message]);
-        const brokerMessageCard = coalesceBrokerInbox([message], new Map())[0].text;
-        for (const card of [messageCard, brokerMessageCard]) {
-            assert.ok(card.includes(`Preview only. Read the full body from file \`${message.ref}\`.`), 'the preview names the exact full-body path');
-        }
-        assert.equal(readFileSync(message.ref, 'utf8'), body, 'the exact delivered path holds the complete message');
-    }
-    const bearings = contextDirNote(recipient);
-    assert.match(bearings, /where you write documents to share with other nodes on the canvas/);
-    assert.doesNotMatch(bearings, /one place the other nodes on the canvas can read from/);
-});

package/dist/core/__tests__/seam/memory-slash-node-relative-inventory.test.d.ts

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

package/dist/core/__tests__/seam/memory-slash-node-relative-inventory.test.js

@@ -1,160 +0,0 @@
-import assert from 'node:assert/strict';
-import { mkdirSync, mkdtempSync, readFileSync, realpathSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { spawn } from 'node:child_process';
-import { test } from 'node:test';
-import { loadedCommandPreview } from '../../../clients/attach/slash/prompt-preview.js';
-const ROOT = join(dirname(fileURLToPath(import.meta.url)), '../../../..');
-const EXTENSION = join(ROOT, 'dist/builtin-pi-packages/pi-crtr-extensions/extensions/memory-slash-commands.ts');
-const LIVE_PROBE = join(ROOT, 'dist/core/__tests__/fixtures/memory-slash-live-probe.js');
-const COMMAND_LOCALS = ['acceptance-context-token', 'acceptance-node-token', 'acceptance-independent'];
-const PROJECT_NAMESPACE = 'workspace';
-const COMMAND_NAMES = COMMAND_LOCALS.map((name) => `${PROJECT_NAMESPACE}:workspace:${name}`);
-function writeSlashDoc(memoryDir, name, description, body) {
-    writeFileSync(join(memoryDir, `${name}.md`), `---\nkind: knowledge\nwhen-and-why-to-read: Acceptance fixture.\nshort-form: ${description}\nslash: true\n---\n${body}`);
-}
-function liveProbe(input) {
-    return new Promise((resolve, reject) => {
-        const child = spawn(process.execPath, [LIVE_PROBE, EXTENSION, JSON.stringify(input.invocations)], {
-            cwd: input.cwd,
-            env: {
-                ...process.env,
-                CRTR_HOME: input.home,
-                CRTR_NODE_ID: input.nodeId,
-                CRTR_PROFILE_ID: '',
-                PI_CODING_AGENT_DIR: join(input.cwd, '.pi'),
-            },
-            stdio: ['ignore', 'pipe', 'pipe', 'pipe'],
-        });
-        let stdout = '';
-        let stderr = '';
-        let response = '';
-        const stdoutStream = child.stdout;
-        const stderrStream = child.stderr;
-        const responseStream = child.stdio[3];
-        if (stdoutStream === null || stderrStream === null || responseStream === null) {
-            child.kill('SIGKILL');
-            reject(new Error('live probe response channel unavailable'));
-            return;
-        }
-        stdoutStream.setEncoding('utf8');
-        stderrStream.setEncoding('utf8');
-        responseStream.setEncoding('utf8');
-        stdoutStream.on('data', (chunk) => { stdout += chunk; });
-        stderrStream.on('data', (chunk) => { stderr += chunk; });
-        responseStream.on('data', (chunk) => { response += chunk; });
-        child.on('error', reject);
-        child.on('close', (code, signal) => {
-            if (code !== 0) {
-                reject(new Error(`live probe exited ${code ?? signal ?? 'unknown'}: ${stderr}${stdout}`));
-                return;
-            }
-            resolve(JSON.parse(response));
-        });
-    });
-}
-function fixtureRows(rows) {
-    return COMMAND_NAMES.map((name) => {
-        const row = rows.find((candidate) => candidate.name === name);
-        assert.ok(row, `Gateway advertises /${name}`);
-        return row;
-    });
-}
-test('node-relative memory slash commands omit preview metadata and register invoked bodies at content', async () => {
-    const repositoryRoot = mkdtempSync(join(tmpdir(), 'crtr-memory-slash-inventory-'));
-    const cwd = join(repositoryRoot, 'workspace');
-    const home = join(repositoryRoot, 'canvas');
-    const memoryDir = join(cwd, '.crouter', 'memory');
-    const repositoryMemory = join(repositoryRoot, '.crouter', 'memory');
-    const nodeId = 'acceptance-live-node';
-    mkdirSync(memoryDir, { recursive: true });
-    mkdirSync(repositoryMemory, { recursive: true });
-    writeFileSync(join(repositoryMemory, 'INDEX.md'), `---\nnamespace: ${PROJECT_NAMESPACE}\n---\nWorkspace front door.\n`);
-    writeSlashDoc(memoryDir, COMMAND_LOCALS[0], 'Context-relative fixture.', 'Store $ARGUMENTS in $CRTR_CONTEXT_DIR/result.md.\n');
-    writeSlashDoc(memoryDir, COMMAND_LOCALS[1], 'Node-relative fixture.', 'Node $CRTR_NODE_ID received $ARGUMENTS.\n');
-    writeSlashDoc(memoryDir, COMMAND_LOCALS[2], 'Node-independent fixture.', 'Independent payload: $ARGUMENTS.\n');
-    try {
-        const live = await liveProbe({
-            cwd,
-            home,
-            nodeId,
-            invocations: COMMAND_NAMES.map((name) => ({ name, args: 'evidence' })),
-        });
-        assert.equal(live.stateBeforeProspective, false);
-        assert.equal(live.stateAfterProspective, false);
-        assert.deepEqual(live.commands, live.prospective.commands);
-        assert.deepEqual(live.memoryRefs, live.prospective.memory_refs);
-        const prospectiveRows = fixtureRows(live.prospective.commands);
-        const liveRows = fixtureRows(live.commands);
-        assert.deepEqual(liveRows, prospectiveRows);
-        for (const local of COMMAND_LOCALS) {
-            assert.equal(live.commands.some((row) => row.name === local), false, `/${local} is not retained as an old command`);
-        }
-        assert.deepEqual(prospectiveRows, [
-            { name: COMMAND_NAMES[0], description: 'Context-relative fixture.', source: 'command' },
-            { name: COMMAND_NAMES[1], description: 'Node-relative fixture.', source: 'command' },
-            {
-                name: COMMAND_NAMES[2],
-                description: 'Node-independent fixture.',
-                source: 'command',
-                expansion: {
-                    kind: 'memory-slash',
-                    commandName: COMMAND_NAMES[2],
-                    body: 'Independent payload: $ARGUMENTS.\n',
-                },
-            },
-        ]);
-        const insightsInit = live.commands.find((row) => row.name === 'insights:init');
-        assert.ok(insightsInit, 'Gateway completion includes /insights:init');
-        assert.equal(insightsInit.expansion, undefined);
-        assert.equal(loadedCommandPreview('/insights:init agent-facing CLI', live.commands), undefined);
-        assert.equal(loadedCommandPreview(`/${COMMAND_NAMES[2]} first evidence`, live.commands)?.content, 'Independent payload: first evidence.\n');
-        assert.equal(loadedCommandPreview(`/${COMMAND_NAMES[2]} changed evidence`, live.commands)?.content, 'Independent payload: changed evidence.\n');
-        assert.equal(loadedCommandPreview('/acceptance-independent first evidence', live.commands), undefined);
-        assert.deepEqual(live.notifications, []);
-        const sentContent = Object.fromEntries(live.sent.map((send) => [send.name, send.message.content]));
-        const invokedBody = {
-            [COMMAND_NAMES[0]]: `Store evidence in ${join(home, 'nodes', nodeId, 'context', 'result.md')}.\n`,
-            [COMMAND_NAMES[1]]: `Node ${nodeId} received evidence.\n`,
-            [COMMAND_NAMES[2]]: 'Independent payload: evidence.\n',
-        };
-        // An invoked document is content delivery, so the FIRST invocation carries the
-        // same companions `crtr memory read` attaches: the listings that place the doc,
-        // plus every corpus doc its memory-read routes match. The doc being delivered is
-        // absent from its own listing because its exposure registers before they render.
-        const firstSent = sentContent[COMMAND_NAMES[0]];
-        assert.ok(firstSent.endsWith(invokedBody[COMMAND_NAMES[0]]), 'the expanded body ends the delivery');
-        const companions = firstSent.slice(0, firstSent.length - invokedBody[COMMAND_NAMES[0]].length);
-        assert.match(companions, /^<auto-loaded-context>\n[\s\S]*<\/auto-loaded-context>\n\n$/);
-        assert.ok(companions.includes('<memory-listing dir="workspace/workspace">\n'
-            + `[[workspace/workspace/${COMMAND_LOCALS[2]}]]: Acceptance fixture.\n`
-            + `[[workspace/workspace/${COMMAND_LOCALS[1]}]]: Acceptance fixture.\n`
-            + '</memory-listing>'), 'the invoked doc\'s own directory listing is attached as a block');
-        assert.ok(companions.includes('<memory-listing dir="workspace">\n[[workspace/workspace]]\n</memory-listing>'));
-        assert.match(companions, /<memory kind="knowledge" name="memory-read-orientation">/);
-        // The later invocations attach nothing: the first delivery already exposed them.
-        assert.equal(sentContent[COMMAND_NAMES[1]], invokedBody[COMMAND_NAMES[1]]);
-        assert.equal(sentContent[COMMAND_NAMES[2]], invokedBody[COMMAND_NAMES[2]]);
-        for (const send of live.sent) {
-            assert.deepEqual(send.message, {
-                customType: 'memory-slash-command',
-                content: sentContent[send.name],
-                display: true,
-            });
-            assert.deepEqual(send.options, { triggerTurn: true });
-        }
-        assert.doesNotMatch(sentContent[COMMAND_NAMES[0]], /\$CRTR_CONTEXT_DIR|\$CRTR_NODE_ID/);
-        assert.doesNotMatch(sentContent[COMMAND_NAMES[1]], /\$CRTR_CONTEXT_DIR|\$CRTR_NODE_ID/);
-        const persisted = JSON.parse(readFileSync(join(home, 'nodes', nodeId, 'injected-docs.json'), 'utf8'));
-        assert.equal(persisted.v, 3);
-        for (const name of COMMAND_LOCALS) {
-            const path = realpathSync(join(memoryDir, `${name}.md`));
-            assert.deepEqual(persisted.exposures[path], { transcript: 3 }, `/${name} registers the invoked document body as transcript content`);
-        }
-    }
-    finally {
-        rmSync(repositoryRoot, { recursive: true, force: true });
-    }
-});

package/dist/core/__tests__/seam/node-outcome-delivery.test.d.ts

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

package/dist/core/__tests__/seam/node-outcome-delivery.test.js

@@ -1,177 +0,0 @@
-// Run with: npm run build && node --test --test-timeout=180000 dist/core/__tests__/seam/node-outcome-delivery.test.js
-//
-// Pins the terminal-outcome delivery boundary: a real node publishes a canonical
-// final through the CLI, then the compiled daemon lane gives the registered
-// command its immutable outcome document on stdin and honors its exit code.
-import { after, before, test } from 'node:test';
-import assert from 'node:assert/strict';
-import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { closeDb } from '../../canvas/db.js';
-import { messageBodyForDelivery, readExternalActionDelivery } from '../../canvas/deliveries.js';
-import { createHeadlessHarness } from '../helpers/harness.js';
-let h;
-let root;
-let project;
-function outcomeDelivery(nodeId) {
-    const row = readExternalActionDelivery(`node-outcome:${nodeId}`);
-    if (row === null)
-        return null;
-    const adapter = row.adapter;
-    if (adapter?.adapter !== 'subprocess' || !Array.isArray(adapter.argv) || !adapter.argv.every((entry) => typeof entry === 'string') || typeof adapter.cwd !== 'string')
-        throw new Error(`outcome delivery ${row.deliveryId} has an invalid subprocess adapter`);
-    if (row.state !== 'armed' && row.state !== 'pending' && row.state !== 'handed_off' && row.state !== 'acknowledged' && row.state !== 'permanent_failed')
-        throw new Error(`outcome delivery ${row.deliveryId} has an invalid state`);
-    return {
-        state: row.state === 'handed_off' ? 'running' : row.state === 'acknowledged' ? 'accepted' : row.state,
-        actionName: row.destinationId,
-        argv: adapter.argv,
-        cwd: adapter.cwd,
-        configOrigin: typeof adapter.config_origin === 'string' ? adapter.config_origin : '',
-        payload: adapter.payload ?? null,
-        document: row.messageId === null ? null : messageBodyForDelivery(row.deliveryId),
-        attempt: row.attempts,
-        nextAttemptAt: row.nextAttemptAt ?? 0,
-        acceptedAt: row.acknowledgedAt,
-        permanentFailedAt: row.failedAt,
-        lastFailure: row.lastFailure,
-    };
-}
-function assertKeys(value, expected, label) {
-    assert.deepEqual(Object.keys(value).sort(), [...expected].sort(), `${label} has the pinned document fields`);
-}
-function readCapture(action, attempt) {
-    const path = join(project, `${action}-${attempt}.json`);
-    assert.ok(existsSync(path), `${action} attempt ${attempt} captured stdin`);
-    return JSON.parse(readFileSync(path, 'utf8'));
-}
-function assertResultDocument(document, nodeId, action, payloadJson, attempt) {
-    assertKeys(document, ['schema', 'outcomeId', 'nodeId', 'revision', 'kind', 'reason', 'settledAt', 'node', 'result', 'action', 'delivery'], 'node outcome document');
-    assert.equal(document.schema, 'crtr.node-outcome/v1');
-    assert.equal(document.outcomeId, `${nodeId}:1`);
-    assert.equal(document.nodeId, nodeId);
-    assert.equal(document.revision, 1);
-    assert.equal(document.kind, 'result');
-    assert.equal(document.reason, 'finalized');
-    assert.match(document.settledAt, /^\d{4}-\d{2}-\d{2}T/);
-    assert.equal(document.failure, undefined, 'result documents do not carry a failure discriminator');
-    assertKeys(document.node, ['name', 'kind', 'mode', 'lifecycle', 'status', 'terminalReason', 'cwd', 'createdAt', 'parent', 'spawnedBy'], 'document node');
-    assert.equal(document.node['kind'], 'general');
-    assert.equal(document.node['mode'], 'base');
-    assert.equal(document.node['lifecycle'], 'terminal');
-    assert.equal(document.node['status'], 'done');
-    assert.equal(document.node['terminalReason'], 'finalized');
-    assert.equal(document.node['cwd'], project);
-    assert.equal(document.node['parent'], root);
-    assert.equal(document.node['spawnedBy'], root);
-    assertKeys(document.result, ['finalReport'], 'result document');
-    const finalReport = document.result['finalReport'];
-    assertKeys(finalReport, ['basename', 'path'], 'result final-report pointer');
-    assert.equal(typeof finalReport['basename'], 'string');
-    assert.equal(typeof finalReport['path'], 'string');
-    assertKeys(document.action, ['name', 'payload'], 'document action');
-    assert.equal(document.action.name, action);
-    assert.equal(JSON.stringify(document.action.payload), payloadJson, 'action payload reaches stdin byte-identically');
-    assertKeys(document.delivery, ['attempt'], 'document delivery');
-    assert.equal(document.delivery.attempt, attempt);
-}
-function deliveryWhen(nodeId, predicate, label) {
-    return h.waitFor(() => {
-        closeDb();
-        const delivery = outcomeDelivery(nodeId);
-        return delivery !== null && predicate(delivery) ? delivery : null;
-    }, { label, timeoutMs: 20_000 });
-}
-async function createAndFinalize(action, payload) {
-    const payloadJson = JSON.stringify(payload);
-    const created = h.cli(root, [
-        '--json', 'node', 'new', '--kind', 'general', '--cwd', project,
-        '--outcome-action', action, '--outcome-payload', payloadJson,
-        `outcome delivery ${action}`,
-    ]);
-    assert.equal(created.code, 0, `node new for ${action}: ${created.stderr}`);
-    const createdBody = created.json;
-    assert.equal(typeof createdBody?.node_id, 'string', `node new returns its node id for ${action}`);
-    const nodeId = createdBody.node_id;
-    await h.awaitBoot(nodeId);
-    closeDb();
-    const armed = outcomeDelivery(nodeId);
-    assert.notEqual(armed, null, `node birth arms ${action} delivery`);
-    assert.equal(armed.state, 'armed');
-    assert.equal(armed.actionName, action);
-    assert.equal(armed.argv[0], join(project, `${action}.sh`));
-    assert.equal(armed.cwd, project);
-    assert.equal(armed.configOrigin, join(project, '.crouter', 'config.json'));
-    assert.equal(JSON.stringify(armed.payload), payloadJson, 'registered payload is frozen before launch');
-    assert.equal(armed.attempt, 0);
-    const finalized = h.cli(nodeId, ['push', 'final', `canonical final for ${action}`]);
-    assert.equal(finalized.code, 0, `push final for ${action}: ${finalized.stderr}`);
-    const pending = await deliveryWhen(nodeId, (delivery) => delivery.state === 'pending', `${action} delivery pending after canonical final`);
-    assert.notEqual(pending.document, null, 'canonical final composes the immutable delivery document');
-    return { nodeId, payloadJson };
-}
-function writeCaptureAction(action, exitPolicy) {
-    const script = join(project, `${action}.sh`);
-    writeFileSync(script, `#!/bin/sh
-attempt_file=.${action}.attempt
-attempt=$(cat "$attempt_file" 2>/dev/null || printf 0)
-attempt=$((attempt + 1))
-printf '%s' "$attempt" > "$attempt_file"
-cat > "${action}-$attempt.json"
-${exitPolicy}
-`);
-    chmodSync(script, 0o755);
-}
-before(async () => {
-    h = await createHeadlessHarness({ sessionPrefix: 'crtr-node-outcome-delivery' });
-    root = h.spawnRoot('node outcome delivery seam root');
-    project = join(h.agentHome, 'outcome-delivery-project');
-    mkdirSync(join(project, '.crouter'), { recursive: true });
-    writeCaptureAction('accepted', 'exit 0');
-    writeCaptureAction('permanent', 'exit 78');
-    writeCaptureAction('retry', 'if [ "$attempt" -eq 1 ]; then exit 1; fi\nexit 0');
-    writeFileSync(join(project, '.crouter', 'config.json'), JSON.stringify({
-        humanActions: {
-            accepted: { argv: ['accepted.sh'], cwd: '.' },
-            permanent: { argv: ['permanent.sh'], cwd: '.' },
-            retry: { argv: ['retry.sh'], cwd: '.' },
-        },
-    }));
-});
-after(async () => {
-    if (h !== undefined)
-        await h.dispose();
-});
-test('canonical outcomes deliver the exact document and honor accepted, permanent, and retry exits', { timeout: 60_000 }, async () => {
-    const acceptedPayload = JSON.parse('{"callbackToken":"accepted-token","callbackId":"accepted-id","nested":{"emoji":"✓"}}');
-    const accepted = await createAndFinalize('accepted', acceptedPayload);
-    await h.tick();
-    const acceptedDelivery = await deliveryWhen(accepted.nodeId, (delivery) => delivery.state === 'accepted' && delivery.attempt === 1, 'accepted outcome delivery');
-    assert.equal(acceptedDelivery.acceptedAt === null, false, 'exit 0 settles delivery as accepted');
-    assertResultDocument(readCapture('accepted', 1), accepted.nodeId, 'accepted', accepted.payloadJson, 1);
-    const permanentPayload = JSON.parse('{"callbackToken":"permanent-token","callbackId":"permanent-id","nested":{"emoji":"✓"}}');
-    const permanent = await createAndFinalize('permanent', permanentPayload);
-    await h.tick();
-    const permanentDelivery = await deliveryWhen(permanent.nodeId, (delivery) => delivery.state === 'permanent_failed' && delivery.attempt === 1, 'permanent outcome delivery');
-    assert.equal(permanentDelivery.permanentFailedAt === null, false, 'exit 78 permanently fails delivery');
-    assert.equal(permanentDelivery.lastFailure?.exitCode, 78);
-    assertResultDocument(readCapture('permanent', 1), permanent.nodeId, 'permanent', permanent.payloadJson, 1);
-    const retryPayload = JSON.parse('{"callbackToken":"retry-token","callbackId":"retry-id","nested":{"emoji":"✓"}}');
-    const retry = await createAndFinalize('retry', retryPayload);
-    await h.tick();
-    const first = await deliveryWhen(retry.nodeId, (delivery) => delivery.state === 'pending' && delivery.attempt === 1 && delivery.lastFailure?.kind === 'exit', 'retryable first outcome delivery');
-    assert.ok(first.nextAttemptAt > Date.now(), 'exit 1 schedules a later retry');
-    assert.equal(first.lastFailure?.exitCode, 1);
-    const firstDocument = readCapture('retry', 1);
-    assertResultDocument(firstDocument, retry.nodeId, 'retry', retry.payloadJson, 1);
-    await h.tick(first.nextAttemptAt + 1);
-    const retried = await deliveryWhen(retry.nodeId, (delivery) => delivery.state === 'accepted' && delivery.attempt === 2, 'second outcome delivery accepted');
-    assert.equal(retried.acceptedAt === null, false, 'the second attempt accepts delivery');
-    const secondDocument = readCapture('retry', 2);
-    assertResultDocument(secondDocument, retry.nodeId, 'retry', retry.payloadJson, 2);
-    const { delivery: firstDelivery, ...firstImmutable } = firstDocument;
-    const { delivery: secondDelivery, ...secondImmutable } = secondDocument;
-    assert.deepEqual(secondImmutable, firstImmutable, 'only delivery.attempt changes across retries');
-    assert.deepEqual(firstDelivery, { attempt: 1 });
-    assert.deepEqual(secondDelivery, { attempt: 2 });
-});

package/dist/core/__tests__/seam/prospective-inventory-stdout.test.d.ts

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

package/dist/core/__tests__/seam/prospective-inventory-stdout.test.js

@@ -1,31 +0,0 @@
-import assert from 'node:assert/strict';
-import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { test } from 'node:test';
-import { runProspectiveInventory } from '../../runtime/prospective-inventory.js';
-test('prospective preflight keeps package stdout out of its response channel', async () => {
-    const cwd = mkdtempSync(join(tmpdir(), 'crtr-prospective-stdout-'));
-    const extension = join(cwd, 'loud-extension.mjs');
-    writeFileSync(extension, `
-export default function (pi) {
-  console.log('harmless package diagnostic');
-  pi.registerCommand('stdout-probe', {
-    description: 'survives package stdout',
-    gateway: true,
-    handler: async () => {},
-  });
-}
-`);
-    try {
-        const rows = await runProspectiveInventory({ cwd, profileId: null, extensions: [extension] });
-        assert.deepEqual(rows.commands.find((row) => row.name === 'stdout-probe'), {
-            name: 'stdout-probe',
-            description: 'survives package stdout',
-            source: 'command',
-        });
-    }
-    finally {
-        rmSync(cwd, { recursive: true, force: true });
-    }
-});

package/dist/core/__tests__/seam/reopen-invalidated-worktree.test.d.ts

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

package/dist/core/__tests__/seam/reopen-invalidated-worktree.test.js

@@ -1,60 +0,0 @@
-// Run with: npm run build && node --test --test-timeout=180000 dist/core/__tests__/seam/reopen-invalidated-worktree.test.js
-//
-// Regression for #1070 and #1064: a completed managed-worktree node loses its
-// session when the worktree closes. Atomic message reopen must start from the
-// retained final report and the new instruction, never replay its birth goal.
-import { after, before, test } from 'node:test';
-import assert from 'node:assert/strict';
-import { existsSync } from 'node:fs';
-import { join } from 'node:path';
-import { createHeadlessHarness } from '../helpers/harness.js';
-import { pushFinal } from '../../feed/feed.js';
-import { persistClosedWorktreeState } from '../../worktree.js';
-import { readGoal } from '../../runtime/kickoff.js';
-let h;
-before(async () => {
-    h = await createHeadlessHarness({ sessionPrefix: 'crtr-reopen-invalidated-worktree' });
-});
-after(async () => {
-    if (h !== undefined)
-        await h.dispose();
-});
-test('atomic message reopen of a closed worktree starts fresh from the prior final and follow-up, not the birth goal', { timeout: 30_000 }, async () => {
-    const root = h.spawnRoot('reopen invalidated-worktree manager');
-    const originalGoal = 'ORIGINAL-MANDATE: do not replay this completed implementation task';
-    const followUp = 'FOLLOW-UP-MANDATE: inspect the completed work without changing it';
-    const child = await h.spawnHeadlessChild(root, originalGoal);
-    await pushFinal(child, 'COMPLETED-FINAL: the original implementation is complete');
-    const finalReport = h.node(child)?.final_report;
-    assert.ok(finalReport, 'the completed worker has a canonical final report');
-    const finalPath = join(h.home, 'nodes', child, 'reports', finalReport);
-    assert.equal(existsSync(finalPath), true, 'the canonical final exists before reopening');
-    persistClosedWorktreeState(child, {
-        state: 'open',
-        path: join(h.home, 'removed-worktree'),
-        branch: 'crtr/reopen-invalidated-worktree',
-        repo_root: process.cwd(),
-        base_ref: 'main',
-        base_sha: 'test',
-        created: new Date().toISOString(),
-    });
-    assert.equal(h.node(child)?.pi_session_file ?? null, null, 'closed worktree invalidates the old session coordinate');
-    const oldPid = h.node(child)?.pi_pid;
-    assert.ok(oldPid != null, 'the original broker is still live until its completed turn exits');
-    process.kill(oldPid, 'SIGKILL');
-    await h.awaitFleetExit(child);
-    const result = h.cli(root, ['node', 'message', 'send', '--to', child, '--reopen', followUp]);
-    assert.equal(result.code, 0, `atomic reopen message should succeed\n--stderr--\n${result.stderr}`);
-    const boot = await h.awaitBoot(child, { minCount: 2 });
-    assert.equal(boot.resuming, false, 'the cleared session forces a fresh broker boot');
-    assert.equal(boot.prompt?.includes(originalGoal), false, 'a completed node never replays its birth mandate');
-    const priorFinalIndex = boot.prompt?.indexOf('reopen-final-report') ?? -1;
-    const followUpIndex = boot.prompt?.indexOf(followUp) ?? -1;
-    assert.ok(priorFinalIndex >= 0 && boot.prompt?.includes(finalPath), 'the prior final report path is delivered as context');
-    assert.ok(followUpIndex >= 0, 'the new instruction is delivered in the fresh kickoff');
-    assert.ok(priorFinalIndex < followUpIndex, 'the prior final report context arrives before the new instruction');
-    assert.equal(readGoal(child)?.trim(), originalGoal, 'the birth goal remains on disk as historical data');
-    assert.equal(existsSync(finalPath), true, 'reopen does not delete the prior final report');
-    assert.equal(h.node(child)?.lifecycle, 'resident', 'atomic reopen restores resident lifecycle before the fresh broker starts');
-    assert.equal(h.node(child)?.final_report ?? null, null, 'atomic reopen clears only the live finalization latch');
-});

package/dist/core/__tests__/seam/self-close-teardown.test.d.ts

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

package/dist/core/__tests__/seam/self-close-teardown.test.js

@@ -1,49 +0,0 @@
-// Run with: npm run build && node --test dist/core/__tests__/seam/self-close-teardown.test.js
-import { after, before, test } from 'node:test';
-import assert from 'node:assert/strict';
-import { existsSync, readFileSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { isPidAlive } from '../../canvas/pid.js';
-import { nodeDir } from '../../canvas/paths.js';
-import { createHarness } from '../helpers/harness.js';
-let h;
-let root;
-before(async () => {
-    h = await createHarness({ headless: true, sessionPrefix: 'crtr-self-close' });
-    root = h.spawnRoot('self-close teardown root');
-});
-after(async () => {
-    if (h !== undefined)
-        await h.dispose();
-});
-test('a node closes itself without killing its long-lived calling shell', { timeout: 60_000 }, async () => {
-    const id = await h.spawnHeadlessChild(root, 'self-close worker');
-    const brokerPid = h.node(id)?.pi_pid;
-    assert.ok(brokerPid != null && isPidAlive(brokerPid), 'precondition: worker broker is alive');
-    const session = h.node(id)?.pi_session_file;
-    assert.ok(session != null, 'worker has a session file');
-    writeFileSync(session, JSON.stringify({ type: 'message', message: { role: 'assistant', content: [{ type: 'text', text: 'work' }] } }) + '\n');
-    const dir = nodeDir(id);
-    const resultPath = join(dir, 'self-close-result');
-    const shellPidPath = join(dir, 'self-close-shell.pid');
-    let shellPid;
-    try {
-        h.fakeCmd(id, { cmd: 'self_close' });
-        await h.waitFor(() => existsSync(resultPath), { label: 'self-close CLI result' });
-        assert.equal(readFileSync(resultPath, 'utf8').trim(), '0', 'the shell received a successful close result');
-        shellPid = Number(readFileSync(shellPidPath, 'utf8').trim());
-        assert.ok(Number.isInteger(shellPid) && shellPid > 0, 'fixture recorded the long-lived calling shell pid');
-        assert.equal(isPidAlive(shellPid), true, 'the calling shell survives the daemon teardown');
-        await h.waitFor(() => !isPidAlive(brokerPid), { label: 'self-closing broker exits' });
-        assert.equal(isPidAlive(shellPid), true, 'the calling shell remains alive after the broker is gone');
-        assert.equal(h.status(id), 'canceled', 'close writes the terminal transition before teardown');
-    }
-    finally {
-        if (shellPid !== undefined) {
-            try {
-                process.kill(shellPid, 'SIGKILL');
-            }
-            catch { /* shell already exited */ }
-        }
-    }
-});

package/dist/core/__tests__/seam/yield-refresh-transaction.test.d.ts

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