@north-light/crouter 0.3.318 → 0.3.319

package/dist/core/runtime/stamp/channel.js

@@ -1,76 +1 @@
-// The in-process announcement channel every delivery seam uses to tell the
-// stamp writer where the next user message came from.
-//
-// crouter's delivery seams straddle a loader boundary: the broker is native
-// ESM, while pi extensions (the inbox watcher, the stophook, the stamp writer
-// itself) are Jiti-loaded and therefore CANNOT share a module singleton with
-// it — the same reason held-deferred-inbox.ts exists. A process-global
-// registered symbol carries the channel across that boundary, so a seam
-// announces through the same two calls whichever side it lives on.
-//
-// Announcements are claimed by CONTENT, not by arrival order: each carries a
-// signature of the text about to be sent, and the writer claims the one whose
-// signature matches the message pi actually persisted. A send that never lands
-// (a delivery the engine refused) therefore cannot leak its origin onto a later
-// message; it simply ages out of the bounded queue.
-import { createHash } from 'node:crypto';
-const STAMP_CHANNEL = Symbol.for('@crouton-kit/crtr:stamp-channel');
-/** Unclaimed announcements held at once. The queue is a correlation buffer, not
- *  a work queue: one pending announcement is the normal state. */
-const MAX_PENDING = 16;
-function channel() {
-    const host = globalThis;
-    const existing = host[STAMP_CHANNEL];
-    if (existing !== undefined)
-        return existing;
-    const created = { announcements: [], ext: [] };
-    host[STAMP_CHANNEL] = created;
-    return created;
-}
-/** The correlation key for one message body. Announcers pass the text they are
- *  about to send; the writer passes the text pi persisted. */
-export function messageSignature(text) {
-    return createHash('sha1').update(text.trim()).digest('hex');
-}
-/** Announce the origin of the user message `text` that is about to be sent. */
-export function announceMessageOrigin(text, origin) {
-    const state = channel();
-    state.announcements.push({
-        signature: messageSignature(text),
-        origin,
-    });
-    while (state.announcements.length > MAX_PENDING)
-        state.announcements.shift();
-}
-/** Take the announced metadata for a persisted message body, or null when no
- *  seam announced this message. */
-export function claimMessageAnnouncement(text) {
-    const state = channel();
-    const signature = messageSignature(text);
-    const index = state.announcements.findIndex((entry) => entry.signature === signature);
-    if (index < 0)
-        return null;
-    const [claimed] = state.announcements.splice(index, 1);
-    return { origin: claimed.origin };
-}
-/** Contribute namespaced fields to the next stamp the writer emits. Unknown
- *  namespaces pass through untouched; the core writer never interprets them. */
-export function contributeStampExt(namespace, fields) {
-    channel().ext.push({ namespace, fields });
-}
-/** Whether any contribution is waiting — an assistant message is stamped only
- *  when one is, so an ordinary assistant turn costs no line. */
-export function hasPendingStampExt() {
-    return channel().ext.length > 0;
-}
-/** Take every buffered contribution, merged per namespace. */
-export function drainStampExt() {
-    const state = channel();
-    if (state.ext.length === 0)
-        return undefined;
-    const merged = {};
-    for (const { namespace, fields } of state.ext.splice(0)) {
-        merged[namespace] = { ...merged[namespace], ...fields };
-    }
-    return merged;
-}
+var m=Object.defineProperty;var o=(n,t)=>m(n,"name",{value:t,configurable:!0});import{createHash as f}from"node:crypto";const i=Symbol.for("@crouton-kit/crtr:stamp-channel"),g=16;function s(){const n=globalThis,t=n[i];if(t!==void 0)return t;const e={announcements:[],ext:[]};return n[i]=e,e}o(s,"channel");function c(n){return f("sha1").update(n.trim()).digest("hex")}o(c,"messageSignature");function l(n,t){const e=s();for(e.announcements.push({signature:c(n),origin:t});e.announcements.length>g;)e.announcements.shift()}o(l,"announceMessageOrigin");function d(n){const t=s(),e=c(n),r=t.announcements.findIndex(u=>u.signature===e);if(r<0)return null;const[a]=t.announcements.splice(r,1);return{origin:a.origin}}o(d,"claimMessageAnnouncement");function h(n,t){s().ext.push({namespace:n,fields:t})}o(h,"contributeStampExt");function S(){return s().ext.length>0}o(S,"hasPendingStampExt");function E(){const n=s();if(n.ext.length===0)return;const t={};for(const{namespace:e,fields:r}of n.ext.splice(0))t[e]={...t[e],...r};return t}o(E,"drainStampExt");export{l as announceMessageOrigin,d as claimMessageAnnouncement,h as contributeStampExt,E as drainStampExt,S as hasPendingStampExt,c as messageSignature};

