@north-light/crouter 0.3.311 → 0.3.313

package/dist/core/__tests__/human-deliver.test.js

@@ -1,256 +0,0 @@
-// Run with: node --import tsx/esm --test src/core/__tests__/human-deliver.test.ts
-//
-// Crouter creates bridge tickets, while crtrd owns terminal ticket delivery.
-import { test, describe, before, after, beforeEach, afterEach } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, rmSync, writeFileSync, readFileSync, existsSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { ApiError } from '../../api/index.js';
-import { createApiServer } from '../../daemon/api/server.js';
-import { cancelHumanTicket, deliverTerminalResult, resolvePageTicket, settleFeedbackCompanion } from '../../daemon/human/finish.js';
-import { humanSend as buildHumanSend } from '../../commands/human/prompts.js';
-const humanSend = buildHumanSend();
-import { getNode, listNodes, closeDb } from '../canvas/index.js';
-import { coalesce, readInboxSince } from '../feed/inbox.js';
-import { createPageFeedbackComment } from '../human/feedback.js';
-import { resolveRef } from '../canvas/history.js';
-import { transition } from '../runtime/lifecycle.js';
-import { reviveNode } from '../runtime/revive.js';
-import { apiSocketPath } from '../canvas/paths.js';
-import { spawnNode } from '../runtime/nodes.js';
-import { bindTicketReplyRoute } from '../human/convention.js';
-import { ticketDir } from '../human/root.js';
-import { pageFeedbackPath } from '../human/feedback.js';
-import { parseCard } from '../../shared/generated-context.js';
-import { readTicketResult, submitPage } from '../human/tickets.js';
-let home;
-let priorHome;
-let server;
-async function waitForSocket(path) {
-    for (let i = 0; i < 200; i++) {
-        if (existsSync(path))
-            return;
-        await new Promise((r) => setTimeout(r, 25));
-    }
-    throw new Error(`api socket never bound at ${path}`);
-}
-async function withMutedStdout(fn) {
-    const originalWrite = process.stdout.write;
-    process.stdout.write = (() => true);
-    try {
-        return await fn();
-    }
-    finally {
-        process.stdout.write = originalWrite;
-    }
-}
-function bridgeUnder() {
-    const parent = spawnNode({ kind: 'general', parent: null, cwd: home, name: 'asker' }).node_id;
-    const bridge = spawnNode({ kind: 'human', parent, creator: parent, cwd: home, name: 'human-page', lifecycle: 'terminal' }).node_id;
-    return { parent, bridge };
-}
-function submitBridgePage(bridge) {
-    const dir = ticketDir(bridge);
-    const sourceDir = mkdtempSync(join(tmpdir(), 'crtr-deliver-page-'));
-    const sourceFile = join(sourceDir, 'page.tsx');
-    writeFileSync(sourceFile, 'export default () => (\n  <Page title="Ship it?" subtitle="Decide whether to ship now so the release can proceed.">\n    <UserText id="question" initialText="" />\n  </Page>\n);\n');
-    try {
-        bindTicketReplyRoute(dir, bridge);
-        submitPage({ dir, sourceFile, delivery: { placement: 'inline', inbox: true, reply: true } });
-    }
-    finally {
-        rmSync(sourceDir, { recursive: true, force: true });
-    }
-    return dir;
-}
-function reportBody(ref) {
-    const resolved = resolveRef(ref);
-    if (resolved === null || resolved.source !== 'report')
-        throw new Error(`push report ref did not resolve to a report: ${ref}`);
-    return resolved.body;
-}
-before(() => {
-    priorHome = process.env['HOME'];
-});
-beforeEach(async () => {
-    closeDb();
-    home = mkdtempSync(join(tmpdir(), 'crtr-deliver-home-'));
-    process.env['CRTR_HOME'] = home;
-    process.env['HOME'] = home;
-    delete process.env['CRTR_NODE_ID'];
-    server = createApiServer();
-    await waitForSocket(apiSocketPath());
-});
-afterEach(async () => {
-    await server?.close();
-    rmSync(home, { recursive: true, force: true });
-});
-after(() => {
-    closeDb();
-    if (priorHome !== undefined)
-        process.env['HOME'] = priorHome;
-    else
-        delete process.env['HOME'];
-    delete process.env['CRTR_HOME'];
-    delete process.env['CRTR_NODE_ID'];
-});
-describe('enqueue is producer-only', () => {
-    test('send preserves title and subtitle from the authored page', async () => {
-        const parent = spawnNode({ kind: 'general', parent: null, cwd: home, name: 'asker' }).node_id;
-        process.env['CRTR_NODE_ID'] = parent;
-        const page = join(home, 'release-decision.tsx');
-        writeFileSync(page, 'export default () => (\n  <Page title="Release decision" subtitle="Decide whether to release now so the launch can proceed.">\n    <p>This first line stays page content.</p>\n    <UserText id="question" initialText="" />\n  </Page>\n);\n');
-        await assert.rejects(() => humanSend.run({}), /a page source is required/);
-        await assert.rejects(() => humanSend.run({ page, document: 'export default () => <Page title="Dup" />;' }), /received both --page and a piped page document/);
-        const result = (await humanSend.run({ page, document: '' }));
-        assert.equal(typeof result['page_id'], 'string');
-        assert.equal(result['reply'], true);
-        assert.equal(typeof result['dir'], 'string');
-        for (const forbidden of ['pane_id', 'render_pane_id', 'pid', 'worker_pid'])
-            assert.ok(!(forbidden in result), `send result must not expose ${forbidden}`);
-        const manifest = JSON.parse(readFileSync(join(result['dir'], 'page.json'), 'utf8'));
-        assert.equal(manifest.title, 'Release decision');
-        assert.equal(manifest.subtitle, 'Decide whether to release now so the launch can proceed.');
-        const document = readFileSync(join(result['dir'], 'page.tsx'), 'utf8');
-        assert.ok(document.includes('This first line stays page content.'));
-        assert.equal(manifest.slots.filter((slot) => slot.kind === 'text').length, 1);
-    });
-    test('send materializes a piped page before validation and publication', async () => {
-        const parent = spawnNode({ kind: 'general', parent: null, cwd: home, name: 'asker' }).node_id;
-        process.env['CRTR_NODE_ID'] = parent;
-        const document = 'export default () => (\n  <Page title="Piped question" subtitle="Answer the question to unblock this task.">\n    <UserText id="question" initialText="" />\n  </Page>\n);\n';
-        const result = (await humanSend.run({ document }));
-        const manifest = JSON.parse(readFileSync(join(result['dir'], 'page.json'), 'utf8'));
-        assert.equal(manifest.title, 'Piped question');
-        assert.equal(readFileSync(join(result['dir'], 'page.tsx'), 'utf8'), document);
-    });
-});
-describe('terminal ticket delivery', () => {
-    test("resolvePageTicket pushFinals the person's words once and wakes the subscribed parent", async () => {
-        const { parent, bridge } = bridgeUnder();
-        const dir = submitBridgePage(bridge);
-        const result = await resolvePageTicket(bridge, { question: { text: 'yes, ship', edited: true } });
-        assert.equal(result.kind, 'page');
-        closeDb();
-        assert.equal(getNode(bridge)?.status, 'done');
-        const finals = readInboxSince(parent).filter((entry) => entry.from === bridge && entry.kind === 'final');
-        assert.equal(finals.length, 1, 'exactly one pushFinal reached the parent');
-        const body = reportBody(finals[0].ref);
-        assert.equal(body, 'yes, ship');
-        assert.equal(finals[0].disposition, 'human-answer');
-        assert.ok(!body.includes(join(dir, 'response.json')));
-    });
-    test('settlement delivers feedback outside the human-answer entry', async () => {
-        const { parent, bridge } = bridgeUnder();
-        const dir = submitBridgePage(bridge);
-        writeFileSync(pageFeedbackPath(dir), JSON.stringify({
-            schema: 'crtr.page-feedback/v1',
-            companionNodeId: 'feedback-companion',
-            firstCommentedSha256: 'stale-page-hash',
-            comments: [],
-        }));
-        await resolvePageTicket(bridge, { question: { text: 'yes, ship', edited: true } });
-        closeDb();
-        const entries = readInboxSince(parent).filter((entry) => entry.from === bridge);
-        const final = entries.find((entry) => entry.kind === 'final');
-        const feedback = entries.find((entry) => entry.kind === 'update');
-        assert.ok(final);
-        assert.ok(feedback);
-        assert.equal(final.disposition, 'human-answer');
-        assert.match(reportBody(feedback.ref), /The page changed during feedback/);
-        const deliveries = coalesce(entries);
-        assert.equal(deliveries.length, 1);
-        const card = parseCard({ role: 'user', content: deliveries[0].text });
-        assert.ok(card);
-        const answer = card.senders.flatMap((sender) => sender.entries).find((entry) => entry.disposition === 'human-answer');
-        assert.deepEqual(answer, { kind: 'final', disposition: 'human-answer', body: `yes, ship\n\nRead this report with \`crtr canvas history read ${final.ref}\`.`, ref: final.ref });
-    });
-    test('a replay against a terminal bridge is a no-op', async () => {
-        const { parent, bridge } = bridgeUnder();
-        submitBridgePage(bridge);
-        await resolvePageTicket(bridge, { question: { text: 'yes', edited: true } });
-        assert.equal(await deliverTerminalResult(bridge), true);
-        closeDb();
-        const finals = readInboxSince(parent).filter((entry) => entry.from === bridge && entry.kind === 'final');
-        assert.equal(finals.length, 1, 'replay after a terminal bridge pushes nothing further');
-    });
-    test('approved companions receive one canonical final while dismissed companions remain canceled', async () => {
-        const { bridge } = bridgeUnder();
-        const dir = submitBridgePage(bridge);
-        const companion = spawnNode({ kind: 'general', parent: bridge, creator: bridge, cwd: home, name: 'feedback companion', lifecycle: 'resident' }).node_id;
-        createPageFeedbackComment(dir, { quote: 'Ship it?', note: 'Confirm the release.', companionNodeId: companion });
-        transition(companion, 'finish');
-        await resolvePageTicket(bridge, { question: { text: 'yes', edited: true } });
-        const finalized = getNode(companion);
-        assert.equal(finalized.status, 'done');
-        assert.equal(finalized.intent, 'done');
-        assert.ok(finalized.final_report);
-        assert.ok(finalized.finalized_at);
-        const finalReport = finalized.final_report;
-        const finalizedAt = finalized.finalized_at;
-        await deliverTerminalResult(bridge);
-        assert.equal(getNode(companion)?.final_report, finalReport, 'terminal replay preserves the first canonical final');
-        assert.equal(getNode(companion)?.finalized_at, finalizedAt, 'terminal replay preserves the first finalization time');
-        await assert.rejects(reviveNode(companion, { resume: true, capacity: 'freeze' }), /finalization latch/);
-        const { bridge: dismissedBridge } = bridgeUnder();
-        const dismissedDir = submitBridgePage(dismissedBridge);
-        const dismissedCompanion = spawnNode({ kind: 'general', parent: dismissedBridge, creator: dismissedBridge, cwd: home, name: 'dismissed feedback companion', lifecycle: 'resident' }).node_id;
-        createPageFeedbackComment(dismissedDir, { quote: 'Ship it?', note: 'Do not ship.', companionNodeId: dismissedCompanion });
-        await cancelHumanTicket(dismissedBridge, { reason: 'dismissed', actor: 'human' });
-        assert.equal(getNode(dismissedCompanion)?.status, 'canceled');
-        assert.equal(getNode(dismissedCompanion)?.final_report, null);
-        const dismissedResult = readTicketResult(dismissedDir);
-        await settleFeedbackCompanion(dismissedBridge, dismissedResult.kind === 'canceled' ? 'canceled' : 'approved');
-        assert.equal(getNode(dismissedCompanion)?.status, 'canceled');
-        assert.equal(getNode(dismissedCompanion)?.final_report, null);
-    });
-    test('cancelHumanTicket finishes the bridge and notifies non-actor subscribers', async () => {
-        const actor = spawnNode({ kind: 'general', parent: null, cwd: home, name: 'actor' }).node_id;
-        const bridge = spawnNode({ kind: 'human', parent: actor, creator: actor, cwd: home, name: 'human-page', lifecycle: 'terminal' }).node_id;
-        const other = spawnNode({ kind: 'general', parent: null, cwd: home, name: 'other' }).node_id;
-        const { subscribe } = await import('../canvas/canvas.js');
-        subscribe(other, bridge, true);
-        submitBridgePage(bridge);
-        await cancelHumanTicket(bridge, { reason: 'stale', actor });
-        closeDb();
-        assert.equal(getNode(bridge)?.status, 'done');
-        assert.equal(readInboxSince(actor).length, 0, 'the canceling actor is not messaged');
-        const notes = readInboxSince(other);
-        assert.equal(notes.length, 1, 'the other waiter gets one waking note');
-        assert.equal(notes[0].tier, 'normal');
-        assert.match(notes[0].label, /canceled/);
-    });
-    test('cancellation reaches subscribers when the bridge is already done, and retries conflict rather than fail', async () => {
-        const actor = spawnNode({ kind: 'general', parent: null, cwd: home, name: 'actor' }).node_id;
-        const bridge = spawnNode({ kind: 'human', parent: actor, creator: actor, cwd: home, name: 'human-page', lifecycle: 'terminal' }).node_id;
-        const other = spawnNode({ kind: 'general', parent: null, cwd: home, name: 'other' }).node_id;
-        const { subscribe } = await import('../canvas/canvas.js');
-        subscribe(other, bridge, true);
-        submitBridgePage(bridge);
-        // The bridge is parked done with no canonical final while its page is still
-        // pending — done is where cancellation wants it, so cancelling must deliver.
-        transition(bridge, 'finish');
-        const result = await cancelHumanTicket(bridge, { reason: 'stale', actor });
-        assert.equal(result.kind, 'canceled');
-        assert.equal(getNode(bridge)?.status, 'done');
-        assert.equal(readInboxSince(other).length, 1, 'the other waiter is told no answer is coming');
-        // The recorded cancellation is final: a retry is an already-resolved
-        // conflict, never a delivery failure that keeps repeating.
-        await assert.rejects(() => cancelHumanTicket(bridge, { reason: 'stale', actor }), (error) => error instanceof ApiError && error.status === 409 && error.code === 'ticket_already_resolved');
-    });
-});
-test('a display-only page publishes passively and creates no canvas node', async () => {
-    const page = join(home, 'build-done.tsx');
-    writeFileSync(page, 'export default () => (\n  <Page title="Build done" subtitle="The build passed, so the change is ready to review.">\n    <p>Build output is ready.</p>\n  </Page>\n);\n');
-    const before = listNodes().length;
-    const result = (await humanSend.run({ page }));
-    assert.equal(result['reply'], false);
-    assert.equal(result['inbox'], false);
-    assert.equal(typeof result['page_id'], 'string');
-    assert.equal(typeof result['dir'], 'string');
-    assert.ok(existsSync(join(result['dir'], 'page.json')));
-    assert.ok(readTicketResult(result['dir']) === null);
-    closeDb();
-    assert.equal(listNodes().length, before);
-});

