@north-light/crouter 0.3.318 → 0.3.320

package/dist/pi-extensions/__tests__/canvas-stophook-agentend.test.js

@@ -1,432 +0,0 @@
-// Run with: node --import tsx/esm --test src/pi-extensions/__tests__/canvas-stophook-agentend.test.ts
-//
-// The stophook stages agent_end and routes only after Pi emits agent_settled. A
-// node reaches its subscribers ONLY through its own explicit `crtr push` calls.
-// These tests pin settlement routing on the three stop outcomes:
-//   • natural stop while awaiting a live worker → idle-release, NO push
-//   • refresh-yield (intent='refresh')          → re-exec/shutdown, NO push
-//   • stalled leaf (nothing live, no final)      → reprompt still fires
-// Every assertion is on DB / disk effects (report files, inbox pointers) plus
-// the captured sendUserMessage — tmux is unavailable here, so the focus/respawn
-// helpers no-op (TMUX_PANE is cleared) and we drive a clean shutdown path.
-import { test, before, after, beforeEach, afterEach } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, rmSync, existsSync, readdirSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import registerCanvasStophook from '../canvas-stophook.js';
-import { createNode, subscribe, getNode, setStatus } from '../../core/canvas/canvas.js';
-import { openFocusRow, getFocusByNode, getFocusById, listFocuses } from '../../core/canvas/focuses.js';
-import { closeDb, migrate, openDb } from '../../core/canvas/db.js';
-import { apiSocketPath } from '../../core/canvas/paths.js';
-import { createApiServer } from '../../daemon/api/server.js';
-import { CrtrClient } from '../../api/client.js';
-import { reportsDir } from '../../core/canvas/paths.js';
-import { enqueueNodeMail } from '../../core/feed/messages.js';
-import { hasUnseenWakeMail } from '../../core/canvas/deliveries.js';
-import { STALL_REPROMPT } from '../../core/runtime/stop-guard.js';
-import { markStopSignal } from '../../core/runtime/stop-signals.js';
-import { readFault, readLiveTurn, recordFault } from '../../core/canvas/recovery.js';
-import { beginExecution } from '../../core/canvas/executions.js';
-let home;
-let server;
-let origNode;
-let origExecution;
-let origPane;
-function activateBroker(nodeId) {
-    process.env['CRTR_NODE_ID'] = nodeId;
-    process.env['CRTR_EXECUTION_ID'] = beginExecution(nodeId, { daemonEpoch: null });
-}
-function node(id, over = {}) {
-    return {
-        node_id: id,
-        name: id,
-        created: new Date().toISOString(),
-        cwd: '/tmp/work',
-        kind: 'general',
-        mode: 'base',
-        lifecycle: 'terminal',
-        status: 'active',
-        ...over,
-    };
-}
-function makeFakePi() {
-    const handlers = {};
-    return {
-        injected: [],
-        on(e, h) { handlers[e] = h; },
-        sendUserMessage(content, options) { this.injected.push({ content, deliverAs: options?.deliverAs }); },
-        async fire(e, ev, ctx) { await handlers[e]?.(ev, ctx); },
-    };
-}
-async function settle(pi, event, ctx) {
-    const nodeId = process.env['CRTR_NODE_ID'];
-    if (nodeId !== undefined && process.env['CRTR_EXECUTION_ID'] === undefined && getNode(nodeId) !== null)
-        activateBroker(nodeId);
-    await pi.fire('agent_end', event, ctx);
-    await pi.fire('agent_settled', { type: 'agent_settled' }, ctx);
-}
-/** A natural-stop agent_end event carrying one assistant text block. */
-function stopEvent(text) {
-    return { messages: [{ role: 'assistant', stopReason: 'stop', content: [{ type: 'text', text }] }] };
-}
-/** Count of report files written under a node's reports/ dir (0 when none). */
-function reportCount(id) {
-    const dir = reportsDir(id);
-    return existsSync(dir) ? readdirSync(dir).filter((f) => f.endsWith('.md')).length : 0;
-}
-before(() => {
-    origNode = process.env['CRTR_NODE_ID'];
-    origExecution = process.env['CRTR_EXECUTION_ID'];
-    origPane = process.env['TMUX_PANE'];
-});
-async function waitForSocket() {
-    const probe = CrtrClient.forLocalSocket({ autostart: false });
-    for (let i = 0; i < 200; i++) {
-        if (existsSync(apiSocketPath())) {
-            try {
-                await probe.healthz();
-                return;
-            }
-            catch {
-                // The socket path appears before the in-process server accepts requests.
-            }
-        }
-        await new Promise((resolve) => setTimeout(resolve, 5));
-    }
-    throw new Error(`api socket never answered at ${apiSocketPath()}`);
-}
-beforeEach(async () => {
-    closeDb();
-    if (home)
-        rmSync(home, { recursive: true, force: true });
-    home = mkdtempSync(join(tmpdir(), 'crtr-stophook-end-'));
-    process.env['CRTR_HOME'] = home;
-    migrate(openDb());
-    server = createApiServer();
-    await waitForSocket();
-    // Force the clean-shutdown path (no in-place respawn) so the refresh test is
-    // deterministic even when the suite runs inside a tmux pane.
-    delete process.env['TMUX_PANE'];
-    delete process.env['CRTR_EXECUTION_ID'];
-});
-afterEach(async () => {
-    await server?.close();
-    server = undefined;
-    closeDb();
-});
-after(() => {
-    closeDb();
-    if (home)
-        rmSync(home, { recursive: true, force: true });
-    delete process.env['CRTR_HOME'];
-    if (origNode === undefined)
-        delete process.env['CRTR_NODE_ID'];
-    else
-        process.env['CRTR_NODE_ID'] = origNode;
-    if (origExecution === undefined)
-        delete process.env['CRTR_EXECUTION_ID'];
-    else
-        process.env['CRTR_EXECUTION_ID'] = origExecution;
-    if (origPane === undefined)
-        delete process.env['TMUX_PANE'];
-    else
-        process.env['TMUX_PANE'] = origPane;
-});
-test('natural stop commits idle-release only at agent_settled', { timeout: 1_000 }, async () => {
-    createNode(node('root', { parent: null, lifecycle: 'resident' }));
-    createNode(node('mgr', { parent: 'root', lifecycle: 'terminal', mode: 'orchestrator' }));
-    createNode(node('worker', { parent: 'mgr', lifecycle: 'terminal', status: 'active' }));
-    subscribe('root', 'mgr', true); // root would receive any push mgr emits
-    subscribe('mgr', 'worker', true); // mgr holds an active live subscription → "awaiting"
-    activateBroker('mgr');
-    const pi = makeFakePi();
-    registerCanvasStophook(pi);
-    let shutdown = false;
-    const ctx = { shutdown: () => { shutdown = true; } };
-    await pi.fire('agent_start', { type: 'agent_start' }, ctx);
-    await pi.fire('agent_end', stopEvent('still waiting on the worker'), ctx);
-    assert.equal(getNode('mgr')?.status, 'active', 'agent_end is staging-only');
-    assert.equal(readLiveTurn('mgr')?.busy, true, 'agent_end cannot close the active turn');
-    assert.equal(shutdown, false, 'agent_end cannot route a natural stop');
-    await pi.fire('agent_settled', { type: 'agent_settled' }, ctx);
-    const m = getNode('mgr');
-    assert.equal(readLiveTurn('mgr')?.busy, false, 'agent_settled closes the active turn');
-    assert.equal(m?.intent, 'idle-release', 'mgr idle-released');
-    assert.equal(m?.status, 'idle', 'mgr marked idle');
-    assert.equal(shutdown, true, 'pi shut down');
-    assert.equal(reportCount('mgr'), 0, 'NO report file written');
-    assert.equal(hasUnseenWakeMail('root'), false, 'NO SQL inbox delivery fanned to subscriber');
-    assert.equal(pi.injected.length, 0, 'no reprompt on a legitimate idle-release');
-    // §5.1 case 6 (awaiting + UNFOCUSED → idle-release, no focus): the awaiting
-    // branch must never create/touch a focus row. Non-vacuous: an impl that ran
-    // the done-branch handoff/openFocus on an idle-release would leave a row here.
-    assert.equal(listFocuses().length, 0, 'awaiting+unfocused leaves the focuses table empty');
-});
-test('gh-451: idle-release does NOT release while a non-deferred SQL delivery is pending', { timeout: 1_000 }, async () => {
-    // Reproduces the #451 race: a subscriber's push landed in mgr's inbox but the
-    // in-process watcher has not yet claimed and acknowledged its SQL delivery.
-    // If this settle released anyway, the daemon would immediately re-wake mgr on
-    // the delivery the watcher was mid-handoff on.
-    createNode(node('root', { parent: null, lifecycle: 'resident' }));
-    createNode(node('mgr', { parent: 'root', lifecycle: 'terminal', mode: 'orchestrator' }));
-    createNode(node('worker', { parent: 'mgr', lifecycle: 'terminal', status: 'active' }));
-    subscribe('root', 'mgr', true);
-    subscribe('mgr', 'worker', true); // mgr awaits a live worker → would idle-release once caught up
-    // A push landed in mgr's SQL inbox delivery set, before the watcher claims it.
-    enqueueNodeMail('mgr', { senderNodeId: 'worker', kind: 'update', label: 'worker made progress', urgency: 'normal', wake: 1 });
-    process.env['CRTR_NODE_ID'] = 'mgr';
-    const pi = makeFakePi();
-    registerCanvasStophook(pi);
-    let shutdown = false;
-    const ctx = { shutdown: () => { shutdown = true; } };
-    await settle(pi, stopEvent('still waiting on the worker'), ctx);
-    assert.equal(getNode('mgr')?.status, 'active', 'mgr stays active — NOT idle-released while a delivery is pending');
-    assert.equal(getNode('mgr')?.intent ?? null, null, 'no idle-release intent while a non-deferred entry is unseen');
-    assert.equal(shutdown, false, 'pi stays alive so the in-process watcher can still deliver/commit');
-});
-test('gh-451: finished does NOT shut down while a non-deferred SQL delivery is pending', { timeout: 1_000 }, async () => {
-    // A canonical final can settle while the in-process watcher has a child
-    // report delivery pending. The finished branch must keep this broker alive
-    // for that delivery.
-    createNode(node('mgr', { parent: null, lifecycle: 'terminal', final_report: 'mgr-final.md' }));
-    enqueueNodeMail('mgr', { senderNodeId: 'worker', kind: 'update', label: 'worker made progress', urgency: 'normal', wake: 1 });
-    process.env['CRTR_NODE_ID'] = 'mgr';
-    const pi = makeFakePi();
-    registerCanvasStophook(pi);
-    let shutdown = false;
-    const ctx = { shutdown: () => { shutdown = true; } };
-    await settle(pi, stopEvent('already finalized'), ctx);
-    assert.equal(getNode('mgr')?.status, 'active', 'mgr stays active while the watcher catches up');
-    assert.equal(getNode('mgr')?.intent ?? null, null, 'no idle-release intent while a non-deferred entry is unseen');
-    assert.equal(shutdown, false, 'pi stays alive so the in-process watcher can still deliver/commit');
-});
-test('a deferred send to a TERMINAL node was raised on append, so it holds the settle instead of riding a later cycle', { timeout: 1_000 }, async () => {
-    createNode(node('root', { parent: null, lifecycle: 'resident' }));
-    createNode(node('mgr', { parent: 'root', lifecycle: 'terminal', mode: 'orchestrator' }));
-    createNode(node('worker', { parent: 'mgr', lifecycle: 'terminal', status: 'active' }));
-    subscribe('root', 'mgr', true);
-    subscribe('mgr', 'worker', true);
-    enqueueNodeMail('mgr', { kind: 'message', label: 'a scheduled deferred note', urgency: 'deferred', wake: 1 });
-    process.env['CRTR_NODE_ID'] = 'mgr';
-    const pi = makeFakePi();
-    registerCanvasStophook(pi);
-    let shutdown = false;
-    const ctx = { shutdown: () => { shutdown = true; } };
-    await settle(pi, stopEvent('still waiting on the worker'), ctx);
-    assert.equal(getNode('mgr')?.intent ?? null, null, 'a terminal node takes no reliable later cycle, so its raised entry blocks the release');
-    assert.equal(getNode('mgr')?.status, 'active', 'mgr stays active for the entry the watcher still owes it');
-    assert.equal(shutdown, false, 'pi stays alive so the in-process watcher can deliver it');
-});
-test('queued continuation finishes before natural-stop routing commits', { timeout: 1_000 }, async () => {
-    createNode(node('leaf', { parent: null, lifecycle: 'terminal' }));
-    process.env['CRTR_NODE_ID'] = 'leaf';
-    activateBroker('leaf');
-    const pi = makeFakePi();
-    registerCanvasStophook(pi);
-    let shutdown = false;
-    const ctx = { shutdown: () => { shutdown = true; } };
-    await pi.fire('agent_start', { type: 'agent_start' }, ctx);
-    await pi.fire('agent_end', stopEvent('first attempt ended while a continuation was queued'), ctx);
-    assert.equal(shutdown, false, 'the intermediate agent_end cannot route a natural stop');
-    assert.equal(getNode('leaf')?.status, 'active');
-    setStatus('leaf', 'done');
-    await pi.fire('agent_start', { type: 'agent_start' }, ctx);
-    await pi.fire('agent_end', stopEvent('queued continuation completed the assignment'), ctx);
-    await pi.fire('agent_settled', { type: 'agent_settled' }, ctx);
-    assert.equal(shutdown, true, 'settlement routes from the completed continuation');
-    assert.equal(getNode('leaf')?.intent ?? null, null, 'the intermediate natural stop never idle-released the node');
-});
-// §5.1 — the §1.7 settlement branch map on the focuses table. Every assertion is
-// on the canvas focuses/runtime rows after firing agent_settled (TMUX_PANE is
-// cleared in beforeEach). NOTE (broker-host cut): the placement read `focusOf`
-// used by the handler now GC-prunes a viewer row whose pane is not a LIVE tmux
-// pane (liveOrPrune → paneExists), so a fabricated '%pane' id is pruned on the
-// first read. To drive the handler's focus path deterministically in the
-// tmux-free ordinary suite we register viewer rows with a NULL pane (a registered-
-// but-not-yet-realized viewer, which liveOrPrune passes through). status='done'
-// is reached by setting the runtime row directly (the branch reads
-// getNode(nodeId).status).
-test('§5.1.2 truly-done + focused → focus row CLOSED, own presence nulled (Q1)', async () => {
-    // R carries a LOCATION so the close-path presence-null is observable.
-    createNode(node('R', { parent: null, lifecycle: 'terminal', pane: '%r', tmux_session: 'Suser', window: '@wr' }));
-    openFocusRow('fR', '%r', 'Suser', 'R');
-    process.env['CRTR_NODE_ID'] = 'R';
-    setStatus('R', 'done');
-    const pi = makeFakePi();
-    registerCanvasStophook(pi);
-    await settle(pi, stopEvent('root done'), { shutdown: () => { } });
-    // The done branch closes the viewer row: closeFocusRow(fR) +
-    // setRemainOnExit(%r's window, false) (return-to-shell) + null R's presence.
-    // Non-vacuous: an impl that leaves the row open keeps it present; one that
-    // skips the presence-null leaves getNode('R').pane === '%r'.
-    assert.equal(getFocusById('fR'), null, 'a finished node\'s focus row is closed');
-    assert.equal(listFocuses().length, 0, 'no focus rows survive');
-    assert.equal(getNode('R')?.pane ?? null, null, 'the finished root\'s own LOCATION pane is nulled (close path reaps)');
-});
-test('§5.1.4 truly-done + UNFOCUSED → no focus row created/touched, shuts down (Invariant P)', async () => {
-    createNode(node('mgr', { parent: null, lifecycle: 'terminal', mode: 'orchestrator' }));
-    createNode(node('M', { parent: 'mgr', lifecycle: 'terminal' }));
-    subscribe('mgr', 'M', true);
-    process.env['CRTR_NODE_ID'] = 'M';
-    setStatus('M', 'done');
-    const pi = makeFakePi();
-    registerCanvasStophook(pi);
-    let shutdown = false;
-    await settle(pi, stopEvent('done, never had a viewport'), { shutdown: () => { shutdown = true; } });
-    // focusOf(M) is null → the focus block is skipped entirely → just shutdown.
-    // Non-vacuous: an impl that created or handed off a focus row would leave
-    // listFocuses non-empty.
-    assert.equal(shutdown, true, 'an unfocused done node shuts down');
-    assert.equal(listFocuses().length, 0, 'no focus row was created or touched');
-});
-test('§5.1.5 awaiting + FOCUSED → STAY ALIVE: pi keeps running (no release), focus row untouched (F3)', async () => {
-    createNode(node('root', { parent: null, lifecycle: 'resident' }));
-    createNode(node('mgr', { parent: 'root', lifecycle: 'terminal', mode: 'orchestrator' }));
-    createNode(node('worker', { parent: 'mgr', lifecycle: 'terminal', status: 'active' }));
-    subscribe('root', 'mgr', true);
-    subscribe('mgr', 'worker', true); // mgr awaits a live worker → would idle-release if UNfocused
-    // null pane (broker cut): focusOf passes a null-pane viewer row through, so the
-    // handler reads mgr as FOCUSED in the tmux-free ordinary suite (a fabricated %pane
-    // would be GC-pruned by liveOrPrune and the node would wrongly release).
-    openFocusRow('fMgr', null, 'Suser', 'mgr');
-    process.env['CRTR_NODE_ID'] = 'mgr';
-    const pi = makeFakePi();
-    registerCanvasStophook(pi);
-    let shutdown = false;
-    await settle(pi, stopEvent('still waiting on the worker'), { shutdown: () => { shutdown = true; } });
-    // A FOCUSED awaiting node holds the user's viewport, so the awaiting branch
-    // keeps pi LIVE and dormant (the in-process inbox-watcher wakes it) instead of
-    // releasing + shutting down. It must NOT release, NOT shut down, and NOT touch
-    // the focus row. Non-vacuous: the old freeze impl flipped intent→idle-release
-    // and shut pi down; this pins all three as untouched.
-    assert.equal(getNode('mgr')?.status, 'active', 'a focused awaiting node stays active (not released)');
-    assert.equal(getNode('mgr')?.intent ?? null, null, 'no idle-release intent while focused');
-    assert.equal(shutdown, false, 'a focused awaiting node is NOT shut down — pi stays live');
-    assert.equal(getFocusByNode('mgr')?.focus_id, 'fMgr', 'the focus row is UNCHANGED — not closed, not handed off');
-});
-test('§5.1.7 resident attended (no live subs) → nothing happens; focus + status survive', async () => {
-    createNode(node('root', { parent: null, lifecycle: 'resident' }));
-    openFocusRow('fR', '%r', 'Suser', 'root');
-    process.env['CRTR_NODE_ID'] = 'root';
-    const pi = makeFakePi();
-    registerCanvasStophook(pi);
-    let shutdown = false;
-    await settle(pi, stopEvent('I have wrapped up'), { shutdown: () => { shutdown = true; } });
-    // evaluateStop on a resident → reason 'dormant' (NOT 'awaiting'), so the
-    // awaiting branch is skipped and the handler does nothing: no release, no
-    // shutdown, no focus touch. Non-vacuous: an impl that idle-released a resident
-    // would flip status→idle / intent→idle-release; one that touched focus would
-    // change/remove fR.
-    assert.equal(getNode('root')?.status, 'active', 'a resident is never forced dormant');
-    assert.equal(getNode('root')?.intent ?? null, null, 'no idle-release intent on a resident');
-    assert.equal(getFocusByNode('root')?.focus_id, 'fR', 'focus row survives untouched');
-    assert.equal(shutdown, false, 'a resident attended node is not shut down');
-});
-test('refresh-yield (intent=refresh) writes NO push — silent to subscribers', async () => {
-    createNode(node('root', { parent: null, lifecycle: 'resident' }));
-    createNode(node('orch', { parent: 'root', lifecycle: 'terminal', mode: 'orchestrator', intent: 'refresh' }));
-    subscribe('root', 'orch', true);
-    process.env['CRTR_NODE_ID'] = 'orch';
-    const pi = makeFakePi();
-    registerCanvasStophook(pi);
-    let shutdown = false;
-    await settle(pi, stopEvent('checkpoint before refreshing'), { shutdown: () => { shutdown = true; } });
-    assert.equal(shutdown, true, 'pi shut down (no tmux pane → clean shutdown)');
-    assert.equal(reportCount('orch'), 0, 'a yield is silent: NO report file');
-    assert.equal(hasUnseenWakeMail('root'), false, 'a yield is silent: NO SQL inbox delivery');
-    assert.equal(pi.injected.length, 0, 'no reprompt on a refresh-yield');
-});
-// turn_end — stale-⚠ fix: reaching turn_end proves the current provider
-// round-trip and any wedge episode are both over, so both fault links clear.
-/** A turn_end event carrying one assistant text block. */
-function turnEndEvent(text) {
-    return { message: { role: 'assistant', content: [{ type: 'text', text }] } };
-}
-test('turn_end clears a stale pi→provider fatal fault (a completed round-trip proves the episode is over)', async () => {
-    createNode(node('leaf', { parent: null, lifecycle: 'terminal' }));
-    recordFault('leaf', {
-        link: 'pi→provider',
-        op: 'generation turn',
-        kind: 'other',
-        retry: { disposition: 'fatal' },
-        message: 'terminated',
-    });
-    assert.notEqual(readFault('leaf'), null, 'precondition: SQL recovery fault recorded');
-    activateBroker('leaf');
-    const pi = makeFakePi();
-    registerCanvasStophook(pi);
-    await pi.fire('turn_end', turnEndEvent('all good now'), {});
-    assert.equal(readFault('leaf'), null, 'the pi→provider fault is cleared at turn_end');
-});
-test('turn_end still clears a daemon→node wedge fault (existing behavior, unchanged)', async () => {
-    createNode(node('leaf', { parent: null, lifecycle: 'terminal' }));
-    recordFault('leaf', {
-        link: 'daemon→node',
-        op: 'wedge detection',
-        kind: 'wedged',
-        retry: { disposition: 'manual' },
-        message: 'no progress for 20m',
-    });
-    assert.notEqual(readFault('leaf'), null, 'precondition: SQL recovery wedge fault recorded');
-    activateBroker('leaf');
-    const pi = makeFakePi();
-    registerCanvasStophook(pi);
-    await pi.fire('turn_end', turnEndEvent('turn completed'), {});
-    assert.equal(readFault('leaf'), null, 'the daemon→node wedge fault is still cleared at turn_end');
-});
-test('a successful final or requested human reply suppresses the stop reprompt', async () => {
-    createNode(node('signal-only', { parent: null, lifecycle: 'terminal' }));
-    for (const [signal, shutsDown] of [['pushedFinal', true], ['requestedHumanReply', false]]) {
-        process.env['CRTR_NODE_ID'] = 'signal-only';
-        activateBroker('signal-only');
-        markStopSignal('signal-only', signal);
-        const pi = makeFakePi();
-        registerCanvasStophook(pi);
-        let shutdown = false;
-        await settle(pi, stopEvent(`completed ${signal}`), { shutdown: () => { shutdown = true; } });
-        assert.equal(pi.injected.length, 0, `${signal} does not re-prompt when the broker cannot read its node`);
-        assert.equal(shutdown, shutsDown, `${signal} takes its expected settled action`);
-    }
-});
-test('an in-run retry (agent_start with no new input) does not erase this run\'s stop signal', async () => {
-    // Regression: pi re-fires agent_start for automatic retries and post-compaction
-    // continuations WITHIN one run. Clearing the marker there erased the ask/final
-    // recorded earlier in the same run, so settlement fell back to a canvas read
-    // and re-prompted a node that had legitimately asked the human.
-    createNode(node('mgr', { parent: null, lifecycle: 'terminal', mode: 'orchestrator' }));
-    createNode(node('leaf', { parent: 'mgr', lifecycle: 'terminal', status: 'active' }));
-    subscribe('mgr', 'leaf', true);
-    process.env['CRTR_NODE_ID'] = 'leaf';
-    const pi = makeFakePi();
-    registerCanvasStophook(pi);
-    const ctx = { shutdown: () => { } };
-    pi.fire('input', { type: 'input' }, ctx);
-    pi.fire('agent_start', { type: 'agent_start' }, ctx);
-    markStopSignal('leaf', 'requestedHumanReply'); // the node ran `crtr human send` mid-run
-    pi.fire('agent_start', { type: 'agent_start' }, ctx); // pi auto-retried after a provider error
-    await settle(pi, stopEvent('waiting on the human now'), ctx);
-    assert.equal(pi.injected.length, 0, 'the ask survives the in-run retry — no stall reprompt');
-    // ...and the NEXT user-directed run does start clean.
-    markStopSignal('leaf', 'requestedHumanReply');
-    pi.fire('input', { type: 'input' }, ctx);
-    await settle(pi, stopEvent('I think I am basically done here'), ctx);
-    assert.equal(pi.injected.length, 1, 'a new input discards a leftover marker from a prior run');
-});
-test('stalled leaf (nothing live to await, no final) is still reprompted', async () => {
-    createNode(node('mgr', { parent: null, lifecycle: 'terminal', mode: 'orchestrator' }));
-    createNode(node('leaf', { parent: 'mgr', lifecycle: 'terminal', status: 'active' }));
-    subscribe('mgr', 'leaf', true); // mgr subscribes to leaf; leaf itself awaits nothing
-    process.env['CRTR_NODE_ID'] = 'leaf';
-    const pi = makeFakePi();
-    registerCanvasStophook(pi);
-    let shutdown = false;
-    await settle(pi, stopEvent('I think I am basically done here'), { shutdown: () => { shutdown = true; } });
-    assert.equal(pi.injected.length, 1, 'the stall reprompt fired');
-    assert.equal(pi.injected[0].content, `<runtime kind="stop-guard">${STALL_REPROMPT}</runtime>`, 'reprompt carries the stall nudge to push final / ask');
-    assert.equal(pi.injected[0].deliverAs, 'followUp', 'reprompt delivered as a followUp');
-    assert.equal(shutdown, false, 'a stalled leaf is NOT shut down — it is re-prompted to finish');
-    assert.notEqual(getNode('leaf')?.intent, 'idle-release', 'a stalled leaf does not idle-release');
-    assert.equal(reportCount('leaf'), 0, 'NO report file written on a stall');
-    assert.equal(hasUnseenWakeMail('mgr'), false, 'NO SQL inbox delivery fanned on a stall');
-});