package/dist/core/runtime/stamp/protocol.js

@@ -1,113 +1 @@
-// crtr-stamp — the durable per-message metadata crouter hangs on a pi session
-// jsonl. One customType carries every record; the record shape is discriminated
-// inside `data` by `kind`.
-//
-// A stamp is a pi CustomEntry: a standalone jsonl line that pi's
-// buildSessionContext ignores, so nothing here ever reaches the LLM. Stamps are
-// correlated to messages by the target message's own `timestamp` (`msgTs`), not
-// by tree position — an extension's message_end handler runs BEFORE pi persists
-// the message, so a stamp is physically the message's parent, never its child.
-//
-// Readers MUST ignore unknown envelope keys: that is what makes adding an
-// optional field later non-breaking. `v` bumps only for a rename, a removal, or
-// a change of meaning.
-//
-// The writer is `src/pi-extensions/canvas-stamp.ts` and nothing else.
-export const CRTR_STAMP_CUSTOM_TYPE = 'crtr-stamp';
-/** Envelope version. Readers switch on `(kind, v)`. */
-export const STAMP_SCHEMA_VERSION = 1;
-/** A kickoff prompt is composed by the daemon but sent by the broker, in a
- *  different process, so its origin rides the broker's spawn env instead of the
- *  in-process announcement channel. */
-export const KICKOFF_ORIGIN_ENV = 'CRTR_KICKOFF_ORIGIN';
-export function encodeKickoffOrigin(origin) {
-    return JSON.stringify(origin);
-}
-/** The kickoff origin the spawner recorded, or null when this launch carried
- *  none (an idle broker, or a launch predating the variable). */
-export function decodeKickoffOrigin(raw) {
-    if (raw === undefined || raw.trim() === '')
-        return null;
-    let parsed;
-    try {
-        parsed = JSON.parse(raw);
-    }
-    catch {
-        return null;
-    }
-    if (!isRecord(parsed))
-        return null;
-    if (parsed['type'] !== 'human' && parsed['type'] !== 'runtime')
-        return null;
-    return parsed;
-}
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-/** The stamp envelope carried by one session entry, or null when the entry is
- *  not a well-formed crtr-stamp. */
-export function readStampEntry(entry) {
-    if (!isRecord(entry))
-        return null;
-    const candidate = entry;
-    if (candidate.type !== 'custom' || candidate.customType !== CRTR_STAMP_CUSTOM_TYPE)
-        return null;
-    const data = candidate.data;
-    if (!isRecord(data))
-        return null;
-    if (typeof data['v'] !== 'number' || typeof data['kind'] !== 'string')
-        return null;
-    if (!isRecord(data['payload']))
-        return null;
-    const ext = data['ext'];
-    if (ext !== undefined && !isRecord(ext))
-        return null;
-    return data;
-}
-/** Every well-formed stamp in `entries`, in file order. */
-export function readStamps(entries) {
-    const stamps = [];
-    for (const entry of entries) {
-        const stamp = readStampEntry(entry);
-        if (stamp !== null)
-            stamps.push(stamp);
-    }
-    return stamps;
-}
-function isSessionStamp(stamp) {
-    if (stamp.kind !== 'session' || stamp.v !== STAMP_SCHEMA_VERSION)
-        return false;
-    const payload = stamp.payload;
-    return typeof payload.node === 'string' && typeof payload.crtr === 'string';
-}
-function isMessageStamp(stamp) {
-    if (stamp.kind !== 'message' || stamp.v !== STAMP_SCHEMA_VERSION)
-        return false;
-    return typeof stamp.payload.msgTs === 'number';
-}
-/** The session stamp in force at the end of `entries` — a fork carries the
- *  source node's stamp until the new node appends its own, so "latest" is what
- *  a reader wants. */
-export function latestSessionStamp(entries) {
-    let latest = null;
-    for (const stamp of readStamps(entries)) {
-        if (isSessionStamp(stamp))
-            latest = stamp;
-    }
-    return latest;
-}
-/** The stamp for the message persisted at `msgTs`. Late or revised metadata is
- *  a second stamp with the same key, so the last one wins. */
-export function messageStampFor(entries, msgTs) {
-    let match = null;
-    for (const stamp of readStamps(entries)) {
-        if (isMessageStamp(stamp) && stamp.payload.msgTs === msgTs)
-            match = stamp;
-    }
-    return match;
-}
-/** Who authored the message persisted at `msgTs`, or null when nothing
- *  announced an origin for it. */
-export function originFor(entries, msgTs) {
-    return messageStampFor(entries, msgTs)?.payload.origin ?? null;
-}
+var s=Object.defineProperty;var e=(t,n)=>s(t,"name",{value:n,configurable:!0});const f="crtr-stamp",y=1,S="CRTR_KICKOFF_ORIGIN";function m(t){return JSON.stringify(t)}e(m,"encodeKickoffOrigin");function g(t){if(t===void 0||t.trim()==="")return null;let n;try{n=JSON.parse(t)}catch{return null}return!i(n)||n.type!=="human"&&n.type!=="runtime"?null:n}e(g,"decodeKickoffOrigin");function i(t){return typeof t=="object"&&t!==null&&!Array.isArray(t)}e(i,"isRecord");function l(t){if(!i(t))return null;const n=t;if(n.type!=="custom"||n.customType!==f)return null;const r=n.data;if(!i(r)||typeof r.v!="number"||typeof r.kind!="string"||!i(r.payload))return null;const o=r.ext;return o!==void 0&&!i(o)?null:r}e(l,"readStampEntry");function u(t){const n=[];for(const r of t){const o=l(r);o!==null&&n.push(o)}return n}e(u,"readStamps");function a(t){if(t.kind!=="session"||t.v!==1)return!1;const n=t.payload;return typeof n.node=="string"&&typeof n.crtr=="string"}e(a,"isSessionStamp");function c(t){return t.kind!=="message"||t.v!==1?!1:typeof t.payload.msgTs=="number"}e(c,"isMessageStamp");function _(t){let n=null;for(const r of u(t))a(r)&&(n=r);return n}e(_,"latestSessionStamp");function p(t,n){let r=null;for(const o of u(t))c(o)&&o.payload.msgTs===n&&(r=o);return r}e(p,"messageStampFor");function x(t,n){return p(t,n)?.payload.origin??null}e(x,"originFor");export{f as CRTR_STAMP_CUSTOM_TYPE,S as KICKOFF_ORIGIN_ENV,y as STAMP_SCHEMA_VERSION,g as decodeKickoffOrigin,m as encodeKickoffOrigin,_ as latestSessionStamp,p as messageStampFor,x as originFor,l as readStampEntry,u as readStamps};