package/dist/core/__tests__/human-node-not-supervised.test.d.ts

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

package/dist/core/__tests__/human-node-not-supervised.test.js

@@ -1,89 +0,0 @@
-// Run with: node --import tsx/esm --test src/core/__tests__/human-node-not-supervised.test.ts
-//
-// BUG REGRESSION (issue #2 — "Headless node can't reach human-ask: human-kind
-// TUI dies at boot"): a headless orchestrator's every reply-bearing `crtr human send` bridge died
-// at boot with "pi vehicle exited before the session came up".
-//
-// ROOT CAUSE: a kind:'human' row is NOT a broker-hosted agent node — it is a
-// bookkeeping row for the `crtr human` bridge. Nothing runs in it: the human
-// answers from humanloop's inbox, and the row's lifecycle is driven entirely by
-// humanloop's completion handler (`crtr human _deliver`) calling `pushFinal` (or
-// `human cancel`). So it never records a `pi_pid` or `pi_session_id`. After the
-// headless hard-cut made the broker the universal node host, the daemon
-// supervised EVERY active|idle row as a broker engine: it read the human row
-// (pid==null, session==null) as a never-booted broker and boot-failed it —
-// killing the human prompt before the person could ever answer.
-//
-// THE FIX under exit-event authority is superviseTick's one filter, driven
-// here: it drops kind:'human' rows before every row pass, including the
-// node-lifecycle tick that classifies a row with no live broker as known-dead.
-// An unfiltered human row (session null, no fork claim) would land in policy
-// row 8 (boot failure), the modern re-incarnation of the exact bug.
-import { test, before, after, beforeEach } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { createNode, getNode, subscribe } from '../canvas/canvas.js';
-import { closeDb } from '../canvas/db.js';
-import { readInboxSince } from '../feed/inbox.js';
-import { superviseTick } from '../../daemon/crtrd.js';
-import { bindTestFleet } from './helpers/fleet.js';
-import { resetFleetForTests } from '../runtime/fleet.js';
-let home;
-let tf;
-function node(id, over = {}) {
-    return {
-        node_id: id,
-        name: id,
-        created: new Date().toISOString(),
-        cwd: '/tmp/work',
-        kind: 'general',
-        mode: 'base',
-        lifecycle: 'terminal',
-        status: 'active',
-        ...over,
-    };
-}
-before(() => {
-    home = mkdtempSync(join(tmpdir(), 'crtr-human-not-supervised-'));
-    process.env['CRTR_HOME'] = home;
-    tf = bindTestFleet(); // superviseTick requires a bound fleet (D-2)
-});
-beforeEach(() => {
-    closeDb();
-    rmSync(home, { recursive: true, force: true });
-});
-after(() => {
-    closeDb();
-    rmSync(home, { recursive: true, force: true });
-    delete process.env['CRTR_HOME'];
-    tf.fleet.dispose();
-    resetFleetForTests();
-});
-test('a kind:"human" bridge row is NEVER boot-failed by the daemon (it has no broker engine)', async () => {
-    // The exact shape spawnNode({kind:'human'}) mints: active, host_kind broker,
-    // but NO pi engine ever booted — so pi_pid and pi_session_id stay null.
-    createNode(node('HUMAN', {
-        kind: 'human',
-        lifecycle: 'terminal',
-        host_kind: 'broker',
-        pi_pid: null,
-        pi_session_id: null,
-        intent: null,
-    }));
-    // The asking node is auto-subscribed to its human bridge node at spawn, so a
-    // surfaceBootFailure (pushUrgent) would land in ASKER's inbox. Park it as a
-    // dormant idle-release row (policy row 4 / pass-2 no-op) so both the sweep and
-    // the tick leave IT alone — it is only here to catch a push.
-    createNode(node('ASKER', { status: 'idle', intent: 'idle-release', pi_session_id: 'booted' }));
-    subscribe('ASKER', 'HUMAN', true);
-    // Two well-spaced ticks: the row passes (controller-wait settle, inbox wake,
-    // and the node-lifecycle classification of a row with no live broker) must
-    // all drop the human row before reading it.
-    const t0 = Date.now();
-    await superviseTick(t0);
-    await superviseTick(t0 + 10_000_000);
-    assert.equal(getNode('HUMAN').status, 'active', 'human bridge row stays alive — never crash-reaped as a dead broker');
-    assert.equal(readInboxSince('ASKER').length, 0, 'no surfaceBootFailure urgent push — the asker is never told its human prompt "never started"');
-});

