@north-light/crouter 0.3.311 → 0.3.313

package/dist/core/human/__tests__/integration/inbox-core.test.js

@@ -1,145 +0,0 @@
-import assert from 'node:assert/strict';
-import { existsSync, mkdirSync, mkdtempSync, readFileSync, realpathSync, rmSync, writeFileSync } from 'node:fs';
-import { spawn } from 'node:child_process';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { submitPage, submitReview, completePage, cancelTicket, readTicketResult } from '../../tickets.js';
-import { claimTicket } from '../../claim.js';
-import { scanInbox } from '../../scan.js';
-import { atomicWriteJson, progressPath, responsePath } from '../../convention.js';
-import { ticketDir } from '../../root.js';
-const temp = mkdtempSync(join(tmpdir(), 'crtr-inbox-core-'));
-process.env['CRTR_HOME'] = temp;
-const source = join(temp, 'source.md');
-writeFileSync(source, '# Source\n');
-const pageSource = join(temp, 'page.tsx');
-writeFileSync(pageSource, 'export default () => (\n  <Page title="A page" subtitle="Go? requires your attention.">\n    <UserText id="go" initialText="" />\n  </Page>\n);\n');
-const page = (id, emittedAt) => submitPage({ dir: ticketDir(id), sourceFile: pageSource, source: { emittedAt, nodeId: 'node-1' }, delivery: { placement: 'inline', inbox: true, reply: true } });
-const answer = { go: { text: 'yes', edited: true } };
-async function waitFor(paths) {
-    const deadline = Date.now() + 10_000;
-    while (!paths.every(existsSync)) {
-        if (Date.now() >= deadline)
-            throw new Error(`workers did not reach barrier: ${paths.join(', ')}`);
-        await new Promise((resolvePromise) => setTimeout(resolvePromise, 10));
-    }
-}
-page('z-last', '2025-01-01T00:00:00.000Z');
-const newPage = page('a-first', '2025-01-02T00:00:00.000Z');
-const review = submitReview({ dir: ticketDir('review'), review: { file: source, title: 'Review source', subtitle: 'Review findings require your decision.', source: { nodeId: 'node-1' }, blockedSince: '2025-01-02T00:00:00.000Z' } });
-assert.throws(() => submitReview({ dir: ticketDir('missing-review-subtitle'), review: { file: source, title: 'Missing subtitle', source: {} } }), /subtitle/, 'a review without an authored subtitle is invalid');
-assert.throws(() => submitReview({ dir: ticketDir('bad-review'), review: { file: join(temp, 'missing.md'), title: 'Bad', subtitle: 'This invalid review must be rejected.', source: {} } }), /existing absolute path/);
-assert.equal(existsSync(ticketDir('bad-review')), false, 'invalid submission does not strand an id');
-const prepared = ticketDir('prepared');
-mkdirSync(prepared);
-writeFileSync(join(prepared, 'asset.png'), 'prepared asset');
-const preparedTicket = submitPage({ dir: prepared, sourceFile: pageSource, source: { emittedAt: '2025-01-02T00:00:00.000Z', nodeId: 'node-1' }, delivery: { placement: 'inline', inbox: true, reply: true } });
-assert.equal(preparedTicket.dir, realpathSync(prepared), 'submission accepts a crouter-precreated direct child and colocated assets');
-// Same timestamp is stable by id; progress is resumable work, never a hidden lease.
-atomicWriteJson(progressPath(newPage.dir), { kind: 'page', responses: {}, savedAt: new Date().toISOString() });
-const scanned = scanInbox();
-assert.deepEqual(scanned.map((item) => item.id), ['a-first', 'prepared', 'review', 'z-last']);
-assert.equal(scanned.find((item) => item.id === 'a-first')?.claim, undefined);
-assert.equal(scanned.find((item) => item.id === 'review')?.kind, 'review');
-assert.equal(scanned.find((item) => item.id === 'review')?.subtitle, 'Review findings require your decision.', 'review scanning exposes its required subtitle');
-const firstClaim = claimTicket(newPage.dir);
-assert.notEqual(firstClaim, null);
-assert.equal(claimTicket(newPage.dir), null, 'a second controller cannot claim a live ticket');
-// A separate process writes a genuine remote claim whose heartbeat is already
-// stale, then exits; this process recovers it — cross-process stale recovery.
-const staleDir = page('stale', '2025-01-03T00:00:00.000Z').dir;
-const staleClaimReady = join(temp, 'stale-claim-ready');
-await new Promise((resolveWorker, rejectWorker) => spawn(process.execPath, ['--conditions=crtr-src', '--import', 'tsx', 'src/core/human/__tests__/inbox-stale-claim-worker.ts', staleDir, staleClaimReady], { cwd: process.cwd(), stdio: ['ignore', 'ignore', 'inherit'] }).once('exit', (code) => code === 0 ? resolveWorker() : rejectWorker(new Error('stale-claim worker failed'))));
-assert.notEqual(JSON.parse(readFileSync(staleClaimReady, 'utf8')), null, 'a separate process wrote a stale remote claim on disk');
-assert.notEqual(claimTicket(staleDir), null, 'a remote claim written by another process recovers once its heartbeat has expired');
-const malformedDir = page('malformed-claim', '2025-01-03T00:00:00.000Z').dir;
-writeFileSync(join(malformedDir, 'claim.json'), '{');
-assert.notEqual(claimTicket(malformedDir), null, 'partial claim crash artifact recovers');
-const final = completePage(newPage.dir, answer, firstClaim.token);
-assert.equal(final.won, true);
-assert.equal(readTicketResult(newPage.dir)?.kind, 'page');
-assert.equal(claimTicket(newPage.dir), null, 'terminal tickets cannot be claimed');
-const exactResults = [
-    { schema: 'crtr.page-response/v1', kind: 'page', responses: {}, summary: '', completedAt: '2025-01-04T00:00:00.000Z' },
-    { schema: 'humanloop.review-response/v1', kind: 'review', result: { file: source, submitted: true, approved: true, comments: [], submittedAt: '2025-01-04T00:00:00.000Z', savedAt: '2025-01-04T00:00:00.000Z', reviewId: 'review-1', changed: false, baselineSha256: 'baseline', approvedSha256: 'approved', companionNodeId: 'companion-1', commentsTotal: 0, commentsUnresolved: 0 }, completedAt: '2025-01-04T00:00:00.000Z' },
-    { schema: 'humanloop.cancel/v1', kind: 'canceled', canceledAt: '2025-01-04T00:00:00.000Z', reason: 'stop', actor: 'test' },
-];
-for (const [index, result] of exactResults.entries()) {
-    const dir = page(`strict-${index}`, '2025-01-03T00:00:00.000Z').dir;
-    writeFileSync(responsePath(dir), JSON.stringify(result));
-    assert.equal(readTicketResult(dir)?.kind, result.kind, `strict decoder accepts exact ${result.kind} result`);
-}
-const validFeedback = exactResults[1].result;
-const iso = '2025-01-04T00:00:00.000Z';
-const rejectFixtures = [
-    { why: 'a wrong kind for a known schema', result: { schema: 'crtr.page-response/v1', kind: 'review', responses: {}, summary: '', completedAt: iso } },
-    { why: 'an unknown schema id', result: { schema: 'crtr.page-response/v9', kind: 'page', responses: {}, summary: '', completedAt: iso } },
-    { why: 'a page missing its required completedAt', result: { schema: 'crtr.page-response/v1', kind: 'page', responses: {}, summary: '' } },
-    { why: 'a page with a non-ISO completedAt', result: { schema: 'crtr.page-response/v1', kind: 'page', responses: {}, summary: '', completedAt: 'now' } },
-    { why: 'a page whose responses are not a slot-keyed map', result: { schema: 'crtr.page-response/v1', kind: 'page', responses: [{ id: 'go' }], summary: '', completedAt: iso } },
-    { why: 'a page with an extra top-level field', result: { schema: 'crtr.page-response/v1', kind: 'page', responses: {}, summary: '', completedAt: iso, extra: true } },
-    { why: 'a review missing its required result', result: { schema: 'humanloop.review-response/v1', kind: 'review', completedAt: iso } },
-    { why: 'a review whose nested result is not submitted', result: { schema: 'humanloop.review-response/v1', kind: 'review', result: { ...validFeedback, submitted: false }, completedAt: iso } },
-    { why: 'a review with incomplete comment columns', result: { schema: 'humanloop.review-response/v1', kind: 'review', result: { ...validFeedback, approved: true, comments: [{ id: 'c1', line: 1, endLine: 1, colStart: 1, lineText: '# Source', comment: 'x', createdAt: iso }] }, completedAt: iso } },
-    { why: 'a review nested comment whose endLine precedes its line', result: { schema: 'humanloop.review-response/v1', kind: 'review', result: { ...validFeedback, approved: false, comments: [{ id: 'c1', line: 5, endLine: 2, lineText: '# Source', comment: 'x', createdAt: iso }] }, completedAt: iso } },
-    { why: 'a review with an extra top-level field', result: { schema: 'humanloop.review-response/v1', kind: 'review', result: validFeedback, completedAt: iso, extra: true } },
-    { why: 'a canceled result missing its required canceledAt', result: { schema: 'humanloop.cancel/v1', kind: 'canceled', reason: 'stop' } },
-    { why: 'a canceled result with a non-ISO canceledAt', result: { schema: 'humanloop.cancel/v1', kind: 'canceled', canceledAt: 'now' } },
-    { why: 'a canceled result with an extra top-level field', result: { schema: 'humanloop.cancel/v1', kind: 'canceled', canceledAt: iso, extra: true } },
-];
-for (const [index, fixture] of rejectFixtures.entries()) {
-    const dir = page(`strict-reject-${index}`, '2025-01-03T00:00:00.000Z').dir;
-    writeFileSync(responsePath(dir), JSON.stringify(fixture.result));
-    assert.equal(readTicketResult(dir), null, `strict decoder rejects ${fixture.why}`);
-}
-const protocolDir = ticketDir('stale-protocol');
-mkdirSync(protocolDir);
-writeFileSync(responsePath(protocolDir), '{}');
-assert.throws(() => submitPage({ dir: protocolDir, sourceFile: pageSource }), /protocol state/, 'precreated assets may not include humanloop lifecycle state');
-const cancelDir = page('cancel-race', '2025-01-03T00:00:00.000Z').dir;
-const canceled = cancelTicket(cancelDir, { reason: 'stop' });
-assert.equal(canceled.status, 'canceled');
-assert.equal(cancelTicket(cancelDir).status, 'already_resolved', 'first final writer wins');
-const finalRaceDir = page('final-race', '2025-01-03T00:00:00.000Z').dir;
-const finalRaceClaim = claimTicket(finalRaceDir);
-const finalBarrier = join(temp, 'final-race-barrier');
-const finalReady = join(temp, 'final-race-ready');
-const cancelWorker = spawn(process.execPath, ['--conditions=crtr-src', '--import', 'tsx', 'src/core/human/__tests__/inbox-cancel-worker.ts', finalRaceDir, finalBarrier, finalReady], { cwd: process.cwd(), stdio: ['ignore', 'pipe', 'pipe'] });
-await waitFor([finalReady]);
-writeFileSync(finalBarrier, 'go');
-const finalRace = completePage(finalRaceDir, answer, finalRaceClaim.token);
-await new Promise((resolveWorker, rejectWorker) => cancelWorker.once('exit', (code) => code === 0 ? resolveWorker() : rejectWorker(new Error('cancel worker failed'))));
-assert.equal(readTicketResult(finalRaceDir)?.kind, finalRace.won ? 'page' : 'canceled', 'submit and cancellation race has one canonical winner');
-const concurrentDir = page('concurrent-claim', '2025-01-03T00:00:00.000Z').dir;
-const claimBarrier = join(temp, 'claim-race-barrier');
-// Both workers block on this release until the parent has read both results, so
-// neither winner's pid dies during the peer's attempt (a dead same-host pid is
-// legitimately reclaimable — that stale-recovery race, not a double claim, is
-// what previously flaked this assertion).
-const claimRelease = join(temp, 'claim-race-release');
-let claimWorkerNumber = 0;
-const claimReadyPaths = [];
-const claimResultPaths = [];
-const runClaimWorker = () => new Promise((resolveWorker, rejectWorker) => {
-    const n = claimWorkerNumber++;
-    const ready = join(temp, `claim-race-ready-${n}`);
-    const result = join(temp, `claim-race-result-${n}`);
-    claimReadyPaths.push(ready);
-    claimResultPaths.push(result);
-    const child = spawn(process.execPath, ['--conditions=crtr-src', '--import', 'tsx', 'src/core/human/__tests__/inbox-claim-worker.ts', concurrentDir, claimBarrier, ready, result, claimRelease], { cwd: process.cwd(), stdio: ['ignore', 'ignore', 'pipe'] });
-    let errors = '';
-    child.stderr.on('data', (chunk) => { errors += chunk; });
-    child.once('exit', (code) => code === 0 ? resolveWorker() : rejectWorker(new Error(errors)));
-});
-const concurrentClaimRuns = [runClaimWorker(), runClaimWorker()];
-await waitFor(claimReadyPaths);
-writeFileSync(claimBarrier, 'go');
-await waitFor(claimResultPaths);
-const concurrentClaims = claimResultPaths.map((path) => JSON.parse(readFileSync(path, 'utf8')));
-assert.equal(concurrentClaims.filter((claim) => claim !== null).length, 1, 'separate processes exclusively claim one ticket');
-writeFileSync(claimRelease, 'go');
-await Promise.all(concurrentClaimRuns);
-assert.throws(() => submitReview({ dir: ticketDir('bad-output'), review: { file: source, output: responsePath(review.dir), title: 'Bad output', subtitle: 'This invalid output path must be rejected.', source: {} } }), /must not alias/, 'review output cannot replace a ticket response');
-assert.throws(() => submitReview({ dir: ticketDir('source-output'), review: { file: source, output: source, title: 'Bad output', subtitle: 'This invalid output path must be rejected.', source: {} } }), /must not alias/, 'review output cannot overwrite its source');
-rmSync(temp, { recursive: true, force: true });
-console.log('inbox core tests passed');