package/dist/core/runtime/stop-guard.js

@@ -1,116 +1,7 @@
-// The stop-guard — no stalled agents.
-//
-// Every time a node's pi process stops, we ask one question: is this node
-// *legitimately waiting*? A node is legitimately waiting iff it holds an ACTIVE
-// subscription to a live node, explicitly awaits a live controller's message,
-// or has a live file-backed background bash job whose completion sends an inbox
-// message — something that can actually wake it. (A passive sub won't wake you,
-// so it doesn't count.)
-//
-//   • resident       → an interactable / human-driven node is NEVER forced to
-//                      submit a final: stopping to go dormant is always
-//                      legitimate (woken by inbox/human). Keyed on the LIFECYCLE
-//                      value, not on parent/mode — what matters is residency.
-//   • waiting        → a TERMINAL node has an active live subscription, an
-//                      explicit controller wait, or a live background bash job.
-//                      Let it sleep; the resulting inbox delivery wakes it.
-//   • finished/asked → it pushed --final (done) or called `crtr ask` this turn.
-//                      Also fine.
-//   • structured     → a TERMINAL node has a pending structured-output request.
-//                      A valid request reprompts with the schema unless the node
-//                      also holds a wake source, which it may sleep on first;
-//                      an invalid request reprompts with an error and requires
-//                      manual cleanup.
-//   • otherwise      → a TERMINAL node with nothing live to wait for and no
-//                      final pushed. Re-prompt it to finish or escalate.
-import { hasActiveLiveSubscription, hasLiveMessageWait, hasPendingCronWake, getNode, contextDir } from '../canvas/index.js';
-import { activeBackgroundBashJobs } from '../bash-jobs.js';
-import { formatCard, formatStructuredOutputReprompt, STALL_REPROMPT } from '../../shared/generated-context.js';
-import { readOutputRequest } from './structured-output.js';
-export { STALL_REPROMPT } from '../../shared/generated-context.js';
-/** Format the stop guard's reprompt for a valid structured-output request. */
-function formatValidStructuredOutputReprompt(schema) {
-    return formatCard('stop-guard', {}, formatStructuredOutputReprompt(JSON.stringify(schema, null, 2)));
-}
-/** Format the stop guard's reprompt for an invalid structured-output request file. */
-function formatInvalidStructuredOutputReprompt(error) {
-    return formatCard('stop-guard', {}, `Structured-output request file is invalid and cannot be used: ${error}\n\n` +
-        `You have two options:\n` +
-        `1. Remove the invalid file (the output-schema.json in your node directory has been corrupted)\n` +
-        `2. Fix the corruption if you know the original request schema\n\n` +
-        `After resolving the file, retry with \`crtr push result\` (or \`crtr push result --decline "<reason>" --code <token>\` when the schema cannot be honestly satisfied). ` +
-        `If this is unexpected, escalate to the user using \`crtr human send\`.`);
-}
-/** The wake sources that legitimize a terminal node's dormancy: a pending cron
- * wake, an active subscription to a live publisher, an explicit live controller
- * wait, or a live background bash job whose completion sends an inbox message.
- * Parentage alone is deliberately absent. */
-function wakeCapableWait(nodeId, backgroundJobsRunning) {
-    if (hasPendingCronWake(nodeId))
-        return 'scheduled';
-    if (hasActiveLiveSubscription(nodeId)
-        || hasLiveMessageWait(nodeId)
-        || backgroundJobsRunning)
-        return 'awaiting';
-    return null;
-}
-/** Decide what to do when a node stops. crtrd supplies every current-canvas
- * fact; the broker contributes only whether its Pi-owned background job registry
- * is still running work. */
-export function evaluateStop(nodeId, signals, backgroundJobsRunning = activeBackgroundBashJobs(contextDir(nodeId)).length > 0) {
-    if (signals.pushedFinal)
-        return { action: 'allow', reason: 'finished' };
-    if (signals.requestedHumanReply)
-        return { action: 'allow', reason: 'escalated' };
-    // A pending structured-output request overrides every stored-state dormancy
-    // path: a post-final one-off follow-up still owes `crtr push result` before it may stop.
-    // A wake source is the exception — the request outlives the sleep, so
-    // reprompting instead would busy-wait the node against its own child, deadline,
-    // or job. Invalid requests surface an explicit error and require manual cleanup.
-    const outputState = readOutputRequest(nodeId);
-    if (outputState.state === 'valid') {
-        const pendingWait = wakeCapableWait(nodeId, backgroundJobsRunning);
-        if (pendingWait !== null)
-            return { action: 'allow', reason: pendingWait };
-        return {
-            action: 'reprompt',
-            reason: 'stalled',
-            message: formatValidStructuredOutputReprompt(outputState.request.schema),
-        };
-    }
-    if (outputState.state === 'invalid') {
-        return {
-            action: 'reprompt',
-            reason: 'stalled',
-            message: formatInvalidStructuredOutputReprompt(outputState.error),
-        };
-    }
-    // Canonically finalized follow-up cycles and already-terminal stored states
-    // are not waiting to be re-prompted for a second final.
-    const node = getNode(nodeId);
-    if (node !== null && (node.final_report != null
-        || node.status === 'done'
-        || node.status === 'dead'
-        || node.status === 'canceled')) {
-        return { action: 'allow', reason: 'finished' };
-    }
-    // A RESIDENT node is interactable / human-driven and is never forced to submit
-    // a final: stopping to go dormant is always legitimate (the inbox or the human
-    // wakes it). Keyed on lifecycle, not parent — whether it has a parent doesn't
-    // matter, only whether it's resident. Roots are resident by birth default, so
-    // this still covers "don't nag the human's root" while generalizing it.
-    if (node !== null && node.lifecycle === 'resident') {
-        return { action: 'allow', reason: 'dormant' };
-    }
-    // A terminal node holding a wake source is legitimately waiting: it should
-    // idle-release rather than busy-wait holding its broker.
-    const pendingWait = wakeCapableWait(nodeId, backgroundJobsRunning);
-    if (pendingWait !== null)
-        return { action: 'allow', reason: pendingWait };
-    // A terminal node with nothing live and no final pushed has stalled.
-    return {
-        action: 'reprompt',
-        reason: 'stalled',
-        message: formatCard('stop-guard', {}, STALL_REPROMPT),
-    };
-}
+var c=Object.defineProperty;var n=(t,r)=>c(t,"name",{value:r,configurable:!0});import{hasActiveLiveSubscription as p,hasLiveMessageWait as f,hasPendingCronWake as d,getNode as m,contextDir as h}from"../canvas/index.js";import{activeBackgroundBashJobs as g}from"../bash-jobs.js";import{formatCard as o,formatStructuredOutputReprompt as v,STALL_REPROMPT as w}from"../../shared/generated-context.js";import{readOutputRequest as S}from"./structured-output.js";import{STALL_REPROMPT as A}from"../../shared/generated-context.js";function R(t){return o("stop-guard",{},v(JSON.stringify(t,null,2)))}n(R,"formatValidStructuredOutputReprompt");function y(t){return o("stop-guard",{},`Structured-output request file is invalid and cannot be used: ${t}
+
+You have two options:
+1. Remove the invalid file (the output-schema.json in your node directory has been corrupted)
+2. Fix the corruption if you know the original request schema
+
+After resolving the file, retry with \`crtr push result\` (or \`crtr push result --decline "<reason>" --code <token>\` when the schema cannot be honestly satisfied). If this is unexpected, escalate to the user using \`crtr human send\`.`)}n(y,"formatInvalidStructuredOutputReprompt");function l(t,r){return d(t)?"scheduled":p(t)||f(t)||r?"awaiting":null}n(l,"wakeCapableWait");function W(t,r,i=g(h(t)).length>0){if(r.pushedFinal)return{action:"allow",reason:"finished"};if(r.requestedHumanReply)return{action:"allow",reason:"escalated"};const a=S(t);if(a.state==="valid"){const s=l(t,i);return s!==null?{action:"allow",reason:s}:{action:"reprompt",reason:"stalled",message:R(a.request.schema)}}if(a.state==="invalid")return{action:"reprompt",reason:"stalled",message:y(a.error)};const e=m(t);if(e!==null&&(e.final_report!=null||e.status==="done"||e.status==="dead"||e.status==="canceled"))return{action:"allow",reason:"finished"};if(e!==null&&e.lifecycle==="resident")return{action:"allow",reason:"dormant"};const u=l(t,i);return u!==null?{action:"allow",reason:u}:{action:"reprompt",reason:"stalled",message:o("stop-guard",{},w)}}n(W,"evaluateStop");export{A as STALL_REPROMPT,W as evaluateStop};

