@north-light/crouter 0.3.170 → 0.3.172

package/dist/commands/workspace.js

@@ -1,165 +0,0 @@
-// workspace.ts — `crtr workspace enter`: the agent-centric editor layout.
-//
-// Turns the current tmux window into an editor view for attached headless nodes:
-// a narrow LEFT rail (the `workspace-sidebar` view — this graph + other live
-// agents in this cwd, with ⚑ inbox flags) beside a CHAT pane (surface attach).
-// Selecting a node in the rail swaps it into the chat pane.
-//
-// Layout build (the only two driver acts, both through placement's seam):
-//   1. splitWindow(here, before+size) → the rail pane, left of here, runs
-//      the workspace-sidebar view host.
-//   2. `crtr surface node focus <node> --pane <here>` → swaps the chat node's attach
-//      viewer into here's slot (here's old content relocates to the backstage).
-// The rail finds the chat pane by DISCOVERY (the `@crtr_node` tag attach sets),
-// so it is robust to that swap — no launch-time pane id is threaded into it.
-//
-// Command shape: under `crtr surface workspace`, this is a BRANCH wrapping one
-// leaf: `enter`.
-import { execFile } from 'node:child_process';
-import { defineBranch, defineLeaf } from '../core/command.js';
-import { InputError } from '../core/io.js';
-import { cliCanvasSource } from './api-client.js';
-// NB: node resolution (getNode/listNodes) now reads via the daemon API
-// (cliCanvasSource). The tmux/editor placement helpers below are pure tmux
-// verbs sourced from the canvas-free placement-tmux seam, so this leaf reaches
-// ZERO canvas.db/canvas.js code.
-import { inTmux, currentTmux, splitWindow, piCommand } from '../core/runtime/placement-tmux.js';
-const RAIL_WIDTH = 32;
-/** Newest LIVE (active|idle) forest root started in `cwd` — the default node the
- *  chat pane attaches to when `--node` is omitted. A root has no parent inside
- *  the cwd-scoped set. Returns null when this cwd has no live root. */
-async function defaultChatNode(cwd) {
-    const rows = (await cliCanvasSource().listNodes({ status: ['active', 'idle'] })).filter((r) => r.cwd === cwd);
-    if (rows.length === 0)
-        return null;
-    const ids = new Set(rows.map((r) => r.node_id));
-    const roots = rows.filter((r) => r.parent === null || !ids.has(r.parent));
-    const pool = roots.length > 0 ? roots : rows;
-    pool.sort((a, b) => (a.created < b.created ? 1 : -1)); // newest first
-    return pool[0].node_id;
-}
-const workspaceEnterLeaf = defineLeaf({
-    name: 'enter',
-    description: 'enter the editor view — a node rail beside a chat pane, in this window',
-    whenToUse: 'you want to work in the agent-centric editor layout: a left rail listing this graph plus the other live agents in this working directory (with ⚑ inbox flags) beside a chat pane attached to a node. Selecting a node in the rail swaps it into the chat pane. Opens in the current tmux window. tmux-only.',
-    help: {
-        name: 'workspace enter',
-        summary: 'split the current window into a left node-rail (the workspace-sidebar view) + a chat pane (surface attach); ↵ in the rail swaps a node into the chat. tmux-only.',
-        params: [
-            {
-                kind: 'flag',
-                name: 'node',
-                type: 'string',
-                required: false,
-                constraint: 'Node to attach in the chat pane. Default: the newest live root in this cwd (rail-only, empty chat, if none).',
-            },
-            {
-                kind: 'flag',
-                name: 'width',
-                type: 'int',
-                required: false,
-                default: RAIL_WIDTH,
-                constraint: `Rail width in columns (default ${RAIL_WIDTH}).`,
-            },
-        ],
-        output: [
-            { name: 'rail', type: 'string', required: false, constraint: 'tmux pane id of the rail.' },
-            { name: 'chat', type: 'string', required: false, constraint: 'node id attached in the chat pane (absent if none).' },
-            { name: 'note', type: 'string', required: false, constraint: 'Set only on the non-TTY/piped path.' },
-        ],
-        outputKind: 'object',
-        effects: [
-            'Splits a narrow LEFT pane in the current window running the workspace-sidebar view.',
-            'Swaps the chosen (or default) node into the current pane as a chat (`crtr surface node focus`), relocating the current pane to the backstage.',
-            'Outside a TTY/tmux: prints a notice and exits 0 (no layout change).',
-        ],
-    },
-    run: async (input) => {
-        const node = input['node'];
-        const width = input['width'] ?? RAIL_WIDTH;
-        if (!process.stdout.isTTY) {
-            return { note: 'surface workspace enter builds a tmux layout — run it in a tmux pane (a TTY), not a pipe.' };
-        }
-        if (!inTmux()) {
-            throw new InputError({
-                error: 'not_in_tmux',
-                message: 'surface workspace is tmux-only — run it inside the crtr tmux session',
-                next: 'Open it from inside tmux.',
-            });
-        }
-        const here = currentTmux();
-        if (here === null) {
-            throw new InputError({
-                error: 'no_tmux_location',
-                message: 'could not resolve the current tmux pane',
-                next: 'Run this inside a tmux pane.',
-            });
-        }
-        // Resolve the chat node (explicit --node, else newest live root here).
-        let chatNode = null;
-        if (node !== undefined && node !== '') {
-            if ((await cliCanvasSource().getNode(node)) === null) {
-                throw new InputError({
-                    error: 'not_found',
-                    message: `no node: ${node}`,
-                    received: node,
-                    next: 'List nodes with `crtr node inspect list`.',
-                });
-            }
-            chatNode = node;
-        }
-        else {
-            chatNode = await defaultChatNode(process.cwd());
-        }
-        // 1. The rail — a narrow split to the LEFT of here. It discovers the chat
-        //    pane itself (the @crtr_node tag), so no pane id is threaded in.
-        const railCmd = piCommand(['surface', 'view', 'run', 'workspace-sidebar', '--target', here.pane], 'crtr');
-        const rail = splitWindow(here.pane, {
-            cwd: process.cwd(),
-            env: {},
-            command: railCmd,
-            before: true,
-            size: Math.max(16, width),
-        });
-        if (rail === null) {
-            throw new InputError({
-                error: 'split_failed',
-                message: 'tmux could not split the rail pane',
-                next: 'Check the tmux server is reachable, then retry.',
-            });
-        }
-        // 2. The chat — swap the node's attach viewer into here's slot. Best-effort:
-        //    the rail is already up, so a focus failure degrades to a rail-only view
-        //    the user can drive (↵ a node) rather than aborting the whole layout.
-        if (chatNode !== null) {
-            await new Promise((resolve) => {
-                execFile('crtr', ['surface', 'node', 'focus', chatNode, '--pane', here.pane], () => resolve());
-            });
-        }
-        return chatNode !== null ? { rail, chat: chatNode } : { rail };
-    },
-    render: (result) => {
-        if (result['note'] !== undefined)
-            return String(result['note']);
-        const chat = result['chat'];
-        return chat !== undefined
-            ? `Workspace ready — rail ${result['rail']}, chat attached to ${chat}.`
-            : `Workspace ready — rail ${result['rail']}. No live agent here yet; press ↵ on a node in the rail to open one.`;
-    },
-});
-export function registerWorkspace() {
-    return defineBranch({
-        name: 'workspace',
-        rootEntry: {
-            concept: 'the agent-centric editor view — a node rail beside a chat pane, in one tmux window',
-            desc: 'enter the editor layout for attached headless nodes',
-            useWhen: 'you want an editor-style workspace in tmux: a left rail of this graph + other live agents in this cwd (with ⚑ inbox flags) next to a chat pane attached to a node, where selecting a node in the rail swaps it into the chat. tmux-only.',
-        },
-        help: {
-            name: 'workspace',
-            summary: 'enter the agent-centric editor view (node rail + chat pane) in the current tmux window',
-            model: 'The branch is a two-pane editor layout: a narrow left rail and a chat pane. The rail shows this graph plus the other live agents in the working directory, and selecting a node swaps it into chat. tmux-only; piped input prints a notice and exits 0.',
-        },
-        children: [workspaceEnterLeaf],
-    });
-}

