@open-everywhere/core 0.1.0

package/dist/agent/channels/turn-terminal-actions.js

@@ -0,0 +1,128 @@
+// turn-terminal-actions — the userland half of the eve patch that makes eve's empty-response reissue COMPLETION-AWARE. A step with no text and no tool call is a failure for a turn that produced nothing, but the correct end of a turn that already discharged itself. The patch is one dumb helper; every judgement about which verbs are terminal is TypeScript here, and an UNREGISTERED hook keeps stock eve behaviour.
+// THE FAILURE RULE FOR THE WHOLE TERMINAL FAMILY: a terminal mark lands only on PLATFORM-CONFIRMED success; a DEFINITIVE failure leaves the turn OPEN, so a fresh post is a legitimate remedy; an AMBIGUOUS failure counts as terminal where a repeat is the larger harm. The rule is "fail toward the smaller harm", and it reads differently per verb because the action differs — `reply` and `react` put something NEW in the room, so a lost answer beats a duplicate, while `edit_reply` changes a message the room already has, so a double post is the loss direction.
+import { defineState } from "eve/context";
+import { currentTurnAddressed, windowGrainOf } from "../identity/binding.js";
+/**
+ * THE TERMINAL VERBS — the tool names whose call discharges this turn's reply obligation, so an empty step after one of them is the CORRECT end of the turn. `stand_down`, `complete_thread` and `update_status` are deliberately OUT: each leaves the room still owed a line, and every absence keeps stock eve behaviour, which is the safe direction.
+ * `edit_reply` belongs because it adds NO message to the room, so counting it terminal cannot hide an undelivered answer. `react` is listed but its suppression is CONDITIONAL — on a turn the message ADDRESSED, a react only acknowledges and one short `reply` is still owed. Worker verbs are held out by the GRAIN GATE below, never by this list, so do not lean on an absence here.
+ */
+export const TURN_TERMINAL_TOOLS = new Set(["reply", "no_reply", "react", "edit_reply"]);
+/** The `globalThis` slot the eve patch's `__oeThrowEmptyResponseUnlessTerminal` reads. */
+const HOOK_KEY = "__oeTurnTerminalActionScan";
+// THE GRAIN GATE — the suppression is for CONVERSATIONAL SEATS ONLY. `reply` and `edit_reply` mount on the `task` grain too, and the scan's window on a WORKER is the whole task rather than one wake, so one early `reply` would disarm eve's recovery for every remaining step and a worker ending on an empty step would return empty text to the parent waiting on its result.
+// The grain is RECORDED rather than read: the patch hands the scan a message array and no ctx, so it is written at the one moment a ctx is in hand. Fail direction is SUPPRESS UNLESS THE SESSION IS A KNOWN WORKER — an unrecorded grain reads as conversational, so a missing write can leave the worker hazard open on one verb but can never silently revert the seat-side fix. No offline probe reaches a worker turn, so the unit test is the only pin on this behaviour.
+/** The grain of the last session that called a terminal verb here. `null` until one does. */
+const grainSlot = defineState("open-everywhere.terminal-call-grain", () => null);
+/**
+ * Record the grain of the session calling a terminal verb. Called by the four terminal tools beside their own marks.
+ * NEVER THROWS, and never blocks its caller: outside an eve context there is no slot to write, and a session with no record reads as conversational.
+ */
+export function noteTerminalCallGrain(ctx) {
+    try {
+        const grain = windowGrainOf(ctx);
+        grainSlot.update(() => grain);
+    }
+    catch {
+        /* no session context, or an unreadable ctx — the guard keeps its pre-OPE-819 behaviour */
+    }
+}
+/** Is this session a one-shot WORKER, as its own terminal call reported? */
+function terminalCallerIsWorker() {
+    try {
+        return grainSlot.get() === "task";
+    }
+    catch {
+        return false;
+    }
+}
+// THE ADDRESSEDNESS GATE — `react` discharges an UNADDRESSED turn only. On a turn the message directly addressed, a react is ADDITIVE and one short `reply` is still owed; without this gate the scan suppressed the reissue after every confirmed react, so a model that reacted and stopped never posted the owed reply.
+// Recorded, not read, exactly like the grain gate, from the host-set `currentTurnAddressed` stamp that a model-authored body cannot forge. Fail direction: unrecorded or false reads as UNADDRESSED, so a react still fully suppresses the reissue and a missed write can never re-open the unwanted-reply regression. Scope is `react` ONLY — the other three verbs are unconditionally terminal.
+/** The addressedness of the last session whose `react` call ran here. `null` until one does. */
+const reactAddressedSlot = defineState("open-everywhere.react-call-addressed", () => null);
+/**
+ * Record whether THIS `react` call answered an ADDRESSED wake, beside {@link noteTerminalCallGrain}. Called ONLY by `tools/react.ts`, because `react` is the one terminal verb whose suppression depends on addressedness.
+ * NEVER THROWS, and never blocks its caller: an unrecorded call reads as unaddressed, which is the safe direction, since it can only keep today's full suppression.
+ */
+export function noteReactCallAddressed(ctx) {
+    try {
+        reactAddressedSlot.update(() => currentTurnAddressed(ctx));
+    }
+    catch {
+        /* no session context, or an unreadable ctx — react keeps its pre-OPE-964 behaviour */
+    }
+}
+/** Did the last recorded `react` call answer an ADDRESSED wake? */
+function reactCallerWasAddressed() {
+    try {
+        return reactAddressedSlot.get() === true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * The `output.type` values that mean the call did NOT succeed — READ FROM THE SDK CONTRACT rather than invented: a thrown tool reaches the next model call as a `tool-result` part whose output is one of the two `error-*` shapes.
+ * `execution-denied` sits with them: a call the user refused never ran, so nothing changed at the platform either.
+ */
+const FAILED_OUTPUT_TYPES = new Set(["error-text", "error-json", "execution-denied"]);
+/**
+ * Did a terminal verb in these parts come back CONFIRMED? THE RESULT PART IS THE ONLY WITNESS: a `tool-call` part records that the model ASKED for the verb, never that the platform did it, so only a `tool-result` with a non-error output counts. The result is always available by then, because eve appends each step's tool results before the next model call.
+ * An output with no `type` reads as success, so a shape this file cannot classify keeps the behaviour it had. A confirmed `react` counts only on an UNADDRESSED turn: the scan CONTINUES past an addressed one, so a `reply` elsewhere in the window still counts and a react-alone step leaves the nudge armed.
+ */
+function confirmedTerminalIn(parts) {
+    for (const part of parts) {
+        if (part === null || typeof part !== "object")
+            continue;
+        const { type, toolName, output } = part;
+        if (type !== "tool-result")
+            continue;
+        if (typeof toolName !== "string" || !TURN_TERMINAL_TOOLS.has(toolName))
+            continue;
+        const outcome = output !== null && typeof output === "object" ? output.type : undefined;
+        if (typeof outcome === "string" && FAILED_OUTPUT_TYPES.has(outcome))
+            continue;
+        if (toolName === "react" && reactCallerWasAddressed())
+            continue;
+        return true;
+    }
+    return false;
+}
+/**
+ * Did THIS turn already call a terminal verb? The scan stops at the last `user` message, which is the wake that opened this turn, so a previous turn that ended in `no_reply` cannot silence this one.
+ * Anything that SHORTENS the window only makes the guard answer `false` more often, which is stock eve — the fail direction is deliberate and one-way. It NEVER THROWS: it runs inside eve's model call, where a throw would fail the turn, so any malformed input answers `false`.
+ */
+export function turnHasTerminalAction(messages) {
+    try {
+        // THE GRAIN GATE FIRST (OPE-819). A worker's empty final step is a real failure — its caller is
+        // waiting on a result — so a worker keeps eve's recovery whatever its message array holds.
+        if (terminalCallerIsWorker())
+            return false;
+        if (!Array.isArray(messages))
+            return false;
+        for (let i = messages.length - 1; i >= 0; i--) {
+            const message = messages[i];
+            if (message === null || typeof message !== "object")
+                continue;
+            const role = message.role;
+            if (role === "user")
+                return false;
+            if (role !== "assistant" && role !== "tool")
+                continue;
+            const content = message.content;
+            if (Array.isArray(content) && confirmedTerminalIn(content))
+                return true;
+        }
+        return false;
+    }
+    catch {
+        return false;
+    }
+}
+/** Install the hook the eve patch consults. Idempotent; runs at module load. Imported for its side
+ *  effect by `channels/turn-delivery.ts` and by `tools/no_reply.ts`, so every process that can
+ *  route a wake or mount the silence verb has the guard armed before its first model call. */
+function installTurnTerminalActionHook() {
+    globalThis[HOOK_KEY] = turnHasTerminalAction;
+}
+installTurnTerminalActionHook();
+//# sourceMappingURL=turn-terminal-actions.js.map

package/dist/agent/channels/turn-terminal-actions.js.map

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

package/dist/agent/channels/unified-redrive.d.ts

@@ -0,0 +1,74 @@
+import { type AuditInput } from "../audit/audit.js";
+import { type NormalizedWake } from "./normalized-wake.js";
+import { type UnifiedWakeOrigin, type UnifiedWakeTargetStore } from "./unified-window.js";
+/** The audit action for a fired redrive — joinable to the original turn by `detail.originalWakeId`
+ *  (the redriven turn's own reply.post carries the SAME wake-id, re-stamped) + `detail.sessionId`. */
+export declare const REDRIVE_ACTION = "unified.turn.redrive";
+/** The durable loop-guard key for one original wake id. */
+export declare function redriveGuardKey(wakeId: string): string;
+/** A short, token-free description of WHERE the dropped answer was owed — for the corrective nudge
+ *  text (origins carry only public ids, never secrets). */
+export declare function describeRedriveTarget(origin: UnifiedWakeOrigin): string;
+/**
+ * The corrective instruction (pure — asserted verbatim in the tests). OE's own notice about the model's OWN previous output: it states the drop, names the ORIGINAL wake id to answer, and names where the answer was owed.
+ * It offers the explicit `no_reply` escape, so it can NEVER coerce a reply the model has judged unwarranted. It renders as a TRUSTED envelope `<system-note>` ({@link buildRedriveWake}), never as a message body: a machine-authored body is `relay` and fenced with a do-not-follow notice, which the model obeys (OPE-2053).
+ */
+export declare function redriveCorrectiveText(chars: number, originalWakeId: string, origin: UnifiedWakeOrigin, owesWorkerReport?: boolean): string;
+/**
+ * Build the corrective SYSTEM wake (pure). AMBIENT `channel-watch` addressing, NOT `direct-mention`: the correction is a machine notice about the model's own output, so it must not claim an address no person made. Trust `relay`, the machine tier; sender `system`, a harness-authored notice rather than a fake human. The ONE-SHOT loop guard in {@link maybeRedrive}, keyed on the original wake id, is what caps the correction at one — a second prose-only ending is a final audited drop.
+ * It re-stamps the ORIGINAL `wakeId`, so the envelope's `<wake wake-id>` — and with it the reply tool's authority fence — targets the original wake's conversation.
+ * 🔴 THE INSTRUCTION RIDES `systemNote`, A TRUSTED `<system-note>`, AND THE BODY STAYS A ONE-LINE MARKER (OPE-2053). The envelope fences every `relay` body and tells the model not to follow it; with the instruction in the body, the seat read the correction as untrusted relay content and ended in `no_reply` — the re-drive could never work. The body stays fenced like every machine body; only OE's own framing moves to the skeleton.
+ */
+export declare function buildRedriveWake(originalWakeId: string, origin: UnifiedWakeOrigin, chars: number, nowIso: string, owesWorkerReport?: boolean): NormalizedWake;
+/**
+ * The eve-specific re-injection the caller supplies, bound over the captured cross-channel `receive` and this turn's token and auth.
+ * `null` means no receive is reachable in THIS process, so the redrive fail-soft skips and the drop stays a final audited drop, exactly as before the redrive existed.
+ */
+export type RedriveReinject = ((origin: UnifiedWakeOrigin, message: string, originalWakeId: string) => Promise<void>) | null;
+/** The operational-store slice the redrive needs: resolve the original origin (the re-stamp target)
+ *  + the durable, restart-surviving loop guard (markEventSeen — atomic first-sighting). */
+export interface RedriveStore extends UnifiedWakeTargetStore {
+    markEventSeen(org: string, key: string, at: string, ttlMs: number): Promise<boolean>;
+}
+export interface RedriveInput {
+    readonly org: string;
+    readonly workspace: string;
+    readonly surface?: string;
+    readonly sessionId?: string;
+    /** The wake id of the turn that dropped — its ORIGIN is the re-stamp/reply target and its id is
+     *  the loop-guard key. Undefined (no oe_wake_id stamp) ⇒ not a single-window wake ⇒ skip. */
+    readonly wakeId: string | undefined;
+    /** The dropped prose length (for the nudge + audit). */
+    readonly chars: number;
+    /** Did the reply tool already post this turn? TRUE ⇒ the dropped prose is benign narration after a
+     *  real reply — NOT a leak — so never redrive. */
+    readonly replied: boolean;
+    /**
+     * Does a background worker THIS TURN dispatched still owe this wake its answer? It changes only the
+     * corrective TEXT, never any gate: `done` defaults to TRUE on the `reply` tool and the OPE-701
+     * guard refuses a call that would close a wake a worker still owes, so a seat that follows a nudge
+     * naming no `done` is refused a second time — and the correction is capped at one, so its answer
+     * then reaches nobody. Naming the move that succeeds is what makes the one correction usable.
+     * This is the one reason the redrive fires on (`delegation-pending` is deliberately not a
+     * withholding), so the flag has exactly one true case.
+     */
+    readonly owesWorkerReport?: boolean;
+}
+export interface RedriveDeps {
+    readonly store: RedriveStore;
+    readonly reinject: RedriveReinject;
+    readonly now?: () => string;
+    /** Audit sink (default appendAudit) — injectable so the test captures the row without a store. */
+    readonly audit?: (entry: AuditInput) => Promise<void>;
+}
+export type RedriveStatus = "skip-replied" | "skip-no-wake" | "skip-unresolved" | "skip-loop-guard" | "skip-no-reinject" | "reinject-failed" | "redriven";
+export interface RedriveResult {
+    readonly status: RedriveStatus;
+    readonly originalWakeId?: string;
+}
+/**
+ * Decide and fire the auto-redrive for a dropped-prose turn. The ORDERING is deliberate: the cheap replied, wake-id and origin gates first, so a skip there is byte-clean; then the `reinject` availability check BEFORE the loop guard, so a missing receive does not burn the one-shot guard and a later turn on a warm process can still correct it.
+ * Then the atomic loop guard — the FIRST drop for a wake proceeds and a second skips, so the redriven turn's own drop is FINAL — then the re-inject, then the audit row, which therefore means "actually fired". Fail-soft throughout: a store or re-inject error degrades to a skip and never throws out of here.
+ */
+export declare function maybeRedrive(input: RedriveInput, deps: RedriveDeps): Promise<RedriveResult>;
+//# sourceMappingURL=unified-redrive.d.ts.map

package/dist/agent/channels/unified-redrive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unified-redrive.d.ts","sourceRoot":"","sources":["../../../agent/channels/unified-redrive.ts"],"names":[],"mappings":"AAGA,OAAO,EAAe,KAAK,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACjE,OAAO,EAA2D,KAAK,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACpH,OAAO,EAGL,KAAK,iBAAiB,EACtB,KAAK,sBAAsB,EAC5B,MAAM,qBAAqB,CAAC;AAG7B;sGACsG;AACtG,eAAO,MAAM,cAAc,yBAAyB,CAAC;AASrD,2DAA2D;AAC3D,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAEtD;AAED;2DAC2D;AAC3D,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,iBAAiB,GAAG,MAAM,CASvE;AAcD;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,EAAE,iBAAiB,EAAE,gBAAgB,UAAQ,GAAG,MAAM,CAYxI;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,cAAc,EAAE,MAAM,EAAE,MAAM,EAAE,iBAAiB,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,gBAAgB,UAAQ,GAAG,cAAc,CAsB3J;AAED;;;GAGG;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,MAAM,EAAE,iBAAiB,EAAE,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC;AAE7H;2FAC2F;AAC3F,MAAM,WAAW,YAAa,SAAQ,sBAAsB;IAC1D,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CACtF;AAED,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B;iGAC6F;IAC7F,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IACpC,wDAAwD;IACxD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB;sDACkD;IAClD,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B;;;;;;;;OAQG;IACH,QAAQ,CAAC,gBAAgB,CAAC,EAAE,OAAO,CAAC;CACrC;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;IAC7B,QAAQ,CAAC,QAAQ,EAAE,eAAe,CAAC;IACnC,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;IAC5B,kGAAkG;IAClG,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACvD;AAED,MAAM,MAAM,aAAa,GACrB,cAAc,GACd,cAAc,GACd,iBAAiB,GACjB,iBAAiB,GACjB,kBAAkB,GAClB,iBAAiB,GACjB,UAAU,CAAC;AAEf,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;IAC/B,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;CAClC;AAED;;;GAGG;AACH,wBAAsB,YAAY,CAAC,KAAK,EAAE,YAAY,EAAE,IAAI,EAAE,WAAW,GAAG,OAAO,CAAC,aAAa,CAAC,CAkDjG"}

package/dist/agent/channels/unified-redrive.js

@@ -0,0 +1,141 @@
+// unified-redrive — the catch-and-fix for a unified turn whose terminal prose was structurally DISCARDED by the message-tool-only gate. A corrective SYSTEM wake is re-injected into the SAME session, so the model gets ONE more turn to re-deliver through the `reply` tool; eve's hooks are observe-only, so the correction is the next turn, never a mid-turn stop. Nothing switches it off — what narrows it is the scope below and the gates in {@link maybeRedrive}.
+// It fires ONLY for a REAL drop: a turn whose prose was hard-dropped with `replied=false`, on ANY addressing — a direct mention reaches it exactly as an ambient wake does, because the prose bridge that used to claim the addressed case is deleted (OPE-1982). Never for a judged silence, and never for a `replied=true` drop, which is benign narration after a real post. The corrective wake re-stamps the ORIGINAL wake id, so the reply tool's authority fence resolves to the original conversation. It must NEVER import channels/unified.ts, which imports this.
+import { appendAudit } from "../audit/audit.js";
+import { renderWake, mkMessageTrigger, REDRIVE_TRIGGER_ID_PREFIX } from "./normalized-wake.js";
+import { resolveUnifiedWakeTarget, WAKE_TARGET_TTL_MS, } from "./unified-window.js";
+import { postArm } from "./post-arms.js";
+/** The audit action for a fired redrive — joinable to the original turn by `detail.originalWakeId`
+ *  (the redriven turn's own reply.post carries the SAME wake-id, re-stamped) + `detail.sessionId`. */
+export const REDRIVE_ACTION = "unified.turn.redrive";
+/** Loop-guard key prefix (a durable markEventSeen mark keyed by the ORIGINAL wake id). */
+const REDRIVE_GUARD_PREFIX = "unified-redrive:";
+/** How long the loop-guard mark survives — matched to the wake-target TTL so it outlives any turn
+ *  that could still be answering the wake, then prunes with the map row it guards. */
+const REDRIVE_GUARD_TTL_MS = WAKE_TARGET_TTL_MS;
+/** The durable loop-guard key for one original wake id. */
+export function redriveGuardKey(wakeId) {
+    return `${REDRIVE_GUARD_PREFIX}${wakeId}`;
+}
+/** A short, token-free description of WHERE the dropped answer was owed — for the corrective nudge
+ *  text (origins carry only public ids, never secrets). */
+export function describeRedriveTarget(origin) {
+    // Per-provider description via the post-arms registry (channels/post-arms.ts). The typed
+    // UnifiedWakeOrigin union is exhaustive over the six unified surfaces, so a missing arm only
+    // fires for a genuinely-unwired platform — fail LOUD rather than emit an undefined description.
+    const arm = postArm(origin.platform);
+    if (!arm?.describeRedriveTarget) {
+        throw new Error(`redrive: no post arm describes a "${origin.platform}" target.`);
+    }
+    return arm.describeRedriveTarget(origin);
+}
+/** The `<channel id>` the corrective envelope names — cosmetic (reply targeting is by wake-id/map,
+ *  never this), so a best-effort primary conversation id per origin is enough. */
+function originContainerId(origin) {
+    // Per-provider container id via the post-arms registry (cosmetic; the value never routes). Fail
+    // LOUD for a genuinely-unwired platform rather than emit an undefined id.
+    const arm = postArm(origin.platform);
+    if (!arm?.redriveContainerId) {
+        throw new Error(`redrive: no post arm resolves a container id for "${origin.platform}".`);
+    }
+    return arm.redriveContainerId(origin);
+}
+/**
+ * The corrective instruction (pure — asserted verbatim in the tests). OE's own notice about the model's OWN previous output: it states the drop, names the ORIGINAL wake id to answer, and names where the answer was owed.
+ * It offers the explicit `no_reply` escape, so it can NEVER coerce a reply the model has judged unwarranted. It renders as a TRUSTED envelope `<system-note>` ({@link buildRedriveWake}), never as a message body: a machine-authored body is `relay` and fenced with a do-not-follow notice, which the model obeys (OPE-2053).
+ */
+export function redriveCorrectiveText(chars, originalWakeId, origin, owesWorkerReport = false) {
+    return (`Your previous turn's final prose (${chars} chars) was DISCARDED by the message-tool-only gate — ` +
+        `it reached no one. If it should reach someone, call the \`reply\` tool NOW with \`wake\` set to ` +
+        `"${originalWakeId}" (target: ${describeRedriveTarget(origin)}) and \`text\` set to your message. ` +
+        (owesWorkerReport
+            ? `Pass \`done: false\` on that call: a worker you started still owes this conversation its answer, ` +
+                `and a call that closes the wake is refused. `
+            : "") +
+        `If it should NOT reach anyone after all, call \`no_reply\` (or end with NO_REPLY) — staying silent ` +
+        `is still a valid outcome. This is a one-time correction: there is no second retry.`);
+}
+/**
+ * Build the corrective SYSTEM wake (pure). AMBIENT `channel-watch` addressing, NOT `direct-mention`: the correction is a machine notice about the model's own output, so it must not claim an address no person made. Trust `relay`, the machine tier; sender `system`, a harness-authored notice rather than a fake human. The ONE-SHOT loop guard in {@link maybeRedrive}, keyed on the original wake id, is what caps the correction at one — a second prose-only ending is a final audited drop.
+ * It re-stamps the ORIGINAL `wakeId`, so the envelope's `<wake wake-id>` — and with it the reply tool's authority fence — targets the original wake's conversation.
+ * 🔴 THE INSTRUCTION RIDES `systemNote`, A TRUSTED `<system-note>`, AND THE BODY STAYS A ONE-LINE MARKER (OPE-2053). The envelope fences every `relay` body and tells the model not to follow it; with the instruction in the body, the seat read the correction as untrusted relay content and ended in `no_reply` — the re-drive could never work. The body stays fenced like every machine body; only OE's own framing moves to the skeleton.
+ */
+export function buildRedriveWake(originalWakeId, origin, chars, nowIso, owesWorkerReport = false) {
+    return {
+        platform: origin.platform,
+        reason: "channel-activity",
+        addressing: "channel-watch",
+        // The ORIGINAL wake id — makes the envelope carry `wake-id="<original>"`, which the reply tool
+        // echoes back; the re-stamp on the delivery auth (divertToUnifiedWindow) is what makes the fence
+        // accept it as THIS turn's wake.
+        wakeId: originalWakeId,
+        locus: { channel: { id: originContainerId(origin) } },
+        trigger: mkMessageTrigger({
+            from: "system",
+            author: "open-everywhere",
+            // The corrective turn's own marker — see REDRIVE_TRIGGER_ID_PREFIX. It is provenance for a
+            // reader of the prompt, never a gate: no product path branches on this id.
+            id: `${REDRIVE_TRIGGER_ID_PREFIX}${originalWakeId}`,
+            sentAt: nowIso,
+            trust: "relay",
+            body: `Corrective re-drive of wake ${originalWakeId}.`,
+        }),
+        systemNote: redriveCorrectiveText(chars, originalWakeId, origin, owesWorkerReport),
+    };
+}
+/**
+ * Decide and fire the auto-redrive for a dropped-prose turn. The ORDERING is deliberate: the cheap replied, wake-id and origin gates first, so a skip there is byte-clean; then the `reinject` availability check BEFORE the loop guard, so a missing receive does not burn the one-shot guard and a later turn on a warm process can still correct it.
+ * Then the atomic loop guard — the FIRST drop for a wake proceeds and a second skips, so the redriven turn's own drop is FINAL — then the re-inject, then the audit row, which therefore means "actually fired". Fail-soft throughout: a store or re-inject error degrades to a skip and never throws out of here.
+ */
+export async function maybeRedrive(input, deps) {
+    if (input.replied)
+        return { status: "skip-replied" };
+    if (!input.wakeId)
+        return { status: "skip-no-wake" };
+    const wakeId = input.wakeId;
+    const now = deps.now ?? (() => new Date().toISOString());
+    const audit = deps.audit ?? appendAudit;
+    // The ORIGINAL origin — the reply/re-stamp target. Fail-closed on unknown/expired (never guess).
+    const origin = await resolveUnifiedWakeTarget(deps.store, input.org, wakeId).catch(() => null);
+    if (!origin)
+        return { status: "skip-unresolved", originalWakeId: wakeId };
+    // No receive reachable in this process → fail-soft, and DON'T burn the guard.
+    if (!deps.reinject)
+        return { status: "skip-no-reinject", originalWakeId: wakeId };
+    // LOOP GUARD (durable, atomic, restart-surviving): at most ONE redrive per original wake id. The
+    // FIRST drop marks + proceeds; a drop on the REDRIVEN turn (same re-stamped wake id) finds the
+    // mark set → FALSE → final drop, no second redrive.
+    let firstDrop;
+    try {
+        firstDrop = await deps.store.markEventSeen(input.org, redriveGuardKey(wakeId), now(), REDRIVE_GUARD_TTL_MS);
+    }
+    catch {
+        return { status: "skip-loop-guard", originalWakeId: wakeId }; // store blip → don't risk a loop
+    }
+    if (!firstDrop)
+        return { status: "skip-loop-guard", originalWakeId: wakeId };
+    // Build + render the corrective wake and re-inject it into the SAME session.
+    const rendered = renderWake(buildRedriveWake(wakeId, origin, input.chars, now(), input.owesWorkerReport === true));
+    try {
+        await deps.reinject(origin, rendered.message, wakeId);
+    }
+    catch {
+        // The re-injection failed after the guard was burned — treat as final (no retry). The prose was
+        // already audited as dropped by the caller; nothing else to post.
+        return { status: "reinject-failed", originalWakeId: wakeId };
+    }
+    await audit({
+        org: input.org,
+        platform: "unified",
+        workspace: input.workspace,
+        ...(input.surface ? { surface: input.surface } : {}),
+        action: REDRIVE_ACTION,
+        detail: {
+            originalWakeId: wakeId,
+            chars: input.chars,
+            platform: origin.platform,
+            ...(input.sessionId ? { sessionId: input.sessionId } : {}),
+        },
+    }).catch(() => undefined);
+    return { status: "redriven", originalWakeId: wakeId };
+}
+//# sourceMappingURL=unified-redrive.js.map

package/dist/agent/channels/unified-redrive.js.map

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

package/dist/agent/channels/unified-reply.d.ts

@@ -0,0 +1,102 @@
+import type { UnifiedWakeOrigin } from "./unified-window.js";
+import { type ReplyAudit, type ReplierLabel } from "./reply-post.js";
+import { type DirectMessageAction, type PostIntent } from "./post-arms.js";
+import type { EditLocus } from "./reply-edit.js";
+type SlackOrigin = Extract<UnifiedWakeOrigin, {
+    platform: "slack";
+}>;
+type GitHubOrigin = Extract<UnifiedWakeOrigin, {
+    platform: "github";
+}>;
+type LinearOrigin = Extract<UnifiedWakeOrigin, {
+    platform: "linear";
+}>;
+type NotionOrigin = Extract<UnifiedWakeOrigin, {
+    platform: "notion";
+}>;
+type DiscordOrigin = Extract<UnifiedWakeOrigin, {
+    platform: "discord";
+}>;
+type TeamsOrigin = Extract<UnifiedWakeOrigin, {
+    platform: "teams";
+}>;
+export interface UnifiedReplyDeps {
+    /** Post into Slack; returns the posted message ts. Defaults to the live slackForm arm. */
+    readonly postSlack?: (origin: SlackOrigin, text: string) => Promise<string>;
+    /** Post a GitHub issue comment; returns the comment id. Defaults to the live REST arm. */
+    readonly postGitHub?: (origin: GitHubOrigin, text: string) => Promise<string>;
+    /** Post a Linear reply as an Agent Activity into the wake's open session; returns the activity id.
+     *  Defaults to the live createLinearAgentActivity arm. `intent` decides the activity TYPE, because
+     *  a `response` ENDS the session (OPE-869) — see linear-post-arm.ts's `activityTypeFor`. */
+    readonly postLinear?: (origin: LinearOrigin, text: string, intent?: PostIntent) => Promise<string>;
+    /** Complete an OPEN Linear agent session on a turn that judged SILENCE — no model prose ever
+     *  posts. Defaults to the live arm, which renders the FIXED HOST ack (OPE-884). `answered` picks
+     *  the ANSWERED line instead of the silence line (OPE-922). */
+    readonly closeLinear?: (origin: LinearOrigin, answered?: boolean) => Promise<void>;
+    /** Post a Notion discussion comment; returns the comment id. Defaults to the live REST arm. */
+    readonly postNotion?: (origin: NotionOrigin, text: string) => Promise<string>;
+    /** Post a Discord channel message; returns the message id. Defaults to the live REST arm. */
+    readonly postDiscord?: (origin: DiscordOrigin, text: string) => Promise<string>;
+    /** Post a Teams reply activity; returns the activity id. Defaults to the live Connector arm. */
+    readonly postTeams?: (origin: TeamsOrigin, text: string) => Promise<string>;
+}
+/**
+ * Post `text` into the conversation `origin` names and return the platform message id. It throws an honest, token-free error when the post did not land, so the model knows the reply failed rather than silently believing it posted.
+ * THE CHOKE POINT: when `audit` is supplied the single canonical `reply.post` row is written HERE, after the id is known, for BOTH callers — and it lands even under the egress spoof, because the eval targets score from the row. Idempotent across a step re-run or a genuine double call: a distinct action tag keeps its outbound key from ever colliding with the per-surface choke point's.
+ */
+export declare function postUnifiedReply(origin: UnifiedWakeOrigin, text: string, deps?: UnifiedReplyDeps, audit?: ReplyAudit, replier?: ReplierLabel, intent?: PostIntent, 
+/**
+ * TAPPABLE ACTIONS beside the text (OPE-1720) — rendered only by an arm that declares
+ * {@link PostArm.dispatchUnifiedActions}, and silently absent on every other surface, where the
+ * same text posts alone. The caller's copy must therefore stand on its own, exactly as it must for
+ * a DM ({@link DirectMessageAction}).
+ * They ride OUTSIDE the dedupe payload on purpose: the key is already the body, and two posts of
+ * one body differing only in their button row would be the same duplicate post this key exists to
+ * suppress.
+ */
+actions?: readonly DirectMessageAction[]): Promise<string>;
+/**
+ * The {@link EditLocus} for a unified wake origin — the host-resolved half of `edit_reply`'s address on a cross-surface session, and the key the own-post ledger records under. PURE, and `null` for an origin with no editable address.
+ * THIS IS THE POST-TIME LOCUS, and `edit_reply` must not use it directly — call {@link resolveUnifiedEditLocus} instead. On Discord an arm can answer inside an auto-thread that did not exist when this origin was frozen, so the frozen channel id is the wrong address for an edit.
+ */
+export declare function unifiedEditLocus(origin: UnifiedWakeOrigin): EditLocus | null;
+/**
+ * Does a TERMINAL post on this origin CLOSE the conversation, so nothing further can land in the
+ * same turn? (OPE-1452.)
+ *
+ * 🔴 IT IS THE ONE PLACE A SECOND ANSWER IS IMPOSSIBLE RATHER THAN MERELY UNWANTED, and that is why
+ * the same-turn `done` teeth read it. A Linear MENTION reply is a `response` Agent Activity, and a
+ * `response` ENDS the agent session — measured over every session in the live workspace, 2026-08-20
+ * (OPE-869, and see the note on `activityTypeFor` in the Linear post arm). The next post on that
+ * session fails `Entity not found: AgentSession`; it cost deploy #99 the real answer to Linear
+ * TOM-67, 38 seconds after the hand-off note that closed the session.
+ *
+ * So the reply path's duplicate-post valve stays SHUT here. Everywhere else a second message is a
+ * matter of style and the model's judgement decides it (Tommy's ruling, 2026-09-03); on this route
+ * the host would be inviting a call that cannot succeed, and the model would burn its remaining
+ * steps re-sending it with no steer left.
+ *
+ * The AMBIENT Linear route is not this shape: it posts a normal issue comment through
+ * `commentCreate` on the workspace token, which is editable and can be posted twice. Same split, and
+ * for the same underlying reason, as {@link unifiedEditLocus}'s `linear` case. The origin codec
+ * enforces the XOR, and `!== true` is the fail-closed read of it: an origin carrying neither flag
+ * refuses a second post rather than inviting a doomed one.
+ *
+ * Every other surface answers FALSE. This is deliberately not a general "is the room closed"
+ * question — {@link PostIntent} is read by exactly one post arm, so no other wired surface ends a
+ * conversation on a post, and inventing a broader predicate here would turn one measured platform
+ * limit into a policy nobody asked for.
+ */
+export declare function terminalPostClosesConversation(origin: UnifiedWakeOrigin): boolean;
+/**
+ * The address `edit_reply` uses on a unified session: {@link unifiedEditLocus}, then the post arm's optional `retargetEditLocus` on top. One arm can answer somewhere the FROZEN origin cannot name — a Discord auto-thread is its own channel id — so the reply lives at an address the origin does not carry, and the ownership READ and the PATCH must both address the conversation the message is actually in.
+ * The retarget runs BEFORE the ownership fence on purpose: checking the base channel and then dispatching to the thread would be a fence on one conversation and a write on another. It NEVER throws — an arm that cannot resolve a better address, or one that throws, degrades to the base locus, which is the correct answer for a reply that did land in the base channel.
+ */
+export declare function resolveUnifiedEditLocus(origin: UnifiedWakeOrigin): Promise<EditLocus | null>;
+/**
+ * Complete the wake's OPEN session for a turn that judged SILENCE — no model prose ever posts — routed generically through the post arm's optional close. Only Linear has an open session to complete today: its @mention divert keeps the native agent session open so an async answer can complete it, and without this a silent turn would leave the session on a spinner forever.
+ * THE RENDERING IS THE ARM'S, and on Linear it is VISIBLE: the platform offers no activity that terminates a session invisibly, so the arm posts a FIXED HOST ack, never model prose. `answered` says the turn already answered this container through a SIBLING wake — the caller PROVES that and this function never re-derives it. The return says whether a session was actually completed, so the caller stamps its audit only when one was.
+ */
+export declare function completeUnifiedSessionSilently(origin: UnifiedWakeOrigin, deps?: UnifiedReplyDeps, answered?: boolean): Promise<boolean>;
+export {};
+//# sourceMappingURL=unified-reply.d.ts.map

package/dist/agent/channels/unified-reply.d.ts.map

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