commandmate 0.31.2 → 0.32.0

package/dist/server/src/lib/relay/relay-messages.js

@@ -0,0 +1,144 @@
+"use strict";
+/**
+ * Every sentence a relay puts in front of an agent or a reader (Issue #2377).
+ *
+ * ## Why the text is here and not in `locales/`
+ *
+ * Two of the four go into an AGENT's composer, which makes them prompts rather
+ * than labels: the `[from …]` header is what tells session A that the paragraph
+ * underneath it was written by somebody else, and a key that resolved to its own
+ * name — a renamed namespace, a dictionary that failed to load — would hand A an
+ * unattributed wall of text from another session and no way to tell. The same
+ * argument `buildDelegationBrief` makes in `lib/cli/command-reference`, and the
+ * same shape `buildModelChangedSentence` uses for the model-change history row
+ * (#2357): both languages written out side by side so a change to one is
+ * visibly a change to the other.
+ *
+ * The UI's own labels — the badges, the chat strip — ARE in `locales/`, because
+ * those are labels.
+ *
+ * ## The header is machine-readable on purpose
+ *
+ * {@link RELAY_HEADER_PREFIX} opens every delivered body in both languages, so
+ * a reader (a human, an agent, a later `capture`) can recognise a relayed
+ * message without knowing which language the server was speaking. The body
+ * after it is B's own text, untouched — summarising or translating it is out of
+ * scope by the Issue's own words.
+ *
+ * @module lib/relay/relay-messages
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RELAY_HEADER_PREFIX = void 0;
+exports.buildRelayHeader = buildRelayHeader;
+exports.buildRelayReplyMessage = buildRelayReplyMessage;
+exports.buildRelayPromptMessage = buildRelayPromptMessage;
+exports.buildRelayExpiredMessage = buildRelayExpiredMessage;
+exports.buildRelaySystemLine = buildRelaySystemLine;
+/**
+ * The literal every relayed body starts with.
+ *
+ * `[from ` and not a localized word: it is the one token a consumer may match
+ * on, and it has to mean the same thing in both dictionaries.
+ */
+exports.RELAY_HEADER_PREFIX = '[from ';
+/** How long a quoted prompt question may be before it is elided. */
+const PROMPT_SUMMARY_MAX_CHARS = 200;
+/** How many options of a confirmation are listed before the rest are counted. */
+const PROMPT_OPTIONS_MAX = 9;
+/**
+ * `[from <alias> / <worktree>]` — the attribution line.
+ *
+ * Both fields, always: an alias alone is ambiguous across worktrees (every
+ * repository's roster tends to contain a `Codex 2`) and a worktree alone does
+ * not say which of its sessions answered.
+ */
+function buildRelayHeader(sender) {
+    return `${exports.RELAY_HEADER_PREFIX}${sender.alias} / ${sender.worktreeId}]`;
+}
+/**
+ * B's reply, attributed.
+ *
+ * The body is passed through verbatim — no summary, no translation, no
+ * re-wrapping. A blank body still gets a header: "they finished and said
+ * nothing" is information, and swallowing the delivery would leave A waiting on
+ * a relay that has already closed.
+ */
+function buildRelayReplyMessage(sender, reply) {
+    const body = reply.trim();
+    return body === ''
+        ? `${buildRelayHeader(sender)} (no reply body)`
+        : `${buildRelayHeader(sender)} ${body}`;
+}
+/** Collapse whitespace and clip, so a 40-line dialog is one readable line. */
+function squeeze(text, max) {
+    const flat = text.replace(/\s+/g, ' ').trim();
+    return flat.length <= max ? flat : `${flat.slice(0, max - 1)}…`;
+}
+const PROMPT_TEMPLATES = {
+    en: {
+        waiting: 'is waiting for a confirmation:',
+        options: 'Options:',
+        more: '(+{n} more)',
+    },
+    ja: {
+        waiting: '確認待ちです:',
+        options: '選択肢:',
+        more: '(他 {n} 件)',
+    },
+};
+/**
+ * "They are blocked on a dialog, and here is what it asks."
+ *
+ * Deliberately NOT an instruction to answer it. `respond` on somebody else's
+ * dialog picks whatever option happens to be highlighted (#1681), and the
+ * delegation brief already forbids it; this notice exists so A can decide what
+ * to do, which is usually to tell a human.
+ */
+function buildRelayPromptMessage(locale, sender, notice) {
+    const t = PROMPT_TEMPLATES[locale];
+    const head = `${buildRelayHeader(sender)} ${t.waiting} ${squeeze(notice.question, PROMPT_SUMMARY_MAX_CHARS)}`;
+    if (notice.options.length === 0)
+        return head;
+    const shown = notice.options.slice(0, PROMPT_OPTIONS_MAX);
+    const rest = notice.options.length - shown.length;
+    const listed = shown.map((o) => `${o.key}) ${squeeze(o.label, 60)}`).join('  ');
+    const more = rest > 0 ? ` ${t.more.replace('{n}', String(rest))}` : '';
+    return `${head}\n${t.options} ${listed}${more}`;
+}
+const EXPIRED_TEMPLATES = {
+    en: 'The reply you were waiting for did not arrive within {hours}h; the relay has expired.',
+    ja: '待っていた返信が {hours} 時間以内に届かなかったため、委任は期限切れになりました。',
+};
+/**
+ * The single line an expired relay leaves in A's composer.
+ *
+ * One line and one only — the Issue's "1行だけ通知". The once-ness is enforced
+ * by the ledger (`markRelayExpired` is a guarded update), not by this string.
+ */
+function buildRelayExpiredMessage(locale, sender, ttlMs) {
+    const hours = Math.max(1, Math.round(ttlMs / 3_600_000));
+    return `${buildRelayHeader(sender)} ${EXPIRED_TEMPLATES[locale].replace('{hours}', String(hours))}`;
+}
+const SYSTEM_TEMPLATES = {
+    en: {
+        requested: 'Delegated to {alias}; waiting for the reply.',
+        replied: 'Reply from {alias}.',
+        waiting: '{alias} is waiting for a confirmation.',
+        expired: 'The delegation to {alias} expired without a reply.',
+    },
+    ja: {
+        requested: '{alias} へ委任、返信待ち',
+        replied: '{alias} から返信',
+        waiting: '{alias} が確認待ち',
+        expired: '{alias} への委任が返信のないまま期限切れ',
+    },
+};
+/**
+ * The one-line system row the chat surface and History both show.
+ *
+ * Written into `chat_messages` exactly as the model-change row is (#2357), in
+ * the readers' language, because a stored row cannot be re-rendered per viewer.
+ */
+function buildRelaySystemLine(locale, kind, alias) {
+    return SYSTEM_TEMPLATES[locale][kind].replace('{alias}', alias);
+}