package/dist/core/runtime/stop-signals.js

@@ -1,46 +1 @@
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { jobDir } from '../canvas/paths.js';
-const SIGNALS = ['pushedFinal', 'requestedHumanReply'];
-function signalPath(nodeId, signal) {
-    return join(jobDir(nodeId), `.${signal}`);
-}
-/** Which broker process a marker belongs to. `broker.ts` exports
- * `CRTR_BROKER_PID` into its own env, so inside a broker this IS `process.pid`
- * and every crtr command it spawns inherits the same value. Both the write and
- * the read side go through this so a marker written by a command is recognized
- * by the broker that consumes it — and so neither side is thrown off by an
- * outer broker's pid leaking in through the environment. */
-function brokerIdentity() {
-    return process.env['CRTR_BROKER_PID'] ?? String(process.pid);
-}
-/** Record a successful command outcome for this broker process. The stophook
- * consumes the marker at settlement, so no broker-side canvas read is needed to
- * recognize the command the node itself just completed. */
-export function markStopSignal(nodeId, signal) {
-    mkdirSync(jobDir(nodeId), { recursive: true });
-    writeFileSync(signalPath(nodeId, signal), brokerIdentity());
-}
-/** Consume command outcomes from this broker's just-settled turn. Markers from
- * an earlier crashed broker are discarded rather than bleeding into its successor. */
-export function consumeStopSignals(nodeId) {
-    const signals = { pushedFinal: false, requestedHumanReply: false };
-    for (const signal of SIGNALS) {
-        const path = signalPath(nodeId, signal);
-        if (!existsSync(path))
-            continue;
-        const brokerPid = readFileSync(path, 'utf8').trim();
-        rmSync(path, { force: true });
-        if (brokerPid === brokerIdentity())
-            signals[signal] = true;
-    }
-    return signals;
-}
-/** Discard any marker left by an earlier run of this same broker — a run that
- * errored or was interrupted returns before settlement consumes its markers, and
- * the pid stamp cannot tell those apart from the current run's. Called when a new
- * user-directed run begins, never on an in-run retry. */
-export function clearStopSignals(nodeId) {
-    for (const signal of SIGNALS)
-        rmSync(signalPath(nodeId, signal), { force: true });
-}
+var p=Object.defineProperty;var e=(r,n)=>p(r,"name",{value:n,configurable:!0});import{existsSync as l,mkdirSync as S,readFileSync as m,rmSync as s,writeFileSync as g}from"node:fs";import{join as y}from"node:path";import{jobDir as c}from"../canvas/paths.js";const u=["pushedFinal","requestedHumanReply"];function o(r,n){return y(c(r),`.${n}`)}e(o,"signalPath");function f(){return process.env.CRTR_BROKER_PID??String(process.pid)}e(f,"brokerIdentity");function x(r,n){S(c(r),{recursive:!0}),g(o(r,n),f())}e(x,"markStopSignal");function F(r){const n={pushedFinal:!1,requestedHumanReply:!1};for(const i of u){const t=o(r,i);if(!l(t))continue;const a=m(t,"utf8").trim();s(t,{force:!0}),a===f()&&(n[i]=!0)}return n}e(F,"consumeStopSignals");function b(r){for(const n of u)s(o(r,n),{force:!0})}e(b,"clearStopSignals");export{b as clearStopSignals,F as consumeStopSignals,x as markStopSignal};