package/dist/core/__tests__/chat-view-reconnect.test.js

@@ -1,105 +0,0 @@
-import assert from 'node:assert/strict';
-import { test } from 'node:test';
-// @ts-ignore -- chat core is a plain built view module with no generated .d.ts.
-import core from '../../builtin-views/chat/core.mjs';
-import { openLocalStream } from '../view/stream-local.js';
-// Settle a real async open failure: the channel is returned synchronously, then
-// the terminal error/close arrive on later ticks. The no-node existence check now
-// goes through crtrd's API (an async socket round-trip), not a synchronous db
-// read, so we poll to a real settle instead of a single microtask flush.
-const settle = async (pred, timeoutMs = 5000) => {
-    const deadline = Date.now() + timeoutMs;
-    while (!pred() && Date.now() < deadline) {
-        await new Promise((r) => setTimeout(r, 10));
-    }
-};
-test('local invalid/no-node stream failures close asynchronously after the channel returns', async () => {
-    // 'not/valid' fails the synchronous target validation; the second is a valid but
-    // nonexistent id whose existence check resolves through the API. Both must report
-    // a clear terminal error and then close, and neither may fire before the channel
-    // is returned. The exact error KIND for the nonexistent id depends on whether
-    // crtrd answers (no-node on a 404) or is unreachable (broker-unavailable once the
-    // broker socket refuses) — the product contract is only "clear error + prompt
-    // close", so we assert generically on the error/close shape.
-    for (const target of ['not/valid', 'definitely-not-a-real-node-review-5362b32']) {
-        const events = [];
-        const channel = openLocalStream({ kind: 'stream', target, role: 'controller' }, {
-            onFrame() {
-                events.push('frame');
-            },
-            onClose(reason) {
-                events.push(`close:${reason}`);
-            },
-            onError(err) {
-                events.push(`error:${err.kind}`);
-            },
-        });
-        assert.equal(events.length, 0, `${target}: callbacks stay deferred until after openLocalStream returns`);
-        assert.equal(typeof channel.close, 'function', `${target}: channel is returned before failure callbacks fire`);
-        await settle(() => events.length >= 2);
-        assert.ok(events[0]?.startsWith('error:'), `${target}: reports the terminal open failure as an error`);
-        assert.equal(events[1]?.startsWith('close:'), true, `${target}: follows with streamClose`);
-    }
-});
-test('reconnect keeps the requested role while welcome and read_only remain authoritative', () => {
-    let current = core.init({ target: 'n1', role: 'controller' });
-    const sent = [];
-    const requestedRoles = [];
-    const closed = [];
-    const channels = [
-        { id: 'first-channel', send(frame) { sent.push(frame); }, close() { closed.push('first-channel'); } },
-        { id: 'replacement-channel', send(frame) { sent.push(frame); }, close() { closed.push('replacement-channel'); } },
-    ];
-    let nextChannel = 0;
-    const ctx = {
-        get state() {
-            return current;
-        },
-        set(next) {
-            current = typeof next === 'function' ? next(current) : next;
-        },
-        connect(_stream, opts) {
-            requestedRoles.push(opts.role);
-            return channels[nextChannel++];
-        },
-        dispatch(intent) {
-            return core.intents[intent](ctx);
-        },
-        signal: {
-            clearBanner() { },
-            setBanner() { },
-            setStatus() { },
-            setSubtitle() { },
-            setMode() { },
-            quit() { },
-        },
-    };
-    core.intents.refresh(ctx);
-    const firstChannel = current.channel;
-    assert.equal(current.desiredRole, 'controller');
-    assert.equal(current.conn, 'connecting');
-    assert.deepEqual(requestedRoles, ['controller']);
-    core.intents.streamOpen(ctx, firstChannel);
-    core.intents.streamFrame(ctx, { type: 'welcome', role: 'controller', snapshot: { state: {}, messages: [] } });
-    assert.equal(current.role, 'controller');
-    assert.equal(current.conn, 'open');
-    core.intents.reconnect(ctx);
-    assert.deepEqual(closed, ['first-channel']);
-    assert.equal(current.desiredRole, 'controller');
-    assert.equal(current.channel?.id, 'replacement-channel');
-    assert.deepEqual(requestedRoles, ['controller', 'controller']);
-    const replacementChannel = current.channel;
-    core.intents.streamOpen(ctx, replacementChannel);
-    core.intents.streamFrame(ctx, { type: 'welcome', role: 'observer', snapshot: { state: {}, messages: [] } });
-    assert.equal(current.role, 'observer', 'welcome.role is authoritative for the active connection');
-    assert.equal(current.desiredRole, 'controller', 'the requested controller role survives reconnect');
-    assert.equal(current.conn, 'open');
-    core.intents.streamClose(ctx, { channelId: 'first-channel', reason: 'closed' });
-    assert.equal(current.channel, replacementChannel, 'a stale close cannot clear the replacement channel');
-    assert.equal(current.conn, 'open');
-    core.intents.streamFrame(ctx, { type: 'error', code: 'read_only' });
-    core.intents.setDraft(ctx, 'hello');
-    core.intents.submitDraft(ctx);
-    assert.deepEqual(sent, [], 'read-only welcome state prevents writes');
-    assert.match(current.notices.at(-1).text, /read-only — sending is disabled/);
-});