package/dist/server/src/lib/relay/relay-policy.js

@@ -0,0 +1,127 @@
+"use strict";
+/**
+ * The four rules that stop relays from becoming a loop (Issue #2377).
+ *
+ * A relay is a standing instruction that fires on somebody else's turn, so the
+ * failure mode it introduces is not "a wrong answer" but "two agents talking to
+ * each other forever, each one's reply being the other's next prompt". None of
+ * the guards below is expensive; all four exist because the cheap version of
+ * this feature has no natural stopping point.
+ *
+ *  1. **A relayed message may not open a relay** (`RELAY_CHAIN_BLOCKED`). The
+ *     default. `--allow-relay-chain` is the deliberate override, and the flag is
+ *     named after what it permits rather than after what it disables.
+ *  2. **Chains are bounded** (`RELAY_HOPS_EXCEEDED`). Even with the override,
+ *     depth stops at {@link MAX_RELAY_HOPS}.
+ *  3. **One open relay per direction** (`RELAY_DUPLICATE_PENDING`). A second
+ *     standing instruction from A to B says nothing the first does not, and both
+ *     would fire on the same finished turn.
+ *  4. **A session may not relay to itself** (`RELAY_SELF_TARGET`), which is a
+ *     one-message loop with no second party in it at all.
+ *
+ * Pure: every decision is a function of values the caller already read. The
+ * database work — finding the parent relay, counting the open ones — is
+ * `relay-service`'s, so the rules can be tested without a schema.
+ *
+ * @module lib/relay/relay-policy
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RELAY_PUMP_INTERVAL_MS = exports.RELAY_SCRAPE_QUIET_MS = exports.MAX_OPEN_RELAYS_PER_PAIR = exports.MAX_RELAY_HOPS = exports.MAX_RELAY_TTL_MS = exports.MIN_RELAY_TTL_MS = exports.DEFAULT_RELAY_TTL_MS = void 0;
+exports.isSameEndpoint = isSameEndpoint;
+exports.decideRelayCreation = decideRelayCreation;
+exports.isRelayRefusal = isRelayRefusal;
+exports.resolveRelayTtlMs = resolveRelayTtlMs;
+/** How long a relay stands before it is swept. 24h, per the Issue. */
+exports.DEFAULT_RELAY_TTL_MS = 24 * 60 * 60 * 1000;
+/** Shortest TTL a caller may ask for: one minute. */
+exports.MIN_RELAY_TTL_MS = 60 * 1000;
+/** Longest TTL a caller may ask for: seven days. */
+exports.MAX_RELAY_TTL_MS = 7 * 24 * 60 * 60 * 1000;
+/**
+ * How deep a chain may go.
+ *
+ * Three, by the Issue. Depth 1 is a relay nothing relayed into; a relay opened
+ * while answering one is 2, and so on. A request that would create depth 4 is
+ * refused — `--allow-relay-chain` widens the door, it does not remove the wall.
+ */
+exports.MAX_RELAY_HOPS = 3;
+/** How many open relays one from→to direction may hold at once. */
+exports.MAX_OPEN_RELAYS_PER_PAIR = 1;
+/**
+ * How long a scrape-only tool must sit still before its pane counts as a reply.
+ *
+ * copilot, gemini and vibe-local keep no transcript, so what a completed turn
+ * leaves behind is the poller's copy of the SCREEN — and the poller's completion
+ * judgement is a string analysis of a frame that is still being drawn. Delivering
+ * on the first such judgement is how a half-written answer reaches session A as
+ * "the reply". The relay therefore waits, re-reads the newest row and delivers
+ * only if nothing newer arrived: the Issue's 「完了検知 + 数秒の静穏」.
+ *
+ * Tools with a transcript skip this entirely — their reader answers `true` only
+ * for a turn the agent has closed, which is a stronger statement than any amount
+ * of quiet.
+ */
+exports.RELAY_SCRAPE_QUIET_MS = 4_000;
+/** How often the pump retries deliveries and sweeps expired relays. */
+exports.RELAY_PUMP_INTERVAL_MS = 15_000;
+/** Whether two endpoints name the same session. */
+function isSameEndpoint(a, b) {
+    return a.worktreeId === b.worktreeId && a.instanceId === b.instanceId;
+}
+/**
+ * Apply all four rules and hand back the depth, or the refusal.
+ *
+ * Order matters only for which sentence an operator sees first, and it is the
+ * order they can act on: "you are the same session" is a typo, "this would be a
+ * chain" is a flag away, "the chain is too deep" and "you already have one" are
+ * decisions about work in flight.
+ */
+function decideRelayCreation(input) {
+    if (isSameEndpoint(input.from, input.to)) {
+        return {
+            code: 'RELAY_SELF_TARGET',
+            message: 'A session cannot relay a reply to itself. --reply-to must name a different '
+                + 'worktree or a different agent instance.',
+        };
+    }
+    const hops = input.parentHops === null ? 1 : input.parentHops + 1;
+    if (input.parentHops !== null && !input.allowRelayChain) {
+        return {
+            code: 'RELAY_CHAIN_BLOCKED',
+            message: 'The last message this session was given arrived over a relay, so opening '
+                + 'another one would chain two deliveries together. Pass --allow-relay-chain '
+                + 'if that is what you mean.',
+        };
+    }
+    if (hops > exports.MAX_RELAY_HOPS) {
+        return {
+            code: 'RELAY_HOPS_EXCEEDED',
+            message: `Relay chains stop at ${exports.MAX_RELAY_HOPS} hops; this one would be ${hops}. `
+                + 'Report the reply to whoever asked instead of forwarding it again.',
+        };
+    }
+    if (input.openBetween >= exports.MAX_OPEN_RELAYS_PER_PAIR) {
+        return {
+            code: 'RELAY_DUPLICATE_PENDING',
+            message: 'There is already an open relay between these two sessions. Wait for it, or '
+                + 'withdraw it with `commandmate relays cancel <id>`.',
+        };
+    }
+    return { ok: true, hops };
+}
+/** Whether a verdict is a refusal. */
+function isRelayRefusal(verdict) {
+    return 'code' in verdict;
+}
+/**
+ * Clamp a requested TTL into the supported window.
+ *
+ * Clamped rather than refused: the TTL is a sweep deadline, not a promise, and
+ * an operator who asked for a year gets the longest one that keeps the ledger
+ * from accumulating rows nobody will ever collect.
+ */
+function resolveRelayTtlMs(requested) {
+    if (requested === undefined || !Number.isFinite(requested))
+        return exports.DEFAULT_RELAY_TTL_MS;
+    return Math.min(exports.MAX_RELAY_TTL_MS, Math.max(exports.MIN_RELAY_TTL_MS, Math.trunc(requested)));
+}