package/dist/core/runtime/stream-watchdog.js

@@ -1,134 +1 @@
-// stream-watchdog.ts — broker-side dead-provider-stream detector.
-//
-// A laptop sleep or Wi-Fi loss can leave the provider's HTTP response stream
-// half-open: the socket never errors and never closes, it just stops
-// delivering bytes. pi's turn loop has no read-timeout on that socket, so the
-// engine wedges in phase='turn' indefinitely — nothing drains (steer/followUp
-// queues included) until the daemon's 20-minute wedge detector SIGTERMs the
-// broker, which is the actual data-loss event a wedge this long causes (see
-// queued-messages-never-delivered-diagnosis.md RC1/RC2). This watchdog aborts
-// the stalled stream itself, well before that backstop: if no engine event has
-// been relayed for STREAM_WATCHDOG_MS while a turn is active, the stream is
-// presumed dead — abort it. The watchdog stamps its abort on the live session
-// generation so settlement records an automatic pi→provider connection fault;
-// the existing fault-retry machinery owns re-driving the turn. The broker
-// process — and its in-memory queues — survives instead of being killed.
-// The default is 5 minutes, comfortably under the daemon's 20-minute
-// WEDGE_QUIET_MS hard kick (crtrd.ts), so this is the common-case recovery
-// path and the daemon kick becomes the rare backstop. Generous enough that a
-// live, healthy stream never trips it: a single LLM turn's own network
-// round-trips (message_update deltas, tool_execution_start/update/end) land
-// well inside 5 minutes. The watchdog covers ONLY time awaiting the provider:
-// the broker disarms it while a tool is executing (a legitimately silent tool
-// can run longer than the timeout — see broker.ts relayEvent) and rearms it
-// once the last in-flight tool ends, so a slow-but-live turn is never mistaken
-// for a dead one. See `envStreamWatchdogMs()` (`shared/env.ts`) for the parsed
-// `CRTR_STREAM_WATCHDOG_MS` accessor and default value.
-import { envStreamWatchdogMs } from '../../shared/env.js';
-/**
- * A single-timer dead-man's switch: `poke(token)` (re)arms it, `clear()`
- * disarms it, and `onStall(token)` fires exactly once if `poke()` isn't called
- * again within `ms`. The broker pokes it on relayed engine events while a turn
- * is awaiting the provider and clears it at `agent_end` / tool execution — see
- * broker.ts `relayEvent`.
- *
- * The `token` is an opaque generation stamp: each arm captures the token passed
- * to its `poke()`, and `onStall` receives exactly that token. The broker bumps
- * a session generation on every rebind, so a timer armed against a since-
- * superseded session hands its stale generation to `onStall`, which no-ops it
- * instead of aborting the live replacement session.
- */
-export class StreamWatchdog {
-    onStall;
-    timer;
-    paused = false;
-    ms;
-    constructor(onStall, ms) {
-        this.onStall = onStall;
-        this.ms = ms ?? envStreamWatchdogMs();
-    }
-    /** Proof of progress — (re)arm the timer for `token`, canceling any prior
-     *  countdown. The fired `onStall` receives THIS arm's token. Inert while
-     *  paused (a deliberate known-stream wait, see `pause`), so a poke relayed
-     *  during the wait cannot rearm the disarmed watchdog. */
-    poke(token) {
-        if (this.paused)
-            return;
-        this.clear();
-        this.timer = setTimeout(() => {
-            this.timer = undefined;
-            this.onStall(token);
-        }, this.ms);
-        // unref() so a live watchdog never keeps the broker process open on its own.
-        if (typeof this.timer.unref === 'function')
-            this.timer.unref();
-    }
-    /** Turn over (or broker tearing down) — no more relay expected until the
-     *  next `poke()`. Idempotent. Does NOT touch the paused flag. */
-    clear() {
-        if (this.timer === undefined)
-            return;
-        clearTimeout(this.timer);
-        this.timer = undefined;
-    }
-    /** Enter a deliberate known-stream wait: disarm the timer AND make `poke()`
-     *  inert, so an intentional provider cooldown (which relays no engine events)
-     *  is not mistaken for a wedged network stream. Paired with `resume()`. */
-    pause() {
-        this.clear();
-        this.paused = true;
-    }
-    /** Leave a known-stream wait and rearm against `token` (the live session
-     *  generation). A no-op arm if the turn has already moved on — the broker only
-     *  resumes while still streaming and idle of tools. */
-    resume(token) {
-        this.paused = false;
-        this.poke(token);
-    }
-    /** Fully disarm AND unpause — the lifecycle reset used at agent_end, session
-     *  rebind, and dispose so a superseded known-stream wait can never strand a
-     *  later session in a paused state. */
-    reset() {
-        this.paused = false;
-        this.clear();
-    }
-}
-/** Broker release policy for a deliberate wait: only an unchanged provider
- * stream resumes; a completed/rebound turn or active tool fully resets. */
-export function releaseKnownStreamWait(watchdog, token, sessionIsStreaming, hasExecutingTools) {
-    if (sessionIsStreaming && !hasExecutingTools)
-        watchdog.resume(token);
-    else
-        watchdog.reset();
-}
-// A globally-stable key for the broker-owned known-stream-wait control, placed on
-// the extension UI context. Package extensions (provider-rotation) load through
-// jiti and may hold a SEPARATE module instance of this file, so a module-level
-// singleton would not be shared; `Symbol.for` + the real broker-owned UI object
-// cross that loader boundary safely (same technique as the pi theme symbol).
-export const KNOWN_STREAM_WAIT_UI = Symbol.for('@crouton-kit/crtr:known-stream-wait');
-/** Run a deliberate, deadline-bounded provider wait as KNOWN liveness so the
- *  broker's dead-stream watchdog does not abort the intentional silence. Looks up
- *  the broker-owned control on the extension UI context (keyed by
- *  `KNOWN_STREAM_WAIT_UI`) and holds the watchdog paused for the duration of
- *  `op`, releasing in `finally`. Falls back to a plain `op()` when no broker
- *  control is present (unit tests, non-broker hosts). */
-export async function withKnownStreamWait(ui, deadlineMs, op) {
-    const control = ui?.[KNOWN_STREAM_WAIT_UI];
-    if (typeof control !== 'function') {
-        await op();
-        return;
-    }
-    const release = control(deadlineMs);
-    try {
-        await op();
-    }
-    finally {
-        try {
-            release();
-        }
-        catch {
-            /* best effort — a failed resume must not swallow the wait's own result */
-        }
-    }
-}
+var a=Object.defineProperty;var s=(e,t)=>a(e,"name",{value:t,configurable:!0});import{envStreamWatchdogMs as o}from"../../shared/env.js";class f{static{s(this,"StreamWatchdog")}onStall;timer;paused=!1;ms;constructor(t,i){this.onStall=t,this.ms=i??o()}poke(t){this.paused||(this.clear(),this.timer=setTimeout(()=>{this.timer=void 0,this.onStall(t)},this.ms),typeof this.timer.unref=="function"&&this.timer.unref())}clear(){this.timer!==void 0&&(clearTimeout(this.timer),this.timer=void 0)}pause(){this.clear(),this.paused=!0}resume(t){this.paused=!1,this.poke(t)}reset(){this.paused=!1,this.clear()}}function h(e,t,i,r){i&&!r?e.resume(t):e.reset()}s(h,"releaseKnownStreamWait");const u=Symbol.for("@crouton-kit/crtr:known-stream-wait");async function l(e,t,i){const r=e?.[u];if(typeof r!="function"){await i();return}const n=r(t);try{await i()}finally{try{n()}catch{}}}s(l,"withKnownStreamWait");export{u as KNOWN_STREAM_WAIT_UI,f as StreamWatchdog,h as releaseKnownStreamWait,l as withKnownStreamWait};