package/dist/core/__tests__/full/consult-startup-failure.test.js

@@ -1,124 +0,0 @@
-// Run with: node --import tsx/esm --test src/core/__tests__/full/consult-startup-failure.test.ts
-//
-// Regression: an exact-model consultation can reject inside runBroker before
-// session_start. Its durable private-fork claim remains active for lifecycle
-// recovery; the daemon sees the fatal model fault, terminalizes the node, and
-// reconciles the armed receipt so the request receives an error.
-import { after, before, test } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, mkdirSync, realpathSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { readFollowUp, registerInboxRoot, requestFollowUp } from '@crouton-kit/humanloop';
-import { closeDb } from '../../canvas/db.js';
-import { armFollowUpWork, getFollowUpWorkRow } from '../../canvas/human-work-outbox.js';
-import { buildLaunchSpec } from '../../runtime/launch.js';
-import { spawnNode } from '../../runtime/nodes.js';
-import { readFault } from '../../runtime/fault.js';
-import { isPidAlive, runStartupRecoverySweep } from '../../../daemon/crtrd.js';
-import { MAX_RESPAWN_ATTEMPTS } from '../../../daemon/fleet.js';
-import { createHarness } from '../helpers/harness.js';
-let h;
-let stateHome;
-let priorStateHome;
-before(async () => {
-    priorStateHome = process.env['XDG_STATE_HOME'];
-    stateHome = mkdtempSync(join(tmpdir(), 'crtr-consult-fatal-state-'));
-    process.env['XDG_STATE_HOME'] = stateHome;
-    h = await createHarness({ headless: true, sessionPrefix: 'crtr-consult-fatal' });
-});
-after(async () => {
-    if (h !== undefined)
-        await h.dispose();
-    rmSync(stateHome, { recursive: true, force: true });
-    if (priorStateHome === undefined)
-        delete process.env['XDG_STATE_HOME'];
-    else
-        process.env['XDG_STATE_HOME'] = priorStateHome;
-});
-test('pre-session exact-consult failure is terminalized and delivered by daemon supervision', async () => {
-    const bridgeId = h.spawnRoot('consult bridge');
-    const interactionRoot = realpathSync(mkdtempSync(join(tmpdir(), 'crtr-consult-fatal-root-')));
-    const ticketDir = join(interactionRoot, 'ticket-1');
-    mkdirSync(ticketDir);
-    // humanloop recognizes registered direct children as tickets only once a
-    // request descriptor exists; its contents are immaterial to this follow-up.
-    writeFileSync(join(ticketDir, 'deck.json'), '{}\n');
-    const benignHandler = { command: process.execPath, args: ['-e', ''] };
-    const registeredRoot = registerInboxRoot({
-        root: interactionRoot,
-        owner: 'crouter',
-        handler: benignHandler,
-        followUpHandler: benignHandler,
-    }).root;
-    const request = requestFollowUp(registeredRoot, ticketDir, { question: 'What should change?' });
-    const branchFile = join(ticketDir, 'branch-point.jsonl');
-    writeFileSync(branchFile, `${JSON.stringify({ type: 'session', id: 'source-session' })}\n`);
-    // The fake registry observes this sentinel live. Exact mode therefore rejects
-    // this captured model during launch rather than substituting or booting
-    // model-less — the production failure that originally stranded the request.
-    writeFileSync(join(h.home, 'fake-pi.no-auth'), '1');
-    const forkId = 'private-fatal-consult';
-    const exactModel = 'openai-codex/unavailable:xhigh';
-    const { launch } = buildLaunchSpec('general', 'base', {
-        lifecycle: 'terminal',
-        hasManager: false,
-        model: exactModel,
-        modelExact: true,
-        cwd: process.cwd(),
-        profileId: null,
-    });
-    armFollowUpWork({ nodeId: forkId, root: registeredRoot, dir: ticketDir, requestId: request.requestId });
-    spawnNode({
-        nodeId: forkId,
-        kind: 'general',
-        mode: 'base',
-        lifecycle: 'terminal',
-        cwd: process.cwd(),
-        parent: null,
-        spawnedBy: bridgeId,
-        forkFrom: branchFile,
-        modelOverride: exactModel,
-        humanWorkTarget: { work_kind: 'follow_up', root: registeredRoot, dir: ticketDir, request_id: request.requestId },
-        privateForkPhase: 'fork_pending',
-        privateForkRecipe: { kickoff: request.question },
-        launch,
-    });
-    assert.equal(h.node(forkId)?.pi_pid ?? null, null, 'the persisted claim starts with no broker');
-    // This row models a fork_pending claim left by the prior daemon epoch. The
-    // explicit startup sweep — not a recurring liveness tick — classifies row 7
-    // and launches its bounded fresh retry through the harness-owned fleet.
-    await runStartupRecoverySweep(h.fleet);
-    await h.waitFor(() => h.node(forkId)?.pi_pid !== null, { label: 'startup sweep launched the durable pending claim' });
-    await h.waitFor(() => readFault(forkId)?.kind === 'model-not-found', { label: 'fatal exact-model fault recorded' });
-    // A broker writes the launch fault immediately before it exits. Its real
-    // ChildProcess exit removes the fleet entry and enqueues a policy job.
-    await h.waitFor(() => {
-        const pid = h.node(forkId)?.pi_pid;
-        return pid !== null && pid !== undefined && !isPidAlive(pid) ? true : null;
-    }, { label: 'fatal consult broker exited after recording its launch fault' });
-    await h.waitFor(() => !h.fleet.has(forkId) ? true : null, { label: 'fatal consult exit left the live fleet' });
-    await h.drainFleet();
-    // Design flow B row 7: a fork_pending death is a bounded fresh retry of the
-    // immutable fork birth — throttled, NOT an immediate boot failure. Every
-    // further short-lived exit increments the same counter, and at
-    // MAX_RESPAWN_ATTEMPTS the respawn loop terminalizes: transition('crash') +
-    // receipt reconcile + surfaceBootFailure + doctrine wake. The real exit above
-    // counted one failure; deliver the remaining short exits synthetically
-    // through the sanctioned seam (§H mode b) so the cap is reached without
-    // minutes of real backoff — each delivery cancels the pending backoff timer,
-    // so no intermediate respawn ever launches.
-    for (let i = 1; i < MAX_RESPAWN_ATTEMPTS; i++) {
-        await h.deliverExit(forkId, { code: 1, signal: null });
-    }
-    await h.waitFor(() => {
-        closeDb();
-        return getFollowUpWorkRow(forkId)?.status === 'errored';
-    }, { timeoutMs: 5_000, label: 'fatal consult receipt settled at throttle exhaustion' });
-    assert.equal(h.status(forkId), 'dead', 'the failed consult fork is terminalized after the fatal launch fault');
-    const followUp = readFollowUp(ticketDir);
-    assert.equal(followUp.request?.state, 'terminal', 'the humanloop request is no longer running');
-    assert.equal(followUp.result?.requestId, request.requestId);
-    assert.equal(followUp.result?.status, 'error');
-    rmSync(interactionRoot, { recursive: true, force: true });
-});

