@north-light/crouter 0.3.318 → 0.3.319

package/dist/daemon/api/__tests__/seam/profile-delete.test.js

@@ -1,372 +0,0 @@
-// Compiled API seam for the profile-deletion lifecycle. It drives the real CLI
-// and daemon HTTP handlers against one isolated canvas, including real broker
-// processes for detach/restart and deferred self-deletion behavior.
-import { request as httpRequest } from 'node:http';
-import { after, before, test } from 'node:test';
-import assert from 'node:assert/strict';
-import { existsSync, mkdirSync, readFileSync, writeFileSync, } from 'node:fs';
-import { join } from 'node:path';
-import { ApiError, CrtrClient } from '../../../../api/index.js';
-import { createHeadlessHarness } from '../../../../core/__tests__/helpers/harness.js';
-import { updateNode } from '../../../../core/canvas/canvas.js';
-import { armCron, getCron } from '../../../../core/canvas/crons.js';
-import { closeDb } from '../../../../core/canvas/db.js';
-import { closeWorktree, openWorktree } from '../../../../core/canvas/worktrees.js';
-import { getDefaultProfileId, setDefaultProfileId, } from '../../../../core/profiles/default-binding.js';
-import { loadProfileManifest } from '../../../../core/profiles/manifest.js';
-import { createComment, getComment, listReviewEvents } from '../../../../core/review/comments.js';
-import { commitBindingRequest, openRequest } from '../../../../core/human/requests.js';
-import { getReview } from '../../../../core/review/store.js';
-import { apiSocketPath, nodeDir, nodesRoot, reviewDir, } from '../../../../core/canvas/paths.js';
-import { isPidAlive } from '../../../../core/canvas/pid.js';
-import { spawnNode } from '../../../../core/runtime/nodes.js';
-let h;
-let client;
-before(async () => {
-    h = await createHeadlessHarness({ sessionPrefix: 'crtr-profile-delete' });
-    client = new CrtrClient({ socketPath: apiSocketPath(), autostart: false });
-});
-after(async () => {
-    await h?.dispose();
-});
-function managedWorktree() {
-    return {
-        state: 'open',
-        path: join(h.agentHome, 'open-worktree'),
-        branch: 'test/profile-delete-blocker',
-        repo_root: process.cwd(),
-        base_ref: 'HEAD',
-        base_sha: '0000000000000000000000000000000000000000',
-        created: new Date().toISOString(),
-    };
-}
-function armTestCron(args) {
-    armCron({
-        cron_id: args.id,
-        name: args.id,
-        created_by: null,
-        command: 'true',
-        fire_at: '2099-01-01T00:00:00.000Z',
-        recur: null,
-        tz: null,
-        expires_at: null,
-        anchor_node: args.anchor ?? null,
-        cancel_on_wake: false,
-        cwd: process.cwd(),
-        env_json: null,
-        profile: args.profile,
-        scope: 'profile',
-        run_timeout_s: 30,
-        overlap: 'skip',
-        on_output: 'silent',
-        sink: '{}',
-        tier: 'normal',
-    });
-}
-function seedTicket(dir, sourceNodeId) {
-    mkdirSync(dir, { recursive: true });
-    writeFileSync(join(dir, 'page.json'), JSON.stringify({ source: { nodeId: sourceNodeId } }));
-    writeFileSync(join(dir, 'reply-route.json'), JSON.stringify({ nodeId: sourceNodeId }));
-}
-function reviewRequest(reviewId, originNodeId, sourceFile) {
-    const dir = reviewDir(reviewId);
-    return {
-        request_id: reviewId,
-        idempotency_key: `request-${reviewId}`,
-        requester_node_id: originNodeId,
-        companion_node_id: `companion-${reviewId}`,
-        request_dir: dir,
-        file: sourceFile,
-        specification: {
-            origin_kind: 'inline',
-            origin_session_file: join(h.agentHome, `${reviewId}-origin.jsonl`),
-            origin_session_id: `session-${reviewId}`,
-            origin_leaf_id: `leaf-${reviewId}`,
-            model_spec: 'anthropic/sonnet',
-            branch_file: join(dir, 'branch-point.jsonl'),
-            baseline_sha256: 'baseline',
-            baseline_bytes: 6,
-            captured_at: new Date().toISOString(),
-            output_path: null,
-        },
-        anchor_base_sha256: 'anchor',
-        anchor_base_bytes: Buffer.from('source'),
-        created_at: new Date().toISOString(),
-        subtitle: null,
-        inbox_listed: false,
-    };
-}
-function seedReview(reviewId, originNodeId) {
-    const sourceFile = join(h.agentHome, `${reviewId}-source.md`);
-    const dir = reviewDir(reviewId);
-    writeFileSync(sourceFile, 'source\n');
-    mkdirSync(dir, { recursive: true });
-    writeFileSync(join(dir, 'branch-point.jsonl'), '{}\n');
-    commitBindingRequest(reviewRequest(reviewId, originNodeId, sourceFile));
-    assert.equal(openRequest(reviewId, new Date().toISOString()), true, 'fixture review becomes visible before its comment is created');
-    const { comment } = createComment({
-        review_id: reviewId,
-        text: 'keep or delete with its review',
-        anchor: { line: 1, end_line: 1 },
-        line_text: 'source',
-        doc_hash: 'baseline',
-        actor: { kind: 'node', node_id: originNodeId },
-        operation_id: `comment-${reviewId}`,
-    });
-    return { sourceFile, commentId: comment.comment_id };
-}
-async function rawDelete(profile, body) {
-    const payload = JSON.stringify(body);
-    return new Promise((resolve, reject) => {
-        const req = httpRequest({
-            socketPath: apiSocketPath(),
-            method: 'DELETE',
-            path: `/v1/profiles/${encodeURIComponent(profile)}`,
-            headers: {
-                'content-type': 'application/json',
-                'content-length': Buffer.byteLength(payload),
-            },
-        }, (res) => {
-            const chunks = [];
-            res.on('data', (chunk) => chunks.push(chunk));
-            res.on('end', () => {
-                const text = Buffer.concat(chunks).toString('utf8');
-                resolve({
-                    status: res.statusCode ?? 0,
-                    body: text === '' ? {} : JSON.parse(text),
-                });
-            });
-        });
-        req.on('error', reject);
-        req.end(payload);
-    });
-}
-test('forced profile deletion owns the complete daemon lifecycle', { timeout: 90_000 }, async () => {
-    // Required confirmation is enforced by both the command parser and the API.
-    const forceProfile = await client.ensureProfile('delete-force-required');
-    const help = h.cli(null, ['profile', 'delete', '-h']);
-    assert.equal(help.code, 0);
-    assert.match(help.stdout, /--force\s+required boolean/, 'leaf help exposes --force as required');
-    const missingForce = h.cli(null, ['profile', 'delete', forceProfile.id]);
-    assert.notEqual(missingForce.code, 0, 'the CLI refuses deletion without --force');
-    assert.match(`${missingForce.stdout}\n${missingForce.stderr}`, /force/i);
-    await assert.rejects(client.deleteProfile(forceProfile.id, { force: false }), (error) => error instanceof ApiError && error.status === 400 && error.code === 'usage', 'the daemon independently rejects a request without force=true');
-    assert.equal((await client.getProfile(forceProfile.id)).id, forceProfile.id, 'force rejection does not remove the profile');
-    // An open managed worktree blocks before any profile-owned state mutates.
-    const blockedProfile = await client.ensureProfile('delete-blocked');
-    const blockedNode = h.spawnRoot('profile delete blocker', { id: 'blocked-profile-deadbeef' });
-    updateNode(blockedNode, { profile_id: blockedProfile.id });
-    openWorktree(blockedNode, managedWorktree());
-    const blockedPin = join(h.agentHome, 'blocked-pin');
-    mkdirSync(blockedPin, { recursive: true });
-    setDefaultProfileId(blockedPin, blockedProfile.id);
-    armTestCron({ id: 'blocked-cron', profile: blockedProfile.id, anchor: blockedNode });
-    await assert.rejects(client.deleteProfile(blockedProfile.id, { force: true }), (error) => {
-        if (!(error instanceof ApiError) || error.status !== 400 || error.code !== 'usage')
-            return false;
-        const details = error.details;
-        return details?.error === 'open_managed_worktree';
-    }, 'an open managed worktree round-trips the blocker without mutation');
-    closeDb();
-    assert.equal(h.node(blockedNode)?.profile_id, blockedProfile.id);
-    assert.equal(getCron('blocked-cron')?.profile, blockedProfile.id);
-    assert.equal(getDefaultProfileId(blockedPin), blockedProfile.id);
-    assert.equal((await client.getProfile(blockedProfile.id)).id, blockedProfile.id);
-    // Hard deletion selects by profile identity, not by graph descent. It removes
-    // matching nodes plus profile/anchor crons, originating tickets and review
-    // audit state, while preserving a cross-profile child and the reviewed file.
-    const hardProfile = await client.ensureProfile('delete-hard');
-    const crossProfile = await client.ensureProfile('delete-cross-profile');
-    const hardNode = h.fabricateBrokerNode({
-        id: 'hard-owner-deadbeef',
-        parent: null,
-        status: 'done',
-    });
-    updateNode(hardNode, { profile_id: hardProfile.id });
-    const crossChild = h.fabricateBrokerNode({
-        id: 'cross-child-deadbeef',
-        parent: hardNode,
-        status: 'done',
-    });
-    updateNode(crossChild, { profile_id: crossProfile.id });
-    armTestCron({ id: 'hard-profile-cron', profile: hardProfile.id });
-    armTestCron({ id: 'hard-anchor-cron', profile: crossProfile.id, anchor: hardNode });
-    armTestCron({ id: 'cross-preserved-cron', profile: crossProfile.id, anchor: crossChild });
-    const hardPin = join(h.agentHome, 'hard-pin');
-    mkdirSync(hardPin, { recursive: true });
-    setDefaultProfileId(hardPin, hardProfile.id);
-    const standaloneTicket = join(nodesRoot(), 'hard-ticket-deadbeef');
-    seedTicket(standaloneTicket, hardNode);
-    seedTicket(nodeDir(crossChild), hardNode);
-    writeFileSync(join(nodeDir(crossChild), 'feedback.json'), '{}\n');
-    mkdirSync(join(nodeDir(crossChild), '.ticket-lock'));
-    writeFileSync(join(nodeDir(crossChild), 'cross-profile-state.txt'), 'preserve');
-    const hardReviewId = 'hard-review-deadbeef';
-    const hardReview = seedReview(hardReviewId, hardNode);
-    const hardResult = await client.deleteProfile(hardProfile.id, { force: true });
-    assert.deepEqual(hardResult, {
-        profile_id: hardProfile.id,
-        name: hardProfile.name,
-        mode: 'deleted',
-        nodes: 1,
-        crons: 2,
-        tickets: 2,
-        reviews: 1,
-        default_pins: 1,
-    });
-    closeDb();
-    assert.equal(h.node(hardNode), null, 'the matching node is hard-deleted');
-    assert.equal(h.node(crossChild)?.parent, hardNode, 'the cross-profile child and topology are preserved');
-    assert.equal(h.node(crossChild)?.profile_id, crossProfile.id);
-    assert.equal(getCron('hard-profile-cron'), null);
-    assert.equal(getCron('hard-anchor-cron'), null);
-    assert.equal(getCron('cross-preserved-cron')?.profile, crossProfile.id);
-    assert.equal(existsSync(standaloneTicket), false, 'standalone originating ticket directory is removed');
-    assert.equal(existsSync(join(nodeDir(crossChild), 'page.json')), false, 'ticket files are removed from a preserved node directory');
-    assert.equal(existsSync(join(nodeDir(crossChild), 'feedback.json')), false, 'default review output is removed with the ticket');
-    assert.equal(existsSync(join(nodeDir(crossChild), '.ticket-lock')), false, 'ticket lock residue is removed');
-    assert.equal(readFileSync(join(nodeDir(crossChild), 'cross-profile-state.txt'), 'utf8'), 'preserve');
-    assert.equal(getReview(hardReviewId), null);
-    assert.equal(getComment(hardReview.commentId), null);
-    assert.deepEqual(listReviewEvents(hardReviewId, {}), { events: [], next_since_seq: 0 });
-    assert.equal(existsSync(reviewDir(hardReviewId)), false, 'review-owned filesystem state is removed');
-    assert.equal(readFileSync(hardReview.sourceFile, 'utf8'), 'source\n', 'the reviewed source document is never removed');
-    assert.equal(getDefaultProfileId(hardPin), null);
-    await assert.rejects(client.getProfile(hardProfile.id), (error) => error instanceof ApiError && error.status === 404);
-    await assert.rejects(() => spawnNode({
-        kind: 'developer',
-        cwd: process.cwd(),
-        parent: null,
-        profile_id: hardProfile.id,
-        nodeId: 'hard-stale-birth-deadbeef',
-    }), /profile not found/, 'the final birth gate rejects a profile resolved before a completed hard deletion');
-    assert.equal(h.node('hard-stale-birth-deadbeef'), null);
-    // Detach preserves nodes, topology, ticket/review state, and conversations;
-    // matching brokers restart with no profile identity and matching crons become
-    // global rather than disappearing.
-    const detachProfile = await client.ensureProfile('delete-detach');
-    const detachNode = (await client.createNode({
-        kind: 'developer',
-        profile: detachProfile.id,
-        root: true,
-        cwd: process.cwd(),
-        prompt: 'detach lifecycle broker',
-        node_id: 'detach-live-deadbeef',
-    })).node_id;
-    await h.awaitBoot(detachNode);
-    const detachBoots = h.bootCount(detachNode);
-    const detachSessionFile = h.node(detachNode)?.pi_session_file;
-    assert.ok(detachSessionFile != null, 'the live detach fixture has a resumable conversation');
-    armTestCron({ id: 'detach-profile-cron', profile: detachProfile.id, anchor: detachNode });
-    const detachPin = join(h.agentHome, 'detach-pin');
-    mkdirSync(detachPin, { recursive: true });
-    setDefaultProfileId(detachPin, detachProfile.id);
-    const detachTicket = join(nodesRoot(), 'detach-ticket-deadbeef');
-    seedTicket(detachTicket, detachNode);
-    const detachReviewId = 'detach-review-deadbeef';
-    const detachReview = seedReview(detachReviewId, detachNode);
-    const detachPid = h.node(detachNode)?.pi_pid;
-    assert.ok(detachPid != null, 'the detach race fixture has a live broker pid');
-    process.kill(detachPid, 'SIGSTOP');
-    const detachDeletion = client.deleteProfile(detachProfile.id, { force: true, detach: true });
-    try {
-        await h.waitFor(() => h.node(detachNode)?.intent === 'idle-release', {
-            timeoutMs: 10_000,
-            intervalMs: 25,
-            label: 'detach reaches its broker-exit wait',
-        });
-        await assert.rejects(client.createNode({
-            kind: 'developer',
-            profile: detachProfile.id,
-            root: true,
-            cwd: process.cwd(),
-            prompt: 'must not escape the accepted detach plan',
-            node_id: 'detach-race-deadbeef',
-        }), (error) => {
-            if (!(error instanceof ApiError) || error.status !== 400 || error.code !== 'usage')
-                return false;
-            const details = error.details;
-            return details?.error === 'profile_deletion_in_progress';
-        }, 'a node whose async preflight crosses detach is rejected at the synchronous birth gate');
-    }
-    finally {
-        if (isPidAlive(detachPid))
-            process.kill(detachPid, 'SIGCONT');
-    }
-    const detachResult = await detachDeletion;
-    assert.deepEqual(detachResult, {
-        profile_id: detachProfile.id,
-        name: detachProfile.name,
-        mode: 'detached',
-        nodes: 1,
-        crons: 1,
-        tickets: 0,
-        reviews: 0,
-        default_pins: 1,
-    });
-    const restarted = await h.awaitBoot(detachNode, { minCount: detachBoots + 1 });
-    closeDb();
-    assert.equal(h.node(detachNode)?.profile_id, null);
-    assert.equal(h.node('detach-race-deadbeef'), null, 'no profile-scoped node escapes the fixed detach plan');
-    assert.equal(h.node(detachNode)?.pi_session_file, detachSessionFile, 'detach preserves the conversation file');
-    assert.equal(restarted.sessionFile, detachSessionFile, 'the restarted broker resumes that conversation file');
-    assert.equal(restarted.resuming, true, 'the previously live broker is restarted as a resume');
-    assert.equal(restarted.env['CRTR_PROFILE_ID'], '', 'the restarted broker no longer names the deleted profile');
-    assert.equal(getCron('detach-profile-cron')?.scope, 'global');
-    assert.equal(getCron('detach-profile-cron')?.profile, null);
-    assert.equal(existsSync(join(detachTicket, 'page.json')), true);
-    assert.equal(getReview(detachReviewId)?.origin_node_id, detachNode);
-    assert.ok(getComment(detachReview.commentId) !== null);
-    assert.equal(existsSync(reviewDir(detachReviewId)), true);
-    assert.equal(getDefaultProfileId(detachPin), null);
-    await assert.rejects(client.getProfile(detachProfile.id), (error) => error instanceof ApiError && error.status === 404);
-    // A node deleting its own profile receives HTTP 202 while its row and broker
-    // are still alive. The daemon performs the accepted hard deletion only after
-    // the response grace has elapsed.
-    const selfProfile = await client.ensureProfile('delete-self');
-    const selfNode = (await client.createNode({
-        kind: 'developer',
-        profile: selfProfile.id,
-        root: true,
-        cwd: process.cwd(),
-        prompt: 'self-delete lifecycle broker',
-        node_id: 'self-delete-deadbeef',
-    })).node_id;
-    await h.awaitBoot(selfNode);
-    const selfPid = h.node(selfNode)?.pi_pid;
-    assert.ok(selfPid != null && isPidAlive(selfPid), 'self-delete fixture starts with a live broker');
-    const accepted = await rawDelete(selfProfile.id, {
-        force: true,
-        caller_node_id: selfNode,
-    });
-    assert.equal(accepted.status, 202);
-    assert.deepEqual(accepted.body, {
-        profile_id: selfProfile.id,
-        name: selfProfile.name,
-        mode: 'deleted',
-        nodes: 1,
-        crons: 0,
-        tickets: 0,
-        reviews: 0,
-        default_pins: 0,
-        accepted: true,
-        grace_ms: 1000,
-    });
-    assert.equal(h.node(selfNode)?.profile_id, selfProfile.id, 'the 202 response settles before node mutation');
-    assert.equal(isPidAlive(selfPid), true, 'the 202 response settles before broker teardown');
-    openWorktree(selfNode, managedWorktree());
-    const repeatedAccepted = await rawDelete(selfProfile.id, {
-        force: true,
-        caller_node_id: selfNode,
-    });
-    closeWorktree(selfNode, { cleanup: 'complete', closedAt: new Date().toISOString() });
-    assert.equal(repeatedAccepted.status, 202, 'a retry returns the accepted result before observing new blockers');
-    assert.deepEqual(repeatedAccepted.body, accepted.body, 'a pending self-deletion is idempotent by profile identity');
-    await h.waitFor(() => h.node(selfNode) === null, {
-        timeoutMs: 15_000,
-        intervalMs: 25,
-        label: 'accepted self-deletion completes after acknowledgement grace',
-    });
-    assert.equal(loadProfileManifest(crossProfile.id).profileId, crossProfile.id, 'unrelated profiles remain resolvable');
-    await assert.rejects(client.getProfile(selfProfile.id), (error) => error instanceof ApiError && error.status === 404);
-});