package/dist/server/src/lib/relay/relay-readiness.js

@@ -0,0 +1,63 @@
+"use strict";
+/**
+ * "Can session A be typed into right now?" (Issue #2377).
+ *
+ * A relay's delivery is a message put into a composer that belongs to somebody
+ * else's turn, so it has to ask the question `send` asks and one more besides.
+ *
+ *  - **Is the session alive?** A relay to a pane that was closed has nowhere to
+ *    land; holding it until the deadline is the honest answer, not starting a
+ *    session on the operator's behalf to receive an answer they may never read.
+ *  - **Is it mid-turn?** This is the one `send` does NOT ask, and the Issue asks
+ *    for it by name: typing into a `running` composer interrupts the turn that
+ *    is running. The relay waits for `ready` instead — the ledger is durable, so
+ *    waiting costs nothing but time.
+ *
+ * The prompt-dialog question is deliberately NOT asked here: `sendUserMessage`
+ * already refuses a send that would land in an open dialog (#1708/#1737), and
+ * duplicating that judgement would give the relay path its own second opinion
+ * about a state the send path is the authority on. A refusal there is a retry
+ * here.
+ *
+ * Fail-open on an unreadable pane, for the same reason `prompt-waiting-guard`
+ * fails open: the cost of a wrong "ready" is a message the send path refuses
+ * and the pump retries, while the cost of a wrong "not ready" is a relay that
+ * expires holding an answer somebody is waiting for.
+ *
+ * @module lib/relay/relay-readiness
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findRelayHoldReason = findRelayHoldReason;
+const manager_1 = require("../../lib/cli-tools/manager");
+const cli_session_1 = require("../../lib/session/cli-session");
+const status_detector_1 = require("../../lib/detection/status-detector");
+const status_capture_config_1 = require("../../config/status-capture-config");
+const logger_1 = require("../../lib/logger");
+const logger = (0, logger_1.createLogger)('relay-readiness');
+/**
+ * Whether a relay may be delivered into this session now.
+ *
+ * @returns `null` when the session can take the message, else why it cannot
+ */
+async function findRelayHoldReason(worktreeId, cliToolId, instanceId) {
+    try {
+        const cliTool = manager_1.CLIToolManager.getInstance().getTool(cliToolId);
+        if (!(await cliTool.isRunning(worktreeId, instanceId)))
+            return 'session_stopped';
+        const output = await (0, cli_session_1.captureSessionOutput)(worktreeId, cliToolId, status_capture_config_1.STATUS_CAPTURE_LINES, instanceId);
+        const status = (0, status_detector_1.detectSessionStatus)(output, cliToolId);
+        // Only `running` holds. `waiting` is a dialog, which is the send path's
+        // judgement to make (and its refusal is a retry); `idle` and `ready` both
+        // mean the composer is the thing on screen.
+        return status.status === 'running' ? 'generating' : null;
+    }
+    catch (error) {
+        logger.warn('relay-readiness-check-failed', {
+            worktreeId,
+            cliToolId,
+            instanceId,
+            error: error instanceof Error ? error.message : String(error),
+        });
+        return null;
+    }
+}

