@north-light/crouter 0.3.318 → 0.3.320

package/dist/pi-extensions/canvas-stophook.js

@@ -1,643 +1 @@
-// canvas-stophook.ts — pi extension for pi-native canvas agent nodes.
-//
-// Loaded into every canvas node's pi process via the node's launch.extensions
-// list. INERT when CRTR_NODE_ID is absent (plain pi session or legacy job agent).
-//
-// In the canvas model each node owns a dedicated pi window (one-window-per-node),
-// so the tmux pane-relocation swap-back guard of the legacy stophook is omitted —
-// there are no shared pane slots to restore.
-//
-// Responsibilities:
-//
-//   turn_end — accumulate token usage and flush telemetry.json under the node's
-//              job/ dir so the dashboard shows live counts.
-//
-//   agent_end — stage the latest Pi attempt for Pi's settlement boundary.
-//
-//   agent_settled — report Pi-only stop facts to crtrd, then enact its one
-//                   returned directive: follow-up reprompt, stay dormant, or
-//                   shut down. crtrd owns every stop-policy and canvas effect.
-//
-// Plain TS-with-types — no imports from @earendil-works/* so this compiles inside
-// crouter's own tsc build without a dep on the pi packages.
-import { envNodeId } from '../shared/env.js';
-import { writeFileSync, mkdirSync, existsSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { contextDir, jobDir } from '../core/canvas/paths.js';
-import { mutateBrokerFault, recordBrokerTurn } from '../core/runtime/broker/daemon-ops.js';
-import { clearStopSignals, consumeStopSignals } from '../core/runtime/stop-signals.js';
-import { bindBrokerSession, brokerExtensionState, relaunchBrokerRoot, settleBroker } from '../core/runtime/broker/daemon-ops.js';
-import { emitEvent } from '../core/events/emit.js';
-import { activeBackgroundBashJobs } from '../core/bash-jobs.js';
-import { CONTEXT_NUDGE_CUSTOM_TYPE, formatCard } from '../shared/generated-context.js';
-import { isReviewBoundary } from '../core/runtime/session-visibility.js';
-import { clearRefusedTurn, refuseTurn, runRefreshAbort } from '../core/runtime/broker/extension-abort.js';
-import { announceMessageOrigin } from '../core/runtime/stamp/channel.js';
-/** Condense a tool call into one short line for the activity cue. Picks the most
- *  identifying arg (command / path / pattern / description), collapses whitespace,
- *  and hard-caps the length so a giant bash command can't bloat telemetry.json. */
-const ACTIVITY_CAP = 80;
-function summarizeActivity(toolName, args) {
-    const a = (args ?? {});
-    const pick = (v) => (typeof v === 'string' ? v : '');
-    const detail = pick(a['command']) || pick(a['path']) || pick(a['file_path']) || pick(a['pattern']) || pick(a['description']) || pick(a['prompt']);
-    const line = (detail !== '' ? `${toolName}: ${detail}` : toolName).replace(/\s+/g, ' ').trim();
-    return line.length > ACTIVITY_CAP ? line.slice(0, ACTIVITY_CAP) : line;
-}
-/**
- * Merge accumulated token counts into nodes/<nodeId>/job/telemetry.json.
- * Creates the directory when it doesn't yet exist. Best-effort; never throws.
- * `contextTokens` is the live window gauge for THIS turn; when null (pi can't
- * size the window yet) the last recorded value is preserved.
- */
-function flushTelemetry(jobDirPath, tokensIn, tokensOut, model, contextTokens, activity) {
-    try {
-        if (!existsSync(jobDirPath))
-            mkdirSync(jobDirPath, { recursive: true });
-        const filePath = join(jobDirPath, 'telemetry.json');
-        // Merge with any existing record so concurrent readers always see a complete
-        // picture. Model name falls back to whatever was last recorded.
-        let existing = {};
-        if (existsSync(filePath)) {
-            try {
-                existing = JSON.parse(readFileSync(filePath, 'utf8'));
-            }
-            catch {
-                /* start fresh on a corrupt file */
-            }
-        }
-        const record = {
-            tokens_in: tokensIn,
-            tokens_out: tokensOut,
-            context_tokens: contextTokens ?? existing.context_tokens,
-            last_activity: activity ?? existing.last_activity,
-            model: model !== '' ? model : (existing.model ?? ''),
-            updated_at: new Date().toISOString(),
-        };
-        writeFileSync(filePath, JSON.stringify(record, null, 2), 'utf8');
-    }
-    catch {
-        /* telemetry is best-effort; never surface */
-    }
-}
-// Message-extraction helpers
-/** Walk backwards through the agent_end messages array to find the last
- *  assistant turn. */
-function lastAssistantMessage(messages) {
-    for (let i = messages.length - 1; i >= 0; i--) {
-        if (messages[i]?.role === 'assistant')
-            return messages[i];
-    }
-    return undefined;
-}
-/** Review markers present in Pi's current branch. The broker reports only this
- * Pi-owned fact; crtrd compares it with the node's daemon-owned review binding. */
-function currentReviewBoundaryIds(ctx) {
-    try {
-        const entries = ctx?.sessionManager?.getBranch();
-        if (!Array.isArray(entries))
-            return [];
-        const ids = new Set();
-        for (const entry of entries) {
-            if (!isReviewBoundary(entry))
-                continue;
-            const reviewId = entry.details?.reviewId;
-            if (typeof reviewId === 'string')
-                ids.add(reviewId);
-        }
-        return [...ids];
-    }
-    catch {
-        return [];
-    }
-}
-// Context-size steering bands — a single shared schedule of thresholds that
-// ESCALATE in tone as input context grows. The first band is a gentle
-// "consider it"; a later band turns firm. The schedule TIGHTENS as it climbs:
-// 130k, 150k, 170k, 185k, 200k, then every 10k (210k, 220k, …) so a long-lived
-// node keeps getting reminded, more often the deeper it goes.
-//
-// The band schedule is shared across all node shapes; only the MESSAGE differs
-// (steerNote), keyed on MODE first, then LIFECYCLE — three reachable personas:
-//   orchestrator (terminal OR resident): HAS a roadmap (promotion / orchestrator
-//             birth seeds context/roadmap.md), so it is steered to checkpoint +
-//             yield — 130k gentle (consider yielding) → 150k firm (do it now) →
-//             185k+ pushy. Keyed on mode, NOT lifecycle: a terminal/orchestrator
-//             yields against its roadmap exactly like a resident one (the
-//             daemon's refresh-revive keys on intent='refresh', not lifecycle).
-//   resident/base (a root conversation): NO roadmap on disk yet, so it is not
-//             told to checkpoint one. `crtr node yield` is still its continue
-//             verb — mode-preserving, continuing fresh against its goal and its
-//             note — offered against wrap-up, since a root chat can simply end.
-//             `--promote` is mentioned only when worthwhile independent work
-//             can run in parallel and coordination should become primary. Gentle → firm → pushy.
-//   terminal/base (a worker): steered to `crtr node yield` to continue in a
-//             fresh window, mode-preserving, when work remains, or `push final`
-//             when close. Gentle → firm → pushy.
-//
-// Every persona's "keep going" verb is `crtr node yield` — NEVER a bare `node
-// promote`, which framed promotion as a heavy "become an orchestrator" step and
-// bred yield-avoidance. A plain yield is always mode-preserving — a base node's
-// yield never auto-promotes, so the agent is never steered to decide about
-// promotion at all; `--promote` is a separate opt-in mentioned only for
-// worthwhile parallel work. Only a terminal node is ever told `push final` (a
-// resident finishes by yielding or being closed); only an orchestrator already
-// HAS a roadmap to checkpoint before it yields.
-const STEER_STEP = 10_000;
-// Shared escalation schedule (both lifecycles). Tightens as it climbs:
-// 130k, 150k, 170k, 185k, 200k, then every 10k (210k, 220k, …).
-const BANDS = [130_000, 150_000, 170_000, 185_000, 200_000];
-/** The highest band threshold at or below `tokens`. Below the first band →
- *  null. At/past the last listed band, bands continue every STEER_STEP (so the
- *  firmest nudge keeps recurring). */
-function steerBand(tokens) {
-    const first = BANDS[0];
-    const last = BANDS[BANDS.length - 1];
-    if (tokens < first)
-        return null;
-    if (tokens >= last)
-        return last + Math.floor((tokens - last) / STEER_STEP) * STEER_STEP;
-    let chosen = first;
-    for (const b of BANDS)
-        if (tokens >= b)
-            chosen = b;
-    return chosen;
-}
-/** The nudge text for a crossed band, specialized to the node's (mode,
- *  lifecycle) persona + how far along the escalation it is. `crtr node yield` is
- *  the single "keep going past this window" verb for every persona: it refreshes
- *  the node into a clean window, MODE-PRESERVING — a base node stays base,
- *  continuing fresh against its goal and its note. `--promote` is a separate,
- *  explicit opt-in (never steered here as auto-behavior) for when worthwhile
- *  independent work can run in parallel and coordination should become the
- *  node's primary job — so no persona is ever steered at a bare `node promote` (which framed promotion as a heavy
- *  "become an orchestrator" step and bred yield-avoidance).
- *
- *  - orchestrator (terminal OR resident): checkpoint context/roadmap.md, then
- *    yield (it already has a roadmap to bring current first).
- *  - resident/base (root conversation): yield to continue fresh if the chat is
- *    growing into a job, else wrap up — a root can simply end.
- *  - terminal/base (worker): yield to continue if work remains, or `push final`
- *    when close.
- *
- *  The wording strengthens with depth: gentle < 150k → firm < 185k → pushy at/
- *  past 185k, where drifting further risks an overflow. */
-export function steerNote(at, lifecycle, mode) {
-    const k = Math.round(at / 1000);
-    const pushy = at >= 185_000;
-    // Keyed on MODE first: any orchestrator (terminal or resident) has a roadmap
-    // to checkpoint + yield against.
-    if (mode === 'orchestrator') {
-        if (at < 150_000) {
-            return `Context ~${k}k and growing. When you reach a good stopping point, consider updating context/roadmap.md and running \`crtr node yield\` to refresh against it — no rush yet.`;
-        }
-        if (!pushy) {
-            return `Context ~${k}k. Update context/roadmap.md so a fresh revive can continue, delegate any outstanding work, then \`crtr node yield\` to refresh.`;
-        }
-        return `Context ~${k}k — this is getting long. Stop taking on new work now: checkpoint context/roadmap.md, hand off anything outstanding, and \`crtr node yield\` immediately to refresh before this context overflows.`;
-    }
-    if (lifecycle === 'resident') {
-        // resident/base — a root conversation, mode-preserving `crtr node yield` is
-        // the natural "carry this forward" verb: it refreshes into a clean window
-        // and continues fresh against your goal and your note — no "become
-        // something" decision. Mention --promote only when worthwhile independent
-        // work can run in parallel and coordination should become primary. Offer
-        // wrap-up as the alternative — a root chat can simply end.
-        const grow = `If substantial work remains, \`crtr node yield\` to continue fresh against your goal and your note. Add --promote only when worthwhile independent work can run in parallel and coordinating it should become your primary job; \`crtr node yield -h\` has the boundary.`;
-        if (at < 150_000) {
-            return `Context ~${k}k and growing. ${grow} Otherwise no rush — wrap up when you reach a good stopping point.`;
-        }
-        if (!pushy) {
-            return `Context ~${k}k. ${grow} If you're near done, just finish here; if there's more open-ended work, \`crtr node yield\` rather than letting this context grow.`;
-        }
-        return `Context ~${k}k — this is getting long. Wrap up now before this context overflows: finish what's in hand, or \`crtr node yield\` immediately to continue fresh against your goal and your note if substantial work remains.`;
-    }
-    // terminal/base — a worker. The natural "keep going past this window" verb is
-    // `crtr node yield`: it refreshes into a clean window, mode-preserving, and
-    // continues fresh against your goal and your note. --promote is a separate
-    // opt-in for worthwhile parallel work, never steered as automatic. Steer it to
-    // yield-or-finish, never a bare promote.
-    if (at < 150_000) {
-        return `Context ~${k}k and growing. If you're near done, finish with \`crtr push final\`. If real work remains, \`crtr node yield\` to continue in a fresh window against your goal and your note — no rush yet.`;
-    }
-    if (!pushy) {
-        return `Context ~${k}k. If you're close, finish with \`crtr push final\`; otherwise \`crtr node yield\` now to refresh into a clean window and keep going against your goal and your note.`;
-    }
-    return `Context ~${k}k — this is getting long. Wrap up now before this context overflows: \`crtr push final\` if you're close, otherwise \`crtr node yield\` immediately to continue in a fresh window against your goal and your note.`;
-}
-// Extension
-/**
- * Register the canvas turn and settlement handlers on `pi`.
- *
- * Returns immediately when CRTR_NODE_ID is absent — the extension is fully
- * inert in a non-canvas pi session. Safe to call multiple times (each call
- * re-registers on the same `pi` instance, so it should only be called once
- * per node lifecycle, matching how pi loads extensions).
- */
-export function registerCanvasStophook(pi) {
-    const nodeId = envNodeId();
-    if (nodeId === undefined || nodeId.trim() === '')
-        return; // not a canvas node
-    const jobDirPath = jobDir(nodeId);
-    // Cumulative throughput across all turns in this pi session, for telemetry
-    // (job/telemetry.json) only — both turn_end and agent_end accumulate so tokens
-    // emitted in the final partial turn (if pi fires agent_end without a preceding
-    // turn_end for it) are captured. NOT used for context-size steering: that is a
-    // per-turn gauge (see contextTokens), not a running sum.
-    let totalIn = 0;
-    let totalOut = 0;
-    let model = '';
-    // Last live context-window gauge + last tool summary, tracked across handlers so
-    // a tool_execution_start flush (activity-only) preserves the latest token figure.
-    let lastContext = null;
-    let lastActivity = null;
-    // Context-size steering. As input context grows we nudge the node once per
-    // band on an escalating, persona-specific schedule (see steerBand/steerNote).
-    // The node's (lifecycle, mode) persona is read at fire time, since a terminal
-    // worker can promote mid-session: an orchestrator is steered to checkpoint
-    // its roadmap + yield; a resident base (root chat) to yield-or-wrap-up (or
-    // yield --promote only when worthwhile independent work can run in parallel);
-    // a terminal worker to yield-or-push-final.
-    const firedBands = new Set();
-    const backgroundJobsRunning = () => activeBackgroundBashJobs(contextDir(nodeId)).length > 0;
-    const emitDaemonOperationFailure = (operation, error) => {
-        emitEvent({
-            event: 'broker.daemon.operation.failed',
-            level: 'error',
-            node_id: nodeId,
-            error,
-            fields: { operation },
-        });
-    };
-    const enactSettleDirective = (directive, ctx) => {
-        if (directive.action === 'reprompt') {
-            announceMessageOrigin(directive.prompt, { type: 'runtime', kind: 'stop-guard' });
-            pi.sendUserMessage(directive.prompt, { deliverAs: 'followUp' });
-            return;
-        }
-        if (directive.action === 'shutdown') {
-            try {
-                ctx?.shutdown?.();
-            }
-            catch { /* Pi shutdown is local best-effort */ }
-        }
-    };
-    // Streaming updates are rate-limited because daemon wedge grace is measured in minutes.
-    const HEARTBEAT_THROTTLE_MS = 3_000;
-    let lastHeartbeatAt = 0;
-    const heartbeat = () => {
-        const now = Date.now();
-        if (now - lastHeartbeatAt < HEARTBEAT_THROTTLE_MS)
-            return;
-        lastHeartbeatAt = now;
-        void Promise.all([
-            recordBrokerTurn(nodeId, { event: 'progress' }),
-            mutateBrokerFault(nodeId, { op: 'clear', link: 'daemon→node' }),
-        ]).catch((error) => emitDaemonOperationFailure('turn_progress', error));
-    };
-    // session_start — capture pi's session id, and detect `/new`.
-    //
-    // pi tags each session_start with a `reason`: 'startup' on boot (a fresh
-    // launch or a daemon revive — both new processes), 'new' when the user runs
-    // `/new` (a brand-new conversation in the SAME process), and 'resume' /
-    // 'reload' / 'fork' for the in-place conversation swaps that keep the same
-    // node. We branch on that reason — NOT on a remembered session id.
-    //
-    // Why reason, not a closure flag: pi RE-ACTIVATES extensions on every session
-    // swap, so any id we stash on boot is reset to its initial value before the
-    // next session_start fires and can never observe the change — a `/new` then
-    // looks identical to a boot. The event reason is delivered fresh on every fire
-    // and is immune to the re-activation.
-    //
-    // `/new` splits by who ran it: crtrd derives rootness from the node row and
-    // either directs a root relaunch or resets a child's session coordinates.
-    pi.on('session_start', async (event, ctx) => {
-        try {
-            const id = ctx?.sessionManager?.getSessionId?.();
-            if (typeof id !== 'string' || id === '')
-                return;
-            // The absolute path to this session's .jsonl, captured alongside the id.
-            // Resuming by path is immune to a cwd discrepancy (pi opens it directly),
-            // whereas a bare id is resolved cwd-relative and forks across projects.
-            const filed = ctx?.sessionManager?.getSessionFile?.();
-            const sessionFile = typeof filed === 'string' && filed !== '' ? filed : null;
-            const reason = typeof event?.reason === 'string' ? event.reason : null;
-            // Pi has already swapped to the fresh conversation. Its local steering
-            // counters reset independently of the durable root/child consequence.
-            if (reason === 'new') {
-                totalIn = 0;
-                totalOut = 0;
-                firedBands.clear();
-            }
-            // crtrd validates the review binding and fork coordinates, derives whether
-            // this node is a root, and commits every durable session-start mutation.
-            const binding = await bindBrokerSession(nodeId, {
-                piSessionId: id,
-                sessionFile,
-                pid: process.pid,
-                reason,
-                reviewBoundaryIds: currentReviewBoundaryIds(ctx),
-            });
-            if (binding.action === 'shutdown') {
-                try {
-                    ctx?.shutdown?.();
-                }
-                catch { /* best-effort */ }
-                return;
-            }
-            if (binding.action === 'relaunch_root') {
-                // The session-bound handler selects this consequence but never calls
-                // back into its calling broker. Do not await the operation that tears
-                // this broker down from Pi's session-start dispatch.
-                void relaunchBrokerRoot(nodeId).catch((error) => {
-                    const message = error instanceof Error ? error.message : String(error);
-                    ctx?.ui?.notify?.(`/new refused: ${message}`, 'error');
-                    emitEvent({
-                        event: 'broker.daemon.operation.failed',
-                        level: 'error',
-                        node_id: nodeId,
-                        error,
-                        fields: { operation: 'relaunch_root' },
-                    });
-                });
-                return;
-            }
-        }
-        catch (error) {
-            // Binding failure leaves Pi alive; crtrd remains the only process that
-            // can retry or reconcile the durable state.
-            emitEvent({
-                event: 'broker.daemon.operation.failed',
-                level: 'error',
-                node_id: nodeId,
-                error,
-                fields: { operation: 'session_bound' },
-            });
-        }
-    });
-    // agent_start — pi entered a turn. Mark the node mid-turn (busy) so a
-    // focus-away while it is genuinely working backstages it (Invariant F2)
-    // rather than reaping it. Cleared only after the whole run settles.
-    pi.on('agent_start', async (_event, ctx) => {
-        // A turn may not enter Pi until crtrd has fenced and recorded it. Otherwise
-        // a broker that lost daemon ownership can run work with no durable turn.
-        try {
-            const result = await recordBrokerTurn(nodeId, { event: 'started' });
-            if (!result.applied)
-                throw new Error('daemon refused turn open');
-        }
-        catch (error) {
-            emitDaemonOperationFailure('turn_open', error);
-            ctx?.ui?.notify?.('Turn refused: the broker no longer owns this node.', 'error');
-            refuseTurn(() => ctx?.abort?.());
-        }
-    });
-    // input — a new user-directed run is beginning. This is the ONLY place stop
-    // signals are cleared: `agent_start` re-fires for pi's automatic retries and
-    // post-compaction continuations within the SAME run, so clearing there would
-    // erase the `crtr human send` / `crtr push final` marker written earlier in the
-    // run and make the eventual settlement fall back to a canvas read (exactly the
-    // read the marker exists to avoid). One run's markers survive until the one
-    // `agent_settled` consumes them; a leftover from an errored or interrupted run
-    // of this same broker is discarded here, when the next prompt arrives (the pid
-    // stamp only rules out a PRIOR broker's markers, not this broker's own).
-    pi.on('input', () => {
-        clearRefusedTurn();
-        try {
-            clearStopSignals(nodeId);
-        }
-        catch { /* best-effort */ }
-    });
-    // tool_execution_start — capture the live "what is it doing" cue. Writes the
-    // one-line tool summary to telemetry.json so out-of-process readers (the nav
-    // chrome) show it inline without a second file or any extra read on their side.
-    pi.on('tool_execution_start', (event) => {
-        try {
-            lastActivity = summarizeActivity(String(event?.toolName ?? ''), event?.args);
-            flushTelemetry(jobDirPath, totalIn, totalOut, model, lastContext, lastActivity);
-            heartbeat(); // a fresh tool starting is a sign of life
-        }
-        catch { /* best-effort */ }
-    });
-    // tool_execution_update — wedge heartbeat + fault clear only. Fired with
-    // partial/streaming tool output (when a tool reports progress); throttled via
-    // `heartbeat()` since it can arrive many times per second. Most tools (e.g.
-    // bash) don't stream progress today, so this is currently a light-touch no-op
-    // for them — it exists so any tool that DOES stream partial output (now or in
-    // the future) counts as live progress instead of tripping the wedge detector,
-    // AND clears any wedge notice that already fired before this progress resumed.
-    pi.on('tool_execution_update', () => {
-        try {
-            heartbeat();
-        }
-        catch { /* best-effort */ }
-    });
-    // message_update — wedge heartbeat + fault clear only. Fired token-by-token
-    // while the assistant is actively streaming a reply — genuine progress,
-    // throttled the same way, and equally clears a stale wedge notice if streaming
-    // resumes before a coarser boundary. A node stuck streaming forever without
-    // ever firing this is exactly the daemon's busy+quiet wedge signature.
-    pi.on('message_update', () => {
-        try {
-            heartbeat();
-        }
-        catch { /* best-effort */ }
-    });
-    // tool_execution_end — IMMEDIATE refresh-yield. When a tool this turn set
-    // intent='refresh' (the node ran `crtr node yield`), shut the broker down NOW
-    // instead of letting the model keep burning its bloated context to the turn's
-    // natural end (the settlement backstop would only catch it there). The yield
-    // command persists the yield-message + any existing roadmap checkpoint BEFORE
-    // it returns, so by the time this fires nothing is lost. Abort the live turn,
-    // then request shutdown; the broker exits after pi's settle boundary. The
-    // daemon then sees the dead pid + intent='refresh' and revives the node FRESH
-    // against its roadmap if it has one, else its original goal.
-    // intent only flips to 'refresh' via `node yield`, so this can't false-fire.
-    // (A node that somehow boots already carrying intent='refresh' correctly
-    // refreshes on its first tool — the desired outcome.)
-    pi.on('tool_execution_end', async (_event, ctx) => {
-        try {
-            heartbeat(); // a tool that returned is a sign of life
-            if ((await brokerExtensionState(nodeId)).node.intent === 'refresh') {
-                // Stop this turn immediately so the large context does not keep running.
-                // The broker clears Pi's queued steering/follow-up messages inside this
-                // refresh scope; their durable inbox entries stay uncommitted and the
-                // fresh kickoff replays them. Leave the broker alive through
-                // agent_settled: only a successful daemon settle directive may request
-                // Pi shutdown.
-                try {
-                    runRefreshAbort(() => ctx?.abort?.());
-                }
-                catch { /* ignore */ }
-            }
-        }
-        catch { /* best-effort */ }
-    });
-    // session_shutdown — Pi's clean /quit fact goes to crtrd, which owns the
-    // finish transition, focus teardown, presence clear, and fault clear. Other
-    // session swaps keep the same node and need no durable settlement.
-    pi.on('session_shutdown', async (event, ctx) => {
-        try {
-            await recordBrokerTurn(nodeId, { event: 'closed', end_reason: 'teardown-aborted' });
-        }
-        catch (error) {
-            emitDaemonOperationFailure('turn_close_teardown', error);
-        }
-        if (event?.reason !== 'quit')
-            return;
-        try {
-            const directive = await settleBroker(nodeId, {
-                stopReason: 'quit',
-                backgroundJobsRunning: backgroundJobsRunning(),
-                pushedFinal: false,
-                requestedHumanReply: false,
-            });
-            enactSettleDirective(directive, ctx);
-        }
-        catch (error) {
-            emitDaemonOperationFailure('settle_quit', error);
-        }
-    });
-    /** Absorb usage + model from any assistant message (turn or final batch). */
-    const accumulate = (msg) => {
-        if (msg?.role !== 'assistant' || msg.usage == null)
-            return;
-        totalIn += Number(msg.usage.input ?? 0) || 0;
-        totalOut += Number(msg.usage.output ?? 0) || 0;
-        if (typeof msg.model === 'string' && msg.model !== '')
-            model = msg.model;
-    };
-    // turn_end — live telemetry refresh.
-    // event shape: { message: AssistantMessage, ... }
-    pi.on('turn_end', async (event, ctx) => {
-        accumulate(event?.message);
-        // The CURRENT context size via ctx.getContextUsage() — the exact figure pi's
-        // footer shows. Captured once here for two consumers: the telemetry flush
-        // (so out-of-process readers like `crtr node new` can size this node) and
-        // the context-size steering below.
-        //   .tokens is null/undefined only when pi can't know the size yet (no model,
-        //   or right after a compaction before the next reply) — telemetry then keeps
-        //   its last value and steering is skipped for the turn.
-        let contextTokens = null;
-        try {
-            const t = ctx.getContextUsage()?.tokens;
-            if (typeof t === 'number')
-                contextTokens = t;
-        }
-        catch { /* gauge unavailable this turn */ }
-        if (contextTokens !== null)
-            lastContext = contextTokens;
-        // Fire-and-forget: flushTelemetry uses synchronous fs writes and never throws.
-        flushTelemetry(jobDirPath, totalIn, totalOut, model, contextTokens, lastActivity);
-        heartbeat(); // reaching turn_end proves this turn was not wedged
-        try {
-            await Promise.all([
-                mutateBrokerFault(nodeId, { op: 'clear', link: 'daemon→node' }),
-                mutateBrokerFault(nodeId, { op: 'clear', link: 'pi→provider' }),
-            ]);
-        }
-        catch (error) {
-            emitDaemonOperationFailure('turn_end_fault_clear', error);
-        }
-        // Will the agent run CONTINUE past this turn? Deterministic at turn_end:
-        // the loop keeps going exactly when this assistant message carried tool
-        // calls and the run wasn't aborted/errored (those end unconditionally,
-        // before tools execute). A tool-calling turn ends with stopReason
-        // 'toolUse' — or 'length' when truncation failed the calls, which still
-        // continues the loop — NEVER 'stop', so gate on the abort/error reasons,
-        // not on an allowlist that excludes 'toolUse'.
-        // This handler runs BEFORE the loop drains the steering queue, so the read
-        // is race-free: zero tool calls ⇒ this is the run's FINAL message, and a
-        // steer sent now would not redirect at a boundary — it would EXTEND the run
-        // past the agent's closing reply, burying the summary the human comes back
-        // to read once the conversation goes quiet.
-        const turnContent = Array.isArray(event?.message?.content) ? event.message.content : [];
-        const turnStopReason = event?.message?.stopReason ?? '';
-        const runContinues = turnStopReason !== 'error' &&
-            turnStopReason !== 'aborted' &&
-            turnContent.some((c) => c?.type === 'toolCall');
-        // Context-size steering: fire the current band once, with lifecycle-specific
-        // guidance (lifecycle is read live — a terminal worker may have promoted to
-        // resident since launch).
-        // Delivery splits on runContinues:
-        //   • mid-run → STEER, not a followUp: guidance to become an orchestrator /
-        //     delegate / yield must redirect the node at the turn boundary, not queue
-        //     behind whatever it does next (where it rides along, easy to ignore).
-        //   • final message → HOLD via pi's 'nextTurn' queue: it injects alongside
-        //     the next user message without triggering a turn, so the nudge is read
-        //     at the start of the next engagement instead of spawning a phantom
-        //     continuation after the agent already said its piece.
-        // Never the cumulative totalIn: under prompt caching that never grows (input
-        // is a ~2-token uncached delta each turn), so the bands were unreachable and
-        // the nudge never fired.
-        try {
-            const state = await brokerExtensionState(nodeId);
-            const node = state.node;
-            const at = contextTokens !== null ? steerBand(contextTokens) : null;
-            if (at !== null && !firedBands.has(at)) {
-                firedBands.add(at);
-                const note = formatCard('context-nudge', {}, steerNote(at, node.lifecycle, node.mode));
-                if (runContinues) {
-                    announceMessageOrigin(note, { type: 'runtime', kind: 'context-nudge' });
-                    pi.sendUserMessage(note, { deliverAs: 'steer' });
-                }
-                else {
-                    pi.sendMessage({ customType: CONTEXT_NUDGE_CUSTOM_TYPE, content: note, display: true }, { deliverAs: 'nextTurn' });
-                }
-            }
-        }
-        catch (error) {
-            emitDaemonOperationFailure('turn_boundary', error);
-        }
-    });
-    // Pi may emit several agent_end attempts while it compacts, retries, and
-    // drains queued continuations. Keep only the latest attempt here; no lifecycle
-    // effect is committed until Pi declares the whole run settled.
-    let stagedAgentEnd = null;
-    pi.on('agent_end', (event) => {
-        stagedAgentEnd = event;
-        try {
-            const messages = Array.isArray(event?.messages) ? event.messages : [];
-            for (const message of messages)
-                accumulate(message);
-        }
-        catch { /* best-effort */ }
-    });
-    // agent_settled — Pi supplies stop facts; crtrd commits every canvas effect
-    // and returns the one Pi-side consequence to enact.
-    pi.on('agent_settled', async (_event, ctx) => {
-        const event = stagedAgentEnd;
-        stagedAgentEnd = null;
-        // crtrd owns the durable turn close, fault marker, stop policy, lifecycle
-        // transition, focus, and mail decision even when Pi had no stageable final
-        // agent_end payload.
-        try {
-            await recordBrokerTurn(nodeId, { event: 'closed', end_reason: 'settled' });
-        }
-        catch (error) {
-            emitDaemonOperationFailure('turn_close', error);
-            return;
-        }
-        const messages = Array.isArray(event?.messages) ? event.messages : [];
-        const last = lastAssistantMessage(messages);
-        const stopReason = typeof last?.stopReason === 'string' ? last.stopReason : '';
-        const stopSignals = event === null
-            ? { pushedFinal: false, requestedHumanReply: false }
-            : consumeStopSignals(nodeId);
-        try {
-            const directive = await settleBroker(nodeId, {
-                stopReason,
-                backgroundJobsRunning: backgroundJobsRunning(),
-                pushedFinal: stopSignals.pushedFinal,
-                requestedHumanReply: stopSignals.requestedHumanReply,
-            });
-            enactSettleDirective(directive, ctx);
-        }
-        catch (error) {
-            // A daemon failure is observable and leaves this broker alive; it must not
-            // masquerade as a completed release, teardown, or cursor settlement.
-            emitDaemonOperationFailure('settle', error);
-        }
-    });
-}
-export default registerCanvasStophook;
+var H=Object.defineProperty;var u=(t,e)=>H(t,"name",{value:e,configurable:!0});import{envNodeId as U}from"../shared/env.js";import{writeFileSync as J,mkdirSync as P,existsSync as E,readFileSync as j}from"node:fs";import{join as W}from"node:path";import{contextDir as Y,jobDir as z}from"../core/canvas/paths.js";import{mutateBrokerFault as A,recordBrokerTurn as b}from"../core/runtime/broker/daemon-ops.js";import{clearStopSignals as G,consumeStopSignals as L}from"../core/runtime/stop-signals.js";import{bindBrokerSession as V,brokerExtensionState as $,relaunchBrokerRoot as X,settleBroker as M}from"../core/runtime/broker/daemon-ops.js";import{emitEvent as R}from"../core/events/emit.js";import{activeBackgroundBashJobs as K}from"../core/bash-jobs.js";import{CONTEXT_NUDGE_CUSTOM_TYPE as Q,formatCard as Z}from"../shared/generated-context.js";import{isReviewBoundary as ee}from"../core/runtime/session-visibility.js";import{clearRefusedTurn as te,refuseTurn as ne,runRefreshAbort as oe}from"../core/runtime/broker/extension-abort.js";import{announceMessageOrigin as F}from"../core/runtime/stamp/channel.js";const O=80;function re(t,e){const a=e??{},o=u(f=>typeof f=="string"?f:"","pick"),i=o(a.command)||o(a.path)||o(a.file_path)||o(a.pattern)||o(a.description)||o(a.prompt),l=(i!==""?`${t}: ${i}`:t).replace(/\s+/g," ").trim();return l.length>O?l.slice(0,O):l}u(re,"summarizeActivity");function N(t,e,a,o,i,l){try{E(t)||P(t,{recursive:!0});const f=W(t,"telemetry.json");let h={};if(E(f))try{h=JSON.parse(j(f,"utf8"))}catch{}const _={tokens_in:e,tokens_out:a,context_tokens:i??h.context_tokens,last_activity:l??h.last_activity,model:o!==""?o:h.model??"",updated_at:new Date().toISOString()};J(f,JSON.stringify(_,null,2),"utf8")}catch{}}u(N,"flushTelemetry");function se(t){for(let e=t.length-1;e>=0;e--)if(t[e]?.role==="assistant")return t[e]}u(se,"lastAssistantMessage");function ae(t){try{const e=t?.sessionManager?.getBranch();if(!Array.isArray(e))return[];const a=new Set;for(const o of e){if(!ee(o))continue;const i=o.details?.reviewId;typeof i=="string"&&a.add(i)}return[...a]}catch{return[]}}u(ae,"currentReviewBoundaryIds");const q=1e4,v=[13e4,15e4,17e4,185e3,2e5];function ie(t){const e=v[0],a=v[v.length-1];if(t<e)return null;if(t>=a)return a+Math.floor((t-a)/q)*q;let o=e;for(const i of v)t>=i&&(o=i);return o}u(ie,"steerBand");function ce(t,e,a){const o=Math.round(t/1e3),i=t>=185e3;if(a==="orchestrator")return t<15e4?`Context ~${o}k and growing. When you reach a good stopping point, consider updating context/roadmap.md and running \`crtr node yield\` to refresh against it \u2014 no rush yet.`:i?`Context ~${o}k \u2014 this is getting long. Stop taking on new work now: checkpoint context/roadmap.md, hand off anything outstanding, and \`crtr node yield\` immediately to refresh before this context overflows.`:`Context ~${o}k. Update context/roadmap.md so a fresh revive can continue, delegate any outstanding work, then \`crtr node yield\` to refresh.`;if(e==="resident"){const l="If substantial work remains, `crtr node yield` to continue fresh against your goal and your note. Add --promote only when worthwhile independent work can run in parallel and coordinating it should become your primary job; `crtr node yield -h` has the boundary.";return t<15e4?`Context ~${o}k and growing. ${l} Otherwise no rush \u2014 wrap up when you reach a good stopping point.`:i?`Context ~${o}k \u2014 this is getting long. Wrap up now before this context overflows: finish what's in hand, or \`crtr node yield\` immediately to continue fresh against your goal and your note if substantial work remains.`:`Context ~${o}k. ${l} If you're near done, just finish here; if there's more open-ended work, \`crtr node yield\` rather than letting this context grow.`}return t<15e4?`Context ~${o}k and growing. If you're near done, finish with \`crtr push final\`. If real work remains, \`crtr node yield\` to continue in a fresh window against your goal and your note \u2014 no rush yet.`:i?`Context ~${o}k \u2014 this is getting long. Wrap up now before this context overflows: \`crtr push final\` if you're close, otherwise \`crtr node yield\` immediately to continue in a fresh window against your goal and your note.`:`Context ~${o}k. If you're close, finish with \`crtr push final\`; otherwise \`crtr node yield\` now to refresh into a clean window and keep going against your goal and your note.`}u(ce,"steerNote");function ue(t){const e=U();if(e===void 0||e.trim()==="")return;const a=z(e);let o=0,i=0,l="",f=null,h=null;const _=new Set,T=u(()=>K(Y(e)).length>0,"backgroundJobsRunning"),y=u((n,s)=>{R({event:"broker.daemon.operation.failed",level:"error",node_id:e,error:s,fields:{operation:n}})},"emitDaemonOperationFailure"),C=u((n,s)=>{if(n.action==="reprompt"){F(n.prompt,{type:"runtime",kind:"stop-guard"}),t.sendUserMessage(n.prompt,{deliverAs:"followUp"});return}if(n.action==="shutdown")try{s?.shutdown?.()}catch{}},"enactSettleDirective"),D=3e3;let I=0;const k=u(()=>{const n=Date.now();n-I<D||(I=n,Promise.all([b(e,{event:"progress"}),A(e,{op:"clear",link:"daemon\u2192node"})]).catch(s=>y("turn_progress",s)))},"heartbeat");t.on("session_start",async(n,s)=>{try{const r=s?.sessionManager?.getSessionId?.();if(typeof r!="string"||r==="")return;const g=s?.sessionManager?.getSessionFile?.(),p=typeof g=="string"&&g!==""?g:null,m=typeof n?.reason=="string"?n.reason:null;m==="new"&&(o=0,i=0,_.clear());const c=await V(e,{piSessionId:r,sessionFile:p,pid:process.pid,reason:m,reviewBoundaryIds:ae(s)});if(c.action==="shutdown"){try{s?.shutdown?.()}catch{}return}if(c.action==="relaunch_root"){X(e).catch(d=>{const w=d instanceof Error?d.message:String(d);s?.ui?.notify?.(`/new refused: ${w}`,"error"),R({event:"broker.daemon.operation.failed",level:"error",node_id:e,error:d,fields:{operation:"relaunch_root"}})});return}}catch(r){R({event:"broker.daemon.operation.failed",level:"error",node_id:e,error:r,fields:{operation:"session_bound"}})}}),t.on("agent_start",async(n,s)=>{try{if(!(await b(e,{event:"started"})).applied)throw new Error("daemon refused turn open")}catch(r){y("turn_open",r),s?.ui?.notify?.("Turn refused: the broker no longer owns this node.","error"),ne(()=>s?.abort?.())}}),t.on("input",()=>{te();try{G(e)}catch{}}),t.on("tool_execution_start",n=>{try{h=re(String(n?.toolName??""),n?.args),N(a,o,i,l,f,h),k()}catch{}}),t.on("tool_execution_update",()=>{try{k()}catch{}}),t.on("message_update",()=>{try{k()}catch{}}),t.on("tool_execution_end",async(n,s)=>{try{if(k(),(await $(e)).node.intent==="refresh")try{oe(()=>s?.abort?.())}catch{}}catch{}}),t.on("session_shutdown",async(n,s)=>{try{await b(e,{event:"closed",end_reason:"teardown-aborted"})}catch(r){y("turn_close_teardown",r)}if(n?.reason==="quit")try{const r=await M(e,{stopReason:"quit",backgroundJobsRunning:T(),pushedFinal:!1,requestedHumanReply:!1});C(r,s)}catch(r){y("settle_quit",r)}});const B=u(n=>{n?.role!=="assistant"||n.usage==null||(o+=Number(n.usage.input??0)||0,i+=Number(n.usage.output??0)||0,typeof n.model=="string"&&n.model!==""&&(l=n.model))},"accumulate");t.on("turn_end",async(n,s)=>{B(n?.message);let r=null;try{const c=s.getContextUsage()?.tokens;typeof c=="number"&&(r=c)}catch{}r!==null&&(f=r),N(a,o,i,l,r,h),k();try{await Promise.all([A(e,{op:"clear",link:"daemon\u2192node"}),A(e,{op:"clear",link:"pi\u2192provider"})])}catch(c){y("turn_end_fault_clear",c)}const g=Array.isArray(n?.message?.content)?n.message.content:[],p=n?.message?.stopReason??"",m=p!=="error"&&p!=="aborted"&&g.some(c=>c?.type==="toolCall");try{const d=(await $(e)).node,w=r!==null?ie(r):null;if(w!==null&&!_.has(w)){_.add(w);const x=Z("context-nudge",{},ce(w,d.lifecycle,d.mode));m?(F(x,{type:"runtime",kind:"context-nudge"}),t.sendUserMessage(x,{deliverAs:"steer"})):t.sendMessage({customType:Q,content:x,display:!0},{deliverAs:"nextTurn"})}}catch(c){y("turn_boundary",c)}});let S=null;t.on("agent_end",n=>{S=n;try{const s=Array.isArray(n?.messages)?n.messages:[];for(const r of s)B(r)}catch{}}),t.on("agent_settled",async(n,s)=>{const r=S;S=null;try{await b(e,{event:"closed",end_reason:"settled"})}catch(d){y("turn_close",d);return}const g=Array.isArray(r?.messages)?r.messages:[],p=se(g),m=typeof p?.stopReason=="string"?p.stopReason:"",c=r===null?{pushedFinal:!1,requestedHumanReply:!1}:L(e);try{const d=await M(e,{stopReason:m,backgroundJobsRunning:T(),pushedFinal:c.pushedFinal,requestedHumanReply:c.requestedHumanReply});C(d,s)}catch(d){y("settle",d)}})}u(ue,"registerCanvasStophook");var xe=ue;export{xe as default,ue as registerCanvasStophook,ce as steerNote};