@open-everywhere/core 0.1.0

package/dist/agent/channels/turn-cancel.js

@@ -0,0 +1,310 @@
+// turn-cancel — the surface-neutral half of "stop the turn". Every stop trigger on every surface funnels through {@link cancelAnchoredTurn}: resolve the anchor from the durable registry, call eve's cancel door, write one audit row. NO SESSION IS MINTED, NO MODEL IS CALLED, NOTHING IS SPENT — which is the point, because an inference-priced stop would stop working for exactly the person most likely to need it.
+// THE RESULT LIES, so do not report it as truth: eve answers `accepted` for a cancel it then drops, and that proves only the session's command hook existed. This module's return is a RECEIPT for the ingress's own logging, never a claim that work stopped; the truth arrives as the `turn.cancelled` EVENT, and a stop that was accepted and never applied earns its OWN `turn.stop_ignored` row rather than widening that one. Copy discipline: "stood down", never "stopped" and never "undone" — the side effects of an aborted step already happened and are irreversible.
+import { appendAudit, readAudit } from "../audit/audit.js";
+import { resolveTurnAnchor, TURN_ANCHOR_TTL_MS } from "./turn-registry.js";
+/** The audit action for an ingress-side cancel request. One row per REQUEST (not per outcome), so
+ *  "someone asked it to stop and nothing was running" is as visible as a successful cancel. */
+export const TURN_CANCEL_ACTION = "turn.cancel_requested";
+/** The audit action for a turn that was actually cancelled — written from the TURN's process
+ *  (hooks/turn-anchor.ts), which is the only one that observes `turn.cancelled`. The ingress writes
+ *  {@link TURN_CANCEL_ACTION}; the pair is what lets "asked to stop" and "actually stopped" be told
+ *  apart, which matters because eve's own `cancel()` return value cannot distinguish them. */
+export const TURN_CANCELLED_ACTION = "turn.cancelled";
+/**
+ * The audit action for a stop the ingress ACCEPTED and the runtime never APPLIED (OPE-1190) — the
+ * second, distinct row of the cancel evidence pair, written from the turn's process
+ * (hooks/turn-anchor.ts).
+ *
+ * 🔴 IT EXISTS SO `turn.cancelled` CAN STAY STRICT. eve answers the ingress `accepted` for a cancel
+ * it then drops; measured, ~18% of sequential runs of the cancel liveness family end the stopped
+ * turn on the ordinary completion path with no `turn.cancelled` event at all. Before this row that
+ * left NO record: an operator saw an acknowledgement, and the audit held a `turn.cancel_requested`
+ * with nothing paired to it — indistinguishable from a request the store simply lost. Widening
+ * `turn.cancelled` to cover it would have closed the visible hole by weakening the evidence claim:
+ * a reader could no longer tell a genuine cancel from an ignored stop. This row keeps both facts
+ * legible, and turns the hole into evidence.
+ *
+ * READ THE PAIR TOGETHER, AND READ IT AS STRONG EVIDENCE RATHER THAN AS AN INVARIANT. Both rows
+ * carry the ids that join back to the request, and in the ordinary case exactly one of them follows
+ * it. Five states break that, and an operator has to know them or the pair misleads:
+ *   • BOTH rows ⇒ the cancel settled later than the turn's own settle grace. The `turn.cancelled`
+ *     row is the true one; the ignored-stop row is a false finding, and the room got two notes.
+ *   • NEITHER row YET ⇒ the turn has not ended. Both partner rows are written from a terminal arm,
+ *     and NOTHING CAPS A TURN'S DURATION, so a stop of a long-running turn is simply not owed a
+ *     partner yet. This is the ordinary case, not a defect, and it is the biggest population in
+ *     {@link unpairedStops}.
+ *   • NEITHER row ⇒ the decision never resolved. The check is scheduled and drained from awaited
+ *     hook arms, but a process suspended before any of them runs takes the answer with it.
+ *   • NEITHER row, and the turn had ALREADY ENDED when the request landed ⇒ there was no terminal
+ *     arm left to notice the stop at all (OPE-1195). {@link unpairedStops} is the reader-side join
+ *     that lists the candidates for this class, because no seam inside the turn can see it.
+ *   • DUPLICATE ignored-stop rows for ONE turn ⇒ the arm's own pre-check (`pairedRowExists` in
+ *     hooks/turn-anchor.ts) READS the audit and then appends, with no transaction between the two,
+ *     so two processes can each see no row and each write one. 🔴 COUNT DISTINCT
+ *     `(sessionId, turnId)` PAIRS, NEVER ROWS — every count over these actions, this module's own
+ *     partner set included.
+ * So an unpaired `turn.cancel_requested` is worth investigating and is not proof on its own.
+ */
+export const TURN_STOP_IGNORED_ACTION = "turn.stop_ignored";
+/**
+ * Is this message body a bare STOP DIRECTIVE? It exists for ONE surface, and only because that vendor sends no webhook for a reaction at all, so the ✋ affordance every other surface reaches through a reaction event is unreachable there.
+ * It is narrow on purpose rather than a magic string: it matches ONLY a comment whose ENTIRE body is the word, so "please stop" and a stop word inside a sentence stay messages for the agent to read. There is deliberately NO @mention spelling, because that would be a MENTION and eve's native channel would open a session for it — cancelling the running turn and starting a new one in the same breath.
+ */
+export function isStopDirective(body) {
+    if (typeof body !== "string")
+        return false;
+    return STOP_DIRECTIVE.test(body.trim());
+}
+/** The one shape {@link isStopDirective} accepts. Anchored at both ends: a body with anything else
+ *  in it is a message, not a directive. */
+const STOP_DIRECTIVE = /^(?:\/oe\s+)?stop[.!]?$/i;
+/**
+ * Ask eve to cancel the turn a stop trigger points at: resolve the anchor, call the cancel door with the turn id, audit, and return a receipt.
+ * `turnId` is passed ALWAYS — without it a stop that raced a turn boundary would kill the NEXT turn, the one the human never asked to stop, and they would have no way to tell. It NEVER THROWS: a stop affordance that can 500 an ingress route is worse than one that quietly reports it found nothing.
+ */
+export async function cancelAnchoredTurn(input) {
+    const anchor = await resolveTurnAnchor(input.org, input.query);
+    if (!anchor) {
+        await auditCancel(input, { outcome: "no_turn_found" });
+        return { outcome: "no_turn_found", message: NOTHING_RUNNING };
+    }
+    let status;
+    try {
+        const res = await input.attachSession(anchor.sessionId).cancel({ turnId: anchor.turnId });
+        status = typeof res?.status === "string" ? res.status : undefined;
+    }
+    catch (err) {
+        await auditCancel(input, { outcome: "error", anchorSurfaceKey: anchor.surfaceKey, note: String(err), sessionId: anchor.sessionId, turnId: anchor.turnId });
+        return { outcome: "error", message: "Couldn't reach that turn to stand it down — try again in a moment.", sessionId: anchor.sessionId, turnId: anchor.turnId };
+    }
+    // eve reports `no_active_turn` for a session that is parked rather than working. That is a real
+    // answer, not a failure — and it is one a human genuinely wants to hear, because it means the
+    // agent is already waiting on them.
+    const outcome = status === "no_active_turn" ? "no_active_turn" : "requested";
+    await auditCancel(input, { outcome, anchorSurfaceKey: anchor.surfaceKey, sessionId: anchor.sessionId, turnId: anchor.turnId, ...(status ? { status } : {}) });
+    return {
+        outcome,
+        message: outcome === "no_active_turn" ? NOTHING_RUNNING : STANDING_DOWN,
+        sessionId: anchor.sessionId,
+        turnId: anchor.turnId,
+    };
+}
+/** Nothing was running. Deliberately the SAME sentence for "no anchor" and "parked": from the
+ *  human's side the two are one fact — the agent isn't doing anything right now. */
+const NOTHING_RUNNING = "Nothing running here right now — I'm already waiting on you.";
+/**
+ * The receipt for an accepted cancel. IT PROMISES A REQUEST, NEVER AN OUTCOME: eve answers `accepted` for a cancel it then drops, so a claim about the TURN is one this process can neither make nor check.
+ * What it CAN promise is the follow-up — the turn's own process posts the outcome into the thread on both paths. Three things break even that: a surface with no message transport, a post whose transport failure is swallowed, and an ignored-stop decision that never resolves on a suspended instance.
+ */
+const STANDING_DOWN = "Standing down — I've asked this turn to stop. I'll post the outcome in the thread.";
+/** How many recent cancel-request rows the join scans. Generous: a stop is a rare, human-paced act,
+ *  so the matching row is all but always the newest one for the org. */
+const CANCEL_REQUEST_SCAN = 50;
+/**
+ * How far back {@link findCancelRequest} looks — a PERFORMANCE bound, not a policy one. The audit table is indexed on `(org, ts)` and NOT on `action`, so an action filter with no time bound walks the org's whole history newest-first, which is unaffordable for a question asked at the end of EVERY turn.
+ * IT IS A COVERAGE TRADE, NOT A PROOF: nothing in this repo caps a turn's duration, so a turn still running past this window finds no request row and writes no ignored-stop row at all — and a runaway turn is exactly what an ignored stop leaves behind. Widening it is cheap in code and expensive in scan.
+ */
+const CANCEL_REQUEST_WINDOW_MS = 2 * TURN_ANCHOR_TTL_MS;
+/**
+ * A principal id this module is willing to put in front of the MODEL. The reminder lands in the TRUSTED standing block inside a markdown code span, so a value carrying a backtick, a newline or an angle bracket could close that span and forge instruction text.
+ * The shape is therefore checked rather than assumed, and a value that fails is DROPPED — never escaped and never truncated, because a mangled id names nobody and this feature exists to name somebody or say nothing.
+ */
+const PLAIN_PRINCIPAL_ID = /^[A-Za-z0-9._:@|+-]{1,64}$/;
+/**
+ * The paired `turn.cancel_requested` row for one turn, or `undefined`. THIS IS THE ONLY WAY THE ANSWER IS KNOWABLE: eve's terminal events carry no cancel history at all, so the turn's own process cannot learn from the runtime that a stop was ever asked for. The ingress records it, and the session and turn ids in that row's detail are what make the pair joinable.
+ * BOTH IDS, not just the turn: eve numbers turns PER SESSION, so a turn id alone repeats across sessions and can match a different turn's request row. It THROWS when the store does, deliberately — a caller whose whole job is to notice a missing row must tell "no request" apart from "could not read". Bounded twice: a row cap, and the TIME window that is what keeps this affordable at the end of every turn.
+ */
+export async function findCancelRequest(input) {
+    const since = new Date(Date.now() - CANCEL_REQUEST_WINDOW_MS).toISOString();
+    const rows = await readAudit({ org: input.org, action: TURN_CANCEL_ACTION, since, limit: CANCEL_REQUEST_SCAN });
+    for (const row of rows) {
+        // Newest-first, so the first match is the most recent request for this turn — the right answer
+        // when a human pressed ✋ twice.
+        const detail = row.detail ?? {};
+        if (detail["turnId"] !== input.turnId)
+            continue;
+        const rowSessionId = detail["sessionId"];
+        if (input.sessionId !== undefined && typeof rowSessionId === "string" && rowSessionId !== input.sessionId)
+            continue;
+        return {
+            ...(typeof row.principalId === "string" ? { principalId: row.principalId } : {}),
+            ...(typeof detail["via"] === "string" ? { via: detail["via"] } : {}),
+            ...(typeof detail["outcome"] === "string" ? { outcome: detail["outcome"] } : {}),
+            ...(typeof row.ts === "string" ? { at: row.ts } : {}),
+        };
+    }
+    return undefined;
+}
+/**
+ * WHO asked to stop this turn, from the paired `turn.cancel_requested` row — or `undefined`.
+ * It NEVER THROWS AND NEVER GUESSES: `undefined` covers all four honest cases — the stop did not come through OE, the request row has not landed, the store is unreachable, or the recorded id is not a shape safe to show a model. The caller renders the anonymous wording for all of them.
+ */
+export async function findCancelRequester(org, turnId, sessionId) {
+    try {
+        const by = (await findCancelRequest({ org, turnId, ...(sessionId === undefined ? {} : { sessionId }) }))?.principalId;
+        return typeof by === "string" && PLAIN_PRINCIPAL_ID.test(by) ? by : undefined;
+    }
+    catch {
+        return undefined; // the store is unreachable — a missing name must never affect the turn
+    }
+}
+// --- the reader-side join (OPE-1195) -----------------------------------------------------------
+//
+// {@link findCancelRequest} above joins from the TURN's side: a turn that is ending asks whether a
+// stop was requested for it. That join can only run while there is still a turn to end, so it
+// cannot see the one shape that has no arm at all — a `turn.cancel_requested` row that lands AFTER
+// its turn already ended. The window is small (the ingress reads a live anchor, the turn ends and
+// clears it, eve still answers `accepted` because the session is alive, and the ingress writes the
+// request row), and NOBODY HAS EVER COUNTED IT, because the audit could not answer the question.
+//
+// {@link unpairedStops} is that question, asked from the READER's side: which accepted stop
+// requests hold no partner row after a grace.
+//
+// 🔴 IT LISTS CANDIDATES, IT DOES NOT MEASURE A RATE. Both partner rows are written from a terminal
+// arm and nothing caps a turn's duration, so the biggest population in any answer is the ordinary
+// one — stops of turns that are simply still running. The constant docs above list all four states
+// that put a request here, and only one of them is this residual. What isolates the residual is the
+// GRACE: set it longer than the longest turn the deployment actually runs, and what remains is the
+// class with no arm. Counting the rows at the default grace and calling the number a rate is wrong.
+//
+// THE LIST IS PER REQUEST ROW, NOT PER TURN. One turn can carry several accepted requests — a person
+// who pressed ✋ twice — and each unpaired one lists separately. The partner side already collapses
+// duplicates (the join builds a SET of `(sessionId, turnId)` keys, which is what the duplicate
+// ignored-stop row above requires); the request side deliberately does not, because who asked and
+// when are per-request facts. A caller counting TURNS must reduce on `(sessionId, turnId)` itself.
+/** How far back {@link unpairedStops} looks by default. A day: long enough to hold a working
+ *  session's stops, short enough that the `(org, ts)` index does the work. */
+const UNPAIRED_STOP_DEFAULT_WINDOW_MS = 24 * 60 * 60_000;
+/** The widest window {@link unpairedStops} will take. The audit table is indexed on `(org, ts)` and
+ *  NOT on `action`, so every widening is paid in scan. */
+export const UNPAIRED_STOP_MAX_WINDOW_MS = 30 * 24 * 60 * 60_000;
+/**
+ * How settled a request must be before an absent partner is worth listing. Six times the turn's own
+ * cancel-settle grace (10s, hooks/turn-anchor.ts): the ignored-stop decision resolves on a timer
+ * inside the turn's process, so a request younger than this is still pairing, and listing it would
+ * manufacture candidates out of ordinary latency.
+ *
+ * IT IS A FLOOR, NOT AN ISOLATOR. It clears the settle timer and nothing else; a stop of a turn that
+ * runs for ten minutes still lists at this grace, because no partner row is due until that turn
+ * ends. Pass a grace longer than the deployment's longest turn to narrow the answer to the class
+ * that has no arm at all.
+ */
+const UNPAIRED_STOP_DEFAULT_GRACE_MS = 60_000;
+/** Rows read per action. A cap, not a policy: a scan that hits it sets `scanTruncated`, and the
+ *  caller must narrow the window before reading "no unpaired stops" as an answer. */
+const UNPAIRED_STOP_SCAN = 1000;
+/** Default and maximum rows RETURNED. The scan is what costs; the page is what a reader can hold. */
+const UNPAIRED_STOP_DEFAULT_LIMIT = 200;
+/** The join key. Both ids, never the turn alone: eve numbers turns PER SESSION, so a turn id
+ *  repeats across sessions and would pair a request with a stranger's terminal row. */
+function pairKey(detail) {
+    const sessionId = detail["sessionId"];
+    const turnId = detail["turnId"];
+    if (typeof sessionId !== "string" || typeof turnId !== "string" || !sessionId || !turnId)
+        return undefined;
+    return JSON.stringify([sessionId, turnId]);
+}
+/**
+ * Accepted stop requests in this org's recent audit with no partner row after the grace — a
+ * CANDIDATE LIST, not a rate. See {@link UNPAIRED_STOP_DEFAULT_GRACE_MS} for why the default grace
+ * lists live turns too, and what to pass instead.
+ *
+ * ONLY `outcome: "requested"` ROWS ARE OWED A PARTNER, and that is the whole precision of the
+ * query: `no_turn_found`, `no_active_turn` and `error` each resolved nothing to cancel, so nothing
+ * inside a turn ever writes a terminal row for them and an absent partner is correct, not a
+ * finding. Counting them would make every "Nothing running here right now" reply look like a bug.
+ *
+ * IT THROWS WHEN THE STORE DOES. A reader whose whole job is to notice missing rows must be able to
+ * tell "no unpaired stops" from "could not read" — the control tool renders the error.
+ */
+export async function unpairedStops(q) {
+    const now = q.now ?? Date.now();
+    const windowMs = Math.min(Math.max(q.windowMs ?? UNPAIRED_STOP_DEFAULT_WINDOW_MS, 0), UNPAIRED_STOP_MAX_WINDOW_MS);
+    const graceMs = Math.max(q.graceMs ?? UNPAIRED_STOP_DEFAULT_GRACE_MS, 0);
+    const limit = Math.min(Math.max(q.limit ?? UNPAIRED_STOP_DEFAULT_LIMIT, 1), UNPAIRED_STOP_SCAN);
+    const since = new Date(now - windowMs).toISOString();
+    const scan = { org: q.org, since, limit: UNPAIRED_STOP_SCAN };
+    const [requests, cancelled, ignored] = await Promise.all([
+        readAudit({ ...scan, action: TURN_CANCEL_ACTION }),
+        readAudit({ ...scan, action: TURN_CANCELLED_ACTION }),
+        readAudit({ ...scan, action: TURN_STOP_IGNORED_ACTION }),
+    ]);
+    const partners = new Set();
+    for (const row of [...cancelled, ...ignored]) {
+        const key = pairKey(row.detail ?? {});
+        if (key)
+            partners.add(key);
+    }
+    const found = [];
+    let requestsConsidered = 0;
+    let requestsWithinGrace = 0;
+    let requestsUndated = 0;
+    for (const row of requests) {
+        const detail = row.detail ?? {};
+        if (detail["outcome"] !== "requested")
+            continue;
+        const key = pairKey(detail);
+        if (!key)
+            continue; // an accepted request always carries both ids (auditCancel); a row without them cannot be joined either way
+        const at = typeof row.ts === "string" ? Date.parse(row.ts) : Number.NaN;
+        if (!Number.isFinite(at)) {
+            requestsUndated++;
+            continue;
+        }
+        const ageMs = now - at;
+        if (ageMs < graceMs) {
+            requestsWithinGrace++;
+            continue;
+        }
+        requestsConsidered++;
+        if (partners.has(key))
+            continue;
+        const [sessionId, turnId] = JSON.parse(key);
+        found.push({
+            sessionId,
+            turnId,
+            requestedAt: row.ts,
+            ageMs,
+            ...(typeof row.principalId === "string" ? { principalId: row.principalId } : {}),
+            ...(typeof detail["via"] === "string" ? { via: detail["via"] } : {}),
+            ...(typeof detail["surfaceKey"] === "string" ? { surfaceKey: detail["surfaceKey"] } : {}),
+        });
+    }
+    return {
+        org: q.org,
+        since,
+        graceMs,
+        requestsConsidered,
+        requestsWithinGrace,
+        requestsUndated,
+        scanTruncated: requests.length >= UNPAIRED_STOP_SCAN || cancelled.length >= UNPAIRED_STOP_SCAN || ignored.length >= UNPAIRED_STOP_SCAN,
+        unpaired: found.slice(0, limit),
+        capped: found.length > limit,
+    };
+}
+async function auditCancel(input, detail) {
+    try {
+        await appendAudit({
+            org: input.org,
+            platform: input.platform,
+            workspace: input.workspace,
+            action: TURN_CANCEL_ACTION,
+            ...(input.requestedBy ? { principalId: input.requestedBy } : {}),
+            // Names and ids only, never message content, the same discipline every other operational row keeps. `via` is the interesting field: it says which affordance people actually reach for.
+            // `sessionId` and `turnId` are what make this row JOINABLE to the `turn.cancelled` row the turn's own process writes: without them "someone asked" and "it actually stopped" could be counted but never connected. Absent on the `no_turn_found` arm, where by definition no turn resolved.
+            detail: {
+                via: input.via,
+                outcome: detail.outcome,
+                ...(detail.sessionId ? { sessionId: detail.sessionId } : {}),
+                ...(detail.turnId ? { turnId: detail.turnId } : {}),
+                ...(detail.anchorSurfaceKey ? { surfaceKey: detail.anchorSurfaceKey } : {}),
+                ...(detail.status ? { eveStatus: detail.status } : {}),
+                ...(detail.note ? { note: detail.note } : {}),
+            },
+        });
+    }
+    catch {
+        /* observation only — a stop must never fail because the audit write did */
+    }
+}
+//# sourceMappingURL=turn-cancel.js.map