package/dist/core/canvas/__tests__/human-work-outbox.test.js

@@ -1,123 +0,0 @@
-// human-work-outbox.test.ts — permanent storage compatibility invariants:
-// legacy follow-up receipts remain retryable and prune-safe, while Visual work
-// is uniquely bound and invisible to old follow-up selectors.
-import { test, before, beforeEach, after } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, rmSync, mkdirSync, existsSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { DatabaseSync } from 'node:sqlite';
-import { createNode, getRow, pruneNodes } from '../canvas.js';
-import { closeDb, MIGRATIONS, migrate, openDb } from '../db.js';
-import { nodeDir } from '../paths.js';
-import { pushFinal } from '../../feed/feed.js';
-import { claimVisualWork, getFollowUpWorkRow, getVisualWorkByRequest, listPendingFollowUpWork, reconcileFollowUpWork, reconcileVisualWork, } from '../human-work-outbox.js';
-let home;
-const DAY = 86_400_000;
-const old = () => new Date(Date.now() - 30 * DAY).toISOString();
-const now = () => new Date().toISOString();
-function node(id, over = {}) {
-    return {
-        node_id: id,
-        name: id,
-        created: now(),
-        cwd: '/tmp/work',
-        kind: 'general',
-        mode: 'base',
-        lifecycle: 'terminal',
-        status: 'active',
-        ...over,
-    };
-}
-function insertLegacyFollowUp(nodeId, dir, root, requestId) {
-    openDb()
-        .prepare('INSERT INTO consult_outbox (node_id, dir, root, request_id, status, final_report, updated_at) VALUES (?, ?, ?, ?, ?, NULL, ?)')
-        .run(nodeId, dir, root, requestId, 'armed', now());
-}
-before(() => {
-    home = mkdtempSync(join(tmpdir(), 'crtr-human-work-outbox-'));
-    process.env['CRTR_HOME'] = home;
-});
-beforeEach(() => {
-    closeDb();
-    rmSync(home, { recursive: true, force: true });
-});
-after(() => {
-    closeDb();
-    rmSync(home, { recursive: true, force: true });
-    delete process.env['CRTR_HOME'];
-});
-test('a v18 follow-up row upgrades with its follow_up default', () => {
-    mkdirSync(home, { recursive: true });
-    const db = new DatabaseSync(join(home, 'v18-canvas.db'));
-    try {
-        for (const migration of MIGRATIONS.slice(0, 18))
-            migration(db);
-        db.exec('PRAGMA user_version = 18');
-        db.prepare("INSERT INTO consult_outbox (node_id, dir, root, request_id, status, updated_at) VALUES ('legacy-node', '/ticket', '/root', 'legacy-request', 'armed', '2026-01-01T00:00:00.000Z')").run();
-        migrate(db);
-        const row = db.prepare("SELECT work_kind, status FROM consult_outbox WHERE node_id = 'legacy-node'").get();
-        assert.equal(row.work_kind, 'follow_up');
-        assert.equal(row.status, 'armed');
-    }
-    finally {
-        db.close();
-    }
-});
-test('legacy follow-up insert, feed promotion, and reconciliation retain their receipt behavior', async () => {
-    const root = join(home, 'unregistered-root');
-    const dir = join(root, 'ticket-1');
-    mkdirSync(dir, { recursive: true });
-    createNode(node('fork-1', { status: 'dead' }));
-    insertLegacyFollowUp('fork-1', dir, root, 'req-1');
-    reconcileFollowUpWork();
-    const retryable = getFollowUpWorkRow('fork-1');
-    assert.ok(retryable !== null);
-    assert.equal(retryable.status, 'armed', 'a rejected follow-up publish stays retryable');
-    createNode(node('fork-2', { created: old() }));
-    insertLegacyFollowUp('fork-2', dir, root, 'req-2');
-    await pushFinal('fork-2', 'follow-up result');
-    assert.equal(getFollowUpWorkRow('fork-2')?.status, 'pending');
-    assert.deepEqual(listPendingFollowUpWork().map((row) => row.node_id), ['fork-2']);
-    const result = pruneNodes({ ttlDays: 14 });
-    assert.deepEqual(result.pruned, [], 'a legacy pending receipt preserves its node and report payload');
-    assert.ok(getRow('fork-2') !== null);
-    assert.ok(existsSync(nodeDir('fork-2')));
-});
-test('Visual claims are unique and legacy armed/pending selectors are blind to them', () => {
-    const root = join(home, 'root');
-    const dir = join(root, 'ticket-visual');
-    mkdirSync(dir, { recursive: true });
-    insertLegacyFollowUp('follow-up-1', dir, root, 'follow-up-request');
-    const binding = {
-        nodeId: 'visual-1',
-        dir,
-        root,
-        requestId: 'visual-request',
-        interactionId: 'interaction-1',
-        generationId: 'generation-1',
-        interactionSnapshot: '{"id":"interaction-1","body":"Visualize this"}',
-        handlerCommand: '/absolute/crtr',
-        handlerArgs: ['human', '_visual'],
-        claimToken: 'claim-token',
-    };
-    assert.equal(claimVisualWork(binding).created, true);
-    assert.equal(claimVisualWork({ ...binding, nodeId: 'unused-duplicate-node' }).created, false);
-    assert.throws(() => claimVisualWork({ ...binding, nodeId: 'conflicting-node', generationId: 'generation-2' }), /conflicting Visual work claim/);
-    assert.throws(() => openDb()
-        .prepare("INSERT INTO consult_outbox (node_id, dir, root, request_id, work_kind, status, updated_at) VALUES (?, ?, ?, ?, 'visual', 'visual_armed', ?)")
-        .run('duplicate-visual-node', dir, root, binding.requestId, now()), /UNIQUE constraint failed/);
-    assert.equal(getVisualWorkByRequest(dir, binding.requestId)?.status, 'visual_armed');
-    createNode(node('visual-1', {
-        status: 'canceled',
-        human_work_target: { work_kind: 'visual', dir, request_id: binding.requestId, root },
-        private_fork_phase: 'fork_pending',
-    }));
-    reconcileVisualWork();
-    assert.equal(getVisualWorkByRequest(dir, binding.requestId)?.status, 'visual_armed', 'the deliberate inert pre-launch fork remains launchable');
-    const legacy = openDb()
-        .prepare("SELECT node_id FROM consult_outbox WHERE status IN ('armed', 'pending') ORDER BY node_id")
-        .all();
-    assert.deepEqual(legacy.map((row) => row.node_id), ['follow-up-1']);
-    assert.deepEqual(listPendingFollowUpWork(), []);
-});

