smol-symphony 0.3.0 → 0.3.1

package/dist/tests/shell/http-handler.test.js

@@ -1,608 +0,0 @@
-// Integration test for the composed dashboard/REST `handle` (src/shell/main-http-handler).
-//
-// Drives `wireHttpHandler` with the REAL pure core http slice (routes + decisions
-// + views + render — exactly the bundle main.ts injects) over a FAKE orchestrator
-// read-surface + a FAKE in-memory tracker. Asserts the routes the composition root
-// now serves live (no 503): the dashboard HTML, the §9.3 state JSON, the disk
-// issue listing + issue-detail page, a CSRF-rejected POST, and a CSRF-accepted
-// POST that lands a write through the tracker.
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { wireHttpHandler } from '../../src/shell/main-http-handler.js';
-// The real pure core http functions (the composition root injects these verbatim).
-import { matchRoute, resolvePartialName, extractBearerToken, classifyContentType, checkSteeringCsrf, checkTriageCsrf, extractFormText, extractJsonText, } from '../../src/core/http/routes.js';
-import { decideCreateIssue, decideMoveTransition, buildIssueDetailDto } from '../../src/core/http/decisions.js';
-import { buildSnapshot, buildHealthRollup, buildSessionTotalsView } from '../../src/core/http/views.js';
-import { renderDashboardHtml, renderHeaderPartial, renderHealthPartial, renderAttentionPartial, renderBoardPartial, renderTotalsPartial, renderIssueDetailPage, renderIssueNotFoundPage, } from '../../src/core/http/render.js';
-const CORE = {
-    matchRoute, resolvePartialName, extractBearerToken, classifyContentType,
-    checkSteeringCsrf, checkTriageCsrf, extractFormText, extractJsonText,
-    decideCreateIssue, decideMoveTransition, buildIssueDetailDto,
-    buildSnapshot, buildHealthRollup, buildSessionTotalsView,
-    renderDashboardHtml, renderHeaderPartial, renderHealthPartial, renderAttentionPartial,
-    renderBoardPartial, renderTotalsPartial, renderIssueDetailPage, renderIssueNotFoundPage,
-};
-const CLOCK = { now: () => 1_700_000_000_000, iso: () => '2023-11-14T22:13:20.000Z' };
-/** A no-op LogSink (the handler only emits best-effort diagnostics). */
-function makeLog() {
-    const sink = { emit: () => undefined, withIssue: () => sink };
-    return sink;
-}
-const CFG = {
-    workflow_path: '/repo/WORKFLOW.md',
-    workflow_dir: '/repo',
-    tracker: { kind: 'local', root: '/tracker', states: { Triage: { role: 'holding' }, Todo: { role: 'active' }, Done: { role: 'terminal' } } },
-    prompt: { preamble_file: null, footer_file: null },
-    polling: { interval_ms: 5000 },
-    workspace: { root: '/ws', base_branch: 'main', github_repo: null },
-    logs: { root: '/logs' },
-    agent: { max_concurrent_agents: 3, max_turns: 20, max_retry_backoff_ms: 60000, memory_admission_enabled: false, host_memory_reserve_mib: 1024, circuit_breaker_threshold: 0 },
-    acp: { adapter: 'claude', model: null, effort: null, shell: 'bash', prompt_timeout_ms: 0, read_timeout_ms: 0, stall_timeout_ms: 0, connect_timeout_ms: 0, heartbeat_interval_ms: 0, heartbeat_timeout_ms: 0 },
-    gondolin: { image: 'sha256:deadbeefcafe', managed_image: false, oci_image: null, oci_pull_policy: 'if-not-present', oci_runtime: null, cpus: 2, mem_mib: 2048, rootfs_size: '3G', volumes: [], forward_env: [], guest_agent_path: '/opt/agent.mjs', node_bin: 'node', mise: { data_dir: '/home/test/.symphony/mise' } },
-    egress: { allowed_hosts: [] },
-    server: { port: null, host: '127.0.0.1' },
-    mcp: { enabled: false, host: 'symphony-mcp', explicit_host_url: null },
-    pr: { enabled: false, poll_interval_ms: 30000 },
-    credentials: { ticker_interval_ms: 0, refresh_margin_ms: 300_000 },
-    states: { Triage: { role: 'holding' }, Todo: { role: 'active' }, Done: { role: 'terminal' } },
-};
-/** A fake orchestrator + in-memory tracker. `disk` is the simulated tracker disk. */
-function makeDeps(opts) {
-    const running = opts?.running ?? [];
-    const retrying = opts?.retrying ?? [];
-    let disk = opts?.disk ?? [];
-    // readIssue resolves from `details` (the move tests' multi-issue disk) falling
-    // back to the single `detail` (the issue-detail page test).
-    const details = opts?.details ?? (opts?.detail ? [opts.detail] : []);
-    const cfg = opts?.cfg ?? CFG;
-    // Operator HTTP actions now fold an event through the single `dispatch` door
-    // (no more `triggerRefresh` side-call). The poll-nudge is an `operator_nudge`
-    // event; `refreshes()` counts those so the existing nudge-count assertions hold.
-    const dispatched = [];
-    const writes = [];
-    const moves = [];
-    const deps = {
-        core: CORE,
-        orchestrator: {
-            runningEntries: () => running,
-            retryEntries: () => retrying,
-            claimedIds: () => new Set(),
-            lastPollAtIso: () => '2023-11-14T22:13:10.000Z',
-            ...(opts?.imageBuildState ? { imageBuildState: opts.imageBuildState } : {}),
-            ...(opts?.imageFailureState ? { imageFailureState: opts.imageFailureState } : {}),
-            dispatch: (event) => { dispatched.push(event); },
-        },
-        tracker: {
-            listIssues: async () => disk,
-            readIssue: async (_root, identifier) => details.find((d) => d.identifier === identifier) ?? null,
-            writeIssue: async (effect) => {
-                writes.push(effect);
-                const newId = effect.identifier ?? String(disk.length + 1);
-                // Mirror the real tracker adapter's create-409 contract: an EXPLICIT
-                // identifier that already exists is a collision, not a silent overwrite.
-                if (effect.identifier && disk.some((d) => d.identifier === effect.identifier)) {
-                    throw Object.assign(new Error(`issue ${effect.identifier} already exists`), { code: 'local_issue_target_exists' });
-                }
-                disk = [...disk, { identifier: newId, state: effect.state, title: effect.title, proposed_by: null, proposed_at: null }];
-                return { kind: 'write_issue', path: `/tracker/${effect.state}/${newId}.md`, identifier: newId, state: effect.state };
-            },
-            // Echo the from-state the handler resolved (the file's actual directory) so
-            // a test can assert the RIGHT file was moved — the issue-126 mis-routing fix.
-            moveIssueToState: async (issueId, toState, o) => {
-                moves.push({ issueId, toState, ...o });
-                return { fromState: o?.fromState ?? '<unknown>', toState, newPath: `/tracker/${toState}/${issueId}.md` };
-            },
-        },
-        clock: CLOCK,
-        log: makeLog(),
-        getLiveCfg: () => cfg,
-        workflowPath: '/repo/WORKFLOW.md',
-        ...(opts?.trackerWritable ? { trackerWritable: opts.trackerWritable } : {}),
-    };
-    return {
-        deps,
-        refreshes: () => dispatched.filter((e) => e.kind === 'operator_nudge').length,
-        dispatched: () => dispatched,
-        moveEvents: () => dispatched.filter((e) => e.kind === 'operator_move'),
-        writes: () => writes,
-        moves: () => moves,
-    };
-}
-/** A workflow with two holding states + a transition graph, so the move tests can
- *  exercise a holding→active move, off-flow, and the mis-routing fix. */
-const FLOW_CFG = {
-    ...CFG,
-    states: {
-        Triage: { role: 'holding' },
-        Parked: { role: 'holding' },
-        Reflect: { role: 'active', allowed_transitions: ['Parked'] },
-        Todo: { role: 'active', allowed_transitions: ['Review', 'Cancelled'] },
-        Review: { role: 'active', allowed_transitions: ['Todo', 'Done'] },
-        Done: { role: 'terminal' }, // open (null) ⇒ re-opening Done is in-flow
-        Cancelled: { role: 'terminal', allowed_transitions: [] }, // dead-end ⇒ any move out is off-flow
-    },
-};
-/** A DiskIssueDetail fixture for the move tests (only identifier + state matter). */
-function diskDetail(identifier, state) {
-    return {
-        identifier,
-        state,
-        filePath: `/tracker/${state}/${identifier}.md`,
-        frontMatter: { title: identifier },
-        body: '',
-    };
-}
-/** An HTMX same-origin JSON-or-form move POST against the wired handler. */
-function movePost(deps, identifier, body) {
-    return wireHttpHandler(deps)(req({
-        method: 'POST',
-        pathname: `/api/v1/issues/${identifier}/move`,
-        headers: { 'content-type': 'application/json', host: 'symphony.local', 'hx-request': 'true' },
-        rawBody: JSON.stringify(body),
-    }));
-}
-function req(over) {
-    return { method: 'GET', pathname: '/', headers: {}, rawBody: '', ...over };
-}
-test('GET / serves the dashboard HTML (200, not 503)', async () => {
-    const { deps } = makeDeps({
-        disk: [{ identifier: '7', state: 'Todo', title: 'wire the dashboard', proposed_by: null, proposed_at: null }],
-    });
-    const handle = wireHttpHandler(deps);
-    const res = await handle(req({ pathname: '/' }));
-    assert.equal(res.status, 200);
-    assert.match(res.contentType, /text\/html/);
-    assert.match(res.body, /<!doctype html>/i);
-    assert.match(res.body, /symphony/);
-    // The disk issue title flows into the board render.
-    assert.match(res.body, /wire the dashboard/);
-});
-test('health strip reflects the injected tracker-writable probe (writable / unset)', async () => {
-    // With the probe wired (true) the health strip renders `tracker=writable`.
-    const writableDeps = makeDeps({ trackerWritable: () => true }).deps;
-    const writableRes = await wireHttpHandler(writableDeps)(req({ pathname: '/api/v1/partials/health' }));
-    assert.equal(writableRes.status, 200);
-    assert.match(writableRes.body, /tracker=writable/);
-    assert.doesNotMatch(writableRes.body, /tracker=unset/);
-    // Without the probe (absent) it falls back to null → `tracker=unset` (the prior bug
-    // was that this was the ONLY possible value — hardcoded null).
-    const unsetRes = await wireHttpHandler(makeDeps().deps)(req({ pathname: '/api/v1/partials/health' }));
-    assert.match(unsetRes.body, /tracker=unset/);
-    // A read-only tracker root probes false → `tracker=readonly`.
-    const roRes = await wireHttpHandler(makeDeps({ trackerWritable: () => false }).deps)(req({ pathname: '/api/v1/partials/health' }));
-    assert.match(roRes.body, /tracker=readonly/);
-});
-test('health strip surfaces the one-time image build + failure banners through the handler (issue 206)', async () => {
-    // The orchestrator tracks the OCI→gondolin build state; the read-surface must
-    // FORWARD it so the `#health` strip actually renders the banner (the prior gap:
-    // wireHttpHandler dropped the accessor, so the banner never reached the dashboard).
-    const buildingRes = await wireHttpHandler(makeDeps({ imageBuildState: () => ({ ref: 'ghcr.io/acme/agent:1', since: '2026-06-04T00:00:00.000Z' }) }).deps)(req({ pathname: '/api/v1/partials/health' }));
-    assert.equal(buildingRes.status, 200);
-    assert.match(buildingRes.body, /building microVM image \(one-time setup\)/);
-    assert.match(buildingRes.body, /ghcr\.io\/acme\/agent:1/);
-    // A FAILED conversion stays visible while dispatch is held, with the error + remediation.
-    const failedRes = await wireHttpHandler(makeDeps({
-        imageFailureState: () => ({ ref: 'ghcr.io/acme/agent:1', since: '2026-06-04T00:00:00.000Z', message: 'manifest unknown' }),
-    }).deps)(req({ pathname: '/api/v1/partials/health' }));
-    assert.match(failedRes.body, /microVM image build failed \(VM dispatch held\)/);
-    assert.match(failedRes.body, /manifest unknown/);
-    assert.match(failedRes.body, /restart symphony to retry/);
-    // Neither set ⇒ no banner (the accessors are optional; pre-206 back-compat).
-    const plainRes = await wireHttpHandler(makeDeps().deps)(req({ pathname: '/api/v1/partials/health' }));
-    assert.doesNotMatch(plainRes.body, /building microVM image/);
-    assert.doesNotMatch(plainRes.body, /microVM image build failed/);
-});
-test('GET /api/v1/state returns the §9.3 snapshot JSON (200)', async () => {
-    const running = [runningEntry({ identifier: '7' })];
-    const { deps } = makeDeps({ running });
-    const handle = wireHttpHandler(deps);
-    const res = await handle(req({ pathname: '/api/v1/state' }));
-    assert.equal(res.status, 200);
-    assert.match(res.contentType, /application\/json/);
-    const body = JSON.parse(res.body);
-    assert.equal(body.running.length, 1);
-    assert.equal(body.running[0].identifier, '7');
-    assert.equal(body.health.running, 1);
-    assert.equal(body.health.global_slots_total, 3);
-    assert.equal(body.generated_at, '2023-11-14T22:13:20.000Z');
-});
-test('GET /api/v1/issues lists disk issues (200)', async () => {
-    const { deps } = makeDeps({
-        disk: [{ identifier: '3', state: 'Triage', title: 'proposal', proposed_by: 'agent', proposed_at: null }],
-    });
-    const handle = wireHttpHandler(deps);
-    const res = await handle(req({ pathname: '/api/v1/issues' }));
-    assert.equal(res.status, 200);
-    const body = JSON.parse(res.body);
-    assert.equal(body.issues.length, 1);
-    assert.equal(body.issues[0].identifier, '3');
-});
-test('GET /issues/<id> renders the issue-detail page; missing → 404 page', async () => {
-    const detail = {
-        identifier: '7', state: 'Todo', filePath: '/tracker/Todo/7.md',
-        frontMatter: { title: 'detail title' }, body: '# heading\n\nsome body',
-    };
-    const { deps } = makeDeps({ detail });
-    const handle = wireHttpHandler(deps);
-    const ok = await handle(req({ pathname: '/issues/7' }));
-    assert.equal(ok.status, 200);
-    assert.match(ok.contentType, /text\/html/);
-    assert.match(ok.body, /detail title/);
-    const missing = await handle(req({ pathname: '/issues/999' }));
-    assert.equal(missing.status, 404);
-    assert.match(missing.body, /issue not found/);
-});
-test('GET /issues/<id> exposes the move control for a terminal issue (off-board reachability)', async () => {
-    // Terminal columns are kept off the board, so the detail page is where a Done /
-    // Cancelled issue stays reachable for a move (issue 126 review follow-up). The
-    // wired handler must serve the control + every non-terminal target.
-    const detail = {
-        identifier: 'fin-1', state: 'Done', filePath: '/tracker/Done/fin-1.md',
-        frontMatter: { title: 'finished work' }, body: '',
-    };
-    const { deps } = makeDeps({ detail });
-    const res = await wireHttpHandler(deps)(req({ pathname: '/issues/fin-1' }));
-    assert.equal(res.status, 200);
-    assert.match(res.body, /class="detail-move"/);
-    assert.match(res.body, /id="detail-move-select"/);
-    assert.match(res.body, /data-from="Done"/);
-    // Done is open (null list) ⇒ moving out to any declared state is in-flow.
-    assert.match(res.body, /<option value="Todo">Todo<\/option>/);
-    assert.match(res.body, /<option value="Triage">Triage<\/option>/);
-});
-test('POST /api/v1/refresh dispatches an operator_nudge (coalesce an immediate poll)', async () => {
-    const { deps, dispatched } = makeDeps();
-    const res = await wireHttpHandler(deps)(req({ method: 'POST', pathname: '/api/v1/refresh' }));
-    assert.equal(res.status, 204);
-    // The operator refresh now folds a single nudge event through the dispatch door
-    // (no imperative triggerRefresh side-call).
-    assert.deepEqual(dispatched(), [{ kind: 'operator_nudge' }]);
-});
-test('POST /api/v1/issues is CSRF-REJECTED for a cross-origin form POST', async () => {
-    const { deps, writes } = makeDeps();
-    const handle = wireHttpHandler(deps);
-    const res = await handle(req({
-        method: 'POST',
-        pathname: '/api/v1/issues',
-        headers: { 'content-type': 'application/x-www-form-urlencoded', host: 'symphony.local', origin: 'https://evil.example' },
-        rawBody: 'title=hijack',
-    }));
-    assert.equal(res.status, 403);
-    const body = JSON.parse(res.body);
-    assert.equal(body.error.code, 'forbidden');
-    assert.equal(writes().length, 0, 'no write should land on a rejected POST');
-});
-test('POST /api/v1/issues is CSRF-ACCEPTED for an application/json POST and writes', async () => {
-    const { deps, writes, refreshes, dispatched } = makeDeps();
-    const handle = wireHttpHandler(deps);
-    const res = await handle(req({
-        method: 'POST',
-        pathname: '/api/v1/issues',
-        headers: { 'content-type': 'application/json', host: 'symphony.local', origin: 'https://evil.example' },
-        rawBody: JSON.stringify({ title: 'legit new issue', state: 'Todo' }),
-    }));
-    assert.equal(res.status, 201);
-    const body = JSON.parse(res.body);
-    assert.equal(body.state, 'Todo');
-    assert.equal(writes().length, 1);
-    const effect = writes()[0];
-    assert.equal(effect.title, 'legit new issue');
-    assert.equal(effect.state, 'Todo');
-    assert.equal(effect.trackerRoot, '/tracker');
-    assert.equal(refreshes(), 1, 'a successful write coalesces a refresh poll');
-    assert.deepEqual(dispatched(), [{ kind: 'operator_nudge' }], 'the create folds a nudge event');
-});
-test('POST /api/v1/issues with an OCCUPIED explicit identifier returns 409 (no overwrite)', async () => {
-    // Seed an existing issue at identifier "5"; the create handler must surface the
-    // tracker's local_issue_target_exists as HTTP 409, not a 500 write_failed.
-    const { deps, writes } = makeDeps({
-        disk: [{ identifier: '5', state: 'Todo', title: 'existing', proposed_by: null, proposed_at: null }],
-    });
-    const handle = wireHttpHandler(deps);
-    const res = await handle(req({
-        method: 'POST',
-        pathname: '/api/v1/issues',
-        headers: { 'content-type': 'application/json', host: 'symphony.local' },
-        rawBody: JSON.stringify({ identifier: '5', title: 'attempted overwrite', state: 'Todo' }),
-    }));
-    assert.equal(res.status, 409);
-    const body = JSON.parse(res.body);
-    assert.equal(body.error.code, 'already_exists');
-    // The write was attempted but rejected; no second disk entry landed.
-    assert.equal(writes().length, 1);
-});
-test('POST /api/v1/issues rejects a bad body (no title) with 400', async () => {
-    const { deps, writes } = makeDeps();
-    const handle = wireHttpHandler(deps);
-    const res = await handle(req({
-        method: 'POST',
-        pathname: '/api/v1/issues',
-        headers: { 'content-type': 'application/json', host: 'symphony.local' },
-        rawBody: JSON.stringify({ state: 'Todo' }),
-    }));
-    assert.equal(res.status, 400);
-    assert.equal(writes().length, 0);
-});
-test('POST move: approve-equivalent (Triage → first active) moves with the actual from-state', async () => {
-    const { deps, moves, refreshes, moveEvents } = makeDeps({ details: [diskDetail('3', 'Triage')] });
-    const res = await movePost(deps, '3', { state: 'Todo', from_state: 'Triage' });
-    assert.equal(res.status, 200);
-    const body = JSON.parse(res.body);
-    assert.equal(body.to_state, 'Todo');
-    assert.equal(body.from_state, 'Triage');
-    assert.equal(body.off_flow, false); // Triage's list is open (null) ⇒ in-flow
-    assert.equal(moves().length, 1);
-    assert.deepEqual(moves()[0], { issueId: '3', toState: 'Todo', fromState: 'Triage', actor: 'symphony/operator' });
-    // The move folds a single operator_move event (issue 199): the active target's
-    // immediate-pickup nudge is now the event's toActive flag, not a separate
-    // operator_nudge, so refreshes() (which counts operator_nudge) is 0.
-    assert.equal(refreshes(), 0, 'no separate operator_nudge — the nudge rides operator_move');
-    assert.deepEqual(moveEvents(), [
-        { kind: 'operator_move', issueId: '3', identifier: '3', toState: 'Todo', toTerminal: false, toActive: true },
-    ]);
-});
-test('POST move: discard-equivalent (Todo → Cancelled terminal) dispatches operator_move (terminal, no nudge)', async () => {
-    const { deps, moves, refreshes, moveEvents } = makeDeps({ cfg: FLOW_CFG, details: [diskDetail('4', 'Todo')] });
-    const res = await movePost(deps, '4', { state: 'Cancelled', from_state: 'Todo' });
-    assert.equal(res.status, 200);
-    const body = JSON.parse(res.body);
-    assert.equal(body.to_state, 'Cancelled');
-    // A terminal target sets toTerminal (the reducer reaps the workspace) and clears
-    // toActive (no redispatch nudge).
-    assert.deepEqual(moveEvents(), [
-        { kind: 'operator_move', issueId: '4', identifier: '4', toState: 'Cancelled', toTerminal: true, toActive: false },
-    ]);
-    assert.equal(refreshes(), 0, 'a terminal target needs no dispatch nudge');
-    assert.equal(body.off_flow, false); // Cancelled ∈ Todo.allowed_transitions
-    assert.equal(moves().length, 1);
-    assert.equal(refreshes(), 0, 'a terminal target needs no dispatch nudge');
-});
-test('POST move: a holding → active move lands in the target (not Todo) and is NOT mis-routed', async () => {
-    // The issue-122 mis-routing bug: clicking approve on a non-Triage holding issue
-    // dispatched it into Todo. The general move lands it in the target active state
-    // with the file's ACTUAL from_state — the right file, the right directory. The
-    // target is active so it gets the nudge, but the move endpoint itself never
-    // dispatches an agent (issue 126).
-    const { deps, moves } = makeDeps({ cfg: FLOW_CFG, details: [diskDetail('reflect-1', 'Parked')] });
-    const res = await movePost(deps, 'reflect-1', { state: 'Reflect', from_state: 'Parked' });
-    assert.equal(res.status, 200);
-    const body = JSON.parse(res.body);
-    assert.equal(body.to_state, 'Reflect');
-    assert.equal(body.from_state, 'Parked'); // NOT Todo — the mis-routing fix
-    assert.equal(body.off_flow, false); // Parked's list is open ⇒ in-flow
-    assert.deepEqual(moves()[0], {
-        issueId: 'reflect-1',
-        toState: 'Reflect',
-        fromState: 'Parked',
-        actor: 'symphony/operator',
-    });
-});
-test('POST move: pulling Todo back to Triage works but is flagged off_flow', async () => {
-    const { deps } = makeDeps({ cfg: FLOW_CFG, details: [diskDetail('5', 'Todo')] });
-    const res = await movePost(deps, '5', { state: 'Triage', from_state: 'Todo' });
-    assert.equal(res.status, 200);
-    const body = JSON.parse(res.body);
-    assert.equal(body.to_state, 'Triage');
-    assert.equal(body.off_flow, true); // Triage ∉ Todo.allowed_transitions
-});
-test('POST move: Review → Done is an ordinary in-flow move', async () => {
-    const { deps } = makeDeps({ cfg: FLOW_CFG, details: [diskDetail('6', 'Review')] });
-    const res = await movePost(deps, '6', { state: 'Done', from_state: 'Review' });
-    assert.equal(res.status, 200);
-    const body = JSON.parse(res.body);
-    assert.equal(body.to_state, 'Done');
-    assert.equal(body.off_flow, false); // Done ∈ Review.allowed_transitions
-});
-test('POST move: an off-flow Review → Cancelled still applies and carries off_flow:true', async () => {
-    const { deps, moves } = makeDeps({ cfg: FLOW_CFG, details: [diskDetail('7', 'Review')] });
-    const res = await movePost(deps, '7', { state: 'Cancelled', from_state: 'Review' });
-    assert.equal(res.status, 200, 'the operator move is never blocked, even off-flow');
-    const body = JSON.parse(res.body);
-    assert.equal(body.to_state, 'Cancelled');
-    assert.equal(body.off_flow, true); // Cancelled ∉ Review.allowed_transitions
-    assert.equal(moves().length, 1, 'the move was applied despite the off-flow warning');
-});
-test('POST move: a terminal Done issue can be re-opened to an active state (in-flow, nudged)', async () => {
-    // Terminal issues are kept off the board but stay reachable via the detail-page
-    // move control (issue 126). Re-opening Done → Todo applies, moves the RIGHT file
-    // (from-state Done, not mis-routed), and earns approve's immediate-pickup nudge
-    // since Todo is active.
-    const { deps, moves, moveEvents } = makeDeps({ cfg: FLOW_CFG, details: [diskDetail('done-1', 'Done')] });
-    const res = await movePost(deps, 'done-1', { state: 'Todo', from_state: 'Done' });
-    assert.equal(res.status, 200);
-    const body = JSON.parse(res.body);
-    assert.equal(body.to_state, 'Todo');
-    assert.equal(body.from_state, 'Done');
-    assert.equal(body.off_flow, false); // Done's list is open (null) ⇒ in-flow
-    assert.deepEqual(moves()[0], { issueId: 'done-1', toState: 'Todo', fromState: 'Done', actor: 'symphony/operator' });
-    // Active target ⇒ the operator_move carries toActive (the immediate-pickup nudge).
-    assert.deepEqual(moveEvents(), [
-        { kind: 'operator_move', issueId: 'done-1', identifier: 'done-1', toState: 'Todo', toTerminal: false, toActive: true },
-    ]);
-});
-test('POST move: a terminal Cancelled issue pulled back to an active state is off-flow but still applies', async () => {
-    // Cancelled declares [] (a dead-end) ⇒ every move out is off-flow; the operator
-    // is warned client-side but the server never blocks. The active target still
-    // gets the nudge — moving OUT of a terminal state is the reachability the review
-    // flagged was missing.
-    const { deps, moves, moveEvents } = makeDeps({ cfg: FLOW_CFG, details: [diskDetail('cancel-1', 'Cancelled')] });
-    const res = await movePost(deps, 'cancel-1', { state: 'Todo', from_state: 'Cancelled' });
-    assert.equal(res.status, 200, 'the operator move is never blocked, even off-flow');
-    const body = JSON.parse(res.body);
-    assert.equal(body.to_state, 'Todo');
-    assert.equal(body.from_state, 'Cancelled');
-    assert.equal(body.off_flow, true); // Cancelled's list is [] ⇒ off-flow
-    assert.equal(moves().length, 1, 'the move applied despite the off-flow warning');
-    assert.equal(moveEvents()[0].toActive, true, 'an active target gets the nudge (toActive)');
-});
-test('POST move: a claimed from_state that disagrees with the file directory → 409', async () => {
-    const { deps, moves } = makeDeps({ cfg: FLOW_CFG, details: [diskDetail('8', 'Todo')] });
-    const res = await movePost(deps, '8', { state: 'Review', from_state: 'Triage' });
-    assert.equal(res.status, 409);
-    const body = JSON.parse(res.body);
-    assert.equal(body.error.code, 'from_state_mismatch');
-    assert.equal(moves().length, 0, 'no move on a from-state mismatch');
-});
-test('POST move: an issue not present on disk → 404', async () => {
-    const { deps, moves } = makeDeps({ cfg: FLOW_CFG, details: [] });
-    const res = await movePost(deps, '999', { state: 'Todo' });
-    assert.equal(res.status, 404);
-    assert.equal(moves().length, 0);
-});
-// ── operator move folds the cancel/cleanup/release decision into one event ────
-// The handler no longer pokes terminateRunning / cancelRetry inline (issue 199):
-// it dispatches a single operator_move event carrying the toTerminal / toActive
-// flags, and the reducer (tested in tests/core/tick.test.ts) turns those into a
-// worker.cancel effect (with cleanupWorkspace = toTerminal), a retry release, and
-// the active-target poll nudge. These handler tests assert the EVENT is dispatched
-// with the right flags regardless of whether a run / retry actually backs the issue
-// — the live-state decision is the reducer's, not the handler's.
-test('POST move: moving a LIVE issue to a terminal state dispatches operator_move (terminal ⇒ cancel-with-cleanup) (issue 199)', async () => {
-    const live = runningEntry({ issue_id: 'run-1', identifier: 'run-1' });
-    const { deps, moves, moveEvents, refreshes } = makeDeps({
-        cfg: FLOW_CFG,
-        details: [diskDetail('run-1', 'Todo')],
-        running: [live],
-    });
-    const res = await movePost(deps, 'run-1', { state: 'Cancelled', from_state: 'Todo' });
-    assert.equal(res.status, 200);
-    assert.equal(moves().length, 1, 'the file still moves');
-    // toTerminal:true ⇒ the reducer reaps the workspace; toActive:false ⇒ no nudge.
-    assert.deepEqual(moveEvents(), [
-        { kind: 'operator_move', issueId: 'run-1', identifier: 'run-1', toState: 'Cancelled', toTerminal: true, toActive: false },
-    ]);
-    assert.equal(refreshes(), 0, 'a terminal target needs no separate nudge');
-});
-test('POST move: moving a LIVE issue to an active state dispatches operator_move (active ⇒ cancel-without-cleanup + nudge) (issue 199)', async () => {
-    const live = runningEntry({ issue_id: 'run-2', identifier: 'run-2' });
-    const { deps, moveEvents } = makeDeps({
-        cfg: FLOW_CFG,
-        details: [diskDetail('run-2', 'Todo')],
-        running: [live],
-    });
-    const res = await movePost(deps, 'run-2', { state: 'Review', from_state: 'Todo' });
-    assert.equal(res.status, 200);
-    // toTerminal:false ⇒ keep the workspace for the redispatch; toActive:true ⇒ nudge.
-    assert.deepEqual(moveEvents(), [
-        { kind: 'operator_move', issueId: 'run-2', identifier: 'run-2', toState: 'Review', toTerminal: false, toActive: true },
-    ]);
-});
-test('POST move: the operator_move issueId is the canonical front-matter id, not the identifier (issue 199)', async () => {
-    // The reducer matches the live running/retry entry by issue_id, so the handler
-    // resolves the canonical id from the file's front-matter `id` (mirrors idOf),
-    // falling back to the identifier only when absent.
-    const detail = {
-        identifier: 'run-3', state: 'Todo', filePath: '/tracker/Todo/run-3.md',
-        frontMatter: { id: 'uuid-run-3', title: 'live attempt' }, body: '',
-    };
-    const { deps, moveEvents } = makeDeps({ cfg: FLOW_CFG, details: [detail] });
-    const res = await movePost(deps, 'run-3', { state: 'Cancelled', from_state: 'Todo' });
-    assert.equal(res.status, 200);
-    assert.equal(moveEvents()[0].issueId, 'uuid-run-3', 'issueId derives from front-matter id');
-    assert.equal(moveEvents()[0].identifier, 'run-3');
-});
-test('POST move: a settled / holding-target move still dispatches operator_move (no live-state peek) (issue 199)', async () => {
-    // No running/retry fixtures, and Triage is a holding state ⇒ neither flag set.
-    // The handler dispatches unconditionally; the reducer no-ops when nothing live
-    // backs the issue. This documents that the handler does NOT consult live state.
-    const { deps, moves, moveEvents, refreshes } = makeDeps({ cfg: FLOW_CFG, details: [diskDetail('5', 'Todo')] });
-    const res = await movePost(deps, '5', { state: 'Triage', from_state: 'Todo' });
-    assert.equal(res.status, 200);
-    assert.equal(moves().length, 1);
-    assert.deepEqual(moveEvents(), [
-        { kind: 'operator_move', issueId: '5', identifier: '5', toState: 'Triage', toTerminal: false, toActive: false },
-    ]);
-    assert.equal(refreshes(), 0, 'a holding target needs no nudge');
-});
-test('POST move: moving a RETRYING issue dispatches operator_move (reducer releases the pending retry) (issue 199)', async () => {
-    // A retrying row has no live worker; the reducer turns the operator_move into a
-    // retry release (tested in tick.test.ts). The handler dispatches the same event
-    // shape — an active target carries toActive so the freed claim is redispatched now.
-    const retry = retryEntry({ issue_id: 'retry-1', identifier: 'retry-1' });
-    const { deps, moves, moveEvents } = makeDeps({
-        cfg: FLOW_CFG,
-        details: [diskDetail('retry-1', 'Todo')],
-        retrying: [retry],
-    });
-    const res = await movePost(deps, 'retry-1', { state: 'Review', from_state: 'Todo' });
-    assert.equal(res.status, 200);
-    assert.equal(moves().length, 1, 'the file still moves');
-    assert.deepEqual(moveEvents(), [
-        { kind: 'operator_move', issueId: 'retry-1', identifier: 'retry-1', toState: 'Review', toTerminal: false, toActive: true },
-    ]);
-});
-test('POST move: an undeclared target → 400', async () => {
-    const { deps, moves } = makeDeps({ cfg: FLOW_CFG, details: [diskDetail('9', 'Todo')] });
-    const res = await movePost(deps, '9', { state: 'Nowhere', from_state: 'Todo' });
-    assert.equal(res.status, 400);
-    assert.equal(moves().length, 0);
-});
-test('POST move is CSRF-REJECTED for a cross-origin form POST', async () => {
-    const { deps, moves } = makeDeps({ cfg: FLOW_CFG, details: [diskDetail('3', 'Triage')] });
-    const res = await wireHttpHandler(deps)(req({
-        method: 'POST',
-        pathname: '/api/v1/issues/3/move',
-        headers: { 'content-type': 'application/x-www-form-urlencoded', host: 'symphony.local', origin: 'https://evil.example' },
-        rawBody: 'state=Todo',
-    }));
-    assert.equal(res.status, 403);
-    assert.equal(moves().length, 0, 'no move should land on a rejected POST');
-});
-test('the MCP control-plane routes 503 when no runtime is wired (mcp-absent build)', async () => {
-    // makeDeps omits the `mcp` surface (an mcp.enabled=false build), so the routes
-    // fall back to an honest 503. The wired-runtime path is covered in mcp-runtime.test.ts.
-    const { deps } = makeDeps();
-    const handle = wireHttpHandler(deps);
-    const mcp = await handle(req({ method: 'POST', pathname: '/api/v1/issues/3/mcp', rawBody: '{}' }));
-    assert.equal(mcp.status, 503);
-    assert.match(mcp.body, /mcp_not_wired/);
-    const steering = await handle(req({
-        method: 'POST', pathname: '/api/v1/issues/3/steering-reply',
-        headers: { 'content-type': 'application/json' }, rawBody: '{}',
-    }));
-    assert.equal(steering.status, 503);
-});
-test('an unknown path 404s (never routes into product code)', async () => {
-    const { deps } = makeDeps();
-    const handle = wireHttpHandler(deps);
-    const res = await handle(req({ pathname: '/nope' }));
-    assert.equal(res.status, 404);
-});
-// ── a minimal RunningEntry fixture ───────────────────────────────────────────
-function runningEntry(over = {}) {
-    return {
-        issue_id: 'id-7',
-        identifier: '7',
-        issue: {
-            id: 'id-7', identifier: '7', title: 'live attempt', description: 'doing work',
-            priority: null, state: 'Todo', branch_name: null, url: null, labels: [],
-            blocked_by: [], created_at: null, updated_at: null,
-        },
-        session_id: 'sess-1', thread_id: null, turn_id: null, adapter_pid: null,
-        last_event: 'turn_started', last_event_at: '2023-11-14T22:13:15.000Z', last_message: 'working',
-        input_tokens: 100, output_tokens: 50, total_tokens: 150,
-        last_reported_input_tokens: 0, last_reported_output_tokens: 0, last_reported_total_tokens: 0,
-        turn_count: 1, retry_attempt: null, started_at: '2023-11-14T22:13:00.000Z', workspace_path: '/ws/7',
-        cancel: () => undefined, recent_events: [], last_error: null, cleanup_workspace_on_exit: false,
-        mcp_token: null, tracker_root_at_dispatch: '/tracker', github_repo_at_dispatch: null,
-        base_branch_at_dispatch: 'main', resolved_actor: 'claude/default', transitioned: false,
-        steering_requested: false, steering_question: null, steering_context: null,
-        active_tool_calls: new Set(), last_transition: null,
-        ...over,
-    };
-}
-// ── a minimal RetryEntry fixture (a pending backoff/continuation) ─────────────
-function retryEntry(over = {}) {
-    return {
-        issue_id: 'id-retry',
-        identifier: 'retry-0',
-        attempt: 1,
-        due_at_ms: 1_700_000_000_000,
-        timer_handle: null,
-        error: null,
-        kind: 'failure',
-        target_state: 'Todo',
-        ...over,
-    };
-}
-//# sourceMappingURL=http-handler.test.js.map