@open-everywhere/core 0.1.0

package/dist/agent/channels/reply-post.js

@@ -0,0 +1,407 @@
+// reply-post — the cross-surface post spine for the `reply` tool. Posting is decoupled from turn-completion: a reply posts mid-turn and returns the message id, and each post is recorded in the own-post ledger as it leaves, which is the fence `edit_reply` later checks. An edit adds no message to the room, so this spine stays the only way a NEW message gets there.
+// THE TARGET COMES FROM THE SESSION'S OWN BINDING, resolved from the per-delivery auth attributes and NEVER from model input, so `reply` can only post into the conversation it was woken for. Which surfaces can post mid-turn is the capability manifest's own answer — uniform verbs, honest availability — so a surface with no arm never sees the tool at all rather than one that throws when called. The per-provider posting lives in the post-arms registry, so this spine holds no vendor imports of its own.
+import { attestedFireCreatorId, authPrincipalId, bindFrom, currentTurnId } from "../identity/binding.js";
+import { capabilitiesForPlatform } from "../identity/capabilities.js";
+import { appendAudit } from "../audit/audit.js";
+import { swallowRoomPost } from "./egress-spoof.js";
+import { postArm } from "./post-arms.js";
+import { outboundKey, postOnce } from "../operational/post-once.js";
+import { withReplierPrefix, truncateMemoryCitationPaths } from "./turn-delivery.js";
+import { recordOwnPost } from "./own-post-ledger.js";
+import { resolvePartition } from "../memory/partition.js";
+import { platformFailureClass, platformFailureStatus } from "./platform-failure.js";
+import { recordPostTail } from "./session-tail-record.js";
+import { markWakeRefusedThisTurn } from "./reply-signal.js";
+import { applyReplyProvenance, auditReplyProvenance } from "./reply-provenance.js";
+import { auditWithheldMemoryClaim, guardMemoryClaims } from "./memory-claim-guard.js";
+import { auditWithheldApprovalClaim, guardApprovalClaims } from "./approval-claim-guard.js";
+import { auditWithheldRequestClaim, guardRequestClaims } from "./request-claim-guard.js";
+/**
+ * Resolve the reply target from a tool ctx, or null when this surface cannot host `reply`, or the post anchor cannot be resolved.
+ * The dynamic gate already hides the tool where the surface cannot post; this is the execute-time belt-and-braces, and what makes the decision unit-testable.
+ */
+export function resolveReplyTarget(ctx) {
+    // THE PLATFORM COMES FROM THE BINDING, NOT FROM `ctx.channel`: a TOOL-EXECUTE context carries no channel object at all, so a channel-derived platform answered `undefined` on every call and this returned null before it ever read the binding — the per-surface `reply` then threw on every native session.
+    // `bindFrom` is the read that already owns the identity-less case, and the read the TARGET below already used, so this is ONE binding for both halves rather than a second, structurally-empty channel. Fail-closed is unchanged: a context the binding cannot place registers no manifest and no arm, so this still returns null.
+    const binding = bindFrom(ctx);
+    const platform = binding.platform;
+    if (!capabilitiesForPlatform(platform).midTurnPost)
+        return null;
+    // No mid-turn post arm for this platform ⇒ an honest "can't post here" (belt-and-braces: the
+    // midTurnPost gate above already filters these, matching the old switch's `default: return null`).
+    const arm = postArm(platform);
+    if (!arm?.resolveTarget)
+        return null;
+    const t = binding.target;
+    // Every locus below comes from the binding's post-back target — the per-delivery auth the surface stowed, NEVER a tool argument — so `reply` can only post into the conversation it was woken for.
+    // The narrowers treat an absent or blank value as unresolved, which yields an honest "cannot post here" rather than a post to the wrong place. The spine owns the binding read; the arm turns these narrowed fields into its own target shape.
+    const str = (k) => (typeof t?.[k] === "string" && t[k].length > 0 ? t[k] : undefined);
+    const num = (k) => (typeof t?.[k] === "number" ? t[k] : undefined);
+    return arm.resolveTarget({ str, num, threadTs: binding.threadTs, ctx });
+}
+/**
+ * Build the reply plane's audit struct from a live tool ctx — the who and where a tool call holds. The choke point then OWNS writing the row, so there is exactly one row per event whichever verb initiated it.
+ * Shared by `reply` and `edit_reply`, so the two cannot drift into different attribution: an edit is audited with the same partition, principal, session and wake as the reply it corrects.
+ *
+ * 🔴 IT STAMPS THE FIRE'S ATTESTED CREATOR (OPE-1982). This route did not, and did not need to while the single-window prose bridge stamped it for a windowed routine fire. That bridge is deleted, so a fire on a unified window now answers through THIS door or through none — and leaving the field off here would have deleted the creator from every such row, making the human who owns the automation reachable only by a join to the routine row. It is read off the SAME ctx the principal is, it is `undefined` on an ordinary human turn, on a webhook fire and on a creator-less routine, and it never becomes the reply's author, which stays {@link principalId}.
+ */
+export function replyAuditFor(ctx, route, wakeId) {
+    const p = resolvePartition(ctx);
+    const sessionId = ctx.session?.id;
+    const turnId = currentTurnId(ctx);
+    const creatorId = attestedFireCreatorId(ctx);
+    return {
+        org: p.org,
+        platform: p.platform,
+        workspace: p.workspace,
+        surface: p.surface,
+        // 🔴 ON AN ATTESTED FIRE, THE DELIVERY'S OWN AUTH PRINCIPAL; EVERYWHERE ELSE, THE BINDING'S
+        // (OPE-1982). The two reads disagree on a fire: the binding resolves the attested CREATOR,
+        // because that is whose standing the turn acts with, while the actor a fired turn SPEAKS AS is
+        // the schedule principal (`eve:app`) — the invariant {@link attestedFireCreatorId}'s own
+        // docstring states, and the one the native chat terminal arms hold by snapshotting it at
+        // `turn.started`. The deleted prose bridge read `authPrincipalId` for exactly that reason; with
+        // that route gone this door is the only one a windowed fire's reply takes, so the derivation had
+        // to come with it or a fire's post would name a human as its author.
+        // 🔴 IT IS GATED ON THE CREATOR STAMP, AND THAT GATE IS THE POINT. `bindFrom` deliberately does
+        // not take the live auth verbatim on several ctx shapes — Slack collapses eve's composite
+        // `slack:<team>:<user>` AuthKey to the raw user id on a post-approval resume step
+        // (`slack-identity.ts` `rawSlackPrincipal`), and a subagent child's bind reads its dispatch
+        // snapshot rather than the live slot. Preferring the auth slot on every reply would write a
+        // SECOND spelling of the same person into `who`, which is hashed, so every principal-filtered
+        // query and every join to the rest of that turn's rows would split. A ctx with no creator stamp
+        // therefore keeps exactly the read it had before this ticket.
+        principalId: creatorId !== undefined ? (authPrincipalId(ctx) ?? bindFrom(ctx).principalId) : bindFrom(ctx).principalId,
+        ...(creatorId ? { creatorId } : {}),
+        ...(sessionId ? { sessionId } : {}),
+        ...(wakeId ? { wakeId } : {}),
+        ...(turnId ? { turnId } : {}),
+        route,
+    };
+}
+/**
+ * Does this reply body carry an ANSWER at all, or is it a stub a reader gets nothing out of? PURE, and the ONE test the unified window's DROP ROW (`channels/unified.ts`) and the e2e content gates share, so a turn the log calls answer-less and a turn a gate grades as answer-less are the same turn.
+ *
+ * 🔴 IT GATES NO DELIVERY, AND THAT IS WORTH SAYING OUT LOUD. It once decided whether the addressed-prose bridge would post; that route is deleted (OPE-1982), so the one in-product reader left LABELS the drop row — `reason: "no-substance"` — and the e2e gates ask the same question from the other side. It is not on the `reply` TOOL route either: a model that calls `reply("...")` still posts it and still spends the wake, because there the model chose to post and is still choosing what to say, so a host refusal reaches it and can steer it. A floor at the choke point would be refusing a call the model could have made honestly, which is a different ticket's argument to make. It lives HERE, beside the choke point, because it is a reply-plane rule and the next route to need it should find it without re-deriving it.
+ *
+ * 🔴 IT IS NOT A LENGTH TEST, AND IT MUST NEVER BECOME ONE. A correct answer here is routinely three characters — `144`, `81`, `no` — so a floor on `chars` strikes the shortest RIGHT answers this deployment gives. S11's own note records the same finding from the gate side: the interim it had to step past ran 194 characters, and a bar wide enough to catch it swallows real short answers too.
+ * The test is instead the weakest one that still separates the two: a body carries substance when at least one LETTER OR DIGIT survives once emoji shortcodes are stripped. `144` passes; `...`, `…`, `👍` and `:+1:` do not.
+ *
+ * WHY THE DISTINCTION EARNS A FIELD (OPE-1911): a turn that trailed off on `...` and a turn that wrote a real answer nobody received are different failures, and the canonical rows carry `chars` rather than whether anything was said. Measured on ship #216, J-ENGAGED-slack: a three-character closing text reached the room and every reader downstream graded it as the answer.
+ *
+ * 🔴 DELIBERATELY NOT A POINTER TEST. "Answered in the comments." is a pointer rather than an answer, and this predicate calls it substantive, because the host cannot grade whether prose answers a question without reading the question — the same line {@link guardMemoryClaims} holds about a durability claim. What separates a pointer from the answer is the turn's own `done` intent, which only the `reply` tool carries.
+ */
+export function replyCarriesSubstance(body) {
+    // Emoji SHORTCODES first (`:+1:`, `:white_check_mark:`), whose letters would otherwise read as
+    // content; then any Unicode letter or digit, which is what a reader can actually read.
+    return /[\p{L}\p{N}]/u.test(body.replace(/:[a-z0-9_+-]+:/gi, " "));
+}
+/**
+ * Write the ONE canonical `reply.post` row at the choke point — best-effort, never throws, and never fails the post; a no-op when the caller passed no audit struct.
+ * The detail is taint-clean, and the `reply.post` action NAME is load-bearing — the eval scorers join on it — so it never changes.
+ *
+ * 🔴 THE `platform` COLUMN NAMES THE SURFACE THE REPLY LANDED ON, never the route that carried it (OPE-1745). It is the `platform` ARGUMENT — the surface the arm posted to — and NOT {@link ReplyAudit.platform}, which is the turn's partition.
+ * The two agree on the one route this plane carries, `tool`. The rule is stated rather than assumed because a struct whose labels name a WINDOW makes them disagree, and such a reply then drops out of every operator query and gate that filters `reply.post` by platform. Measured on deploy #201, when the deleted bridge route was one: a Linear reply rowed as `platform: "unified"` with `detail.platform: "linear"`, and the e2e driver's `actions=reply.post&platform=linear` gate saw nothing for 60 s while the row sat there.
+ * NOTHING IS LOST: `detail.route` still says how the reply was posted. The column answers "where did it land", the detail answers "which door did it take".
+ */
+export async function auditReplyPost(audit, id, platform, chars) {
+    if (!audit)
+        return;
+    await appendAudit({
+        org: audit.org,
+        platform,
+        workspace: audit.workspace,
+        surface: audit.surface,
+        principalId: audit.principalId,
+        action: "reply.post",
+        detail: {
+            id,
+            platform,
+            chars,
+            route: audit.route,
+            ...(audit.creatorId ? { creatorId: audit.creatorId } : {}),
+            ...(audit.wakeId ? { wakeId: audit.wakeId } : {}),
+            ...(audit.sessionId ? { sessionId: audit.sessionId } : {}),
+        },
+    }).catch(() => undefined);
+}
+/**
+ * Ceiling on the model-authored wake string that reaches an audit `detail`. The input has no upper bound of its own, and the refusal row is the ONE place a rejected — that is, possibly attacker-suggested — value gets durably written.
+ * The answerable-reply fence already refuses anything over this length outright, so nothing legitimate is ever cut here.
+ */
+const REFUSED_WAKE_MAX = 200;
+/**
+ * `detail.reason` on a `reply.post.failed` row — the host cleared the post and the PLATFORM rejected
+ * it. ONE greppable string, the post-side twin of `reply.edit.refused`'s `platform-error`.
+ */
+const POST_PLATFORM_ERROR_REASON = "platform-error";
+/**
+ * Write the `reply.post.failed` row — a post that reached the transport and did not land. It has its OWN action because `reply.post` is the row the eval scorers join on to count DELIVERED messages, so a failure must never appear in it, and `reply.refused` is the host-verdict detective row, whose count would stop meaning what it means.
+ * `detail.failure` is the CLASS the spine acted on, which lets an operator count a definitive refusal apart from an ambiguous one; `detail.status` is the platform's HTTP status when the arm attached one — a number, never a response body. Best-effort and taint-clean, like every row on this path.
+ * 🔴 Its `platform` COLUMN names the SURFACE the post failed on, for the same reason and from the same argument as {@link auditReplyPost}'s: "how many replies failed to reach Linear" is a platform-filtered count, and a failure filed under a window label rather than the surface drops out of it.
+ */
+async function auditReplyPostFailed(audit, platform, failure, status) {
+    if (!audit)
+        return;
+    await appendAudit({
+        org: audit.org,
+        platform,
+        workspace: audit.workspace,
+        surface: audit.surface,
+        principalId: audit.principalId,
+        action: "reply.post.failed",
+        detail: {
+            reason: POST_PLATFORM_ERROR_REASON,
+            platform,
+            failure,
+            route: audit.route,
+            ...(status !== undefined ? { status } : {}),
+            ...(audit.wakeId ? { wakeId: audit.wakeId.slice(0, REFUSED_WAKE_MAX) } : {}),
+            ...(audit.sessionId ? { sessionId: audit.sessionId } : {}),
+        },
+    }).catch(() => undefined);
+}
+/**
+ * What BOTH post choke points do with a thrown dispatch: classify it, write the one `reply.post.failed` row, and hand the class back. The caller re-throws the ORIGINAL error, so the model still reads the arm's own token-free copy.
+ * It is one function for the reason {@link recordLandedPost} is: the per-surface spine and the unified spine drifted before, and a third choke point must get this or nothing.
+ */
+export async function notePostFailure(audit, err, platform) {
+    await auditReplyPostFailed(audit, platform, platformFailureClass(err), platformFailureStatus(err));
+}
+/**
+ * Should a failed post give its dedupe claim back? THE DEFINITIVE CASE MUST RELEASE: the claim is mark-then-run, so a post that threw already holds its key, and the model's most likely retry is the SAME text — without a release that retry is answered with the dedupe sentinel, `reply` reports posted, and the wake is marked ANSWERED for a message nobody ever received.
+ * THE AMBIGUOUS CASE MUST NOT: the post may already be in the room, and the claim is the only thing stopping an identical retry from saying it twice. The turn stays OPEN either way, since no mark lands, so the class decides only whether an identical retry inside the window reaches the platform.
+ */
+export const releasePostKeyOnFailure = (err) => platformFailureClass(err) === "definitive";
+/**
+ * Write a `reply.refused` row — the DETECTIVE half of the wake-decoy bound, and a deliberate carve-out from the actions-only posture: the SYMPTOM of this failure is the ABSENCE of rows, so a refused reply is otherwise indistinguishable from a turn that judged silence warranted. It also turns "the blast radius is bounded to availability" from reasoning into evidence an operator can count.
+ * IT ALSO RECORDS THE DECISION ON THE TURN, not only in the log. A refusal leaves the reply tool having posted nothing, which is the exact state the unified window's dropped-prose branch reads, so without this mark the log cannot say the host withheld that answer and the corrective redrive would nudge the model back towards the call the host had just refused. This is the ONE choke point every refusal row goes through, so recording here is what makes a future refusal site unable to forget. It never throws, and runs BEFORE the row.
+ */
+export async function auditReplyRefused(audit, reason) {
+    if (!audit)
+        return;
+    markWakeRefusedThisTurn(audit.turnId, audit.wakeId, reason);
+    await appendAudit({
+        org: audit.org,
+        platform: audit.platform,
+        workspace: audit.workspace,
+        surface: audit.surface,
+        principalId: audit.principalId,
+        action: "reply.refused",
+        detail: {
+            reason,
+            route: audit.route,
+            ...(audit.wakeId ? { wakeId: audit.wakeId.slice(0, REFUSED_WAKE_MAX) } : {}),
+            ...(audit.sessionId ? { sessionId: audit.sessionId } : {}),
+        },
+    }).catch(() => undefined);
+}
+/**
+ * Write a `reply.forced` row — the model OVERRODE a host verdict on the reply path and posted anyway.
+ * It has its own action rather than a flag on the post row next door, because an override is a different EVENT: it is the one place the reply path lets the model decide against the host, so an operator must be able to COUNT it without joining and filtering the whole post stream. It pairs with `reply.refused`, and the post still writes its own `reply.post` row beside it, never instead of it.
+ */
+export async function auditReplyForced(audit, reason) {
+    if (!audit)
+        return;
+    await appendAudit({
+        org: audit.org,
+        platform: audit.platform,
+        workspace: audit.workspace,
+        surface: audit.surface,
+        principalId: audit.principalId,
+        action: "reply.forced",
+        detail: {
+            reason,
+            route: audit.route,
+            ...(audit.wakeId ? { wakeId: audit.wakeId.slice(0, REFUSED_WAKE_MAX) } : {}),
+            ...(audit.sessionId ? { sessionId: audit.sessionId } : {}),
+        },
+    }).catch(() => undefined);
+}
+/**
+ * The (channel, threadTs) pair a reply's DEDUPE key hashes on — it mirrors {@link ReplyTarget}'s discriminated union field for field.
+ * Used only to build the idempotency key below; never a post target itself.
+ */
+function replyDedupeLocus(target) {
+    switch (target.platform) {
+        case "slack":
+            return { channel: target.channelId, threadTs: target.threadTs };
+        case "discord":
+            return { channel: target.channelId };
+        case "notion":
+            return { channel: target.discussionId };
+        case "teams":
+            return { channel: `${target.serviceUrl}::${target.conversationId}`, threadTs: target.replyToActivityId };
+        case "linear":
+            // Two Linear routes, two dedupe loci (OPE-811): the agent-session route keys on the session,
+            // the ambient route on the issue + the thread root it replies under. Never collapse them —
+            // an ambient repost and a mention repost are different posts into different places.
+            return "agentSessionId" in target ? { channel: target.agentSessionId } : { channel: target.issueId, threadTs: target.parentId };
+        case "github":
+            return { channel: `${target.owner}/${target.repo}`, threadTs: `#${target.issueNumber}` };
+        default:
+            // A platform outside the typed union — a test fake or an out-of-tree arm registered via
+            // registerPostArm. The registry seam deliberately accepts those, so the key builder must be
+            // total: dedupe keys on the whole serialized target instead of crashing the post.
+            return { channel: JSON.stringify(target) };
+    }
+}
+/**
+ * Sentinel `id` the choke points return when a byte-identical repost was suppressed within the dedupe window — never a real platform message id, so a caller must not treat it as one to query.
+ * The genuine post's own `reply.post` row is the durable record; a suppressed repost writes NO second row, because no second post actually happened.
+ */
+export const REPLY_DEDUPE_SKIPPED_ID = "deduped:reply";
+/**
+ * WHAT EVERY LANDED REPLY OWES, in one place — called by BOTH choke points from inside their dedupe run, right after the platform returned the message id. It is ONE function because two call sites DRIFTED before: a standing seat on a cross-surface window replies through the other choke point, so every post it made was recorded nowhere and the next generation inherited a tail of questions with no answers. A third choke point can now only get both or neither.
+ * The two records answer different questions about the same post: the LEDGER says "this message is ours, and here is how to edit it", and the RING says "this is what was said here", which the next generation inherits. Both are best-effort and neither throws, and a `null` edit locus skips only the ledger write, because the two are independent facts.
+ */
+export async function recordLandedPost(input) {
+    if (input.editLocus)
+        await recordOwnPost(input.org, input.editLocus, input.messageId);
+    // `messageId` THREADS THROUGH: a post row without it can never be found by a later confirmed `edit_reply`, which is the whole precondition the ring-rewrite rests on.
+    // `wake` threads through the same way, and 🔴 the cost of losing it is now the WHOLE gate, not a softer verdict (OPE-1528): a row without it is one the should-be-edit policy cannot tell apart from an answer to a different question, so it is never a fold target at all.
+    await recordPostTail({
+        text: input.body,
+        at: new Date().toISOString(),
+        platform: input.platform,
+        id: input.messageId,
+        ...(input.wake ? { wake: input.wake } : {}),
+    });
+}
+/**
+ * Post a NEW message into the session's conversation and return its id — the audit and output anchor. This NOTIFIES: it is a real reply, and it throws an honest, token-free error if the post did not land, so the model reads the failure and can call again. There is NO fallback to the turn's closing text (OPE-2006): that text is dropped on every seat, so a post that did not land is an answer that did not leave.
+ * THE CHOKE POINT: the single canonical `reply.post` row is written HERE, immediately after the platform returns the id — audit where the bytes leave — and it lands even under the egress spoof, because the eval targets score from the row. It is also IDEMPOTENT across a step re-run or a genuine double call, keyed on the target and the text: two distinct tool invocations with the same wake and the same bytes are something nothing upstream of this seam could catch.
+ */
+/**
+ * `replier` marks THIS reply as a worker or delegated turn's, and is present only for a task-grain session. A surface that can vary its per-message display name passes it straight through to its arm, unchanged.
+ * Every other surface gets the shared bracket prefix baked into the posted BODY ONCE, here at the choke point, before dedupe-keying and dispatch — so the prefix is part of the idempotency key too, and a worker reply and a supervisor reply with the same underlying text are correctly different posts.
+ */
+export async function postReply(target, text, audit, replier) {
+    // OPE-916: truncate any memory citation down to its silo-relative path BEFORE the replier
+    // prefix / dedupe key / audit chars are computed, so every downstream reader (the dispatched
+    // arm, the audit row, the dedupe hash) sees the same, member-safe text.
+    // OPE-1608: the connector footer joins it here for the same reason — one place where the bytes a
+    // room will see are settled. It is BYTE-EXACTLY the model's text on every turn that read no
+    // connector, which is every turn OPE-1516's silence is about.
+    const claimGuard = guardMemoryClaims(truncateMemoryCitationPaths(text), audit);
+    // OPE-1876: and the no-approval claim, on the same body, at the same choke point — a door that
+    // struck one and posted the other would read as a rendering glitch.
+    const approvalGuard = guardApprovalClaims(claimGuard.body, audit);
+    // OPE-2022: and the propose claim, on the same body, at the same choke point. A seat may not say
+    // it submitted a request the host never saw the propose plane make.
+    const requestGuard = guardRequestClaims(approvalGuard.body, audit);
+    const provenance = applyReplyProvenance(requestGuard.body, audit);
+    const clean = provenance.body;
+    const arm = postArm(target.platform);
+    const nativeReplier = arm?.displayNameCapable ? replier : undefined;
+    const body = replier && !arm?.displayNameCapable ? withReplierPrefix(clean, replier) : clean;
+    const locus = replyDedupeLocus(target);
+    // stableId = wakeId: the incident this wrap closes was a double post WITHIN one wake; two
+    // legitimate replies with identical bytes on DIFFERENT wakes (templated refusals are routinely
+    // byte-identical) must never collide, even inside the short TTL.
+    const key = outboundKey({
+        surface: target.platform,
+        channel: locus.channel,
+        threadTs: locus.threadTs,
+        action: "reply.dispatch",
+        stableId: audit?.wakeId,
+        payload: body,
+    });
+    const id = await postOnce({
+        org: audit?.org,
+        key,
+        run: async () => {
+            let realId;
+            try {
+                realId = await dispatchReply(target, body, nativeReplier);
+            }
+            catch (err) {
+                // OPE-821 — the failed post leaves ONE row carrying its CLASS, then the original error
+                // re-throws untouched so the model reads the arm's own copy. See `notePostFailure`.
+                await notePostFailure(audit, err, target.platform);
+                throw err;
+            }
+            await auditReplyPost(audit, realId, target.platform, body.length);
+            // OPE-1608 STORE-FIRST: the row records the FULL source list, including what the reach rule
+            // withheld from this room, so "what did this reply draw on" stays answerable after the render
+            // changes. A turn that read nothing writes no row.
+            await auditReplyProvenance(audit, realId, target.platform, provenance.reads, provenance.shown);
+            await auditWithheldMemoryClaim(audit, target.platform, claimGuard.withheld);
+            await auditWithheldApprovalClaim(audit, target.platform, approvalGuard.withheld, approvalGuard.cause);
+            await auditWithheldRequestClaim(audit, target.platform, requestGuard.withheld);
+            await recordLandedPost({
+                org: audit?.org,
+                editLocus: replyEditLocus(target),
+                messageId: realId,
+                body,
+                platform: target.platform,
+                wake: audit?.wakeId,
+            });
+            return realId;
+        },
+        // A DEFINITIVE failure gives the dedupe claim back, so an identical retry really posts; an
+        // AMBIGUOUS one keeps it, so an identical retry cannot double-post. See its own note.
+        releaseKeyOnFailure: releasePostKeyOnFailure,
+        skipped: () => REPLY_DEDUPE_SKIPPED_ID,
+    });
+    return id ?? REPLY_DEDUPE_SKIPPED_ID;
+}
+/**
+ * Post a HOST-AUTHORED notice — never a `reply.post` row, by construction. It is {@link postReply} with the audit parameter REMOVED FROM THE SIGNATURE, not merely omitted at the call site.
+ * Exporting the bare function to a provider bundle would hand every provider channel a way to post a MODEL's actual answer with no row, silently breaking the "one canonical `reply.post` per byte-leaving post" invariant and the eval scorers' join on that action. A caller that cannot pass an audit struct cannot make that mistake.
+ */
+export async function postHostNotice(target, text) {
+    return await postReply(target, text);
+}
+/**
+ * The {@link EditLocus} for a resolved per-surface {@link ReplyTarget} — the host-resolved half of `edit_reply`'s address, and the key the own-post ledger records under.
+ * Deliberately NOT {@link replyDedupeLocus}, though both read the same union: that one builds a DEDUPE key, so it may composite fields freely, while an edit locus is an ADDRESS an arm dispatches on. PURE, and the ONE definition both the ledger write and the edit read use, so a message can only be edited at the address it was posted to. `null` for a surface with no editable address.
+ */
+export function replyEditLocus(target) {
+    switch (target.platform) {
+        case "slack":
+            // chat.update addresses (channel, ts) — the thread anchor is not part of it.
+            return { platform: "slack", channelId: target.channelId };
+        case "discord":
+            // A Discord thread IS its own channel id, so this is already the message's own channel.
+            return { platform: "discord", channelId: target.channelId };
+        case "teams":
+            return { platform: "teams", channelId: target.conversationId, serviceUrl: target.serviceUrl };
+        case "github":
+            // OPE-862: the composite "owner/repo" string github-post-arm.ts's editMessage parses back
+            // apart — the SAME shape replyDedupeLocus already builds for this platform's dedupe key, so
+            // this is not a new address grammar, just a second reader of one already in use.
+            return { platform: "github", channelId: `${target.owner}/${target.repo}` };
+        case "linear":
+            // ONLY the AMBIENT route has an editable address: a created comment is a real `Comment`, so an update mutation can rewrite it.
+            // A MENTION reply posts an Agent Activity instead, and the live schema has no mutation that updates one at all — a PLATFORM LIMIT, not a not-yet, so this branch returns `null` on purpose.
+            return "agentSessionId" in target
+                ? null
+                : { platform: "linear", channelId: target.issueId, ...(target.organizationId ? { organizationId: target.organizationId } : {}) };
+        case "notion":
+            // The address is the SAME `<workspace>/<page>` conversation key the surface's own message-ops module composes, inlined here rather than imported, because this file holds no vendor imports.
+            // Those two fields are CONTEXT-only on the target, so a target minted before they were stamped, or a row with neither, has no credential to resolve — `null`, the same "no editable address" every other case already handles.
+            return target.workspaceId && target.pageId
+                ? { platform: "notion", channelId: `${target.workspaceId}/${target.pageId}` }
+                : null;
+        default:
+            // THE POST-ARM REGISTRY IS OPEN AND THIS SWITCH IS NOT, so a new surface takes TWO edits: an `editMessage` member on its arm, and a case here saying what its address looks like.
+            // Registering only the arm leaves the verb permanently refused rather than broken — the honest direction, but a silent one, so it is stated here rather than discovered.
+            return null;
+    }
+}
+async function dispatchReply(target, text, replier) {
+    // LOCAL EVAL SPOOF — the shared exit, which owns the flag read, the Vercel refusal and the swallow log for every room post this host makes.
+    // It stays SPINE-level, before the registry lookup, so no arm can ever be reached with real credentials on a spoofed run.
+    const swallowed = swallowRoomPost(`a ${target.platform} reply (${text.length}c)`, target.platform);
+    if (swallowed !== undefined)
+        return swallowed;
+    // Dispatch by platform key through the post-arms registry; every wired surface's mid-turn post primitive lives in its own per-provider arm.
+    // An unregistered platform, or one with no mid-turn arm, fails LOUD rather than silently mis-posting.
+    const arm = postArm(target.platform);
+    if (!arm?.dispatchReply) {
+        throw new Error(`reply couldn't post — no mid-turn post arm registered for "${target.platform}".`);
+    }
+    return arm.dispatchReply(target, text, replier);
+}
+//# sourceMappingURL=reply-post.js.map