package/dist/core/canvas/human-work-outbox.d.ts

@@ -1,73 +0,0 @@
-export type HumanWorkKind = 'follow_up' | 'visual';
-export type FollowUpWorkStatus = 'armed' | 'pending' | 'acked' | 'errored' | 'canceled';
-export type VisualWorkStatus = 'visual_armed' | 'visual_pending' | 'visual_retired';
-export type HumanWorkStatus = FollowUpWorkStatus | VisualWorkStatus;
-export interface HumanWorkRow {
-    node_id: string;
-    dir: string;
-    root: string;
-    request_id: string;
-    work_kind: HumanWorkKind;
-    status: HumanWorkStatus;
-    final_report: string | null;
-    interaction_id: string | null;
-    generation_id: string | null;
-    interaction_snapshot: string | null;
-    handler_command: string | null;
-    handler_args_json: string | null;
-    claim_token: string | null;
-    updated_at: string;
-}
-export interface VisualWorkBinding {
-    nodeId: string;
-    dir: string;
-    root: string;
-    requestId: string;
-    interactionId: string;
-    generationId: string;
-    interactionSnapshot: string;
-    handlerCommand: string;
-    handlerArgs: readonly string[];
-    claimToken: string;
-}
-export interface VisualWorkClaim {
-    row: HumanWorkRow;
-    created: boolean;
-}
-/** Insert a follow-up receipt before its fork launches. `work_kind` is explicit
- * even though the migration default preserves old inserts, so new code never
- * depends on a compatibility default. */
-export declare function armFollowUpWork(opts: {
-    nodeId: string;
-    dir: string;
-    root: string;
-    requestId: string;
-}): void;
-/** Promote only follow-up work inside the canonical-final transaction. */
-export declare function promoteFollowUpWork(nodeId: string, finalReportBasename: string): boolean;
-export declare function ackFollowUpWork(nodeId: string): void;
-export declare function errorFollowUpWork(nodeId: string): void;
-export declare function cancelFollowUpWork(nodeId: string): void;
-/** Create or return the one immutable Visual claim for a request. A conflicting
- * duplicate fails closed; a byte-identical duplicate reuses its original row. */
-export declare function claimVisualWork(binding: VisualWorkBinding): VisualWorkClaim;
-/** The future Visual finalizer may promote only its exact armed claim. */
-export declare function promoteVisualWork(nodeId: string, finalReportBasename: string): boolean;
-/** Retire only an exact Visual request binding; cancellation never creates work. */
-export declare function retireVisualWork(dir: string, requestId: string): boolean;
-export declare function getHumanWorkRow(nodeId: string): HumanWorkRow | null;
-export declare function getFollowUpWorkRow(nodeId: string): HumanWorkRow | null;
-export declare function listActiveVisualWorkByDir(dir: string): HumanWorkRow[];
-export declare function getVisualWorkByRequest(dir: string, requestId: string): HumanWorkRow | null;
-export declare function listPendingFollowUpWork(): HumanWorkRow[];
-export declare function listArmedFollowUpWork(): HumanWorkRow[];
-export declare function getActiveFollowUpWorkByRequest(dir: string, requestId: string): HumanWorkRow | null;
-export declare function listActiveFollowUpWorkByDir(dir: string): HumanWorkRow[];
-/** Deliver one pending follow-up receipt. */
-export declare function dispatchFollowUpWork(nodeId: string): void;
-/** Dispatch a checked canonical final as the single correlated Visual result. */
-export declare function dispatchVisualWork(nodeId: string): void;
-/** Reconcile this durable lane after a dead private child or interrupted dispatch. */
-export declare function reconcileVisualWork(): void;
-/** Reconcile only follow-up work. */
-export declare function reconcileFollowUpWork(): void;