package/dist/core/__tests__/integration/human-deliver-e2e.test.d.ts

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

package/dist/core/__tests__/integration/human-deliver-e2e.test.js

@@ -1,131 +0,0 @@
-// Run with: npm run test:integration
-//
-// Drive a terminal ticket through the public crtrd ticket route. Terminal
-// delivery is daemon-owned; no subprocess handler or delivery receipt exists.
-import { test, before, beforeEach, afterEach, after } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, rmSync, existsSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { ApiError, CrtrClient } from '../../../api/index.js';
-import { createApiServer } from '../../../daemon/api/server.js';
-import { apiSocketPath } from '../../canvas/paths.js';
-import { claimTicket, readTicketClaim } from '../../human/claim.js';
-import { bindTicketReplyRoute } from '../../human/convention.js';
-import { ticketDir } from '../../human/root.js';
-import { submitPage, submitReview } from '../../human/tickets.js';
-import { spawnNode } from '../../runtime/nodes.js';
-import { getNode, closeDb } from '../../canvas/index.js';
-import { readInboxSince } from '../../feed/inbox.js';
-import { resolveRef } from '../../canvas/history.js';
-let home;
-let priorHome;
-let server;
-let client;
-async function waitForSocket(path) {
-    for (let i = 0; i < 200; i++) {
-        if (existsSync(path))
-            return;
-        await new Promise((r) => setTimeout(r, 25));
-    }
-    throw new Error(`api socket never bound at ${path}`);
-}
-before(() => {
-    priorHome = process.env['HOME'];
-});
-beforeEach(async () => {
-    closeDb();
-    home = mkdtempSync(join(tmpdir(), 'crtr-e2e-home-'));
-    process.env['CRTR_HOME'] = home;
-    process.env['HOME'] = home;
-    delete process.env['CRTR_NODE_ID'];
-    server = createApiServer();
-    await waitForSocket(apiSocketPath());
-    client = new CrtrClient({ socketPath: apiSocketPath(), autostart: false });
-});
-afterEach(async () => {
-    await server?.close();
-    server = undefined;
-    closeDb();
-});
-after(() => {
-    closeDb();
-    if (priorHome !== undefined)
-        process.env['HOME'] = priorHome;
-    else
-        delete process.env['HOME'];
-    delete process.env['CRTR_HOME'];
-    delete process.env['CRTR_NODE_ID'];
-});
-async function expectBadResolve(nodeId, body) {
-    await assert.rejects(() => client.request('POST', `/v1/human/tickets/${nodeId}/resolve`, body), (error) => error instanceof ApiError && error.status === 400 && error.code === 'invalid_request' && !error.message.includes('POST /v1/human/reviews/:review_id/submit'));
-}
-async function expectReviewSubmitGuidance(nodeId, body) {
-    await assert.rejects(() => client.request('POST', `/v1/human/tickets/${nodeId}/resolve`, body), (error) => error instanceof ApiError && error.status === 400 && error.code === 'invalid_request' && error.message.includes('POST /v1/human/reviews/:review_id/submit'));
-}
-/** Publish a one-text-slot page ticket into the bridge's ticket directory. */
-function submitBridgePage(bridge) {
-    const dir = ticketDir(bridge);
-    const sourceDir = mkdtempSync(join(tmpdir(), 'crtr-e2e-page-'));
-    const sourceFile = join(sourceDir, 'page.tsx');
-    writeFileSync(sourceFile, 'export default () => (\n  <Page title="Ship it?" subtitle="Decide whether to ship now so the release can proceed.">\n    <UserText id="question" initialText="" />\n  </Page>\n);\n');
-    try {
-        bindTicketReplyRoute(dir, bridge);
-        // The delivery `human send` derives for a terminal bridge page: a
-        // response-bearing slot gives it a reply route, and a terminal sender's page
-        // always projects to the inbox.
-        submitPage({ dir, sourceFile, delivery: { placement: 'inline', inbox: true, reply: true } });
-    }
-    finally {
-        rmSync(sourceDir, { recursive: true, force: true });
-    }
-    return dir;
-}
-function reportBody(ref) {
-    const resolved = resolveRef(ref);
-    if (resolved === null || resolved.source !== 'report')
-        throw new Error(`push report ref did not resolve to a report: ${ref}`);
-    return resolved.body;
-}
-test('malformed resolves leave the mounted ticket claim in place', async () => {
-    const parent = spawnNode({ kind: 'general', parent: null, cwd: home, name: 'asker' }).node_id;
-    const pageBridge = spawnNode({ kind: 'human', parent, creator: parent, cwd: home, name: 'human-page', lifecycle: 'terminal' }).node_id;
-    const pageDir = submitBridgePage(pageBridge);
-    const pageClaim = claimTicket(pageDir);
-    assert.ok(pageClaim !== null);
-    for (const body of [{ responses: [] }, { response: {} }, { responses: {}, debug: true }]) {
-        await expectBadResolve(pageBridge, body);
-        assert.equal(readTicketClaim(pageDir)?.token, pageClaim.token, 'malformed page input must not take over the live claim');
-    }
-    for (const body of [{ responses: {}, feedback: {} }, { feedback: [] }]) {
-        await expectReviewSubmitGuidance(pageBridge, body);
-        assert.equal(readTicketClaim(pageDir)?.token, pageClaim.token, 'feedback-shaped input must not take over the live claim');
-    }
-    const reviewBridge = spawnNode({ kind: 'human', parent, creator: parent, cwd: home, name: 'human-review', lifecycle: 'terminal' }).node_id;
-    const reviewDir = ticketDir(reviewBridge);
-    const file = join(home, 'review.md');
-    writeFileSync(file, '# Review\n');
-    bindTicketReplyRoute(reviewDir, reviewBridge);
-    submitReview({ dir: reviewDir, review: { title: 'Review', subtitle: 'Review this file so implementation can proceed safely.', source: {}, file } });
-    const reviewClaim = claimTicket(reviewDir);
-    assert.ok(reviewClaim !== null);
-    await expectReviewSubmitGuidance(reviewBridge, { responses: {} });
-    assert.equal(readTicketClaim(reviewDir)?.token, reviewClaim.token, 'review ticket resolve must not take over the live claim');
-});
-test('the ticket resolve route pushFinals the readable answer to the parent', async () => {
-    const parent = spawnNode({ kind: 'general', parent: null, cwd: home, name: 'asker' }).node_id;
-    const bridge = spawnNode({ kind: 'human', parent, creator: parent, cwd: home, name: 'human-page', lifecycle: 'terminal' }).node_id;
-    const dir = submitBridgePage(bridge);
-    const result = await client.resolveHumanTicket(bridge, { responses: { question: { text: 'yes, ship', edited: true } } });
-    assert.deepEqual(result, { completed: true, reply_delivered: true, kind: 'page' });
-    assert.equal(getNode(bridge)?.status, 'done', 'bridge finalized by crtrd');
-    const finals = readInboxSince(parent).filter((entry) => entry.from === bridge && entry.kind === 'final');
-    assert.equal(finals.length, 1, 'exactly one pushFinal reached the parent');
-    // A typed answer's final is purely the person's words, attributed by the
-    // human-answer disposition — no record path, no "Answered …" trailer.
-    assert.equal(finals[0].disposition, 'human-answer');
-    const body = reportBody(finals[0].ref);
-    assert.ok(body.includes('yes, ship'));
-    assert.ok(!body.includes(join(dir, 'response.json')));
-    assert.ok(!body.includes('humanloop.response/v2'));
-});