package/dist/agent/channels/reply-post.js.map

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

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

@@ -0,0 +1,172 @@
+import type { ReplyAudit } from "./reply-post.js";
+/** WHICH proof a recorded read may be named by, stamped where the read happened.
+ *
+ *  🔴 IT IS EXPLICIT RATHER THAN INFERRED FROM WHICH FIELD IS SET, and that is the fence. A reply
+ *  cannot tell a unified seat from a per-surface one by itself — on the unified `reply` route the
+ *  partition resolves to the ORIGIN surface, so the reply's own fields look per-surface — so if the
+ *  surface branch were the default, ANY entry carrying a surface key would be named on a unified
+ *  reply whose partition matched, which is always. `defineState` is serialized into the session
+ *  context, so an entry written by an EARLIER DEPLOYMENT can be read back by this one; such an entry
+ *  carries no recognised proof, reads as `"none"`, and is counted by kind on every reply. */
+export type ConnectorReadProof = "surface" | "wake" | "none";
+/** WHICH RECORD a read pulled, as an ID AND A KIND — never its title (OPE-1714).
+ *
+ *  🔴 THE LEDGER'S "IDS AND VERBS ONLY" CONTRACT IS WHY THIS CARRIES NO NAME. A record title is the
+ *  op's OUTPUT, and the ledger is serialized into the session context, so a title stored here would
+ *  outlive the turn that read it and be readable back by a later deployment. The durable
+ *  `reply.provenance` row carries less again — connection and op names plus counts, and no record at
+ *  all — which is what keeps that row's own "ids and verbs only" contract exactly as it was. The
+ *  footer still shows a name: {@link rememberRecordName} keeps it in PROCESS MEMORY for this turn
+ *  alone, and the render resolves it there. An entry whose name has gone (a resumed session, another
+ *  process) renders as the connection name alone, which is the under-reporting direction this module
+ *  keeps everywhere else.
+ *
+ *  🔴 AN ENTRY CARRIES A RECORD ONLY WHERE THE HOST PROVED THE ROOM IS ENTITLED TO ITS NAME. That is
+ *  the second half of the disclosure rule (`channels/read-reach.ts` decides it, at the moment of the
+ *  read); the first half is the reach rule below, applied per reply. Both must hold for a name to
+ *  reach a reader. An AUTHORED read proves the room already holds the id, off the host's own wake
+ *  stamps. A BORROWED read proves it off the grant row instead: the name is the pinned target the
+ *  grant plane already discloses into that room on every call (OPE-2018). */
+export interface ConnectorReadRecord {
+    /** The record's kind — `notion-page`, `linear-issue`, `credential-grant`. A closed set owned by
+     *  `channels/read-reach.ts`, which is the only writer. */
+    readonly kind: string;
+    /** The record's id. An ID, in a ledger of ids: it is what the render keys a display name by, and
+     *  what a reader of the durable row can join back to the system it came from. */
+    readonly id: string;
+}
+/** One connector READ this turn made, as the `action.result` seam saw it. IDS AND VERBS ONLY — never
+ *  an op argument and never the op's output, the same contract the `connector.op` audit row keeps. */
+export interface ConnectorRead {
+    /** Which of the two keys below may name this read — see {@link ConnectorReadProof}. `"none"` means
+     *  the host could not place the read, and it is then counted by kind on every reply. */
+    readonly proof: ConnectorReadProof;
+    /** The connection the op ran under — the operator-chosen connector name (`notion`, `linear`),
+     *  which is the display name too. Never a credential id and never a record id. */
+    readonly connection: string;
+    /** The op verb (`get_page`, `list_issues`). Recorded for the durable row; the footer never shows
+     *  it, because a reader wants to know WHICH system was consulted, not which endpoint. */
+    readonly op: string;
+    /** `platform/workspace/surface` — the partition's SURFACE KEY, never the bare surface id. The reach
+     *  rule's whole input FOR A READ MADE ON A PER-SURFACE SEAT, and the reason it is the key: a bare
+     *  id (`C1`) is unique only inside one workspace on one platform, so comparing bare ids would call
+     *  two unrelated rooms the same room. NEVER set for a read made on a UNIFIED seat, where it would
+     *  name the delivery eve happened to keep rather than the conversation the read served — see the
+     *  module header. Absent means the host could not place the read, which counts as another domain. */
+    readonly surfaceKey?: string;
+    /** The wake THE TURN WAS WORKING FOR when the op ran — the reach rule's whole input for a read made
+     *  on a UNIFIED seat, where the surface proves nothing. Never set on a per-surface seat, which
+     *  carries no wake id at all (OPE-1601). Set means this read is provable ONLY by the wake: a reply
+     *  that answers another wake counts it by kind, and so does one that answers no wake. */
+    readonly wakeId?: string;
+    /** A SECOND wake id, in the SAME conversation, that may also name this read (OPE-1869).
+     *  🔴 IT EXISTS FOR ONE SHAPE ONLY: a delegated read carried onto a seat's turn at the settlement.
+     *  `installTaskWake` mints the task its OWN wake and the turn adopts it, so `hooks/spawn-taint.ts`
+     *  can prove the carriage only against that minted id ({@link wakeId}). The seat then REPLIES under
+     *  the wake the turn was delivered with — the stamp `installTaskWake` records as `inheritedWakeId`
+     *  — so the two ends named two different ids for one conversation and the reach rule below matched
+     *  neither. Ship #213 measured the whole of that: every `reply.provenance` row carried `named: 0`
+     *  with a non-zero `withheld`, on six replies whose reads the settle had already carried
+     *  (`delegation.provenance_carried … reads:4 found:4 outcome:"carried"`).
+     *  🔴 IT WIDENS NOTHING. The writer sets it only where the turn ADOPTED this task's own wake, which
+     *  is what makes the inherited stamp this same turn's own address rather than a sibling
+     *  conversation's — the OPE-1713 disclosure the `wakeProvable` guard closes. Absent is the ordinary
+     *  case: a seat-turn read has one address and sets only {@link wakeId}. */
+    readonly alsoWakeId?: string;
+    /** WHICH RECORD this read pulled — see {@link ConnectorReadRecord}. Set only by the two doors in
+     *  `channels/read-reach.ts`, and only where that module proved the room is entitled to the name:
+     *  the authored-tool door where the room ALREADY HOLDS this id, the borrow door where the name is
+     *  the grant's pinned target. A connector-op read never sets it: the `action.result` seam hands the
+     *  hook untyped vendor JSON, so the host cannot name the record such an op read without guessing
+     *  at keys in third-party content. Absent is the ordinary case and renders the connection alone. */
+    readonly record?: ConnectorReadRecord;
+}
+/** The op tier that counts as READING. Written as a constant so the hook and this module cannot
+ *  disagree about which verbs produce provenance (`access/connector-op-gating.ts` owns the tiering). */
+export declare const PROVENANCE_READ_TIER: "read";
+/** The audit action one landed reply writes to record what it drew on. STORE FIRST is the ruling
+ *  (Tommy, 2026-09-08): the render is a first cut that is expected to change, and the row is the
+ *  durable part, so the row carries the FULL list while the footer carries the reach-safe view. */
+export declare const REPLY_PROVENANCE_ACTION = "reply.provenance";
+/**
+ * Record that THIS turn READ something through a connector.
+ *
+ * Called from `hooks/connector-audit.ts` beside the `connector.op` row it already writes, for a
+ * `read`-tier op that did not error. Deduplicated on the whole entry, so a turn that pages a list
+ * twenty times contributes one source rather than twenty. No-op without a turn id.
+ */
+export declare function noteConnectorRead(turnId: string | undefined, read: ConnectorRead): void;
+/**
+ * Remember one record's DISPLAY NAME for the length of this turn, in this process.
+ *
+ * Called by the authored-tool door (`channels/read-reach.ts`) beside the ledger entry it writes, and
+ * only for a record the room is entitled to see. The name never reaches the ledger, the session
+ * context or the durable row — see {@link recordNames} for why that is the whole point.
+ */
+export declare function rememberRecordName(sessionId: string | undefined, turnId: string | undefined, kind: string, id: string, name: string | undefined): void;
+/**
+ * Every connector read THIS turn recorded, or an empty list.
+ *
+ * Answers empty for an unreadable turn id, for a record stamped for another turn, for a turn that
+ * read nothing, and whenever the eve context is unavailable — all of which render no footer, the
+ * fail-soft direction.
+ */
+export declare function connectorReadsThisTurn(turnId: string | undefined): readonly ConnectorRead[];
+/** The reach-safe view of a turn's reads, from the point of view of ONE reply.
+ *
+ *  `named` — distinct connection names the reply's own room is entitled to see, in first-read order.
+ *  `otherDomains` — how many distinct connections were read that this room cannot be shown, named by
+ *  kind alone. It is a COUNT, not a list: the count discloses that the turn consulted something
+ *  else, which is honest, while the name would disclose what. */
+export interface ReplyProvenance {
+    readonly named: readonly string[];
+    readonly otherDomains: number;
+    /** The RECORD NAME this room may see beside a named connection, keyed by that connection name — at
+     *  most one per connection, the first such read of the turn. Present only where BOTH halves of the
+     *  disclosure rule held: the room already holds the record's id (proved at the read, see
+     *  `channels/read-reach.ts`) and this reply lands in the room the read was scoped to (the reach
+     *  rule, applied here). Empty is the ordinary case, and it renders today's connection-only line. */
+    readonly records?: Readonly<Record<string, string>>;
+}
+/** The footer's leading marker — and, because {@link stripForgedFooter} strikes it out of the model's
+ *  own text, the string that RESERVES this line shape for the host. One constant so the render and
+ *  the strip can never disagree about what the marker is. */
+export declare const PROVENANCE_FOOTER_PREFIX = "Sources read this turn:";
+/**
+ * Write the durable provenance row for ONE landed reply — best-effort, never throws, never fails the
+ * reply, and a no-op when the turn read nothing.
+ *
+ * THE ROW CARRIES THE FULL LIST, the footer carries the reach-safe view, and the row records how many
+ * sources the footer withheld. That asymmetry is the point: the row is an internal record answering
+ * "what did this reply actually draw on", and an answer that had already dropped the redacted sources
+ * could not answer it. The row is readable with `readAudit({ action: "reply.provenance" })`.
+ *
+ * 🔴 Its `platform` COLUMN names the SURFACE the reply landed on — the `platform` ARGUMENT, not
+ * `audit.platform` — so it files beside the `reply.post` row it describes rather than under the
+ * route that carried it. See `channels/reply-post.ts` `auditReplyPost` for the measurement.
+ * `audit.platform` stays the turn's partition, and {@link provenanceForReply} still reads its
+ * `"unified"` value as the sentinel for "these labels name the window, not a room".
+ */
+export declare function auditReplyProvenance(audit: ReplyAudit | undefined, messageId: string, platform: string, reads: readonly ConnectorRead[], shown: ReplyProvenance | undefined): Promise<void>;
+/**
+ * The whole per-reply step, in one call both choke points make: read this turn's sources, apply the
+ * reach rule, and hand back the body to post plus the view to audit.
+ *
+ * ONE function because two choke points DRIFTED before over exactly this kind of shared step (see
+ * `recordLandedPost`): a post that footed its sources and an edit that silently stripped them would
+ * make the footer look like a rendering glitch rather than a record.
+ */
+export declare function applyReplyProvenance(text: string, audit: ReplyAudit | undefined): {
+    /** The text to post: the model's text with any forged marker struck and the footer appended. What
+     *  a choke point that posts the body WHOLE uses. */
+    readonly body: string;
+    /** The same text with the forged marker struck but NO footer appended, plus the {@link footer} to
+     *  add. A choke point that SPLITS the body to a message cap needs these two apart: appending
+     *  before the split lets the cap cut the footer in half across two messages, so it appends to the
+     *  last chunk instead. */
+    readonly bare: string;
+    readonly footer: string | undefined;
+    readonly reads: readonly ConnectorRead[];
+    readonly shown: ReplyProvenance | undefined;
+};
+//# sourceMappingURL=reply-provenance.d.ts.map

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

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