@north-light/crouter 0.3.172 → 0.3.174

package/dist/daemon/api/__tests__/inbox.test.js

@@ -1,489 +0,0 @@
-// Run with: node --import tsx/esm --test src/daemon/api/__tests__/inbox.test.ts
-//
-// Integration coverage for crtrd's `/v1/human/inbox` routes
-// (inbox-contract.md §A, `handlers/inbox.ts`). Exercises the full leaf → typed
-// `CrtrClient` → in-process `createApiServer()` → handler → ticket store —
-// never a mock client or pre-parsed handler call. Tickets live directly under
-// the derived `ticketsRoot()` and use the same public store APIs as production.
-// A raw hand-written `deck.json` is used only for states that submission cannot
-// produce: an unresolved `bodyPath`, a malformed stored deck, or a raced final.
-import { test, describe, before, after, beforeEach } from 'node:test';
-import assert from 'node:assert/strict';
-import { spawn } from 'node:child_process';
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync, readFileSync, existsSync, realpathSync, } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { createHash } from 'node:crypto';
-import { claimTicket, releaseClaim } from '../../../core/human/claim.js';
-import { deckPath, responsePath } from '../../../core/human/convention.js';
-import { notifyDeck } from '../../../core/human/deck-factories.js';
-import { ticketsRoot } from '../../../core/human/root.js';
-import { submitDeck, submitReview } from '../../../core/human/tickets.js';
-import { createApiServer } from '../server.js';
-import { apiSocketPath } from '../../../core/canvas/paths.js';
-import { CrtrClient, ApiError } from '../../../api/index.js';
-const TICKET_ID_PATTERN = /^[a-f0-9]{64}$/;
-// ---------------------------------------------------------------------------
-// Harness — one server for the whole file; a fresh derived tickets root per
-// test.
-// ---------------------------------------------------------------------------
-let crtrHome;
-let priorCrtrHome;
-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(async () => {
-    priorCrtrHome = process.env['CRTR_HOME'];
-    crtrHome = mkdtempSync(join(tmpdir(), 'crtr-inbox-home-'));
-    process.env['CRTR_HOME'] = crtrHome;
-    server = createApiServer();
-    await waitForSocket(apiSocketPath());
-    client = new CrtrClient({ socketPath: apiSocketPath(), autostart: false });
-});
-after(async () => {
-    await server?.close();
-    rmSync(crtrHome, { recursive: true, force: true });
-    if (priorCrtrHome !== undefined)
-        process.env['CRTR_HOME'] = priorCrtrHome;
-    else
-        delete process.env['CRTR_HOME'];
-});
-beforeEach(() => {
-    rmSync(ticketsRoot(), { recursive: true, force: true });
-    mkdirSync(ticketsRoot(), { recursive: true, mode: 0o700 });
-});
-// ---------------------------------------------------------------------------
-// Fixture helpers
-// ---------------------------------------------------------------------------
-function freshRoot(..._unused) {
-    mkdirSync(ticketsRoot(), { recursive: true, mode: 0o700 });
-    return realpathSync(ticketsRoot());
-}
-function deckJson(blockedSince, extra = {}) {
-    return {
-        title: 'Ship it?',
-        source: { blockedSince },
-        interactions: [{ id: 'q', title: 'Ship it?', subtitle: 'Approve shipping now so the release can proceed.', options: [{ id: 'yes', label: 'Yes' }, { id: 'no', label: 'No' }] }],
-        ...extra,
-    };
-}
-/** Create a real pending deck ticket through the public submission API — the
- *  normal fixture path for any test that just needs a valid, answerable
- *  ticket on disk. */
-function submitTestDeck(root, id, blockedSince, extra = {}) {
-    return submitDeck({ dir: join(root, id), deck: deckJson(blockedSince, extra) }).dir;
-}
-/** Create a real pending review ticket through the public submission API. */
-function submitTestReview(root, id, blockedSince) {
-    const srcDir = mkdtempSync(join(tmpdir(), 'crtr-inbox-review-src-'));
-    const file = join(srcDir, 'plan.md');
-    writeFileSync(file, '# Plan\n\nDo the thing.\n');
-    return submitReview({ dir: join(root, id), review: { title: 'Review the plan', subtitle: 'Review the plan now so implementation can begin with confidence.', source: {}, file, blockedSince } }).dir;
-}
-/** RAW fixture writer — bypasses `submitDeck`'s own submit-time validation
- *  and body-path resolution entirely. Used ONLY to construct on-disk states
- *  a real submitter cannot produce: an unresolved `bodyPath`, a tampered
- *  stored deck, or an adversarial root-replacement target. */
-function writeRawDeckTicket(root, id, deck) {
-    const dir = join(root, id);
-    mkdirSync(dir, { recursive: true, mode: 0o700 });
-    writeFileSync(deckPath(dir), JSON.stringify(deck));
-    return dir;
-}
-function ticketIdFor(root, basename) {
-    return createHash('sha256').update(`${root}\0${basename}`, 'utf8').digest('hex');
-}
-async function expectApiError(promise, status, code) {
-    try {
-        await promise;
-    }
-    catch (err) {
-        assert.ok(err instanceof ApiError, `expected ApiError, got ${String(err)}`);
-        assert.equal(err.status, status, `status: ${err.message}`);
-        assert.equal(err.code, code, `code: ${err.message}`);
-        return err;
-    }
-    throw new Error('expected the promise to reject');
-}
-// ---------------------------------------------------------------------------
-// Wire-shape assertions — a closed allowlist per DTO plus a recursive
-// forbidden-content walk (host paths, claim/dir/file/output/bodyPath keys).
-// ---------------------------------------------------------------------------
-function assertKeys(obj, allowed, label) {
-    for (const key of Object.keys(obj)) {
-        assert.ok(allowed.includes(key), `unexpected field "${key}" in ${label}: ${JSON.stringify(obj)}`);
-    }
-}
-function assertSourceShape(source) {
-    assert.equal(typeof source, 'object');
-    assertKeys(source, ['sessionName', 'askedBy', 'blockedSince', 'nodeId'], 'DeckSourceDTO');
-}
-function assertTicketSummaryShape(ticket) {
-    assert.match(ticket.ticket_id, TICKET_ID_PATTERN);
-    assert.ok(ticket.kind === 'deck' || ticket.kind === 'review');
-    const allowed = ticket.kind === 'deck'
-        ? ['ticket_id', 'kind', 'title', 'subtitle', 'blocked_since', 'source', 'interaction_kind']
-        : ['ticket_id', 'kind', 'title', 'subtitle', 'blocked_since', 'source'];
-    assertKeys(ticket, allowed, `InboxTicketSummaryDTO(${ticket.kind})`);
-    assertSourceShape(ticket.source);
-}
-function assertInboxListShape(body) {
-    assertKeys(body, ['tickets'], 'InboxListDTO');
-    for (const ticket of body.tickets)
-        assertTicketSummaryShape(ticket);
-}
-function assertInteractionShape(interaction) {
-    assertKeys(interaction, ['id', 'title', 'subtitle', 'body', 'options', 'multiSelect', 'allowFreetext', 'freetextLabel', 'kind', 'preAnswered'], 'InteractionDTO');
-    for (const option of interaction.options) {
-        assertKeys(option, ['id', 'label', 'description'], 'InteractionOptionDTO');
-    }
-    if (interaction.preAnswered !== undefined) {
-        assertKeys(interaction.preAnswered, ['selectedOptionId', 'selectedOptionIds', 'freetext', 'label'], 'InteractionPreAnswerDTO');
-    }
-}
-function assertDeckShape(deck) {
-    assertKeys(deck, ['title', 'source', 'interactions'], 'DeckDTO');
-    if (deck.source !== undefined)
-        assertSourceShape(deck.source);
-    for (const interaction of deck.interactions)
-        assertInteractionShape(interaction);
-}
-function assertInboxDeckShape(body) {
-    assertKeys(body, ['ticket_id', 'kind', 'deck'], 'InboxDeckDTO');
-    assert.equal(body.kind, 'deck');
-    assert.match(body.ticket_id, TICKET_ID_PATTERN);
-    assertDeckShape(body.deck);
-}
-function assertDeckResultShape(result) {
-    assertKeys(result, ['schema', 'kind', 'responses', 'summary', 'completedAt'], 'DeckTicketResultDTO');
-    assert.equal(result.schema, 'humanloop.response/v2');
-    assert.equal(result.kind, 'deck');
-    for (const response of result.responses) {
-        assertKeys(response, ['id', 'selectedOptionId', 'selectedOptionIds', 'freetext', 'optionComments'], 'InteractionResponseDTO');
-    }
-}
-function assertCanceledResultShape(result) {
-    assertKeys(result, ['schema', 'kind', 'canceledAt', 'reason', 'actor'], 'CanceledTicketResultDTO');
-    assert.equal(result.schema, 'humanloop.cancel/v1');
-    assert.equal(result.kind, 'canceled');
-}
-const FORBIDDEN_KEYS = new Set(['dir', 'file', 'output', 'claim', 'bodyPath']);
-/** Recursively walk a parsed JSON value, failing on any forbidden key name or
- *  any string value containing one of the given forbidden substrings (host
- *  paths, in practice). Used against full success AND error bodies. */
-function assertNoForbiddenContent(value, forbidden, path = '$') {
-    if (Array.isArray(value)) {
-        value.forEach((item, i) => assertNoForbiddenContent(item, forbidden, `${path}[${i}]`));
-        return;
-    }
-    if (value !== null && typeof value === 'object') {
-        for (const [key, val] of Object.entries(value)) {
-            assert.ok(!FORBIDDEN_KEYS.has(key), `forbidden key "${key}" present at ${path}.${key}`);
-            assertNoForbiddenContent(val, forbidden, `${path}.${key}`);
-        }
-        return;
-    }
-    if (typeof value === 'string') {
-        for (const needle of forbidden) {
-            assert.ok(!value.includes(needle), `forbidden content "${needle}" leaked at ${path}: ${JSON.stringify(value)}`);
-        }
-    }
-}
-// ---------------------------------------------------------------------------
-// GET /v1/human/inbox — enumerate
-// ---------------------------------------------------------------------------
-describe('GET /v1/human/inbox — enumerate', () => {
-    test('mixed deck + review tickets preserve canonical-root hash ids while sorting newest first', async () => {
-        const root = freshRoot('crouter');
-        // This is the pre-cutover opaque-id formula: canonical root + NUL + ticket
-        // basename. The single derived root retains that canonical root, so an id
-        // a client computed before root registration disappeared still resolves.
-        const olderDeckId = ticketIdFor(root, 'older-deck');
-        submitTestDeck(root, 'older-deck', '2026-01-01T00:00:00.000Z');
-        submitTestReview(root, 'newer-review', '2026-01-02T00:00:00.000Z');
-        const list = await client.listHumanInbox();
-        assertInboxListShape(list);
-        assertNoForbiddenContent(list, [root]);
-        assert.equal(list.tickets.length, 2);
-        assert.equal(list.tickets[0].kind, 'review', 'newer blocked_since sorts first');
-        assert.equal(list.tickets[1].kind, 'deck');
-        assert.equal(list.tickets[0].ticket_id, ticketIdFor(root, 'newer-review'));
-        assert.equal(list.tickets[1].ticket_id, olderDeckId);
-        assert.equal((await client.getHumanInboxDeck(olderDeckId)).deck.title, 'Ship it?');
-    });
-    test('sorts by parsed instant across differing UTC offsets, not lexical string order', async () => {
-        const root = freshRoot('crouter');
-        // '+14:00' is lexically GREATER than 'Z' at the date digit that differs,
-        // but the instant it names is two hours EARLIER than the 'Z' ticket
-        // below (2026-01-01T10:00:00Z vs. 2026-01-01T12:00:00Z). A lexical
-        // descending sort would (wrongly) place this ticket first.
-        submitTestDeck(root, 'lexically-later-but-earlier-instant', '2026-01-02T00:00:00+14:00');
-        submitTestDeck(root, 'lexically-earlier-but-later-instant', '2026-01-01T12:00:00Z');
-        const list = await client.listHumanInbox();
-        assert.equal(list.tickets.length, 2);
-        assert.equal(list.tickets[0].blocked_since, '2026-01-01T12:00:00Z', 'the chronologically newer instant sorts first regardless of lexical string order');
-        assert.equal(list.tickets[0].ticket_id, ticketIdFor(root, 'lexically-earlier-but-later-instant'));
-        assert.equal(list.tickets[1].ticket_id, ticketIdFor(root, 'lexically-later-but-earlier-instant'));
-    });
-});
-// ---------------------------------------------------------------------------
-// GET /v1/human/inbox/:ticket_id — read a pending deck
-// ---------------------------------------------------------------------------
-describe('GET /v1/human/inbox/:ticket_id', () => {
-    test('inlines bodyPath at read time; no bodyPath key on the wire', async () => {
-        // RAW fixture: `submitDeck` resolves `bodyPath` to inline `body` at
-        // submit time, so a ticket with a still-unresolved `bodyPath` on disk
-        // (the state crtrd's own `parseDeck` read-time resolution exists to
-        // handle) cannot be produced through the public submission API.
-        const root = freshRoot('crouter');
-        const dir = join(root, 'body-deck');
-        mkdirSync(dir, { recursive: true, mode: 0o700 });
-        writeFileSync(join(dir, 'body.md'), 'Full markdown body.\n');
-        writeFileSync(deckPath(dir), JSON.stringify({
-            title: 'Ship it?',
-            source: { blockedSince: '2026-01-01T00:00:00.000Z' },
-            interactions: [{ id: 'q', title: 'Ship it?', subtitle: 'Approve shipping now so the release can proceed.', bodyPath: 'body.md', options: [{ id: 'yes', label: 'Yes' }] }],
-        }));
-        const id = ticketIdFor(root, 'body-deck');
-        const deckDto = await client.getHumanInboxDeck(id);
-        assertInboxDeckShape(deckDto);
-        assertNoForbiddenContent(deckDto, [root, dir]);
-        assert.equal(deckDto.deck.interactions[0].body, 'Full markdown body.\n');
-    });
-    test('404 ticket_not_found for a syntactically valid but unknown ticket id', async () => {
-        await expectApiError(client.getHumanInboxDeck('a'.repeat(64)), 404, 'ticket_not_found');
-    });
-    test('409 ticket_kind_unsupported for a review ticket', async () => {
-        const root = freshRoot('crouter');
-        submitTestReview(root, 'rev', '2026-01-01T00:00:00.000Z');
-        await expectApiError(client.getHumanInboxDeck(ticketIdFor(root, 'rev')), 409, 'ticket_kind_unsupported');
-    });
-    test('malformed stored deck sanitizes to 500 internal: no bodyPath value or host path in error.message', async () => {
-        // RAW fixture: simulates a ticket mutated on disk after enumeration (or a
-        // corrupted store) — a state `submitDeck` cannot produce, since it
-        // validates and resolves bodyPath before ever writing deck.json. This
-        // reproduces the review's exact repro shape: a bodyPath that escapes the
-        // ticket directory to an existing absolute host file.
-        const root = freshRoot('crouter');
-        const dir = writeRawDeckTicket(root, 'malformed', deckJson('2026-01-01T00:00:00.000Z', {
-            interactions: [{ id: 'q', title: 'Ship it?', subtitle: 'Approve shipping now so the release can proceed.', bodyPath: process.execPath, options: [{ id: 'yes', label: 'Yes' }] }],
-        }));
-        const id = ticketIdFor(root, 'malformed');
-        const err = await expectApiError(client.getHumanInboxDeck(id), 500, 'internal');
-        assert.ok(!err.message.includes(process.execPath), `error.message leaked a host path: ${err.message}`);
-        assert.ok(!err.message.includes(dir), `error.message leaked the ticket directory: ${err.message}`);
-        assert.ok(!err.message.toLowerCase().includes('bodypath'), `error.message named bodyPath: ${err.message}`);
-    });
-});
-// ---------------------------------------------------------------------------
-// POST /v1/human/inbox/:ticket_id/respond
-// ---------------------------------------------------------------------------
-describe('POST /v1/human/inbox/:ticket_id/respond', () => {
-    test('persists the canonical humanloop.response/v2 result unchanged and matches stored response.json exactly', async () => {
-        const root = freshRoot('crouter', true);
-        const dir = submitTestDeck(root, 'ask', '2026-01-01T00:00:00.000Z');
-        const id = ticketIdFor(root, 'ask');
-        const result = await client.respondHumanInboxDeck(id, { responses: [{ id: 'q', selectedOptionId: 'yes' }] });
-        assertDeckResultShape(result);
-        assertNoForbiddenContent(result, [root, dir]);
-        assert.deepEqual(result.responses, [{ id: 'q', selectedOptionId: 'yes' }]);
-        const stored = JSON.parse(readFileSync(responsePath(dir), 'utf8'));
-        assert.deepEqual(stored, result, 'the wire result is the stored humanloop response exactly, unreconstructed');
-        assert.ok(existsSync(responsePath(dir)), 'the canonical response remains the only ticket receipt');
-    });
-    test('ordinary notify acknowledgement — no special endpoint/shape', async () => {
-        const root = freshRoot('crouter');
-        const id_ = 'notify';
-        submitDeck({ dir: join(root, id_), deck: notifyDeck('Build done', { subtitle: 'The build completed successfully, so the change is ready to review.' }) });
-        const id = ticketIdFor(root, 'notify');
-        const result = await client.respondHumanInboxDeck(id, { responses: [{ id: 'notify', selectedOptionId: 'ok' }] });
-        assert.equal(result.kind, 'deck');
-        assert.deepEqual(result.responses, [{ id: 'notify', selectedOptionId: 'ok' }]);
-    });
-    test('409 ticket_kind_unsupported for a review ticket', async () => {
-        const root = freshRoot('crouter');
-        submitTestReview(root, 'rev', '2026-01-01T00:00:00.000Z');
-        await expectApiError(client.respondHumanInboxDeck(ticketIdFor(root, 'rev'), { responses: [] }), 409, 'ticket_kind_unsupported');
-    });
-    test('409 ticket_already_resolved on a second respond after the first succeeds', async () => {
-        const root = freshRoot('crouter');
-        submitTestDeck(root, 'ask', '2026-01-01T00:00:00.000Z');
-        const id = ticketIdFor(root, 'ask');
-        await client.respondHumanInboxDeck(id, { responses: [{ id: 'q', selectedOptionId: 'yes' }] });
-        await expectApiError(client.respondHumanInboxDeck(id, { responses: [{ id: 'q', selectedOptionId: 'no' }] }), 409, 'ticket_already_resolved');
-    });
-    test('a live foreign claim is taken over by the daemon finish path', async () => {
-        const root = freshRoot('crouter');
-        const dir = submitTestDeck(root, 'ask', '2026-01-01T00:00:00.000Z');
-        const id = ticketIdFor(root, 'ask');
-        const foreignClaim = claimTicket(dir, { host: 'someone-else' });
-        assert.ok(foreignClaim !== null, 'foreign claim acquired');
-        const result = await client.respondHumanInboxDeck(id, { responses: [{ id: 'q', selectedOptionId: 'yes' }] });
-        assertDeckResultShape(result);
-        assert.equal(releaseClaim(dir, foreignClaim.token), false, 'the takeover released the replaced claim');
-    });
-    test('external cancel/resolve race: a resolution that lands between the precheck and claimTicket() reports ticket_already_resolved, never ticket_unavailable', async () => {
-        const root = freshRoot('crouter');
-        const dir = submitTestDeck(root, 'race', '2026-01-01T00:00:00.000Z');
-        const id = ticketIdFor(root, 'race');
-        // A real separate OS process holds the SAME ticket lock humanloop's
-        // `claimTicket` contends for (`<dir>/.ticket-lock`, matching the marker
-        // scheme in humanloop's `convention.ts`). It signals once it holds the
-        // lock, then after a short real delay writes `response.json` directly
-        // (simulating an external actor's cancel/respond winning the race) and
-        // releases. Because the holder grabs the lock BEFORE this test sends the
-        // respond request, the precheck inside the handler is guaranteed to see
-        // the ticket still pending, and `claimTicket()`'s own lock acquisition is
-        // guaranteed to block until the holder resolves the ticket and releases
-        // — deterministically reproducing the exact interleaving the fix must
-        // handle, without relying on a microsecond-scale timing coincidence.
-        const script = `
-      const { mkdirSync, writeFileSync, rmSync } = require('node:fs');
-      const dir = process.env.RACE_TICKET_DIR;
-      const lockPath = dir + '/.ticket-lock';
-      mkdirSync(lockPath, { mode: 0o700 });
-      writeFileSync(lockPath + '/owner.race-holder', '', { flag: 'wx', mode: 0o600 });
-      process.stdout.write('holding\\n');
-      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 300);
-      writeFileSync(dir + '/response.json', JSON.stringify({
-        schema: 'humanloop.cancel/v1', kind: 'canceled',
-        canceledAt: new Date().toISOString(), reason: 'external race', actor: 'external',
-      }) + '\\n', { mode: 0o600 });
-      rmSync(lockPath, { recursive: true, force: true });
-      process.stdout.write('resolved\\n');
-    `;
-        const holder = spawn(process.execPath, ['-e', script], {
-            env: { ...process.env, RACE_TICKET_DIR: dir },
-            stdio: ['ignore', 'pipe', 'pipe'],
-        });
-        let stdout = '';
-        let stderr = '';
-        holder.stdout.setEncoding('utf8');
-        holder.stderr.setEncoding('utf8');
-        holder.stdout.on('data', (chunk) => {
-            stdout += chunk;
-        });
-        holder.stderr.on('data', (chunk) => {
-            stderr += chunk;
-        });
-        const exited = new Promise((resolve) => holder.once('close', resolve));
-        try {
-            await new Promise((resolve, reject) => {
-                const timer = setTimeout(() => reject(new Error(`race holder never signaled "holding": stdout=${stdout} stderr=${stderr}`)), 5000);
-                const check = () => {
-                    if (stdout.includes('holding')) {
-                        clearTimeout(timer);
-                        resolve();
-                    }
-                };
-                holder.stdout.on('data', check);
-                holder.once('error', (err) => {
-                    clearTimeout(timer);
-                    reject(err);
-                });
-                check();
-            });
-            await expectApiError(client.respondHumanInboxDeck(id, { responses: [{ id: 'q', selectedOptionId: 'yes' }] }), 409, 'ticket_already_resolved');
-        }
-        finally {
-            await exited;
-        }
-        assert.ok(stdout.includes('resolved'), `race holder did not complete its resolve+release: stdout=${stdout} stderr=${stderr}`);
-    });
-    test('500 internal for a finalize failure that is not a response-shape rejection — sanitized, not misclassified as 400', async () => {
-        const root = freshRoot('crouter');
-        const dir = submitTestDeck(root, 'ask', '2026-01-01T00:00:00.000Z');
-        const id = ticketIdFor(root, 'ask');
-        // RAW tamper: rewrite the persisted deck so its own re-read inside
-        // `finalizeDeck` fails deck-schema validation (interactions.min(1)) —
-        // this is a storage-layer failure, not a response-shape rejection, and
-        // `submitDeck` could never have written it in the first place.
-        writeFileSync(deckPath(dir), JSON.stringify({ title: 'Ship it?', interactions: [] }));
-        const err = await expectApiError(client.respondHumanInboxDeck(id, { responses: [{ id: 'q', selectedOptionId: 'yes' }] }), 500, 'internal');
-        assert.equal(err.message, 'the ticket could not be finalized');
-        assert.ok(!err.message.includes(dir), `error.message leaked the ticket directory: ${err.message}`);
-    });
-    test('400 invalid_ticket_response releases the claim so a following valid respond succeeds', async () => {
-        const root = freshRoot('crouter');
-        submitTestDeck(root, 'ask', '2026-01-01T00:00:00.000Z');
-        const id = ticketIdFor(root, 'ask');
-        const err = await expectApiError(client.respondHumanInboxDeck(id, { responses: [{ id: 'nonexistent', freetext: 'x' }] }), 400, 'invalid_ticket_response');
-        assert.match(err.message, /response does not match a unique deck interaction: nonexistent/);
-        const result = await client.respondHumanInboxDeck(id, { responses: [{ id: 'q', selectedOptionId: 'yes' }] });
-        assert.equal(result.kind, 'deck', 'the claim was released, so a valid respond now succeeds');
-    });
-    test('400 invalid_request for a malformed body', async () => {
-        const root = freshRoot('crouter');
-        submitTestDeck(root, 'ask', '2026-01-01T00:00:00.000Z');
-        const id = ticketIdFor(root, 'ask');
-        const path = `/v1/human/inbox/${id}/respond`;
-        await expectApiError(client.request('POST', path, { responses: [], extra: true }), 400, 'invalid_request');
-        await expectApiError(client.request('POST', path, { responses: 'nope' }), 400, 'invalid_request');
-    });
-});
-// ---------------------------------------------------------------------------
-// POST /v1/human/inbox/:ticket_id/cancel
-// ---------------------------------------------------------------------------
-describe('POST /v1/human/inbox/:ticket_id/cancel', () => {
-    test('default reason and hardcoded human actor match stored response.json', async () => {
-        const root = freshRoot('crouter', true);
-        const dir = submitTestDeck(root, 'ask', '2026-01-01T00:00:00.000Z');
-        const id = ticketIdFor(root, 'ask');
-        const result = await client.cancelHumanInboxTicket(id);
-        assertCanceledResultShape(result);
-        assertNoForbiddenContent(result, [root, dir]);
-        assert.equal(result.reason, 'Canceled from the inbox.');
-        assert.equal(result.actor, 'human');
-        const stored = JSON.parse(readFileSync(responsePath(dir), 'utf8'));
-        assert.deepEqual(stored, result, 'the wire result is the stored humanloop cancellation exactly, unreconstructed');
-        assert.ok(existsSync(responsePath(dir)), 'the canonical cancellation remains the only ticket receipt');
-    });
-    test('custom reason is honored; actor is always human regardless of any client-supplied field', async () => {
-        const root = freshRoot('crouter');
-        submitTestDeck(root, 'ask', '2026-01-01T00:00:00.000Z');
-        const id = ticketIdFor(root, 'ask');
-        const result = await client.cancelHumanInboxTicket(id, { reason: 'changed my mind' });
-        assert.equal(result.reason, 'changed my mind');
-        assert.equal(result.actor, 'human');
-    });
-    test('recordless review cancellation returns the stored humanloop.cancel/v1 result', async () => {
-        const root = freshRoot('crouter');
-        const dir = submitTestReview(root, 'rev', '2026-01-01T00:00:00.000Z');
-        const result = await client.cancelHumanInboxTicket(ticketIdFor(root, 'rev'));
-        assertCanceledResultShape(result);
-        assert.deepEqual(JSON.parse(readFileSync(responsePath(dir), 'utf8')), result);
-    });
-    test('409 ticket_already_resolved after the ticket was already resolved via respond', async () => {
-        const root = freshRoot('crouter');
-        submitTestDeck(root, 'ask', '2026-01-01T00:00:00.000Z');
-        const id = ticketIdFor(root, 'ask');
-        await client.respondHumanInboxDeck(id, { responses: [{ id: 'q', selectedOptionId: 'yes' }] });
-        await expectApiError(client.cancelHumanInboxTicket(id), 409, 'ticket_already_resolved');
-    });
-    test('400 invalid_request for an empty (post-trim) reason and for a >1000-char reason', async () => {
-        const root = freshRoot('crouter');
-        submitTestDeck(root, 'ask', '2026-01-01T00:00:00.000Z');
-        const id = ticketIdFor(root, 'ask');
-        await expectApiError(client.cancelHumanInboxTicket(id, { reason: '   ' }), 400, 'invalid_request');
-        await expectApiError(client.cancelHumanInboxTicket(id, { reason: 'x'.repeat(1001) }), 400, 'invalid_request');
-    });
-});
-// ---------------------------------------------------------------------------
-// Malformed ticket id syntax
-// ---------------------------------------------------------------------------
-describe('malformed ticket id syntax', () => {
-    test('400 invalid_request on GET/respond/cancel for a non-hex or wrong-length id', async () => {
-        for (const bad of ['not-hex-not-64-chars', 'a'.repeat(63), 'g'.repeat(64)]) {
-            await expectApiError(client.request('GET', `/v1/human/inbox/${bad}`), 400, 'invalid_request');
-            await expectApiError(client.request('POST', `/v1/human/inbox/${bad}/respond`, { responses: [] }), 400, 'invalid_request');
-            await expectApiError(client.request('POST', `/v1/human/inbox/${bad}/cancel`, {}), 400, 'invalid_request');
-        }
-    });
-});