package/dist/core/__tests__/phase4-review-store.test.d.ts

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

package/dist/core/__tests__/phase4-review-store.test.js

@@ -1,144 +0,0 @@
-import { test, before, after, beforeEach } from 'node:test';
-import assert from 'node:assert/strict';
-import { existsSync, mkdtempSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { closeDb, openDb } from '../canvas/db.js';
-import { approveReviewLocked, bindBridgeNode, cancelReviewRow, commitBindingReview, getReview, getReviewByBridge, getReviewByCompanion, listReviews, markDelivered, markDeliveryError, markProjected, markProjectionError, openReviewRow, readAnchorBase, } from '../review/store.js';
-let home;
-function row(overrides = {}) {
-    return {
-        review_id: 'review-one',
-        idempotency_key: 'request-one',
-        origin_kind: 'inline',
-        origin_node_id: 'origin-one',
-        bridge_node_id: null,
-        companion_node_id: 'companion-one',
-        review_dir: '/tmp/review-one',
-        file: '/tmp/does-not-exist.txt',
-        origin_session_file: '/tmp/origin.jsonl',
-        origin_session_id: 'session-one',
-        origin_leaf_id: 'leaf-one',
-        model_spec: 'anthropic/claude:test',
-        branch_file: '/tmp/review-one/branch-point.jsonl',
-        baseline_sha256: 'baseline-hash',
-        baseline_bytes: 3,
-        anchor_base_sha256: 'anchor-hash',
-        anchor_base_bytes: Buffer.from('abc'),
-        state: 'binding',
-        created: '2026-01-01T00:00:00.000Z',
-        captured_at: '2026-01-01T00:00:00.000Z',
-        opened_at: null,
-        submit_requested_at: null,
-        output_path: null,
-        subtitle: null,
-        approved_at: null,
-        approved_sha256: null,
-        changed: null,
-        comments_total: null,
-        comments_unresolved: null,
-        result_json: null,
-        canceled_at: null,
-        cancel_reason: null,
-        cancel_actor: null,
-        delivery_entry_id: null,
-        delivered_at: null,
-        delivery_error: null,
-        projected_at: null,
-        projection_error: null,
-        ...overrides,
-    };
-}
-before(() => {
-    home = mkdtempSync(join(tmpdir(), 'crtr-phase4-review-store-'));
-    process.env['CRTR_HOME'] = home;
-});
-beforeEach(() => {
-    closeDb();
-    rmSync(home, { recursive: true, force: true });
-});
-after(() => {
-    closeDb();
-    rmSync(home, { recursive: true, force: true });
-    delete process.env['CRTR_HOME'];
-});
-test('reviews DAO owns idempotent binding and conditional lifecycle writes', () => {
-    const first = row();
-    assert.equal(existsSync(first.review_dir), false, 'the birth commit does not create filesystem state');
-    assert.deepEqual(commitBindingReview(first), { review_id: 'review-one', won: true });
-    assert.deepEqual(commitBindingReview(row({ review_id: 'review-two', companion_node_id: 'companion-two' })), {
-        review_id: 'review-one',
-        won: false,
-    });
-    assert.equal(listReviews({}).length, 0, 'binding rows are hidden from ordinary review lists');
-    assert.equal(getReview(first.review_id)?.source_missing, true, 'source_missing is computed from the current filesystem');
-    assert.equal(getReviewByCompanion(first.companion_node_id), null);
-    assert.equal(bindBridgeNode(first.review_id, 'bridge-one'), true);
-    assert.equal(bindBridgeNode(first.review_id, 'bridge-two'), false);
-    assert.equal(getReviewByBridge('bridge-one'), null, 'binding rows are not exposed by bridge lookup');
-    assert.equal(openReviewRow(first.review_id, '2026-01-01T00:01:00.000Z'), true);
-    assert.equal(openReviewRow(first.review_id, '2026-01-01T00:02:00.000Z'), false);
-    assert.equal(getReviewByBridge('bridge-one')?.review_id, first.review_id);
-    const db = openDb();
-    assert.equal(approveReviewLocked(db, {
-        review_id: first.review_id,
-        approved_at: '2026-01-01T00:03:00.000Z',
-        approved_sha256: 'approved-hash',
-        changed: true,
-        comments_total: 2,
-        comments_unresolved: 1,
-        result_json: '{"approved":true}',
-    }), true);
-    assert.equal(approveReviewLocked(db, {
-        review_id: first.review_id,
-        approved_at: '2026-01-01T00:04:00.000Z',
-        approved_sha256: 'approved-hash-2',
-        changed: false,
-        comments_total: 0,
-        comments_unresolved: 0,
-        result_json: '{}',
-    }), false, 'a second approval cannot win the conditional write');
-    markProjectionError(first.review_id, 'temporary projection failure');
-    markProjected(first.review_id, '2026-01-01T00:05:00.000Z');
-    markDeliveryError(first.review_id, 'temporary delivery failure');
-    markDelivered(first.review_id, 'receipt-one', '2026-01-01T00:06:00.000Z');
-    const approved = getReview(first.review_id);
-    assert.equal(approved?.projection_error, null);
-    assert.equal(approved?.delivery_error, null);
-    assert.equal(approved?.delivered_at, '2026-01-01T00:06:00.000Z');
-    assert.deepEqual(readAnchorBase(first.review_id), { bytes: Buffer.from('abc'), sha256: 'anchor-hash' });
-});
-test('stale ledger errors cannot overwrite recorded success', () => {
-    const review = row({ review_id: 'review-ledgers', idempotency_key: 'request-ledgers', companion_node_id: 'companion-ledgers' });
-    commitBindingReview(review);
-    markProjected(review.review_id, '2026-01-01T00:05:00.000Z');
-    markProjectionError(review.review_id, 'stale projection failure');
-    markDelivered(review.review_id, 'receipt-ledgers', '2026-01-01T00:06:00.000Z');
-    markDeliveryError(review.review_id, 'stale delivery failure');
-    const recorded = getReview(review.review_id);
-    assert.equal(recorded?.projected_at, '2026-01-01T00:05:00.000Z');
-    assert.equal(recorded?.projection_error, null);
-    assert.equal(recorded?.delivered_at, '2026-01-01T00:06:00.000Z');
-    assert.equal(recorded?.delivery_error, null);
-});
-test('approval cannot win after cancellation and companion ids remain unique', () => {
-    const canceled = row({ review_id: 'review-canceled', idempotency_key: 'request-canceled', companion_node_id: 'companion-canceled' });
-    commitBindingReview(canceled);
-    assert.equal(openReviewRow(canceled.review_id, '2026-01-01T00:59:00.000Z'), true);
-    assert.equal(cancelReviewRow(canceled.review_id, { at: '2026-01-01T01:00:00.000Z', reason: 'not needed', actor: 'human' }), true);
-    assert.equal(approveReviewLocked(openDb(), {
-        review_id: canceled.review_id,
-        approved_at: '2026-01-01T01:01:00.000Z',
-        approved_sha256: 'hash',
-        changed: false,
-        comments_total: 0,
-        comments_unresolved: 0,
-        result_json: '{}',
-    }), false);
-    assert.throws(() => commitBindingReview(row({
-        review_id: 'review-duplicate-companion',
-        idempotency_key: 'request-duplicate-companion',
-        companion_node_id: 'companion-canceled',
-        state: 'binding',
-    })), /UNIQUE constraint failed: reviews\.companion_node_id/);
-});

package/dist/core/__tests__/watchdog-abort-arms-retry.test.d.ts

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