package/dist/agent/channels/turn-cancel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"turn-cancel.js","sourceRoot":"","sources":["../../../agent/channels/turn-cancel.ts"],"names":[],"mappings":"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"}

package/dist/agent/channels/turn-delivery.d.ts

@@ -0,0 +1,213 @@
+import "./turn-terminal-actions.js";
+import { NO_REPLY_SENTINEL } from "./normalized-wake.js";
+import type { ChannelSessionRow } from "../operational/store.js";
+export { NO_REPLY_SENTINEL };
+/**
+ * True when a turn's final message is the silence sentinel. It is a PREFIX match after trimming rather than an exact one: a model that half-complies must still be swallowed, because posting its private rationale is worse than over-silencing.
+ * A genuine reply never STARTS with the bare sentinel.
+ */
+export declare function isNoReply(message: string): boolean;
+/** What the slack `message.completed` override should do with a turn's final text. */
+export type FinalMessageAction = {
+    readonly kind: "buffer-tool-status";
+} | {
+    readonly kind: "silent";
+    readonly reason: string;
+} | {
+    readonly kind: "post";
+    readonly text: string;
+};
+/**
+ * `FinalMessageAction.reason` when the turn's final text was the bare sentinel.
+ * Exported so a caller can tell the sentinel route apart from an empty completion or the `no_reply` tool route, rather than each provider file re-typing the string.
+ */
+export declare const NO_REPLY_SENTINEL_REASON = "NO_REPLY sentinel \u2014 judged not warranted";
+/**
+ * The pure decision behind the `message.completed` override: it mirrors eve's default handler — tool calls buffer for the typing status, an empty completion posts nothing — plus the ONE addition.
+ * The silence sentinel is SWALLOWED, not posted.
+ */
+export declare function finalMessageAction(finishReason: string, message: string | null): FinalMessageAction;
+/**
+ * {@link finalMessageAction} plus the `no_reply` TOOL route: a turn that called the tool ends its reply obligation exactly like the sentinel would, EVEN IF the model still emits trailing narration, because the tool call already made the decision. Every channel's completion override calls THIS, so the tool works identically on every surface the sentinel already works on. The signal is read-and-reset only on a genuinely terminal call, because an intermediate step's pending tool call might BE the `no_reply` call.
+ * Plus the SILENT-ROUTINE gate: a turn belonging to a routine whose product is an action, not a message, NEVER posts its terminal completion. That check is deliberately STRUCTURAL, because a routine that exists to say nothing must not depend on the model remembering to say nothing. ORDER: the tool signal is consumed FIRST and unconditionally, so a set flag can never bleed into the next turn of a resumed session; the silent verdict then wins on reason text, because it is the stronger fact.
+ *
+ * 🔴 PLUS THE STAND-DOWN LATCH (OPE-1647), and it is the arm that catches a turn whose `no_reply` was REFUSED. `tools/no_reply.ts` refuses the silence call while the stand-down acknowledgement is still owed, and a refused call sets NO signal — so before this arm existed the model acknowledged the stop through `reply` and then had its trailing prose posted into the very conversation it had just been asked to leave (measured on deploy #187: the acknowledgement at 09:40:50, the trailing post at 09:41:01). `channels/stand-down-silence.ts` latches on the post that discharged the stop, so this reads a fact rather than a promise.
+ * `turnId` is OPTIONAL because the latch is turn-keyed and a caller that cannot name its turn must never be silenced on another turn's latch. Absent ⇒ the latch is still CLEARED (it can never outlive its turn) and this returns exactly what it returned before the latch existed.
+ * 🔴 ONE ARM'S CLOSING PROSE STILL POSTS, and it is the set to check against when adding a caller — not a surface count. Linear's NATIVE arm: its non-silent verdict hands the completion to the framework's default poster, which puts the terminal text in the room, and that is what makes the latch load-bearing there. Every other arm DROPS its closing prose since OPE-2006 — `channels/closing-prose-drop.ts` on the chat surfaces and GitHub's native arm, the message-tool-only gate on the ticketing supervisors, and structurally on the unified window — so the latch has no door to shut on them. They still PASS the turn id, because the latch also decides WHICH row a dropped turn files: a stood-down turn files its silence under the stand-down reason rather than as a lost answer. Discord's GUILD path reaches the same latch by its own read (`discord-gateway.ts`), because that handler consumes the `no_reply` signal itself and so cannot call this function.
+ * ORDER: the two consuming reads run FIRST and unconditionally, for the bleed reason above. The silent-routine verdict then keeps its win on reason text, because a routine that exists to say nothing is the stronger fact; the stand-down reason then wins over the `no_reply` one, because a stop the person ASKED for says more about the turn than the reason the model picked for its silence.
+ */
+export declare function finalMessageActionForTurn(finishReason: string, message: string | null, turnId?: string): FinalMessageAction;
+/**
+ * True when this turn is a "bare stop": nothing explains the silence. `action` must already be the terminal decision for this turn.
+ * `actedThisTurn` is the caller's OR of the per-turn action signals, so a turn that reacted OR posted mid-turn DID something even if its final text is empty, and is never a bare stop.
+ */
+export declare function isBareStop(action: Extract<FinalMessageAction, {
+    kind: "silent";
+} | {
+    kind: "post";
+}>, actedThisTurn: boolean): boolean;
+/**
+ * Case-insensitive matcher for the agent's display name as a standalone phrase.
+ * It uses non-word boundaries rather than `\b`, so a name that starts or ends with a symbol still anchors, and inner whitespace is normalised so a doubled space still hits.
+ */
+export declare function nameDropPattern(name: string): RegExp;
+/**
+ * The unified name-drop WAKE token set: the surface's live vendor display name UNION the deployment's canonical name, extended by the operator's include list and NARROWED by the exclude list — EXCLUDE WINS over include and over the automatic base. De-duplication and exclusion are case-insensitive, and an empty-after-trim token is dropped rather than handed to the matcher, where an empty needle would match almost every position.
+ * Deliberately NOT the broader agent-name helper: this set never carries that helper's brand-default tiers, because folding those in would broaden a real display name's ambient trigger for no gain. Everything past the two automatic members is the operator's explicit choice, made by a reviewed diff — token lists, no regex and no predicate.
+ */
+export declare function wakeNameDropTokens(displayName: string | undefined): string[];
+/** A worker/delegated-turn REPLIER TIER label — present ⇔ a task-grain worker's reply, as opposed
+ *  to a bare supervisor/ambient one. `taskLabel` is a short, already-truncated, single-line
+ *  description of the delegated work — never the raw multi-line brief. */
+export interface ReplierLabel {
+    readonly taskLabel: string;
+}
+/**
+ * Collapse a possibly long, possibly multi-line task brief into a short ONE-LINE display label: whitespace-normalised, brackets STRIPPED, and capped with a trailing ellipsis. Pure, and an empty input yields an empty string.
+ * THE BRACKET STRIP IS LOAD-BEARING, NOT COSMETIC. The label is the model's OWN brief text rendered verbatim inside the bracket pair that IS the tier signal, so a brief starting with a close bracket would end the real one early and open a fake one — forging the exact framing the signal exists to be trustworthy about. Stripped rather than escaped, because the label is a short display string and not markup a reader parses.
+ */
+export declare function truncateTaskLabel(text: string, max?: number): string;
+/**
+ * The REPLIER label for a turn of this grain, or `undefined` for a bare, non-worker reply. Only the task grain ever brackets; every other grain, an unset or unknown one included, renders bare.
+ * An absent or blank label still brackets, with a generic fallback: a worker turn is ALWAYS visibly distinguishable from a supervisor one, even when the specific brief text is not available on this wake.
+ */
+export declare function replierLabelFor(grain: string | undefined, taskLabel: string | undefined): ReplierLabel | undefined;
+/**
+ * {@link replierLabelFor} straight off a turn's own host-stamped auth attributes — the ONE read every provider channel file's turn-start snapshot needs, because a completion handler has no live auth ctx and the decision must be made here and read back at completion time.
+ * Pure, total and fail-soft: a non-string or absent attribute on either key reads as absent, and it never throws.
+ */
+export declare function replierLabelFromAuthAttributes(attrs: Record<string, unknown> | undefined): ReplierLabel | undefined;
+/** Render `text` with its worker-turn bracket prefix applied — the fallback every surface without a
+ *  native per-message display-name override renders (Discord/Teams/Notion/Linear body text; Slack
+ *  uses a native `username` override instead, see slack-post-arm.ts). No-op (`text` unchanged) when
+ *  `replier` is undefined — a bare supervisor/ambient reply is never touched. */
+export declare function withReplierPrefix(text: string, replier: ReplierLabel | undefined): string;
+/**
+ * 🔴 THE PENDING-WORK INSTRUCTION — THE WHOLE MECHANISM, ON THE FOUR TOOL DOORS
+ * (OPE-1516, OPE-1544, OPE-1575). Those four are now every door a seat's words leave by, bar the one
+ * path the note above names. It lives HERE, beside the note that explains why the frame is gone,
+ * because it is model-facing DELIVERY COPY: it decides what a message says, never what the agent may
+ * reach.
+ * `access/pending-delegation-signal.ts` owns the CONDITION (`pendingDelegationOwing`) and this
+ * module owns the SENTENCE, which is the same split every other line the host writes on a body
+ * follows.
+ *
+ * ONE STRING, FOUR DOORS — the unified pair and the per-surface pair, one post door and one edit
+ * door each. The edit door is the sharper of each pair, because it rewrites the very message that
+ * carried the caveat and notifies nobody.
+ *
+ * NO terminal-prose path can use the string, and none pretends to. By the time a completion handler
+ * runs the model has stopped talking, so there is nothing left to instruct — which is why the
+ * per-surface handlers DROP that text rather than post it uninstructed.
+ *
+ * It opens with a leading space: every caller appends it to a note that is already a sentence.
+ */
+export declare const PENDING_WORK_INSTRUCTION: string;
+/**
+ * Render every memory citation in `text` as its bare silo-relative path in plain text — never a link, and never carrying the sandbox mount prefix.
+ * Conservative by construction: only a token that literally names the memory mount is touched, and every other URL, path or code-block byte passes through unchanged. ORDER MATTERS — the two wrapped shapes are unwrapped FIRST, so their inner URL is not left half-mangled by the bare pass.
+ */
+export declare function truncateMemoryCitationPaths(text: string): string;
+/**
+ * Quiet-gap rotation threshold: a generation not woken in this long rotates fresh on its NEXT wake rather than resuming a stale session. The default is affordable BECAUSE the tail got tight — a rotation now rebuilds from a recorded, capped tail rather than a re-fetched backscroll bundle, and the two changes shipped together on purpose.
+ * This is IDLENESS, not AGE — a sibling of the expiry trigger below, not a duplicate: a seat woken hourly for a month never trips the gap and always trips the expiry, and a seat woken twice a week trips the gap without ever aging out. Both are context arguments; keep both.
+ */
+export declare function supervisorRotateQuietGapMs(): number;
+/**
+ * Read a rotation clock expressed in DAYS off the environment, with the fail-safe posture the rest of this chain uses. Shared by the window default here and the DM seat's longer clock, so the two can never drift in how they PARSE, only in what they default to.
+ * Unset, blank or unparseable all yield the committed default — a typo'd override must never silently DISABLE a trigger, and the loudest safe answer is "behave as shipped" — while zero or negative yields infinity, the deliberate "disabled" spelling.
+ */
+export declare function rotationClockMsFromDays(raw: string | undefined, defaultDays: number): number;
+/**
+ * PRIMARY rotation trigger: a window rotates once THIS GENERATION has been alive longer than this, measured from a timestamp every rotation resets — so it is the generation's own age and never the seat's.
+ * WHY TIME: a standing seat's context decays on a calendar — last month's norms, a resolved incident still framed as open, a person who has since left — and none of that shows up in a token counter or a turn count. Age is a coarse proxy deliberately: it is a FRESHNESS lever, not a size one, and its job is to guarantee no generation carries a stale world view indefinitely. NO OTHER WINDOW TYPE GETS IT, because a clock over a session that lives for one unit of work measures nothing, and those seats never reach the chain at all.
+ */
+export declare function supervisorRotateExpiryMs(): number;
+/**
+ * TOKEN BACKSTOP, and the former primary trigger: the measured cumulative input plus cache-read tokens the spend hook accumulates onto the registry row.
+ * DEMOTED, NOT RE-VALUED, and the reason to keep the number is the reason it stopped being primary — it is not a size measurement. Every step re-counts the full context, so it meters step-count times cache re-reads and fires after a handful of mature wakes rather than the turn count it was modelled on. As a primary that made rotation a slow-drip amnesia machine; as a BACKSTOP the same early-firing conservatism is what you want from a last line of defence, and it keeps the session-park remedy working unchanged.
+ */
+export declare function supervisorRotateTokenBudget(): number;
+/**
+ * TURN BACKSTOP: it binds if the spend hook is broken while wakes still deliver, so the token counter stalls, and — the reason it moved — if a generation outgrows the SUBSTRATE. The old value was derived against ONE wall, and a SECOND, LOWER wall then appeared underneath it: a durable session is a workflow run, and a run is capped at a fixed number of EVENTS, so at the measured events-per-turn that wall binds far below where the old backstop sat.
+ * The current value leaves real headroom on the MEAN, because a tool-heavy turn is a multiple of it and a backstop set at the mean-derived limit protects only an average seat. FRAGILE POINT: both the event cap and the events-per-turn figure are measurements of someone else's substrate, so the latter should be RE-MEASURED after any change to tool-call shape or step ceiling, and this number re-derived from it rather than nudged.
+ */
+export declare function supervisorRotateTurnBudget(): number;
+/**
+ * CONTEXT-SIZE BACKSTOP: the LAST request's measured input plus cache-read tokens — the size of the context the model actually saw, which is the measure compaction reads. It is a DIFFERENT QUANTITY from the cumulative counter, and that distinction is why this rung exists: the cumulative one meters step-count times cache re-reads and says nothing about how big the context is.
+ * What it buys is that a standing seat which would otherwise COMPACT re-mints instead, carrying a recorded tail rather than a utility-model summary of itself. THE ORDERING IS LOAD-BEARING AND PINNED OUTSIDE THIS FILE: this threshold must stay under the deployed stack's compaction fire point, or the seat compacts before it rotates and the whole design is inert — the two numbers live in different files and only a dedicated test joins them.
+ */
+export declare function supervisorRotateContextSize(): number;
+/** Which rung of the rotation chain fired. Ordered as the chain evaluates: fail-safes, then the
+ *  PRIMARY time triggers, then the backstops. Exposed (rather than a bare boolean) so a call site
+ *  or a test can say WHY a generation was retired without re-deriving it from the row. */
+export type RotationTrigger = 
+/** FAIL-SAFE: the eve build changed under this seat, so its session cannot be proven resumable
+ *  (channels/runtime-rotation.ts, OPE-599). Supplied by the caller, not derived from the row. */
+"runtime-changed"
+/** OPERATOR: a human ops sweep stamped `channel_session.rotate_marked_at` on this generation
+ *  (OPE-820). Nothing in the product ever sets it, and the rotation it asks for is the seat's own
+ *  in-band leg — which is the point, because only that leg carries the recorded tail. */
+ | "operator-marked"
+/** FAIL-SAFE: the token counter is NULL — a pre-migration row whose accumulation can't be proven safe. */
+ | "unknown-accumulation"
+/** FAIL-SAFE: `now`, `created_at` or `last_wake_at` did not parse — an age we can't prove is an age we don't trust. */
+ | "unparseable-timestamp"
+/** PRIMARY: this generation is older than its expiry clock (context freshness). */
+ | "expiry"
+/** PRIMARY: nothing has woken this generation for longer than the quiet gap (idleness ⇒ pseudo-session boundary). */
+ | "quiet-gap"
+/** BACKSTOP: the LAST request's input tokens crossed the context-size line, so the seat re-mints
+ *  with a tail instead of compacting into a summary (see {@link supervisorRotateContextSize}). */
+ | "context-size"
+/** BACKSTOP: turn count past the substrate-derived bound (see {@link supervisorRotateTurnBudget}). */
+ | "turn-backstop"
+/** BACKSTOP: the measured cumulative-token counter reached its budget (also the OPE-171 park remedy's route). */
+ | "token-backstop";
+/**
+ * The options {@link rotationTrigger} evaluates against. The NUMBERS are thresholds, each overridable per call — the DM seat passes its own set and tests pass narrow ones — defaulting to the module readers above, each resolved at the moment the chain is evaluated.
+ * `runtimeChanged` is not a threshold: it is a per-wake verdict the CALLER resolves against the store, carried here so the chain still has one home.
+ */
+export interface RotationThresholds {
+    readonly quietGapMs?: number;
+    readonly turnBudget?: number;
+    readonly tokenBudget?: number;
+    /** Last-request input tokens past which a standing generation re-mints (OPE-794). */
+    readonly contextSizeTokens?: number;
+    /** Max age of ONE generation, from `created_at`. `Number.POSITIVE_INFINITY` disables expiry. */
+    readonly expiryMs?: number;
+    /**
+     * FAIL-SAFE, CALLER-SUPPLIED: the eve build changed under this seat, so OE cannot prove the durable session is resumable. True means rotate, whatever the row says.
+     * It is an INPUT rather than a rung this function derives, because the verdict needs a durable one-shot claim and this function is pure. Another module owns that claim and its audit; every surface reads it there and passes the boolean here, so the rotation CHAIN still has exactly one home. Absent is byte-identical to the chain before the rung existed.
+     */
+    readonly runtimeChanged?: boolean;
+}
+/**
+ * Pure: WHICH rotation trigger, if any, applies to this generation before the next wake is delivered. `null` means resume the current generation.
+ * ORDER IS THE CHAIN'S MEANING, not an optimisation: the runtime fail-safe first, because a session we cannot prove resumable must never be resumed; then the OPERATOR MARK, because an explicit instruction outranks every measurement of the row; then the backfill fail-safes, because a row we cannot read must not be reasoned about; then the two TIME triggers rotation actually owns; then the backstops, context size leading them. Every timestamp is parsed up front, and an unparseable one reads as ROTATE — the same fail-safe posture the null counter takes.
+ */
+export declare function rotationTrigger(row: Pick<ChannelSessionRow, "createdAt" | "lastWakeAt" | "turnCount" | "inputTokensTotal"> & Partial<Pick<ChannelSessionRow, "lastInputTokens" | "rotateMarkedAt">>, now: string, opts?: RotationThresholds): RotationTrigger | null;
+/**
+ * Pure: should this generation rotate BEFORE the next wake is delivered?
+ * The boolean face of {@link rotationTrigger} — every surface's rotate leg calls THIS, and the trigger enum is there for anything that wants to say why.
+ */
+export declare function shouldRotate(row: Pick<ChannelSessionRow, "createdAt" | "lastWakeAt" | "turnCount" | "inputTokensTotal"> & Partial<Pick<ChannelSessionRow, "lastInputTokens" | "rotateMarkedAt">>, now: string, opts?: RotationThresholds): boolean;
+/** The message-tool-only decision for a supervisor turn's TERMINAL completion text. */
+export interface SupervisorTextDelivery {
+    /** May the terminal completion text be posted as a reply? false under message-tool-only. */
+    readonly postText: boolean;
+    /** Non-empty terminal prose that the gate is dropping (→ an observability signal). */
+    readonly droppedProse: boolean;
+    readonly reason: string;
+}
+/**
+ * The pure message-tool-only gate. `hasTerminalProse` is the only case that can leak; `midTurnPostAvailable` says whether the reply tool is armed on this surface.
+ * When the tool IS available, terminal text never posts; when it is NOT, the gate fails open and lets it post, because there is no tool route to reply through.
+ */
+export declare function supervisorTextDelivery(hasTerminalProse: boolean, midTurnPostAvailable: boolean): SupervisorTextDelivery;
+/**
+ * Pure: is a dropped terminal completion on a supervisor turn a STRAY-PROSE LEAK worth a loud audit? True when there WAS terminal prose, the model did NOT reply through the tool, and no approval card narrated for it — a judge that emitted prose it never took a positive action to post.
+ * Trailing narration after a real tool reply, or a card-suppressed narration, is dropped just the same but is expected, not a leak signal.
+ */
+export declare function isSupervisorProseLeak(hasTerminalProse: boolean, repliedViaTool: boolean, cardPosted: boolean): boolean;
+//# sourceMappingURL=turn-delivery.d.ts.map

package/dist/agent/channels/turn-delivery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"turn-delivery.d.ts","sourceRoot":"","sources":["../../../agent/channels/turn-delivery.ts"],"names":[],"mappings":"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"}