@north-light/crouter 0.3.318 → 0.3.319

package/dist/daemon/api/__tests__/seam/leaf-api-parity.test.js

@@ -1,351 +0,0 @@
-// Run with: node --import tsx/esm --test src/daemon/api/__tests__/seam/leaf-api-parity.test.ts
-//
-// The `crtr push` and `crtr node worktree close` leaves are pure crtrd API
-// clients: the report write, the per-subscriber inbox fan, the lifecycle
-// transition (spec §7.4), and the worktree land+close git transaction all
-// happen SERVER-side. These tests drive the ACTUAL leaves (not the client
-// methods directly) against a CRTR_HOME-isolated in-process crtrd, with real
-// parent+child pairs and real git repos.
-//
-// COMPILED SEAM (real-boot-bound): lives in `__tests__/seam/` for the 30s-per-test
-// / CI-only tier, same harness as api-server.test.ts. tmux-free
-// (createHeadlessHarness) but boots REAL broker processes with the fake engine
-// — no LLM cost.
-//
-// A leaf resolves its client through `cliClient()` →
-// `CrtrClient.forLocalSocket` → `apiSocketPath()` == `<CRTR_HOME>/crtrd.sock`,
-// the SAME socket `createApiServer()` binds here. So `pushLeaf(tier).run()` in
-// this process, with `CRTR_NODE_ID` set to the caller, connects to the
-// in-process server exactly as a real `crtr push` CLI process would.
-import { test, before, after } from 'node:test';
-import assert from 'node:assert/strict';
-import { existsSync, mkdtempSync, readFileSync, realpathSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { createHeadlessHarness } from '../../../../core/__tests__/helpers/harness.js';
-import { createApiServer } from '../../server.js';
-import { apiSocketPath } from '../../../../core/canvas/paths.js';
-import { CrtrClient } from '../../../../api/index.js';
-import { registerPush } from '../../../../commands/push.js';
-import { registerNode } from '../../../../commands/node.js';
-import { createNode, getNode } from '../../../../core/canvas/canvas.js';
-import { branchIsPushedAtCurrentTip, createManagedWorktree } from '../../../../core/worktree.js';
-import { openDb } from '../../../../core/canvas/db.js';
-import { gitSync } from '../../../../core/git.js';
-import { InputError } from '../../../../core/io.js';
-// A terminal fabricated node (no broker needed) that OWNS a managed worktree —
-// the row the server's push-final worktree guard reads. Terminal + no
-// subscriber self-completes (the resident no_final_recipient guard is skipped).
-function worktreeNode(id, cwd, wt) {
-    return { node_id: id, name: id, created: new Date().toISOString(), cwd, kind: 'developer', mode: 'base', lifecycle: 'terminal', status: 'active', managed_worktree: wt };
-}
-function git(args, cwd) {
-    const r = gitSync(args, cwd);
-    if (r.status !== 0)
-        throw new Error(`git ${args.join(' ')} failed in ${cwd}: ${r.stderr || r.stdout}`);
-}
-/** A fresh git repo with one commit on `main` — the base a managed worktree
- *  branches off. Returns the repo dir (caller removes it). */
-function initRepo() {
-    const repo = mkdtempSync(join(tmpdir(), 'crtr-leafparity-repo-'));
-    git(['init', '-b', 'main'], repo);
-    git(['config', 'user.email', 'test@example.com'], repo);
-    git(['config', 'user.name', 'Test'], repo);
-    writeFileSync(join(repo, 'README.md'), 'hello\n');
-    git(['add', '.'], repo);
-    git(['commit', '-m', 'init'], repo);
-    return repo;
-}
-let h;
-let server;
-let client;
-let sockPath;
-const savedNoAutostart = process.env['CRTR_NO_DAEMON_AUTOSTART'];
-const savedNodeId = process.env['CRTR_NODE_ID'];
-// The push leaf under test — resolved fresh from the real command tree, exactly
-// as the CLI dispatcher would resolve it. Its `.run()` is the code path a real
-// `crtr push <tier>` process executes.
-function pushLeaf(tier) {
-    const leaf = registerPush().children.find((c) => c.name === tier);
-    assert.ok(leaf !== undefined && leaf.kind === 'leaf', `push ${tier} leaf resolves`);
-    return leaf;
-}
-// Drive the leaf as the given caller node — sets CRTR_NODE_ID (client-side
-// identity resolution stays in the CLI process, per the B-5 scope) around the
-// run, restoring it after.
-async function runPushAs(caller, tier, body, input = {}) {
-    const prev = process.env['CRTR_NODE_ID'];
-    process.env['CRTR_NODE_ID'] = caller;
-    try {
-        return (await pushLeaf(tier).run({ body, ...input }));
-    }
-    finally {
-        if (prev === undefined)
-            delete process.env['CRTR_NODE_ID'];
-        else
-            process.env['CRTR_NODE_ID'] = prev;
-    }
-}
-// The `node worktree close` leaf, resolved from the real command tree exactly as
-// the CLI dispatcher would.
-function closeLeaf() {
-    const worktree = registerNode().children.find((c) => c.name === 'worktree');
-    assert.ok(worktree !== undefined && worktree.kind === 'branch', 'node worktree branch resolves');
-    const close = worktree.children.find((c) => c.name === 'close');
-    assert.ok(close !== undefined && close.kind === 'leaf', 'node worktree close leaf resolves');
-    return close;
-}
-async function runCloseAs(caller) {
-    const prev = process.env['CRTR_NODE_ID'];
-    process.env['CRTR_NODE_ID'] = caller;
-    try {
-        return (await closeLeaf().run({}));
-    }
-    finally {
-        if (prev === undefined)
-            delete process.env['CRTR_NODE_ID'];
-        else
-            process.env['CRTR_NODE_ID'] = prev;
-    }
-}
-before(async () => {
-    h = await createHeadlessHarness({ sessionPrefix: 'crtr-leafparity' });
-    server = createApiServer(); // binds <h.home>/crtrd.sock (CRTR_HOME set by harness)
-    sockPath = apiSocketPath();
-    await h.waitFor(() => existsSync(sockPath), { label: 'api socket bound', timeoutMs: 10_000 });
-    // The socket is already bound in-process; forbid autostart so the leaf's
-    // cliClient() never tries to spawn a real detached crtrd — it connects to the
-    // bound in-process server deterministically.
-    process.env['CRTR_NO_DAEMON_AUTOSTART'] = '1';
-    client = new CrtrClient({ socketPath: sockPath, autostart: false });
-});
-after(async () => {
-    await server?.close();
-    await h?.dispose();
-    if (savedNoAutostart === undefined)
-        delete process.env['CRTR_NO_DAEMON_AUTOSTART'];
-    else
-        process.env['CRTR_NO_DAEMON_AUTOSTART'] = savedNoAutostart;
-    if (savedNodeId === undefined)
-        delete process.env['CRTR_NODE_ID'];
-    else
-        process.env['CRTR_NODE_ID'] = savedNodeId;
-});
-// push final — the report write, the subscriber fan, and the lifecycle
-// transition all happen server-side, driven through the real push.ts leaf. A
-// parent spawns a child (so the parent subscribes to the child); the child
-// pushes.
-test('`crtr push final` from a child writes a report, notifies the subscribed parent, AND transitions the child row active→done', async () => {
-    const parent = h.spawnRoot('leaf-api-parity final parent');
-    const child = (await client.createNode({ kind: 'developer', parent, prompt: 'final worker' })).node_id;
-    await h.awaitBoot(child);
-    assert.equal(h.node(child)?.status, 'active', 'the child is live/active before the final push');
-    const out = await runPushAs(child, 'final', 'final result from the child');
-    // Same report_path + notified parity as update.
-    assert.equal(typeof out['report_path'], 'string', 'report_path is a string');
-    assert.ok(existsSync(out['report_path']), `final report file written at ${String(out['report_path'])}`);
-    assert.ok(Array.isArray(out['notified']), 'notified is an array');
-    assert.ok(out['notified'].includes(parent), `final MUST notify the subscribed parent (notified=${JSON.stringify(out['notified'])})`);
-    // final MUST transition the row — asserted BOTH on the leaf output AND on the
-    // authoritative canvas row (the server applied it, not the CLI).
-    assert.deepEqual(out['transitioned'], { from: 'active', to: 'done' }, 'final leaf output reports the server-side active→done transition');
-    assert.equal(h.node(child)?.status, 'done', 'the child row is genuinely done after final — the transition happened server-side');
-    assert.ok(h.node(child)?.final_report, 'the canonical final_report is recorded on the row');
-    // A normal node (no managed worktree) carries NO worktree_auto_dropped field
-    // — the re-homed guard only engages for a managed-worktree owner.
-    assert.equal('worktree_auto_dropped' in out, false, 'a normal node final is unaffected by the worktree guard');
-});
-test('`crtr push update --tier deferred` fans a deferred pointer while preserving an update report', async () => {
-    const parent = h.spawnRoot('leaf-api-parity deferred parent');
-    const child = (await client.createNode({ kind: 'developer', parent, prompt: 'deferred worker' })).node_id;
-    await h.awaitBoot(child);
-    const out = await runPushAs(child, 'update', 'deferred progress', { tier: 'deferred' });
-    assert.ok(out['notified'].includes(parent), 'the subscribed parent receives the report pointer');
-    const entry = openDb().prepare(`SELECT m.kind, d.urgency FROM deliveries d JOIN messages m ON m.message_id = d.message_id
-      WHERE d.destination_kind = 'node_inbox' AND d.destination_id = ? AND m.sender_node_id = ? AND m.label = ?`).get(parent, child, 'deferred progress');
-    assert.equal(entry?.kind, 'update', 'the stored SQL message remains an update');
-    assert.equal(entry?.urgency, 'deferred', 'the requested delivery urgency reaches the parent');
-});
-// Re-homed worktree guard/auto-drop (ambiguity-2 follow-up): the pre-B-5 CLI
-// `push final` worktree behavior now lives SERVER-side in handlers/reports.ts,
-// exercised end-to-end through the real push.ts leaf.
-test('re-homed guard: `crtr push final` on a node with a managed worktree holding REAL unlanded commits blocks with the parity open_managed_worktree InputError (round-tripped from the server), and does NOT finalize', async () => {
-    const repo = initRepo();
-    try {
-        const id = 'wt-real-work-final';
-        const wt = createManagedWorktree(repo, id);
-        // A real unlanded commit in the worktree — auto-drop must refuse, guard fires.
-        writeFileSync(join(wt.path, 'feature.txt'), 'real unlanded work\n');
-        git(['add', '.'], wt.path);
-        git(['-c', 'user.email=test@example.com', '-c', 'user.name=Test', 'commit', '-m', 'feature'], wt.path);
-        createNode(worktreeNode(id, wt.path, wt));
-        await assert.rejects(() => runPushAs(id, 'final', 'trying to finish without landing'), (e) => e instanceof InputError &&
-            e.payload.error === 'open_managed_worktree' &&
-            typeof e.payload.next === 'string' &&
-            e.payload.next.includes('node worktree close'), 'the server guard round-trips as the parity open_managed_worktree InputError with its next-hint');
-        assert.equal(getNode(id)?.managed_worktree?.state, 'open', 'a real unlanded commit is never auto-dropped');
-        assert.equal(getNode(id)?.final_report ?? null, null, 'the node did not finalize while blocked');
-        assert.equal(getNode(id)?.status, 'active', 'the row stays active — the guard fired before the transition');
-    }
-    finally {
-        rmSync(repo, { recursive: true, force: true });
-    }
-});
-test('`crtr push final` retains a clean managed worktree checked out on a pushed PR branch (#1109, #1061)', async () => {
-    const repo = initRepo();
-    const remote = mkdtempSync(join(tmpdir(), 'crtr-leafparity-remote-'));
-    try {
-        git(['init', '--bare'], remote);
-        git(['remote', 'add', 'origin', remote], repo);
-        git(['push', '-u', 'origin', 'main'], repo);
-        const id = 'wt-pushed-pr-branch-final';
-        const wt = createManagedWorktree(repo, id);
-        writeFileSync(join(wt.path, 'delivered-via-pr.txt'), 'delivered via a PR branch\n');
-        git(['add', '.'], wt.path);
-        git(['commit', '-m', 'delivered via PR branch'], wt.path);
-        const tip = gitSync(['rev-parse', 'HEAD'], wt.path).stdout.trim();
-        const prBranch = 'fix/pushed-pr-worktree-final';
-        git(['switch', '-c', prBranch], wt.path);
-        git(['push', 'origin', `HEAD:refs/heads/${wt.branch}`], wt.path);
-        git(['push', 'origin', `HEAD:refs/heads/${prBranch}`], wt.path);
-        assert.equal(gitSync(['rev-parse', `refs/heads/${wt.branch}`], wt.path).stdout.trim(), tip, 'the recorded branch remains at the checkout tip');
-        assert.equal(gitSync(['rev-parse', '--abbrev-ref', 'HEAD'], wt.path).stdout.trim(), prBranch, 'the checkout uses the PR branch instead of the recorded branch');
-        assert.equal(gitSync(['ls-remote', '--exit-code', '--heads', 'origin', `refs/heads/${wt.branch}`], wt.path).stdout.split('\t')[0], tip, 'origin carries the recorded branch tip');
-        assert.equal(gitSync(['ls-remote', '--exit-code', '--heads', 'origin', `refs/heads/${prBranch}`], wt.path).stdout.split('\t')[0], tip, 'origin carries the PR branch tip');
-        const untracked = join(wt.path, 'generated.uid');
-        writeFileSync(untracked, 'untracked generated file\n');
-        assert.equal(await branchIsPushedAtCurrentTip(wt), false, 'an untracked file still rejects the origin-retention proof');
-        rmSync(untracked);
-        createNode(worktreeNode(id, wt.path, wt));
-        const out = await runPushAs(id, 'final', 'delivered through a PR branch');
-        assert.equal(out['worktree_auto_dropped'], undefined, 'the remote-tip allowance retains the open worktree');
-        assert.equal(getNode(id)?.managed_worktree?.state, 'open', 'the remote-tip allowance does not close the worktree record');
-        assert.equal(getNode(id)?.managed_worktree?.branch, wt.branch, 'the retained record keeps its recorded branch');
-        assert.equal(gitSync(['rev-parse', '--abbrev-ref', 'HEAD'], wt.path).stdout.trim(), prBranch, 'finalization does not change the checked-out PR branch');
-        assert.equal(getNode(id)?.status, 'done', 'the node finalizes when both pushed branches have its exact tip');
-    }
-    finally {
-        rmSync(repo, { recursive: true, force: true });
-        rmSync(remote, { recursive: true, force: true });
-    }
-});
-test('auto-drop: `crtr push final` on a node with a CLEAN, zero-commit managed worktree auto-drops it server-side, surfaces worktree_auto_dropped(+path) on the leaf output, and finalizes normally', async () => {
-    const repo = initRepo();
-    try {
-        const id = 'wt-clean-empty-final';
-        const wt = createManagedWorktree(repo, id); // branch == base tip, clean => nothing to land
-        createNode(worktreeNode(id, wt.path, wt));
-        const out = await runPushAs(id, 'final', 'read-only review, nothing to land');
-        assert.equal(out['worktree_auto_dropped'], true, 'the leaf surfaces the server-side auto-drop');
-        assert.equal(out['worktree_auto_dropped_path'], wt.path, 'the dropped checkout path round-trips onto the leaf output');
-        assert.equal(getNode(id)?.managed_worktree?.state, 'closed', 'the clean worktree row is marked closed by the drop');
-        assert.deepEqual(out['transitioned'], { from: 'active', to: 'done' }, 'the final still transitions the row after the auto-drop');
-        assert.equal(getNode(id)?.status, 'done', 'the node finalized normally after the auto-drop');
-        assert.ok(getNode(id)?.final_report, 'the canonical final_report is recorded');
-    }
-    finally {
-        rmSync(repo, { recursive: true, force: true });
-    }
-});
-// #671: after a failed local close, a node may safely deliver its branch to
-// the base's upstream and remove its own clean checkout. The path is gone, so
-// only the remote-tracking ref can prove finalization will not discard work.
-test('`crtr push final` concludes an absent managed worktree whose branch is delivered to its base upstream (#671)', async () => {
-    const repo = initRepo();
-    const remote = mkdtempSync(join(tmpdir(), 'crtr-leafparity-remote-'));
-    try {
-        git(['init', '--bare'], remote);
-        git(['remote', 'add', 'origin', remote], repo);
-        git(['push', '-u', 'origin', 'main'], repo);
-        const id = 'wt-671-upstream-delivered';
-        const wt = createManagedWorktree(repo, id);
-        writeFileSync(join(wt.path, 'delivered.txt'), 'delivered remotely\n');
-        git(['add', '.'], wt.path);
-        git(['commit', '-m', 'delivered remotely'], wt.path);
-        const deliveredSha = gitSync(['rev-parse', 'HEAD'], wt.path).stdout.trim();
-        // This is the incident delivery route: origin/main contains the branch,
-        // while the local base remains deliberately untouched.
-        git(['push', 'origin', `${wt.branch}:main`], wt.path);
-        git(['fetch', 'origin'], repo);
-        assert.equal(gitSync(['merge-base', '--is-ancestor', deliveredSha, 'origin/main'], repo).status, 0, 'the remote-tracking upstream must prove delivery');
-        git(['worktree', 'remove', wt.path], repo);
-        assert.equal(existsSync(wt.path), false, 'the incident shape has no checkout path left');
-        createNode(worktreeNode(id, wt.path, wt));
-        const out = await runPushAs(id, 'final', 'delivered remotely and cleaned up');
-        assert.equal(out['worktree_auto_dropped'], true, 'the absent-path proof must unblock finalization');
-        assert.equal(getNode(id)?.managed_worktree?.state, 'closed', 'the record is tombstoned as closed');
-        assert.equal(getNode(id)?.cwd, wt.repo_root, 'the closed record repoints revive to the durable base checkout');
-        assert.equal(getNode(id)?.status, 'done', 'finalization completes after the proven drop');
-    }
-    finally {
-        rmSync(repo, { recursive: true, force: true });
-        rmSync(remote, { recursive: true, force: true });
-    }
-});
-test('`crtr push final` keeps an absent managed worktree open when its branch is not delivered (#671)', async () => {
-    const repo = initRepo();
-    try {
-        const id = 'wt-671-absent-unlanded';
-        const wt = createManagedWorktree(repo, id);
-        writeFileSync(join(wt.path, 'unlanded.txt'), 'must remain reachable\n');
-        git(['add', '.'], wt.path);
-        git(['commit', '-m', 'unlanded work'], wt.path);
-        git(['worktree', 'remove', wt.path], repo);
-        createNode(worktreeNode(id, wt.path, wt));
-        await assert.rejects(() => runPushAs(id, 'final', 'must block'), (e) => e instanceof InputError
-            && e.payload.error === 'open_managed_worktree'
-            && typeof e.payload.next === 'string'
-            && e.payload.next.includes(`Push or land ${wt.branch}`)
-            && !e.payload.next.includes('node worktree close'), 'an absent checkout with unlanded commits must remain blocked with a usable recovery path');
-        assert.equal(getNode(id)?.managed_worktree?.state, 'open', 'the ambiguous record must stay open');
-        assert.equal(gitSync(['rev-parse', '--verify', `refs/heads/${wt.branch}`], repo).status, 0, 'the unlanded branch must remain reachable');
-    }
-    finally {
-        rmSync(repo, { recursive: true, force: true });
-    }
-});
-test('`crtr node worktree close` warns with the retained stash SHA when base-checkout changes conflict (#1066)', async () => {
-    const repo = initRepo();
-    try {
-        writeFileSync(join(repo, 'conflict.txt'), 'base\n');
-        writeFileSync(join(repo, 'disjoint.txt'), 'base\n');
-        git(['add', '.'], repo);
-        git(['commit', '-m', 'tracked base files'], repo);
-        const id = 'wt-close-stash-warning';
-        const wt = createManagedWorktree(repo, id);
-        createNode(worktreeNode(id, wt.path, wt));
-        writeFileSync(join(wt.path, 'conflict.txt'), 'child\n');
-        git(['add', 'conflict.txt'], wt.path);
-        git(['commit', '-m', 'child conflict'], wt.path);
-        writeFileSync(join(repo, 'conflict.txt'), 'base live edit\n');
-        writeFileSync(join(repo, 'disjoint.txt'), 'disjoint live edit\n');
-        const out = await runCloseAs(id);
-        const stashSha = gitSync(['rev-parse', 'refs/stash'], repo).stdout.trim();
-        const rendered = closeLeaf().render?.(out) ?? '';
-        assert.match(out['base_checkout_stash'], new RegExp(`stash ${stashSha}`), 'the API result identifies the exact retained stash');
-        assert.match(rendered, new RegExp(`stash ${stashSha}`), 'the CLI output identifies the exact retained stash');
-        assert.match(rendered, new RegExp(`git -C '${realpathSync(repo)}' stash apply ${stashSha}`), 'the CLI output gives the exact recovery command');
-        assert.match(rendered, /shared base checkout was reset to landed commit/, 'the CLI output states that the shared checkout was reset');
-        assert.doesNotMatch(rendered, /nothing was lost/i, 'the CLI does not claim all concurrent work was preserved');
-        assert.equal(readFileSync(join(repo, 'disjoint.txt'), 'utf8'), 'base\n', 'the reset removes the disjoint live edit from the checkout but leaves it in the reported stash');
-    }
-    finally {
-        rmSync(repo, { recursive: true, force: true });
-    }
-});
-// `node worktree close` error parity — the SPECIFIC WorktreeError code + its
-// `next` remediation round-trip verbatim through the server → ApiError → the
-// bespoke CLI mapper in node-worktree.ts, instead of collapsing to a generic
-// status bucket. That mapper exists for exactly this contract, so this is the
-// load-bearing regression to lock.
-test('`crtr node worktree close` on a node with NO managed worktree round-trips the specific `no_managed_worktree` code + its exact next-hint (not a generic status bucket)', async () => {
-    const id = 'wt-close-none';
-    createNode({ node_id: id, name: id, created: new Date().toISOString(), cwd: process.cwd(), kind: 'developer', mode: 'base', lifecycle: 'terminal', status: 'active' });
-    await assert.rejects(() => runCloseAs(id), (e) => e instanceof InputError &&
-        e.payload.error === 'no_managed_worktree' &&
-        typeof e.payload.next === 'string' &&
-        e.payload.next.includes('Nothing to close'), 'the specific WorktreeError code + next survive the server → ApiError → custom CLI mapper');
-});
-test('`crtr node worktree close` for an UNKNOWN node round-trips the specific `unknown_node` code (a 404 that is NOT flattened to not_found)', async () => {
-    await assert.rejects(() => runCloseAs('no-such-node-xyz'), (e) => e instanceof InputError && e.payload.error === 'unknown_node', 'unknown_node keeps its specific code even though it maps to a 404 status');
-});

package/dist/daemon/api/__tests__/seam/node-outcome-api.test.d.ts

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

package/dist/daemon/api/__tests__/seam/node-outcome-api.test.js

@@ -1,159 +0,0 @@
-// Run with: npm run build && node --test --test-timeout=180000 dist/daemon/api/__tests__/seam/node-outcome-api.test.js
-//
-// Pins the public node-outcome routes against the compiled API server on its
-// Unix socket. The fixture node is written through the canvas, then finalized
-// through the API, so the pending and settled documents cross the real wire.
-import { after, before, test } from 'node:test';
-import assert from 'node:assert/strict';
-import { request as httpRequest } from 'node:http';
-import { chmodSync, mkdirSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { CrtrClient } from '../../../../api/index.js';
-import { createNode } from '../../../../core/canvas/canvas.js';
-import { resetScopeCache } from '../../../../core/scope.js';
-import { createHeadlessHarness } from '../../../../core/__tests__/helpers/harness.js';
-let h;
-let client;
-let nodeId;
-function assertKeys(value, expected, label) {
-    assert.deepEqual(Object.keys(value).sort(), [...expected].sort(), `${label} has the pinned wire fields`);
-}
-async function rawRequest(method, path, body) {
-    const encoded = body === undefined ? undefined : JSON.stringify(body);
-    return new Promise((resolve, reject) => {
-        const request = httpRequest({
-            socketPath: join(h.home, 'crtrd.sock'),
-            method,
-            path,
-            headers: encoded === undefined ? undefined : {
-                'content-type': 'application/json',
-                'content-length': Buffer.byteLength(encoded),
-            },
-        }, (response) => {
-            let content = '';
-            response.setEncoding('utf8');
-            response.on('data', (chunk) => { content += chunk; });
-            response.on('end', () => {
-                try {
-                    resolve({ status: response.statusCode ?? 0, body: content === '' ? null : JSON.parse(content) });
-                }
-                catch (error) {
-                    reject(error);
-                }
-            });
-        });
-        request.on('error', reject);
-        request.end(encoded);
-    });
-}
-function assertError(response, status, code) {
-    assert.equal(response.status, status);
-    const body = response.body;
-    assert.equal(body.error.code, code);
-    assert.equal(typeof body.error.message, 'string');
-}
-before(async () => {
-    h = await createHeadlessHarness({ sessionPrefix: 'crtr-node-outcome-api' });
-    client = new CrtrClient({ socketPath: join(h.home, 'crtrd.sock'), autostart: false });
-    const actions = join(h.home, 'actions');
-    mkdirSync(actions, { recursive: true });
-    writeFileSync(join(actions, 'capture'), '#!/bin/sh\ncat >/dev/null\nexit 0\n');
-    chmodSync(join(actions, 'capture'), 0o755);
-    mkdirSync(join(h.home, '.crouter'), { recursive: true });
-    writeFileSync(join(h.home, '.crouter', 'config.json'), JSON.stringify({
-        humanActions: {
-            capture: { argv: ['actions/capture'], cwd: '.' },
-            broken: { argv: ['actions/missing'], cwd: '.' },
-        },
-    }));
-    resetScopeCache();
-    nodeId = `outcome-api-${process.pid}`;
-    createNode({
-        node_id: nodeId,
-        name: 'outcome API fixture',
-        created: new Date().toISOString(),
-        cwd: h.home,
-        kind: 'developer',
-        mode: 'base',
-        lifecycle: 'terminal',
-        status: 'active',
-        parent: null,
-    });
-});
-after(async () => {
-    resetScopeCache();
-    await h?.dispose();
-});
-test('node outcome and delivery routes preserve their public response and error contracts', async () => {
-    assertError(await rawRequest('GET', '/v1/nodes/missing-node/outcome'), 404, 'node_not_found');
-    assertError(await rawRequest('GET', `/v1/nodes/${nodeId}/outcome?wait=26.5`), 400, 'invalid_request');
-    assertError(await rawRequest('PUT', '/v1/nodes/missing-node/outcome-delivery', { action: 'capture' }), 404, 'node_not_found');
-    const pendingResponse = await rawRequest('GET', `/v1/nodes/${nodeId}/outcome`);
-    assert.equal(pendingResponse.status, 200, 'GET outcome → 200');
-    const pending = pendingResponse.body;
-    assertKeys(pending, ['node_id', 'state', 'outcome', 'node_status', 'deadline_at'], 'pending outcome response');
-    assert.deepEqual(pending, {
-        node_id: nodeId,
-        state: 'pending',
-        outcome: null,
-        node_status: 'active',
-        deadline_at: null,
-    }, 'GET outcome returns the complete pending NodeOutcomeResponseDTO');
-    assertError(await rawRequest('PUT', `/v1/nodes/${nodeId}/outcome-delivery`, { action: '' }), 400, 'invalid_request');
-    assertError(await rawRequest('PUT', `/v1/nodes/${nodeId}/outcome-delivery`, { action: 'unknown-action' }), 422, 'unknown_action');
-    const invalidAction = await rawRequest('PUT', `/v1/nodes/${nodeId}/outcome-delivery`, { action: 'broken' });
-    assertError(invalidAction, 422, 'invalid_action');
-    assertKeys(invalidAction.body.error.details, ['reason', 'configOrigin'], 'invalid_action details');
-    assertError(await rawRequest('PUT', `/v1/nodes/${nodeId}/outcome-delivery`, { action: 'capture', payload: 'x'.repeat(65 * 1024) }), 413, 'payload_too_large');
-    assertError(await rawRequest('GET', `/v1/nodes/${nodeId}/outcome-delivery`), 404, 'outcome_delivery_not_found');
-    const payload = { callback: 'fixture', sequence: [1, 2, 3] };
-    const armedResponse = await rawRequest('PUT', `/v1/nodes/${nodeId}/outcome-delivery`, { action: 'capture', payload });
-    assert.equal(armedResponse.status, 200, 'PUT delivery → 200');
-    const armed = armedResponse.body;
-    assertKeys(armed, ['node_id', 'state', 'action', 'attempt', 'next_attempt_at', 'accepted_at', 'permanent_failed_at', 'last_failure', 'created_at', 'updated_at'], 'armed delivery response');
-    assert.equal(armed.node_id, nodeId);
-    assert.equal(armed.state, 'armed');
-    assert.equal(armed.action, 'capture');
-    assert.equal(armed.attempt, 0);
-    assert.equal(armed.next_attempt_at, null);
-    assert.equal(armed.accepted_at, null);
-    assert.equal(armed.permanent_failed_at, null);
-    assert.equal(armed.last_failure, null);
-    assert.match(armed.created_at, /^\d{4}-\d{2}-\d{2}T/);
-    assert.match(armed.updated_at, /^\d{4}-\d{2}-\d{2}T/);
-    const registered = await rawRequest('GET', `/v1/nodes/${nodeId}/outcome-delivery`);
-    assert.equal(registered.status, 200, 'GET delivery → 200');
-    assert.deepEqual(registered.body, armed, 'GET delivery returns the registered DTO unchanged');
-    assert.equal((await rawRequest('DELETE', `/v1/nodes/${nodeId}/outcome-delivery`)).status, 204, 'DELETE armed delivery → 204');
-    assert.equal((await rawRequest('DELETE', `/v1/nodes/${nodeId}/outcome-delivery`)).status, 204, 'DELETE absent delivery remains idempotent → 204');
-    assertError(await rawRequest('GET', `/v1/nodes/${nodeId}/outcome-delivery`), 404, 'outcome_delivery_not_found');
-    const final = await client.pushReport(nodeId, { tier: 'final', body: 'outcome API canonical final' });
-    const settledResponse = await rawRequest('GET', `/v1/nodes/${nodeId}/outcome`);
-    assert.equal(settledResponse.status, 200, 'GET settled outcome → 200');
-    const settled = settledResponse.body;
-    assertKeys(settled, ['node_id', 'state', 'outcome', 'node_status', 'deadline_at'], 'settled outcome response');
-    assert.equal(settled.node_id, nodeId);
-    assert.equal(settled.state, 'settled');
-    assert.equal(settled.node_status, 'done');
-    assert.equal(settled.deadline_at, null);
-    assert.notEqual(settled.outcome, null, 'a canonical final settles an outcome');
-    const outcome = settled.outcome;
-    assertKeys(outcome, ['node_id', 'revision', 'kind', 'reason', 'settled_at', 'final_report', 'final_report_path', 'structured_result', 'detail', 'declined'], 'settled NodeOutcomeDTO');
-    assert.equal(outcome.node_id, nodeId);
-    assert.equal(outcome.revision, 1);
-    assert.equal(outcome.kind, 'result');
-    assert.equal(outcome.reason, 'finalized');
-    assert.match(outcome.settled_at, /^\d{4}-\d{2}-\d{2}T/);
-    assert.equal(outcome.final_report_path, final.report_path);
-    assert.ok(outcome.final_report !== null && outcome.final_report.length > 0, 'result carries its report basename');
-    assert.equal(outcome.structured_result, null);
-    assert.equal(outcome.detail, null);
-    const repeated = await rawRequest('GET', `/v1/nodes/${nodeId}/outcome`);
-    assert.equal(repeated.status, 200, 'repeat GET outcome → 200');
-    assert.deepEqual(repeated.body, settled, 'repeat GET returns the identical durable outcome response');
-    const pendingDelivery = await rawRequest('PUT', `/v1/nodes/${nodeId}/outcome-delivery`, { action: 'capture', payload });
-    assert.equal(pendingDelivery.status, 200, 'PUT delivery after settlement → 200');
-    assert.equal(pendingDelivery.body.state, 'pending', 'PUT after settlement arms immediate delivery');
-    assertError(await rawRequest('PUT', `/v1/nodes/${nodeId}/outcome-delivery`, { action: 'capture', payload }), 409, 'outcome_delivery_settled');
-    assertError(await rawRequest('DELETE', `/v1/nodes/${nodeId}/outcome-delivery`), 409, 'outcome_delivery_settled');
-});

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

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