package/dist/daemon/api/__tests__/submit-result.test.d.ts

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

package/dist/daemon/api/__tests__/submit-result.test.js

@@ -1,215 +0,0 @@
-// Run with: node --import tsx/esm --test src/daemon/api/__tests__/submit-result.test.ts
-//
-// `POST /v1/nodes/{id}/result` — the server side of `crtr push result` — and
-// the `structured_result_pending` gate on the plain push route. In-process
-// handler calls against a throwaway CRTR_HOME (reopen-delivery.test.ts pattern).
-import { after, before, beforeEach, test } from 'node:test';
-import assert from 'node:assert/strict';
-import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
-import { dirname } from 'node:path';
-import { createNode, getNode } from '../../../core/canvas/index.js';
-import { closeDb, migrate, openDb } from '../../../core/canvas/db.js';
-import { InputError } from '../../../core/io.js';
-import { outputResultPath, outputSchemaPath, writeOutputSchema, } from '../../../core/runtime/structured-output.js';
-import { reportRoutes } from '../handlers/reports.js';
-import { toNodeOutcomeDTO } from '../map.js';
-let home;
-const priorHome = process.env['CRTR_HOME'];
-before(() => {
-    // macOS limits Unix-socket paths to 104 bytes; keep the home short.
-    home = mkdtempSync('/tmp/crtr-result-');
-    process.env['CRTR_HOME'] = home;
-});
-beforeEach(() => {
-    closeDb();
-    rmSync(home, { recursive: true, force: true });
-    migrate(openDb());
-});
-after(() => {
-    closeDb();
-    rmSync(home, { recursive: true, force: true });
-    if (priorHome === undefined)
-        delete process.env['CRTR_HOME'];
-    else
-        process.env['CRTR_HOME'] = priorHome;
-});
-function node(id, lifecycle = 'terminal') {
-    return {
-        node_id: id,
-        name: id,
-        created: new Date().toISOString(),
-        cwd: '/tmp',
-        kind: 'general',
-        mode: 'base',
-        lifecycle,
-        status: 'active',
-    };
-}
-function finalize(id) {
-    openDb()
-        .prepare('UPDATE nodes SET final_report = ?, finalized_at = ? WHERE node_id = ?')
-        .run('final.md', new Date().toISOString(), id);
-}
-function route(method, pattern) {
-    const def = reportRoutes.find((r) => r.method === method && r.pattern === pattern);
-    assert.ok(def, `route ${method} ${pattern} registered`);
-    return (id, body) => Promise.resolve(def.handler({
-        method,
-        path: pattern.replace(':id', id),
-        params: { id },
-        query: new URLSearchParams(),
-        body,
-    }));
-}
-const submit = route('POST', '/v1/nodes/:id/result');
-const pushReport = route('POST', '/v1/nodes/:id/reports');
-const SCHEMA = {
-    type: 'object',
-    properties: { status: { type: 'string' }, count: { type: 'number' } },
-    required: ['status'],
-};
-async function rejection(promise) {
-    let caught;
-    await promise.then(() => assert.fail('expected a rejection'), (err) => { caught = err; });
-    assert.ok(caught instanceof InputError, `expected InputError, got ${String(caught)}`);
-    return caught;
-}
-test('terminal happy path: result written, schema cleared, node finished', async () => {
-    createNode(node('t1'));
-    writeOutputSchema('t1', 'terminal', SCHEMA);
-    const res = await submit('t1', { value: { status: 'ok' } });
-    assert.equal(res.status, 200);
-    const dto = res.body;
-    assert.equal(dto.mode, 'terminal');
-    assert.equal(dto.result_path, outputResultPath('t1'));
-    assert.ok(dto.report_path.endsWith('.md'));
-    assert.deepEqual(dto.notified, []);
-    assert.deepEqual(dto.transitioned, { from: 'active', to: 'done' });
-    assert.deepEqual(JSON.parse(readFileSync(outputResultPath('t1'), 'utf8')), { status: 'ok' });
-    assert.equal(existsSync(outputSchemaPath('t1')), false);
-    const meta = getNode('t1');
-    assert.equal(meta?.status, 'done');
-    assert.notEqual(meta?.final_report, null);
-    assert.match(readFileSync(dto.report_path, 'utf8'), /Structured output submitted/);
-});
-test('one-off happy path: update pushed, node keeps working', async () => {
-    createNode(node('o1', 'resident'));
-    writeOutputSchema('o1', 'oneoff', SCHEMA);
-    const res = await submit('o1', { value: { status: 'ok' } });
-    const dto = res.body;
-    assert.equal(dto.mode, 'oneoff');
-    assert.equal(dto.transitioned, undefined);
-    assert.equal(existsSync(outputSchemaPath('o1')), false);
-    const meta = getNode('o1');
-    assert.equal(meta?.status, 'active');
-    assert.equal(meta?.final_report, null);
-});
-test('schema mismatch: field errors, nothing recorded, request retained for retry', async () => {
-    createNode(node('m1'));
-    writeOutputSchema('m1', 'terminal', SCHEMA);
-    const err = await rejection(submit('m1', { value: { count: 3 } }));
-    assert.equal(err.payload.error, 'result_schema_mismatch');
-    assert.match(err.payload.message, /status/);
-    assert.equal(existsSync(outputResultPath('m1')), false);
-    assert.equal(existsSync(outputSchemaPath('m1')), true);
-    assert.equal(getNode('m1')?.status, 'active');
-});
-test('coercion parity with the retired submit tool: "5" persists as 5', async () => {
-    createNode(node('c1'));
-    writeOutputSchema('c1', 'terminal', SCHEMA);
-    await submit('c1', { value: { status: 'ok', count: '5' } });
-    assert.deepEqual(JSON.parse(readFileSync(outputResultPath('c1'), 'utf8')), { status: 'ok', count: 5 });
-});
-test('no pending request → no_output_request', async () => {
-    createNode(node('n1'));
-    const err = await rejection(submit('n1', { value: {} }));
-    assert.equal(err.payload.error, 'no_output_request');
-});
-test('corrupt request file → invalid_output_request naming the parse failure', async () => {
-    createNode(node('i1'));
-    const path = outputSchemaPath('i1');
-    mkdirSync(dirname(path), { recursive: true });
-    writeFileSync(path, '{not json', 'utf8');
-    const err = await rejection(submit('i1', { value: {} }));
-    assert.equal(err.payload.error, 'invalid_output_request');
-    assert.match(err.payload.message, /not valid JSON/);
-});
-test('unknown node → 404', async () => {
-    await assert.rejects(submit('ghost', { value: {} }), (err) => err.code === 'not_found');
-});
-test('already-finalized node, terminal submit → already_finalized; schema retained', async () => {
-    createNode(node('f1'));
-    finalize('f1');
-    writeOutputSchema('f1', 'terminal', SCHEMA);
-    const err = await rejection(submit('f1', { value: { status: 'ok' } }));
-    assert.equal(err.payload.error, 'already_finalized');
-    assert.equal(existsSync(outputSchemaPath('f1')), true);
-});
-test('missing value key → usage error (distinct from a legal null value)', async () => {
-    createNode(node('u1'));
-    writeOutputSchema('u1', 'terminal', SCHEMA);
-    await assert.rejects(submit('u1', {}), (err) => err.code === 'usage');
-    // A PRESENT null value is legal input to validation (here: a mismatch, not usage).
-    const err = await rejection(submit('u1', { value: null }));
-    assert.equal(err.payload.error, 'result_schema_mismatch');
-});
-test('non-object value against an object schema → mismatch, not a crash', async () => {
-    createNode(node('s1'));
-    writeOutputSchema('s1', 'terminal', SCHEMA);
-    const err = await rejection(submit('s1', { value: 42 }));
-    assert.equal(err.payload.error, 'result_schema_mismatch');
-    assert.equal(existsSync(outputSchemaPath('s1')), true);
-});
-test('push final while a valid schema is pending → structured_result_pending', async () => {
-    createNode(node('g1'));
-    writeOutputSchema('g1', 'terminal', SCHEMA);
-    const err = await rejection(pushReport('g1', { tier: 'final', body: 'done' }));
-    assert.equal(err.payload.error, 'structured_result_pending');
-    assert.match(err.payload.next ?? '', /crtr push result/);
-    assert.equal(getNode('g1')?.status, 'active');
-});
-test('push update while a schema is pending is still allowed', async () => {
-    createNode(node('g2'));
-    writeOutputSchema('g2', 'oneoff', SCHEMA);
-    const res = await pushReport('g2', { tier: 'update', body: 'progress' });
-    assert.equal(res.status, 200);
-});
-test('push final with a corrupt schema file stays allowed (manual-cleanup escape)', async () => {
-    createNode(node('g3'));
-    const path = outputSchemaPath('g3');
-    mkdirSync(dirname(path), { recursive: true });
-    writeFileSync(path, '{not json', 'utf8');
-    const res = await pushReport('g3', { tier: 'final', body: 'done' });
-    assert.equal(res.status, 200);
-    assert.equal(getNode('g3')?.status, 'done');
-});
-test('terminal decline: declined.json + failure/declined outcome carrying reason, code, retryable', async () => {
-    createNode(node('d1'));
-    writeOutputSchema('d1', 'terminal', SCHEMA);
-    const res = await submit('d1', { decline: 'The route is blocked. ', code: 'blocked-device-route', retryable: true });
-    const dto = res.body;
-    assert.equal(dto.mode, 'terminal');
-    assert.deepEqual(dto.declined, { reason: 'The route is blocked.', code: 'blocked-device-route', retryable: true });
-    assert.deepEqual(dto.transitioned, { from: 'active', to: 'done' });
-    assert.equal(existsSync(outputResultPath('d1')), false);
-    assert.equal(existsSync(outputSchemaPath('d1')), false);
-    const marker = JSON.parse(readFileSync(dto.result_path, 'utf8'));
-    assert.equal(marker['code'], 'blocked-device-route');
-    assert.equal(marker['retryable'], true);
-    const outcome = toNodeOutcomeDTO(getNode('d1'));
-    assert.ok(outcome !== null && outcome.kind === 'failure' && outcome.reason === 'declined');
-    assert.deepEqual(outcome.declined, { reason: 'The route is blocked.', code: 'blocked-device-route', retryable: true });
-    assert.equal(outcome.detail?.message, 'The route is blocked.');
-    assert.match(readFileSync(dto.report_path, 'utf8'), /Code: blocked-device-route/);
-});
-test('decline without a code, or with a non-boolean retryable, records nothing', async () => {
-    createNode(node('d2'));
-    writeOutputSchema('d2', 'terminal', SCHEMA);
-    const noCode = await rejection(submit('d2', { decline: 'blocked', retryable: false }));
-    assert.equal(noCode.payload.error, 'invalid_decline_code');
-    const spaced = await rejection(submit('d2', { decline: 'blocked', code: 'has space', retryable: false }));
-    assert.equal(spaced.payload.error, 'invalid_decline_code');
-    await assert.rejects(submit('d2', { decline: 'blocked', code: 'x' }), (err) => err.code === 'usage');
-    assert.equal(existsSync(outputSchemaPath('d2')), true);
-    assert.equal(getNode('d2')?.status, 'active');
-});

package/dist/migrations/__tests__/activation-concurrency.test.d.ts

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