package/dist/pi-extensions/__tests__/canvas-stophook-context-nudge.test.d.ts

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

package/dist/pi-extensions/__tests__/canvas-stophook-context-nudge.test.js

@@ -1,152 +0,0 @@
-// Run with: node --import tsx/esm --test src/pi-extensions/__tests__/canvas-stophook-context-nudge.test.ts
-//
-// The context-size nudge's delivery mode splits on whether the agent run
-// continues past the turn. The regression this pins: the nudge used to be an
-// unconditional STEER, and pi's agent loop drains the steering queue right
-// after turn_end — so a band crossing on the run's FINAL message (no tool
-// calls) extended the run past the agent's closing reply, burying the summary
-// a human comes back to read once the conversation goes quiet.
-//   • turn_end with toolCall content (mid-run) → sendUserMessage steer
-//   • turn_end with text-only content (final)  → sendMessage 'nextTurn' hold
-//
-// Second regression pinned here: a tool-calling turn ends with stopReason
-// 'toolUse' (pi-ai's StopReason), NEVER 'stop'. Gating the steer path on
-// stopReason 'stop'/'length' made runContinues unconditionally false, so the
-// nudge was ALWAYS appended as nextTurn and never steered mid-run.
-import { test, before, after, beforeEach, afterEach } from 'node:test';
-import assert from 'node:assert/strict';
-import { existsSync, mkdtempSync, mkdirSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import registerCanvasStophook from '../canvas-stophook.js';
-import { createNode } from '../../core/canvas/canvas.js';
-import { beginExecution } from '../../core/canvas/executions.js';
-import { closeDb, migrate, openDb } from '../../core/canvas/db.js';
-import { apiSocketPath } from '../../core/canvas/paths.js';
-import { createApiServer } from '../../daemon/api/server.js';
-let home;
-let origNode;
-let origExecution;
-let server;
-async function waitForSocket(path) {
-    for (let i = 0; i < 200; i++) {
-        if (existsSync(path))
-            return;
-        await new Promise((resolve) => setTimeout(resolve, 10));
-    }
-    throw new Error(`api socket never bound at ${path}`);
-}
-function node(id) {
-    return {
-        node_id: id,
-        name: id,
-        created: new Date().toISOString(),
-        cwd: '/tmp/work',
-        kind: 'general',
-        mode: 'base',
-        lifecycle: 'terminal',
-        status: 'active',
-    };
-}
-function makeFakePi() {
-    const handlers = {};
-    return {
-        steered: [],
-        held: [],
-        on(e, h) { handlers[e] = h; },
-        sendUserMessage(content, options) { this.steered.push({ content, deliverAs: options?.deliverAs }); },
-        sendMessage(m, options) {
-            this.held.push({ customType: m.customType, content: m.content, deliverAs: options?.deliverAs, triggerTurn: options?.triggerTurn });
-        },
-        async fire(e, ev, ctx) { await handlers[e]?.(ev, ctx); },
-    };
-}
-/** A turn_end event whose assistant message crossed a steering band. A
- *  tool-calling turn really ends with stopReason 'toolUse'; text-only finals
- *  end with 'stop'. */
-function turnEnd(content, stopReason = 'stop') {
-    return { message: { role: 'assistant', stopReason, content, usage: { input: 1, output: 1 } }, toolResults: [] };
-}
-const ctxAt = (tokens) => ({ getContextUsage: () => ({ tokens }) });
-before(() => {
-    origNode = process.env['CRTR_NODE_ID'];
-    origExecution = process.env['CRTR_EXECUTION_ID'];
-});
-beforeEach(async () => {
-    closeDb();
-    if (home)
-        rmSync(home, { recursive: true, force: true });
-    home = mkdtempSync(join(tmpdir(), 'crtr-stophook-nudge-'));
-    process.env['CRTR_HOME'] = home;
-    mkdirSync(home, { recursive: true });
-    migrate(openDb());
-    server = createApiServer();
-    await waitForSocket(apiSocketPath());
-});
-afterEach(async () => {
-    await server.close();
-});
-after(() => {
-    closeDb();
-    if (home)
-        rmSync(home, { recursive: true, force: true });
-    delete process.env['CRTR_HOME'];
-    if (origNode === undefined)
-        delete process.env['CRTR_NODE_ID'];
-    else
-        process.env['CRTR_NODE_ID'] = origNode;
-    if (origExecution === undefined)
-        delete process.env['CRTR_EXECUTION_ID'];
-    else
-        process.env['CRTR_EXECUTION_ID'] = origExecution;
-});
-test('band crossing mid-run (tool calls present) → context nudge is a STEER', async () => {
-    createNode(node('midrun'));
-    process.env['CRTR_NODE_ID'] = 'midrun';
-    process.env['CRTR_EXECUTION_ID'] = beginExecution('midrun', { daemonEpoch: null });
-    const pi = makeFakePi();
-    registerCanvasStophook(pi);
-    await pi.fire('turn_end', turnEnd([{ type: 'toolCall', id: 't1', name: 'bash', arguments: {} }], 'toolUse'), ctxAt(150_000));
-    assert.equal(pi.steered.length, 1, 'exactly one steer delivered');
-    assert.equal(pi.steered[0].deliverAs, 'steer');
-    assert.match(pi.steered[0].content, /^<runtime kind="context-nudge">Context ~150k/);
-    assert.equal(pi.held.length, 0, 'nothing held for nextTurn');
-});
-test('band crossing on the FINAL message (no tool calls) → nudge is HELD as nextTurn, never a steer', async () => {
-    createNode(node('final'));
-    process.env['CRTR_NODE_ID'] = 'final';
-    process.env['CRTR_EXECUTION_ID'] = beginExecution('final', { daemonEpoch: null });
-    const pi = makeFakePi();
-    registerCanvasStophook(pi);
-    await pi.fire('turn_end', turnEnd([{ type: 'text', text: 'here is my summary' }]), ctxAt(150_000));
-    assert.equal(pi.steered.length, 0, 'no steer — a steer here would extend the run past the closing reply');
-    assert.equal(pi.held.length, 1, 'nudge held for the next user message');
-    assert.equal(pi.held[0].deliverAs, 'nextTurn');
-    assert.equal(pi.held[0].customType, 'crtr-context-nudge');
-    assert.match(pi.held[0].content, /^<runtime kind="context-nudge">Context ~150k/);
-    assert.notEqual(pi.held[0].triggerTurn, true, 'must not trigger a turn');
-});
-test('a truncated tool-calling turn (stopReason length) still steers — the loop continues past failed calls', async () => {
-    createNode(node('lengthrun'));
-    process.env['CRTR_NODE_ID'] = 'lengthrun';
-    process.env['CRTR_EXECUTION_ID'] = beginExecution('lengthrun', { daemonEpoch: null });
-    const pi = makeFakePi();
-    registerCanvasStophook(pi);
-    await pi.fire('turn_end', turnEnd([{ type: 'toolCall', id: 't1', name: 'bash', arguments: {} }], 'length'), ctxAt(150_000));
-    assert.equal(pi.steered.length, 1);
-    assert.equal(pi.steered[0].deliverAs, 'steer');
-    assert.equal(pi.held.length, 0);
-});
-test('an aborted final turn also holds (the loop ends unconditionally on abort)', async () => {
-    createNode(node('aborted'));
-    process.env['CRTR_NODE_ID'] = 'aborted';
-    process.env['CRTR_EXECUTION_ID'] = beginExecution('aborted', { daemonEpoch: null });
-    const pi = makeFakePi();
-    registerCanvasStophook(pi);
-    // Aborted mid-tool-call: toolCall content present, but the run ends anyway —
-    // a steer would sit queued and leak into the NEXT run's start instead.
-    await pi.fire('turn_end', turnEnd([{ type: 'toolCall', id: 't1', name: 'bash', arguments: {} }], 'aborted'), ctxAt(150_000));
-    assert.equal(pi.steered.length, 0);
-    assert.equal(pi.held.length, 1);
-    assert.equal(pi.held[0].deliverAs, 'nextTurn');
-});

package/dist/pi-extensions/__tests__/canvas-structured-output.test.d.ts

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