package/dist/core/human/__tests__/page-tickets.test.d.ts

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

package/dist/core/human/__tests__/page-tickets.test.js

@@ -1,161 +0,0 @@
-import assert from 'node:assert/strict';
-import { existsSync, mkdtempSync, readFileSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import test from 'node:test';
-const home = mkdtempSync(join(tmpdir(), 'crtr-page-tickets-'));
-process.env['CRTR_HOME'] = home;
-const { atomicWriteJson, bindTicketReplyRoute, pageManifestPath, pagePath, progressPath, responsePath } = await import('../convention.js');
-const { claimTicket } = await import('../claim.js');
-const { scanInbox, scanPageHistory } = await import('../scan.js');
-const { ticketDir } = await import('../root.js');
-const { cancelTicket, completePage, readPageProgress, readPageTicket, preparePage, readTicketResult, submitPage, takeoverAndCompletePage, validatePageTicketResponses, writePageProgress, } = await import('../tickets.js');
-const sources = mkdtempSync(join(tmpdir(), 'crtr-page-sources-'));
-function sourceFile(name, body) {
-    const path = join(sources, name);
-    writeFileSync(path, body);
-    return path;
-}
-const askPage = sourceFile('ask.tsx', `export default function Rollout() {
-  return (
-    <Page title="Rollout scope" subtitle="Pick tonight\u2019s rollout">
-      <p>Which rollout do you want?</p>
-      <UserQuestion id="rollout" label="Rollout lane" body="Canary limits the blast radius." mode="single" options={[{ id: 'canary', label: 'Canary first' }, { id: 'full', label: 'Full' }]} />
-    </Page>
-  );
-}
-`);
-const displayPage = sourceFile('display.tsx', `export default function Nightly() {
-  return (
-    <Page title="Nightly report">
-      <h1>All green</h1>
-    </Page>
-  );
-}
-`);
-function submit(id, source, emittedAt, nodeId = 'node-1', replyExpected = true) {
-    const dir = submitPage({ dir: ticketDir(id), sourceFile: source, source: { nodeId, emittedAt }, delivery: { placement: 'inline', inbox: replyExpected, reply: replyExpected } }).dir;
-    if (replyExpected)
-        bindTicketReplyRoute(dir, id);
-    return dir;
-}
-test('submitPage publishes the authored source, the derived manifest and the emittedAt stamp', () => {
-    const submitted = submitPage({ dir: ticketDir('ask'), sourceFile: askPage, source: { nodeId: 'node-1' }, delivery: { placement: 'inline', inbox: true, reply: true } });
-    assert.equal(submitted.kind, 'page');
-    assert.equal(submitted.id, 'ask');
-    assert.equal(readFileSync(pagePath(submitted.dir), 'utf8'), readFileSync(askPage, 'utf8'));
-    const manifest = JSON.parse(readFileSync(pageManifestPath(submitted.dir), 'utf8'));
-    assert.equal(manifest['schema'], 'crtr.page/v2');
-    assert.equal(manifest['document'], 'page.tsx');
-    assert.deepEqual(manifest['delivery'], { placement: 'inline', inbox: true, reply: true });
-    const source = manifest['source'];
-    assert.equal(source.nodeId, 'node-1');
-    assert.ok(Date.parse(source.emittedAt) > 0, 'submission stamps emittedAt');
-    // A ticket's request is replaceable in place — what `human send --replace`
-    // does. Republishing over the same directory revises the page and leaves one
-    // ticket behind, rather than refusing or raising a second one.
-    const stamp = { nodeId: 'node-replace', emittedAt: '2026-01-05T00:00:00.000Z' };
-    const first = submitPage({ dir: ticketDir('revisable'), sourceFile: askPage, source: stamp });
-    const revised = submitPage({ dir: ticketDir('revisable'), sourceFile: displayPage, source: stamp });
-    assert.equal(revised.id, first.id);
-    assert.equal(revised.manifest.title, 'Nightly report');
-    assert.equal(readFileSync(pagePath(revised.dir), 'utf8'), readFileSync(displayPage, 'utf8'));
-    assert.deepEqual(scanPageHistory('node-replace').map((entry) => entry.id), ['revisable'], 'a replaced page is one ticket, not two');
-    bindTicketReplyRoute(submitted.dir, 'ask');
-    const listed = scanInbox().find((item) => item.id === 'ask');
-    assert.equal(listed?.kind, 'page');
-    assert.equal(listed?.kind === 'page' ? listed.awaitsResponse : undefined, true);
-    assert.deepEqual(listed?.kind === 'page' ? listed.slotKinds : undefined, ['options']);
-});
-test('an HTML page derives a slotless manifest from declared metadata', () => {
-    const report = sourceFile('report.html', '<!doctype html><html><head><meta content="Summary" name="description"><title>Report</title></head><body>done</body></html>');
-    const prepared = preparePage({ sourceFile: report });
-    assert.equal(prepared.module, undefined);
-    assert.deepEqual(prepared.manifest, { schema: 'crtr.page/v2', dialect: 'html', title: 'Report', subtitle: 'Summary', delivery: { placement: 'inline', inbox: false, reply: false }, document: 'page.html', steps: 1, slots: [], source: prepared.manifest.source });
-});
-test('progress round-trips through validation and rejects malformed saved work', () => {
-    const dir = ticketDir('ask');
-    assert.equal(readPageProgress(dir), null, 'no progress file reads as null');
-    writePageProgress(dir, { rollout: { selectedOptionIds: ['canary'], comments: [] } });
-    assert.deepEqual(readPageProgress(dir), { rollout: { selectedOptionIds: ['canary'], comments: [] } });
-    assert.throws(() => writePageProgress(dir, { rollout: { selectedOptionIds: ['nope'], comments: [] } }), /nope/);
-    assert.throws(() => writePageProgress(dir, { unknown: { selectedOptionIds: [], comments: [] } }), /unknown/);
-    atomicWriteJson(progressPath(dir), { kind: 'page', responses: { rollout: 'not an object' }, savedAt: new Date().toISOString() });
-    assert.throws(() => readPageProgress(dir), /malformed/, 'malformed progress is an error, never silently discarded');
-    // Saved work can outlive the slot it answered, because the agent may replace
-    // the page under it. The stale entry is dropped on read so the ticket stays
-    // readable; every entry the current page still declares hydrates.
-    atomicWriteJson(progressPath(dir), { kind: 'page', responses: { rollout: { selectedOptionIds: ['canary'], comments: [] }, retired: { selectedOptionIds: ['gone'], comments: [] } }, savedAt: new Date().toISOString() });
-    assert.deepEqual(readPageProgress(dir), { rollout: { selectedOptionIds: ['canary'], comments: [] } });
-    writePageProgress(dir, { rollout: { selectedOptionIds: ['canary'], comments: [] } });
-});
-test('readPageTicket derives pending, resolved and canceled state and carries the document', () => {
-    const dir = ticketDir('ask');
-    const pending = readPageTicket(dir);
-    assert.equal(pending.state, 'pending');
-    assert.equal(pending.manifest.title, 'Rollout scope');
-    assert.ok(pending.document.includes('Which rollout do you want?'));
-    assert.deepEqual(pending.progress, { rollout: { selectedOptionIds: ['canary'], comments: [] } });
-    const claim = claimTicket(dir);
-    assert.notEqual(claim, null, 'a page ticket is claimable');
-    assert.throws(() => completePage(dir, { rollout: { selectedOptionIds: [], comments: [] } }, claim.token), /rollout/, 'single-select requires one selection');
-    const completed = completePage(dir, { rollout: { selectedOptionIds: ['full'], comments: [] }, }, claim.token);
-    assert.equal(completed.won, true);
-    const written = JSON.parse(readFileSync(responsePath(dir), 'utf8'));
-    assert.equal(written['schema'], 'crtr.page-response/v1');
-    assert.equal(written['kind'], 'page');
-    assert.deepEqual(written['responses'], { rollout: { selectedOptionIds: ['full'], comments: [] } });
-    assert.equal(written['summary'], 'Full');
-    assert.equal(readTicketResult(dir)?.kind, 'page', 'the strict decoder accepts the page result');
-    assert.equal(existsSync(progressPath(dir)), false, 'completion clears owned work');
-    const resolved = readPageTicket(dir);
-    assert.equal(resolved.state, 'resolved');
-    assert.equal(resolved.progress, null);
-    assert.equal(scanInbox().some((item) => item.id === 'ask'), false, 'a resolved page leaves the pending list');
-    const canceledDir = submit('canceled', askPage, '2026-01-03T00:00:00.000Z');
-    cancelTicket(canceledDir, { reason: 'no longer needed' });
-    assert.equal(readPageTicket(canceledDir).state, 'canceled');
-});
-test('page scan derives response expectation from the page shape and its reply route', () => {
-    const dir = submit('display', displayPage, '2026-01-04T00:00:00.000Z');
-    const ticket = readPageTicket(dir);
-    assert.equal(ticket.manifest.dialect, 'jsx');
-    assert.equal(ticket.manifest.slots.length, 0);
-    const display = scanInbox().find((item) => item.id === 'display');
-    assert.equal(display?.kind === 'page' ? display.awaitsResponse : undefined, true, 'a reply-bearing page waits even with no response-bearing slots');
-    const announcementDir = submit('announcement-with-options', askPage, '2026-01-04T00:00:01.000Z', 'node-1', false);
-    const announcement = scanInbox().find((item) => item.id === 'announcement-with-options');
-    assert.equal(announcement, undefined, 'a passive page stays out of the inbox');
-    assert.equal(readPageTicket(announcementDir).state, 'passive');
-    assert.throws(() => takeoverAndCompletePage(announcementDir, {}, { host: 'crtrd', pid: process.pid }), /page_has_no_response_lifecycle/);
-    const acknowledged = takeoverAndCompletePage(dir, {}, { host: 'crtrd', pid: process.pid });
-    assert.equal(acknowledged.won, true);
-    const written = JSON.parse(readFileSync(responsePath(dir), 'utf8'));
-    assert.equal(written['schema'], 'crtr.page-response/v1');
-    assert.deepEqual(written['responses'], {});
-    assert.equal(written['summary'], '');
-});
-test('an inbox page that asks something waits on the person with no reply route', () => {
-    const stamp = (emittedAt) => ({ nodeId: 'node-durable', emittedAt });
-    // The programmatic request shape: answerable from the inbox, never routed to an agent bridge.
-    const durable = submitPage({ dir: ticketDir('durable-request'), sourceFile: askPage, source: stamp('2026-01-06T00:00:00.000Z'), delivery: { placement: 'panel', inbox: true, reply: false } }).dir;
-    submitPage({ dir: ticketDir('durable-notice'), sourceFile: displayPage, source: stamp('2026-01-06T00:00:01.000Z'), delivery: { placement: 'panel', inbox: true, reply: false } });
-    const listed = scanInbox();
-    const request = listed.find((item) => item.id === 'durable-request');
-    assert.equal(request?.kind === 'page' ? request.awaitsResponse : undefined, true, 'a page with response-bearing slots waits on the person even with no bridge to reply to');
-    const notice = listed.find((item) => item.id === 'durable-notice');
-    assert.equal(notice?.kind === 'page' ? notice.awaitsResponse : undefined, false, 'a display-only notice waits on nothing');
-    const claim = claimTicket(durable);
-    const answered = completePage(durable, { rollout: { selectedOptionIds: ['canary'], comments: [] } }, claim.token);
-    assert.equal(answered.won, true, 'a request with no reply route still takes a real answer');
-    assert.deepEqual(JSON.parse(readFileSync(responsePath(durable), 'utf8'))['responses'], { rollout: { selectedOptionIds: ['canary'], comments: [] } });
-});
-test('scanPageHistory returns every page of one node, oldest first, regardless of terminal file', () => {
-    submit('older', askPage, '2026-01-01T00:00:00.000Z');
-    submit('other-node', askPage, '2026-01-02T00:00:00.000Z', 'node-2');
-    const history = scanPageHistory('node-1');
-    assert.deepEqual(history.map((entry) => entry.id), ['older', 'canceled', 'display', 'announcement-with-options', 'ask']);
-    assert.deepEqual(history.map((entry) => entry.state), ['pending', 'canceled', 'resolved', 'passive', 'resolved']);
-    assert.deepEqual(scanPageHistory('node-2').map((entry) => entry.id), ['other-node']);
-    assert.deepEqual(scanPageHistory('node-missing'), []);
-});

package/dist/core/review/ticket-filter.d.ts

@@ -1,17 +0,0 @@
-/**
- * Terminal-review ticket visibility filter.
- * Hides review tickets by canonical state.
- * This module never imports canvas DB directly; daemon call sites apply the filter.
- */
-import type { TicketSummary } from '../human/types.js';
-/**
- * Determines if a review ticket should be visible based on its canonical review state.
- * Only an open row is visible: 'binding', 'approved', and 'canceled' are hidden, and so is a
- * ticket with no row at all — a row is committed before its ticket is ever published.
- */
-export declare function isReviewTicketVisible(bridgeNodeId: string): boolean;
-/**
- * Filters a ticket summary array to remove hidden terminal-review tickets.
- * Page tickets pass through unchanged. Review tickets are filtered by state.
- */
-export declare function filterTerminalReviewTickets(items: TicketSummary[]): TicketSummary[];

package/dist/core/review/ticket-filter.js

@@ -1,21 +0,0 @@
-/**
- * Terminal-review ticket visibility filter.
- * Hides review tickets by canonical state.
- * This module never imports canvas DB directly; daemon call sites apply the filter.
- */
-import { getReviewByBridge } from './store.js';
-/**
- * Determines if a review ticket should be visible based on its canonical review state.
- * Only an open row is visible: 'binding', 'approved', and 'canceled' are hidden, and so is a
- * ticket with no row at all — a row is committed before its ticket is ever published.
- */
-export function isReviewTicketVisible(bridgeNodeId) {
-    return getReviewByBridge(bridgeNodeId)?.state === 'open';
-}
-/**
- * Filters a ticket summary array to remove hidden terminal-review tickets.
- * Page tickets pass through unchanged. Review tickets are filtered by state.
- */
-export function filterTerminalReviewTickets(items) {
-    return items.filter((item) => (item.kind === 'review' ? isReviewTicketVisible(item.id) : true));
-}

package/dist/core/runtime/broker/passive.d.ts

@@ -1,17 +0,0 @@
-/** Structural copy of an InboxEntry used by broker presentation only. Keeping
- * this type here avoids importing the feed implementation into the broker. */
-export interface BrokerPassiveEntry {
-    entry_id: string;
-    operation_id: string;
-    ts: string;
-    from: string | null;
-    from_name?: string;
-    tier: string;
-    kind: string;
-    ref?: string;
-    label: string;
-    data?: Record<string, unknown>;
-}
-/** Read and clear the passive accumulator, preserving the rename-before-read
- * race boundary used by the daemon's feed writer. */
-export declare function drainBrokerPassive(nodeId: string): BrokerPassiveEntry[];

package/dist/core/runtime/broker/passive.js

@@ -1,44 +0,0 @@
-// Broker-local passive feed access. This deliberately avoids the canvas/feed
-// barrels: those are daemon-side modules and their import graph reaches the
-// canvas database. A broker only needs the node-owned JSONL accumulator.
-import { existsSync, readFileSync, renameSync, rmSync, } from 'node:fs';
-import { passivePath } from '../../canvas/paths.js';
-function parseEntries(text) {
-    const entries = [];
-    for (const line of text.split('\n')) {
-        if (line.trim() === '')
-            continue;
-        try {
-            entries.push(JSON.parse(line));
-        }
-        catch {
-            // Preserve the feed's tolerant per-line corruption behavior.
-        }
-    }
-    return entries;
-}
-/** Read and clear the passive accumulator, preserving the rename-before-read
- * race boundary used by the daemon's feed writer. */
-export function drainBrokerPassive(nodeId) {
-    const path = passivePath(nodeId);
-    if (!existsSync(path))
-        return [];
-    const snapshot = `${path}.draining`;
-    try {
-        renameSync(path, snapshot);
-    }
-    catch {
-        return [];
-    }
-    let entries = [];
-    try {
-        entries = parseEntries(readFileSync(snapshot, 'utf8'));
-    }
-    finally {
-        try {
-            rmSync(snapshot, { force: true });
-        }
-        catch { /* best effort */ }
-    }
-    return entries;
-}

package/dist/core/runtime/busy.d.ts

@@ -1,46 +0,0 @@
-export type TransportPoisonVerdict = {
-    consecutivePasses: number;
-    routes: string[];
-};
-/** Mark a node mid-turn (pi entered a turn). Best-effort. A new turn makes any
- * prior clean-abort certificate stale before it can affect a later crash. */
-export declare function markBusy(nodeId: string): void;
-/** Clear the mid-run marker after Pi settles, however it routed. Best-effort. */
-export declare function clearBusy(nodeId: string): void;
-/** Certify that this broker aborted a busy turn and Pi persisted its settled
- * aborted entry before teardown. Settling clears the busy marker, so the daemon
- * consumes this durable certificate as the surviving interrupted-turn witness
- * and resumes with a continuation. A dirty death instead leaves `busy` behind. */
-export declare function markCleanAbort(nodeId: string): void;
-/** Remove a consumed clean-abort certificate as a broker boots. */
-export declare function clearCleanAbort(nodeId: string): void;
-/** Record the provider-rotation verdict immediately before it terminates this broker.
- * It survives the broker exit so the fleet can surface the cause if this launch
- * exhausts respawn recovery. */
-export declare function recordTransportPoisonVerdict(nodeId: string, verdict: TransportPoisonVerdict): void;
-/** A verdict belongs to one broker launch. Clear it before every replacement so
- * a later unrelated crash loop cannot inherit an old transport diagnosis. */
-export declare function clearTransportPoisonVerdict(nodeId: string): void;
-/** Read only a complete, structurally valid provider-rotation verdict. */
-export declare function readTransportPoisonVerdict(nodeId: string): TransportPoisonVerdict | null;
-/** Whether the dead broker left a persisted clean-abort turn witness. */
-export declare function hasCleanAbort(nodeId: string): boolean;
-/** Is the node currently inside a turn? AND this with `pidAlive` at the call
- *  site — a stale marker from a crashed pi is harmless because the dead pid
- *  fails the AND. */
-export declare function isBusy(nodeId: string): boolean;
-/** Re-touch the mid-turn marker's mtime — the daemon's wedge-detection
- *  heartbeat (crtrd.ts `handleWedgeDetection`). Called from canvas-stophook on
- *  every engine-level sign of life WITHIN a turn (a tool starting/streaming/
- *  ending, a streamed assistant token, a turn ending) so the marker's mtime
- *  always reflects the last moment the engine visibly did something, not just
- *  when the run began. No-ops when the node isn't currently busy — a touch
- *  arriving after `clearBusy` (e.g. a late event racing agent_settled) must
- *  never resurrect a stale marker. Best-effort. */
-export declare function touchBusy(nodeId: string): void;
-/** The mid-turn marker's mtime: the last moment ANY engine-level progress was
- *  observed while the node was busy (see `touchBusy`). Null when the node isn't
- *  busy or the marker is unreadable. This is the sole heartbeat the daemon's
- *  wedge detector reads — it needs no new instrumentation beyond re-touching an
- *  already-existing file. */
-export declare function busySince(nodeId: string): number | null;

package/dist/core/runtime/busy.js

@@ -1,150 +0,0 @@
-// busy.ts — the "is pi actually mid-turn" signal (a marker file, no db column).
-//
-// The disposition of a focus's OUTGOING node on a hot-swap (placement.ts
-// `outgoingDisposition`) must distinguish a terminal worker that is GENUINELY
-// mid-turn (keep it running off-screen, Invariant F2) from one merely PARKED at
-// its prompt with a live pi (a viewer revived for inspection — despawn it back to
-// dormant on focus-away). A live pid is NOT that signal: a parked node has a live
-// pid too. This marker is.
-//
-// `<jobDir>/busy` exists for exactly the span pi is inside a whole run: the
-// stophook touches it on `agent_start` and unlinks it at `agent_settled` (and
-// defensively on `session_shutdown`). It is always AND-ed with `pidAlive` at the
-// read site, so a stale marker (process crashed mid-turn without firing
-// agent_end) is harmless — the dead pid fails the AND and the node is reaped.
-// No db migration, atomic touch/unlink, best-effort (never throws).
-import { existsSync, readFileSync, writeFileSync, rmSync, mkdirSync, statSync } from 'node:fs';
-import { join } from 'node:path';
-import { jobDir } from '../canvas/paths.js';
-function busyPath(nodeId) {
-    return join(jobDir(nodeId), 'busy');
-}
-function cleanAbortPath(nodeId) {
-    return join(jobDir(nodeId), 'clean-abort');
-}
-function transportPoisonPath(nodeId) {
-    return join(jobDir(nodeId), 'transport-poison.json');
-}
-/** Mark a node mid-turn (pi entered a turn). Best-effort. A new turn makes any
- * prior clean-abort certificate stale before it can affect a later crash. */
-export function markBusy(nodeId) {
-    try {
-        mkdirSync(jobDir(nodeId), { recursive: true });
-        rmSync(cleanAbortPath(nodeId), { force: true });
-        writeFileSync(busyPath(nodeId), '');
-    }
-    catch {
-        /* best-effort */
-    }
-}
-/** Clear the mid-run marker after Pi settles, however it routed. Best-effort. */
-export function clearBusy(nodeId) {
-    try {
-        rmSync(busyPath(nodeId), { force: true });
-    }
-    catch {
-        /* best-effort */
-    }
-}
-/** Certify that this broker aborted a busy turn and Pi persisted its settled
- * aborted entry before teardown. Settling clears the busy marker, so the daemon
- * consumes this durable certificate as the surviving interrupted-turn witness
- * and resumes with a continuation. A dirty death instead leaves `busy` behind. */
-export function markCleanAbort(nodeId) {
-    try {
-        mkdirSync(jobDir(nodeId), { recursive: true });
-        writeFileSync(cleanAbortPath(nodeId), '');
-    }
-    catch {
-        /* best-effort */
-    }
-}
-/** Remove a consumed clean-abort certificate as a broker boots. */
-export function clearCleanAbort(nodeId) {
-    try {
-        rmSync(cleanAbortPath(nodeId), { force: true });
-    }
-    catch {
-        /* best-effort */
-    }
-}
-/** Record the provider-rotation verdict immediately before it terminates this broker.
- * It survives the broker exit so the fleet can surface the cause if this launch
- * exhausts respawn recovery. */
-export function recordTransportPoisonVerdict(nodeId, verdict) {
-    try {
-        mkdirSync(jobDir(nodeId), { recursive: true });
-        writeFileSync(transportPoisonPath(nodeId), JSON.stringify(verdict));
-    }
-    catch {
-        /* best-effort: no marker means the crash report remains explicitly unknown */
-    }
-}
-/** A verdict belongs to one broker launch. Clear it before every replacement so
- * a later unrelated crash loop cannot inherit an old transport diagnosis. */
-export function clearTransportPoisonVerdict(nodeId) {
-    try {
-        rmSync(transportPoisonPath(nodeId), { force: true });
-    }
-    catch {
-        /* best-effort */
-    }
-}
-/** Read only a complete, structurally valid provider-rotation verdict. */
-export function readTransportPoisonVerdict(nodeId) {
-    try {
-        const value = JSON.parse(readFileSync(transportPoisonPath(nodeId), 'utf8'));
-        if (typeof value !== 'object' || value === null)
-            return null;
-        const verdict = value;
-        const consecutivePasses = verdict.consecutivePasses;
-        const routes = verdict.routes;
-        if (typeof consecutivePasses !== 'number' || !Number.isInteger(consecutivePasses) || consecutivePasses < 1 || !Array.isArray(routes) || routes.length === 0 || !routes.every((route) => typeof route === 'string' && route !== ''))
-            return null;
-        return { consecutivePasses, routes };
-    }
-    catch {
-        return null;
-    }
-}
-/** Whether the dead broker left a persisted clean-abort turn witness. */
-export function hasCleanAbort(nodeId) {
-    return existsSync(cleanAbortPath(nodeId));
-}
-/** Is the node currently inside a turn? AND this with `pidAlive` at the call
- *  site — a stale marker from a crashed pi is harmless because the dead pid
- *  fails the AND. */
-export function isBusy(nodeId) {
-    return existsSync(busyPath(nodeId));
-}
-/** Re-touch the mid-turn marker's mtime — the daemon's wedge-detection
- *  heartbeat (crtrd.ts `handleWedgeDetection`). Called from canvas-stophook on
- *  every engine-level sign of life WITHIN a turn (a tool starting/streaming/
- *  ending, a streamed assistant token, a turn ending) so the marker's mtime
- *  always reflects the last moment the engine visibly did something, not just
- *  when the run began. No-ops when the node isn't currently busy — a touch
- *  arriving after `clearBusy` (e.g. a late event racing agent_settled) must
- *  never resurrect a stale marker. Best-effort. */
-export function touchBusy(nodeId) {
-    try {
-        if (!existsSync(busyPath(nodeId)))
-            return;
-        writeFileSync(busyPath(nodeId), '');
-    }
-    catch {
-        /* best-effort */
-    }
-}
-/** The mid-turn marker's mtime: the last moment ANY engine-level progress was
- *  observed while the node was busy (see `touchBusy`). Null when the node isn't
- *  busy or the marker is unreadable. This is the sole heartbeat the daemon's
- *  wedge detector reads — it needs no new instrumentation beyond re-touching an
- *  already-existing file. */
-export function busySince(nodeId) {
-    try {
-        return statSync(busyPath(nodeId)).mtimeMs;
-    }
-    catch {
-        return null;
-    }
-}

package/dist/daemon/__tests__/startup-block-marker.test.d.ts

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