package/dist/server/src/lib/relay/relay-session-ref.js

@@ -0,0 +1,72 @@
+"use strict";
+/**
+ * Turning "worktree + instance" into the three facts a relay needs (#2377).
+ *
+ * A ledger row stores two ids and nothing else, on purpose — an alias can be
+ * renamed and a roster row deleted, and a relay must survive both. Everything
+ * else a delivery needs (which CLI tool drives the session, what to call it in
+ * the attribution header) is therefore resolved at the moment it is needed, from
+ * the roster, with the id as the fallback for every field.
+ *
+ * Never throws. A relay whose roster cannot be read still delivers, attributed
+ * to the instance id — which is worse to read and strictly better than not
+ * delivering.
+ *
+ * @module lib/relay/relay-session-ref
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveRelaySession = resolveRelaySession;
+exports.relayWorktreeExists = relayWorktreeExists;
+const agent_instances_db_1 = require("../../lib/db/agent-instances-db");
+const worktree_db_1 = require("../../lib/db/worktree-db");
+const logger_1 = require("../../lib/logger");
+const logger = (0, logger_1.createLogger)('relay-session-ref');
+/** The tool assumed when neither the roster nor the worktree declares one. */
+const FALLBACK_CLI_TOOL = 'claude';
+/**
+ * Resolve one end of a relay.
+ *
+ * The tool comes from `resolveInstanceCliTool` — the same authority
+ * `POST /api/worktrees/:id/send` uses, so a relay cannot address a session the
+ * send route would address differently (#1629 is the record of what two
+ * authorities on that cost) — falling back to the worktree's own tool and then
+ * to claude.
+ */
+function resolveRelaySession(db, endpoint) {
+    let cliToolId = FALLBACK_CLI_TOOL;
+    let alias = endpoint.instanceId;
+    try {
+        const resolution = (0, agent_instances_db_1.resolveInstanceCliTool)(db, endpoint.worktreeId, endpoint.instanceId);
+        if (resolution.ok && resolution.cliToolId) {
+            cliToolId = resolution.cliToolId;
+        }
+        else {
+            cliToolId = (0, worktree_db_1.getWorktreeById)(db, endpoint.worktreeId)?.cliToolId ?? FALLBACK_CLI_TOOL;
+        }
+        const rosterRow = (0, agent_instances_db_1.getAgentInstance)(db, endpoint.worktreeId, endpoint.instanceId);
+        if (rosterRow?.alias)
+            alias = rosterRow.alias;
+    }
+    catch (error) {
+        logger.warn('relay-session-resolve-failed', {
+            worktreeId: endpoint.worktreeId,
+            instanceId: endpoint.instanceId,
+            error: error instanceof Error ? error.message : String(error),
+        });
+    }
+    return {
+        worktreeId: endpoint.worktreeId,
+        instanceId: endpoint.instanceId,
+        cliToolId,
+        alias,
+    };
+}
+/** Whether this worktree exists at all. The one check a create must make. */
+function relayWorktreeExists(db, worktreeId) {
+    try {
+        return (0, worktree_db_1.getWorktreeById)(db, worktreeId) !== null;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/server/src/lib/relay/relay-system-line.js

@@ -0,0 +1,79 @@
+"use strict";
+/**
+ * The one-line system rows a relay leaves in the requester's transcript (#2377).
+ *
+ * Exactly the mechanism Issue #2357 built for "the model changed": a row in
+ * `chat_messages`, written in the readers' language, followed by the same
+ * `message` frame `sendUserMessage` publishes. One write therefore reaches the
+ * chat surface, the History tab and any transcript that happens to be open,
+ * without a fourth history surface being invented for four sentences.
+ *
+ * Idempotent: the request id is `relay-sys:<relayId>:<kind>` and each row is
+ * probed for before it is written, so a delivery that is retried — which the
+ * pump does by design — does not stack four "waiting for the reply" lines.
+ *
+ * Never throws. A transcript line is the least important of a relay's three
+ * effects, and it must not cost the delivery.
+ *
+ * @module lib/relay/relay-system-line
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeRelaySystemLine = writeRelaySystemLine;
+const chat_db_1 = require("../../lib/db/chat-db");
+const model_change_push_notifier_1 = require("../../lib/push/model-change-push-notifier");
+const ws_server_1 = require("../../lib/ws-server");
+const relay_messages_1 = require("../../lib/relay/relay-messages");
+const logger_1 = require("../../lib/logger");
+const logger = (0, logger_1.createLogger)('relay-system-line');
+/**
+ * Write one system line into `target`'s transcript, once.
+ *
+ * @param db - Database
+ * @param relayId - The ledger row the line is about
+ * @param kind - Which of the four sentences
+ * @param target - Whose transcript the line goes in (always the requester, A)
+ * @param subject - Whose name the sentence carries (always the worker, B)
+ * @param at - Epoch ms
+ * @returns Whether a row was written by this call
+ */
+function writeRelaySystemLine(db, relayId, kind, target, subject, at = Date.now()) {
+    const requestId = `${chat_db_1.RELAY_SYSTEM_REQUEST_ID_PREFIX}${relayId}:${kind}`;
+    try {
+        if ((0, chat_db_1.findMessageByRequestId)(db, target.worktreeId, requestId))
+            return false;
+        const locale = (0, model_change_push_notifier_1.resolveReadersLocale)(db);
+        const message = (0, chat_db_1.createRelaySystemMessage)(db, {
+            worktreeId: target.worktreeId,
+            cliToolId: target.cliToolId,
+            instanceId: target.instanceId,
+            content: (0, relay_messages_1.buildRelaySystemLine)(locale, kind, subject.alias),
+            relayId,
+            kind,
+            at,
+        });
+        try {
+            (0, ws_server_1.broadcastMessage)('message', {
+                worktreeId: target.worktreeId,
+                message: { ...message, cliToolId: target.cliToolId, instanceId: target.instanceId },
+            });
+        }
+        catch (error) {
+            // The row is already durable; a socket with no owner must not turn a
+            // written line into a failure the caller reports.
+            logger.warn('relay-system-line-broadcast-failed', {
+                relayId,
+                kind,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+        return true;
+    }
+    catch (error) {
+        logger.warn('relay-system-line-failed', {
+            relayId,
+            kind,
+            error: error instanceof Error ? error.message : String(error),
+        });
+        return false;
+    }
+}

package/dist/server/src/lib/relay/relay-triggers.js

@@ -0,0 +1,177 @@
+"use strict";
+/**
+ * Where a relay is woken up (Issue #2377).
+ *
+ * Three edges matter, and this module is the seam each of them calls into. It
+ * exists as a seam rather than as three direct calls for one concrete reason:
+ * the delivery reaches `sendUserMessage`, which reaches `response-poller`, which
+ * reaches `response-checker` — one of the callers below. A static import would
+ * close that cycle, so every entry point here loads `relay-delivery` lazily and
+ * the poller's module graph stays what it was. It is the same move
+ * `stop-history-capture` makes for the transcript readers, and for the same
+ * reason.
+ *
+ * The three edges:
+ *
+ *  1. **A turn ended.** {@link onRelayTurnCompleted}, called from the two places
+ *     that record a finished reply — the structured-history gate (the agent's
+ *     own transcript; both the Stop hook and the poller reach it) and the
+ *     poller's own scrape, for the tools that keep no transcript.
+ *  2. **A session stopped on a dialog.** The waiting edge, subscribed to here
+ *     rather than polled: `waiting-episode-state` already makes the crossing
+ *     observable exactly once, and a fourth surface keeping its own "was it
+ *     waiting last time?" is precisely what #1786 exists to prevent.
+ *  3. **Time passed.** The maintenance tick — expire the deadlines, retry the
+ *     deliveries a busy composer refused.
+ *
+ * Armed by `startWaitingStatusBroadcast`, which `ws-server` calls from
+ * `setupWebSocket`; disarmed with it. That is where #2357 put the model-change
+ * subscription for the same reason: it is the one place in the process that
+ * knows the server is up, and a suite that stands a server up and tears it down
+ * leaves nothing running.
+ *
+ * @module lib/relay/relay-triggers
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onRelayTurnCompleted = onRelayTurnCompleted;
+exports.onRelayPromptWaiting = onRelayPromptWaiting;
+exports.runRelayMaintenance = runRelayMaintenance;
+exports.startRelayTriggers = startRelayTriggers;
+exports.stopRelayTriggers = stopRelayTriggers;
+exports.areRelayTriggersActive = areRelayTriggersActive;
+const waiting_episode_state_1 = require("../../lib/session/waiting-episode-state");
+const relay_policy_1 = require("../../lib/relay/relay-policy");
+const logger_1 = require("../../lib/logger");
+const logger = (0, logger_1.createLogger)('relay-triggers');
+/**
+ * Tell the relays that this instance finished a turn.
+ *
+ * `settled` distinguishes the two producers: `true` for a turn the agent's own
+ * transcript says is closed, `false` for one judged from the screen — which is
+ * what makes the quiet window in `relay-delivery` apply to exactly the tools
+ * that need it.
+ *
+ * Fire-and-forget and never throws: this is called from inside the poller's save
+ * path and from a hook receiver, and in both a relay failure must not cost the
+ * turn that was just recorded.
+ */
+function onRelayTurnCompleted(worktreeId, cliToolId, instanceId, settled) {
+    const worker = { worktreeId, cliToolId, instanceId: instanceId ?? cliToolId };
+    void (async () => {
+        try {
+            const { notifyRelayTurnCompleted } = await Promise.resolve().then(() => __importStar(require('../../lib/relay/relay-delivery')));
+            await notifyRelayTurnCompleted(worker, { settled });
+        }
+        catch (error) {
+            logger.warn('relay-turn-trigger-failed', {
+                worktreeId,
+                cliToolId,
+                instanceId: worker.instanceId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    })();
+}
+/** Tell the relays that this instance is blocked on a confirmation. */
+function onRelayPromptWaiting(worktreeId, cliToolId, instanceId) {
+    const worker = { worktreeId, cliToolId, instanceId: instanceId ?? cliToolId };
+    void (async () => {
+        try {
+            const { notifyRelayPromptWaiting } = await Promise.resolve().then(() => __importStar(require('../../lib/relay/relay-delivery')));
+            notifyRelayPromptWaiting(worker);
+        }
+        catch (error) {
+            logger.warn('relay-prompt-trigger-failed', {
+                worktreeId,
+                cliToolId,
+                instanceId: worker.instanceId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    })();
+}
+/** Run one maintenance tick now. Exported for the suite and for the timer. */
+async function runRelayMaintenance() {
+    try {
+        const { runRelayMaintenanceTick } = await Promise.resolve().then(() => __importStar(require('../../lib/relay/relay-delivery')));
+        await runRelayMaintenanceTick();
+    }
+    catch (error) {
+        logger.warn('relay-maintenance-failed', {
+            error: error instanceof Error ? error.message : String(error),
+        });
+    }
+}
+/**
+ * Subscribe to the waiting edge and start the maintenance loop.
+ *
+ * Idempotent: calling it again replaces what is already armed rather than
+ * adding a second copy, so a re-entered `setupWebSocket` cannot notify twice or
+ * leave two timers running.
+ */
+function startRelayTriggers() {
+    stopRelayTriggers();
+    globalThis.__relayTriggersUnsubscribe = (0, waiting_episode_state_1.onWaitingTransition)((transition) => {
+        // Only the OPENING edge, and only a real dialog. `menu` is a pager or a
+        // model picker — nobody is being asked anything — and `unclassified` is a
+        // frame the detectors failed on, which is not something to describe to
+        // another session as a question it might report to a human.
+        if (!transition.waiting || transition.kind !== 'prompt')
+            return;
+        onRelayPromptWaiting(transition.worktreeId, transition.cliToolId, transition.instanceId);
+    });
+    const timer = setInterval(() => void runRelayMaintenance(), relay_policy_1.RELAY_PUMP_INTERVAL_MS);
+    // The loop must not be the reason a process stays alive: a CLI that imported
+    // this graph for one call would otherwise never exit.
+    timer.unref?.();
+    globalThis.__relayMaintenanceTimer = timer;
+}
+/** Drop the subscription and the timer. Safe when nothing is armed. */
+function stopRelayTriggers() {
+    const unsubscribe = globalThis.__relayTriggersUnsubscribe;
+    if (unsubscribe) {
+        unsubscribe();
+        globalThis.__relayTriggersUnsubscribe = undefined;
+    }
+    if (globalThis.__relayMaintenanceTimer) {
+        clearInterval(globalThis.__relayMaintenanceTimer);
+        globalThis.__relayMaintenanceTimer = undefined;
+    }
+}
+/** Whether the triggers are armed. Test seam. */
+function areRelayTriggersActive() {
+    return globalThis.__relayTriggersUnsubscribe !== undefined;
+}