@open-everywhere/provider-slack 0.1.0

package/agent/channels/slack-input-response.ts

@@ -0,0 +1,162 @@
+// THE SLACK ARM OF THE HITL-ANSWER ADMISSION (OPE-574).
+//
+// eve's Slack channel accepts an answer to any parked `ask_question` / session-limit prompt from
+// whoever pressed the widget, with no check at all: `defaultOnInputResponse(ctx){return{auth:
+// ctx.defaultAuth}}`. Authoring `onInputResponse` replaces that default with OE code. The decision
+// itself lives in core (approvals/input-response-floor.ts) so the Teams arm reaches the same
+// verdict; this file is the Slack-shaped edge — resolve the partition, hand the facts over, render
+// the refusal.
+//
+// 🔴 FAIL-OPEN ON A THROW, deliberately. eve logs a thrown hook and treats it as REJECTION
+// (`slack/input-response.js` catches and returns `null`), so a transient store or roster blip
+// inside our code would silently make every question unanswerable — the exact outcome the
+// clicker floor's own catch exists to prevent. Anything unexpected therefore returns eve's own
+// default result and says so in the log; only a real verdict refuses.
+//
+// The refusal is EPHEMERAL, not a thread post. The card is still live for someone who may answer,
+// and a public "you may not answer" note in the room adds nothing the answerer does not already
+// need to know. This mirrors the Discord approval refusal (an ephemeral), not the Slack approval
+// refusal (a thread note, which exists there because the CARD is public and its state matters to
+// the room).
+//
+// LEG B HAS TEETH HERE (OPE-589) — the core header's "Slack cannot [answer B]" is now stale. This
+// module reuses `slackClickerIsGuest` (channels/slack-events.ts) — `slackAuthorIsMember`, the SAME
+// `users.info` call OPE-466 already makes to mark a non-member's chat message, inverted to a guest
+// verdict. The clicker floor's own leg D (approvals/flow.ts's `handleApprovalPayload`) reuses the
+// SAME function, so the two planes cannot drift on what "positively a guest" means. An unresolvable
+// probe returns `undefined` and the leg stays INERT, exactly as it did before.
+//
+// 🔴 SPEND GATE (OPE-588), FIRST — ahead of the room/guest admission below. This click RESUMES a
+// parked turn: a decision to spend more, taken through a button, on a scope nobody asked whether it
+// could afford. Every ordinary ingress door consults the ONE shared spend gate before it dispatches
+// a turn (spend/ingress-gate.ts); eve's own interactivity route calls `onInputResponse` and then
+// `.respond()` directly, with no call site of that gate anywhere on the seam — verified against the
+// installed eve/dist. `ingressSpendGate` fails open on a broken check and fails closed (visible
+// refusal, door `"answer"`) on a definite over-cap, the same posture the DM/channel doors already
+// hold. A decline returns eve's own reject-the-answer `null`, so the request stays PENDING — the
+// same outcome a room/guest refusal already leaves.
+
+import type {
+  SlackInputResponseContext,
+  SlackInputResponseResult,
+  SlackInputResponseSubmission,
+} from "eve/channels/slack";
+import {
+  admitInputResponse,
+  ingressSpendGate,
+  resolvePartition,
+  SLACK_SPEND_BADGES,
+  type BindableContext,
+  type IngressSpendGateInput,
+  type InputResponseAdmission,
+  type InputResponseScope,
+  type SpendGateDecision,
+} from "@open-everywhere/core/agent/adapter-api.js";
+import { slackClickerIsGuest } from "./slack-events.js";
+
+/**
+ * The RAW `team_id` off the interaction's own auth attributes — never `resolvePartition`'s
+ * `workspace` field (OPE-589 review fix). `resolvePartition` degrades an unnamed workspace to the
+ * `UNNAMED_TENANT` placeholder ("dev"), which is harmless where `workspace` only ever fed a
+ * surfaceKey lookup, but the guest-verdict probe below compares it against Slack's REAL `team_id`
+ * (`partnerFactsFromInfo`'s `ownWorkspace` check) — a placeholder there does not mean "no team", it
+ * means "a team literally named dev", and would falsely fail that comparison and refuse a genuine
+ * member. Reading the wire attribute directly keeps "no team known" as `undefined`. The probe then
+ * answers that absence from the operator's register alone (OPE-1508): a declared workspace or Grid
+ * still clears leg B, and an undeclared one is a GUEST, because absence infers non-member. Only an
+ * unreadable `users.info` leaves leg B inert. This is
+ * the same shape `flow.ts`'s `handleApprovalPayload` already reads off the raw Slack
+ * payload for the SAME probe on the approval-click side. LOCAL COPY of the attribute read (the
+ * `slack-identity.ts` header states the precedent): a three-line structural read over the public
+ * auth shape, not worth a barrel export.
+ */
+function slackAuthTeamId(auth: SlackInputResponseContext["defaultAuth"]): string | undefined {
+  const v = auth.attributes?.["team_id"];
+  if (typeof v === "string" && v.length > 0) return v;
+  if (Array.isArray(v) && typeof v[0] === "string" && v[0].length > 0) return v[0];
+  return undefined;
+}
+
+export interface SlackInputResponseDeps {
+  /** The core admission. Injected in tests; the live default is the shared decision. */
+  readonly admit?: (scope: InputResponseScope) => Promise<InputResponseAdmission>;
+  /** Render the refusal to the answerer alone. Live default is `chat.postEphemeral` in the thread. */
+  readonly notify?: (userId: string, text: string) => Promise<void>;
+  /**
+   * Positive per-answerer guest verdict for leg B (OPE-589). Live default is `slackClickerIsGuest`
+   * (channels/slack-events.ts). `undefined` is ALWAYS inert.
+   */
+  readonly guestVerdict?: (userId: string, teamId: string | undefined) => Promise<boolean | undefined>;
+  /** The shared spend-admission decision (OPE-588). Injected in tests; the live default is
+   *  `ingressSpendGate` (spend/ingress-gate.ts) — the SAME function every ordinary ingress door
+   *  consults. */
+  readonly spendGate?: (input: IngressSpendGateInput) => Promise<SpendGateDecision>;
+}
+
+/**
+ * Admit or refuse one eve-owned HITL answer submitted through Slack interactivity.
+ *
+ * Returns eve's own default result (`{ auth: ctx.defaultAuth }`) on an allow, so an admitted answer
+ * is byte-identical to today's behaviour. Returns `null` on a refusal, which leaves the request
+ * PENDING — eve has no cancel on this seam (see the core module's residual note).
+ */
+export async function admitSlackInputResponse(
+  ctx: SlackInputResponseContext,
+  submission: SlackInputResponseSubmission,
+  deps: SlackInputResponseDeps = {},
+): Promise<SlackInputResponseResult> {
+  const allow: SlackInputResponseResult = { auth: ctx.defaultAuth };
+  try {
+    const bindable = {
+      channel: { kind: "slack" },
+      session: { auth: { current: ctx.defaultAuth } },
+    } as BindableContext;
+    const p = resolvePartition(bindable);
+    const teamId = slackAuthTeamId(ctx.defaultAuth);
+
+    // SPEND GATE (OPE-588) — FIRST, ahead of the room/guest admission below (see the header note).
+    // A decline skips the guest probe entirely (over budget outranks identity) and returns eve's
+    // reject-the-answer `null`, leaving the request PENDING exactly like a room/guest refusal.
+    const spendGate = deps.spendGate ?? ingressSpendGate;
+    const spendVerdict = await spendGate({
+      bindable,
+      door: "answer",
+      principalId: submission.user.id,
+      workspaceRef: teamId ?? null,
+      badges: SLACK_SPEND_BADGES,
+      post: async (text) => {
+        await ctx.thread.postEphemeral(submission.user.id, text);
+      },
+    });
+    if (spendVerdict === "declined") return null;
+
+    const guestVerdict = deps.guestVerdict ?? slackClickerIsGuest;
+    const answererIsGuest = await guestVerdict(submission.user.id, teamId).catch(() => undefined);
+    const verdict = await (deps.admit ?? admitInputResponse)({
+      org: p.org,
+      platform: p.platform,
+      workspace: p.workspace,
+      surface: p.surface,
+      surfaceKey: p.surfaceKey,
+      principalId: submission.user.id,
+      responses: submission.inputResponses.length,
+      // Leg B (OPE-589): a POSITIVE per-answerer guest verdict from `slackAuthorIsMember`, or
+      // omitted when the probe could not answer — `undefined` never refuses.
+      ...(answererIsGuest === undefined ? {} : { answererIsGuest }),
+    });
+    if (verdict.ok) return allow;
+    const notify =
+      deps.notify ??
+      (async (userId: string, text: string): Promise<void> => {
+        await ctx.thread.postEphemeral(userId, text);
+      });
+    await notify(submission.user.id, verdict.notice).catch((err: unknown) => {
+      // The refusal still stands — the human just does not see why. One log line, never a throw.
+      console.error(`[open-everywhere:slack] HITL refusal notice failed to post: ${String(err)}`);
+    });
+    return null;
+  } catch (err) {
+    console.error(`[open-everywhere:slack] HITL answer admission failed softly — accepting the answer: ${String(err)}`);
+    return allow;
+  }
+}

package/agent/channels/slack-mrkdwn.ts

@@ -0,0 +1,61 @@
+// slack-mrkdwn — markdown (what the model writes) → Slack's mrkdwn dialect (OPE-870).
+//
+// Slack renders mrkdwn, not GitHub markdown: `*bold*` (not `**bold**`), `_italic_`, `~strike~`,
+// `<url|text>` links, no heading syntax. Every Slack post shipped the model's raw markdown
+// verbatim until this file existed, so `**bold**` and `[text](url)` rendered as literal
+// characters — observed live 2026-08-20, #oe-soak-ops, the channel-join intro's
+// `**Track soak health**`.
+//
+// PURE — no I/O. Applied at the Slack provider's delivery seam (slack-post-arm.ts): the reply
+// tool, edit_reply, and the join intro all post through dispatchSlackReply / liveSlackPost /
+// editSlackMessage, so converting there covers all three without touching core or any other
+// provider (Linear/GitHub take real markdown; Notion has its own block model).
+//
+// Code fences and inline code are protected FIRST and restored LAST — their contents must never
+// change, even when they look like markdown. Text that is already valid Slack mrkdwn (a single
+// `*bold*`, an existing `_italic_`, a `>` blockquote) is left untouched: Slack has no `**`/`__`
+// bold marker, so those are unambiguous GFM syntax safe to convert, but a single `*`/`_` is
+// ALREADY Slack's own syntax, and converting it again would corrupt it. That is also why this
+// function is idempotent — running it twice on its own output is a no-op.
+
+const CODE_PLACEHOLDER = "";
+
+/** Convert model-authored markdown to Slack mrkdwn. */
+export function markdownToSlackMrkdwn(text: string): string {
+  if (!text) return text;
+
+  // 1. Protect fenced code blocks, then inline code spans — restored verbatim at the end. Fences
+  //    first: an inline-code regex would otherwise match the single backticks INSIDE a fence.
+  const blocks: string[] = [];
+  const stash = (s: string): string => {
+    const token = `${CODE_PLACEHOLDER}${blocks.length}${CODE_PLACEHOLDER}`;
+    blocks.push(s);
+    return token;
+  };
+  let out = text.replace(/```[\s\S]*?```/g, (m) => stash(m));
+  out = out.replace(/`[^`\n]+`/g, (m) => stash(m));
+
+  // 2. Headers → a bold line (Slack has no heading syntax).
+  out = out.replace(/^ {0,3}#{1,6}[ \t]+(.+)$/gm, (_m, body: string) => `*${body.trim()}*`);
+
+  // 3. Links: [text](url) → <url|text>.
+  out = out.replace(/\[([^\]\n]+)\]\((\S+?)\)/g, (_m, label: string, url: string) => `<${url}|${label}>`);
+
+  // 4. Bold: **text** / __text__ → *text* — unambiguous, Slack has no ** or __ marker so this
+  //    never fires on text that is already Slack mrkdwn.
+  out = out.replace(/\*\*([^*\n]+)\*\*/g, (_m, body: string) => `*${body}*`);
+  out = out.replace(/__([^_\n]+)__/g, (_m, body: string) => `*${body}*`);
+
+  // 5. Strikethrough: ~~text~~ → ~text~.
+  out = out.replace(/~~([^~\n]+)~~/g, (_m, body: string) => `~${body}~`);
+
+  // 6. Bullet lists: "- item" / "* item" → "• item". The dash/star must be followed by
+  //    whitespace to match — a line opening on **bold** or *bold* never qualifies (no space
+  //    right after the marker), so this never collides with rule 4's untouched single-star text.
+  out = out.replace(/^(\s*)[-*][ \t]+/gm, (_m, indent: string) => `${indent}• `);
+
+  // 7. Restore code spans/fences untouched — no rule above ever saw their contents.
+  out = out.replace(new RegExp(`${CODE_PLACEHOLDER}(\\d+)${CODE_PLACEHOLDER}`, "g"), (_m, i: string) => blocks[Number(i)] ?? "");
+
+  return out;
+}

package/agent/channels/slack-origin-codec.ts

@@ -0,0 +1,62 @@
+// The Slack UnifiedWakeOrigin codec — MOVED VERBATIM out of core's
+// channels/wake-origin-codecs.ts (OPE-114 stage 4). STORED-DATA COMPATIBILITY IS THE
+// CONTRACT: a Slack origin is JSON-serialised into the durable operational store and
+// fail-closed re-validated on read, so every behaviour here is frozen by core's
+// scripts/wake-origin-fixtures-test.ts (run from the app root with this bundle's boot
+// wiring — scripts/wake-origin-fixtures-boot.ts). Validator tolerances (typeof-only
+// optional checks, extra unknown fields) are LOAD-BEARING for rows already on disk — never
+// tighten them here.
+//
+// The `UnifiedWakeOrigin` TYPE union (including its slack arm) stays in core — it is the
+// wire schema for stored rows; only the codec BEHAVIOUR lives in the bundle, registered by
+// registerSlackProvider() (../register.ts).
+
+import type { UnifiedWakeOrigin, WakeOriginCodec } from "@open-everywhere/core/agent/adapter-api.js";
+
+type SlackOrigin = Extract<UnifiedWakeOrigin, { platform: "slack" }>;
+
+/** COLON-FREE by construction (a task windowId is `[^:]+` — core channels/window-key.ts): any colon
+ *  in a raw surface id is folded to `_`, deterministically, so spawn + ingress agree on identity. */
+const noColon = (s: string): string => s.replace(/:/g, "_");
+
+export const slackWakeOriginCodec: WakeOriginCodec<SlackOrigin> = {
+  validate: (o) =>
+    typeof o.channelId === "string" &&
+    o.channelId.length > 0 &&
+    (o.threadTs === undefined || typeof o.threadTs === "string") &&
+    (o.replyAnchorTs === undefined || typeof o.replyAnchorTs === "string"),
+  threadRef: (origin) => ({ channelKey: noColon(`slack/${origin.channelId}`), threadKey: noColon(origin.threadTs ?? origin.channelId) }),
+  // threadTs present ⇔ the trigger was itself in a thread (the exact same presence threadRef keys
+  // on). Absent = a top-level trigger, which stays top-level for IDENTITY even though its reply
+  // opens a thread on it — that placement rides `replyAnchorTs`, which nothing here reads (OPE-759).
+  isThreadScoped: (origin) => typeof origin.threadTs === "string" && origin.threadTs.length > 0,
+  containerId: (origin) => origin.channelId,
+  // THE PLACEMENT CARRY (OPE-1824) — Slack is the one surface that needs it, and the line above says
+  // why: `replyAnchorTs` is placement ONLY and stays outside `threadRef`, so two top-level wakes in
+  // one channel are ONE conversation holding two different anchors, and a wake minted for a message
+  // that answers nothing (a routine fire, a webhook post-back) holds none. The reply fence admits a
+  // sibling wake on the conversation test alone; without this carry it would hand the post arm an
+  // anchorless origin and the answer would land FLAT on the channel.
+  // NARROWING-ONLY, and both guards are load-bearing. A `threadTs` target is already placed — its
+  // answer goes in that thread and must never re-anchor on a trigger message (the rule
+  // slackThreadTarget states) — and a target that already holds an anchor keeps it, because the model
+  // named THAT wake. So this fills exactly one gap: no placement at all, where the source has one.
+  // EMPTINESS IS ABSENCE ON ALL THREE READS, matching `slackThreadTarget` and `isThreadScoped`: a
+  // stored `""` is not a thread, not an anchor, and not an anchor worth carrying. No mint site writes
+  // one today, and reading it three ways in one file is how that stops being true quietly.
+  carryPlacement: (target, source) =>
+    !(target.threadTs && target.threadTs.length > 0) && !(target.replyAnchorTs && target.replyAnchorTs.length > 0) && typeof source.replyAnchorTs === "string" && source.replyAnchorTs.length > 0
+      ? { ...target, replyAnchorTs: source.replyAnchorTs }
+      : target,
+  // THE PLACEMENT AXIS ITSELF (OPE-1826) — the declaration `carryPlacement` above always implied and
+  // never stated. `replyAnchorTs` is the whole of it: `threadTs` is IDENTITY (it is what `threadRef`
+  // keys on and what `isThreadScoped` answers from), so a threaded origin's placement is already
+  // settled by the conversation test and naming it here would make two origins of one thread compare
+  // unequal on an axis that cannot differ. EMPTINESS IS ABSENCE, the third of the three reads this
+  // file takes that way.
+  placementRef: (origin) => (typeof origin.replyAnchorTs === "string" && origin.replyAnchorTs.length > 0 ? origin.replyAnchorTs : undefined),
+  // A `dmOrigin` arm lived here (OPE-306) to mint a DM delegation anchor's reply origin from the
+  // binding. OPE-368 deleted the anchor and the interface member with it — a Slack 1:1 or group DM
+  // now diverts into its own first-class window (OPE-351 stages 2 + 4), so its origin is minted and
+  // STORED at dispatch time by `scheduleDmWake` like every other wake.
+};

package/agent/channels/slack-post-arm.ts

@@ -0,0 +1,314 @@
+// slack-post-arm — Slack's POST arm for the post-arms registry (OPE-114 stage 1c). Absorbs, VERBATIM,
+// Slack's arms out of the three reply/delivery spines: reply-post.ts (resolveReplyTarget's slack
+// case + dispatchReply's chat.postMessage branch), unified-reply.ts (liveSlackPost), and
+// unified-redrive.ts (the slack describe/container cases). Slack's ONE bot-token write client is
+// slackForm (slack-events.ts) — every Slack post here funnels through it.
+
+import { slackForm, botDisplayName } from "./slack-events.js";
+import { markdownToSlackMrkdwn } from "./slack-mrkdwn.js";
+import { markNotApplied } from "@open-everywhere/core/agent/adapter-api.js";
+import type {
+  PostArm,
+  TargetResolveBag,
+  ReplyTarget,
+  ReplierLabel,
+  EditLocus,
+  UnifiedWakeOrigin,
+  UnifiedReplyDeps,
+  DirectMessageRequest,
+  DirectMessageDelivery,
+  DirectMessageAction,
+} from "@open-everywhere/core/agent/adapter-api.js";
+
+type SlackTarget = Extract<ReplyTarget, { platform: "slack" }>;
+type SlackOrigin = Extract<UnifiedWakeOrigin, { platform: "slack" }>;
+
+// --- OPE-508: the reply TIER signal, native on Slack ------------------------------------------
+//
+// Slack is the one surface OE's send path can vary the display NAME on, per message: chat.postMessage
+// takes an optional `username` override on a bot-token post — needs the `chat:write.customize` scope
+// (see docs/deploy/surfaces/slack.md). Every other wired surface (Discord's bot-token REST message
+// create, Teams' Bot-Framework activity, Notion's/Linear's comment APIs) has no equivalent per-message
+// override in what OE's send path already uses, so they get the shared bracket-BODY fallback instead
+// (reply-post.ts / unified-reply.ts, gated on `displayNameCapable` being false/absent for them).
+//
+// 🔴 SCOPE-OPTIONAL, GRACEFUL FALLBACK — BY CONSTRUCTION, NOT BY AN ASSUMPTION ABOUT SLACK'S OWN
+// BEHAVIOUR. Whether an app WITHOUT `chat:write.customize` gets `username` silently ignored or the
+// WHOLE post refused (`missing_scope`) is a Slack-side behaviour this codebase has not measured
+// against a real unscoped app — asserting one over the other would be an unmeasured vendor claim
+// baked into an availability-critical path. {@link postSlackMessage} makes the answer not matter: a
+// username-bearing post that comes back non-`ok` is retried EXACTLY ONCE with the tier-signal params
+// stripped, so a missing scope costs only the bracket, never the reply. A genuine failure (a
+// non-scope error, or a failure on the retry too) still throws — the fallback only ever widens what
+// counts as "the reply landed", never swallows a real one.
+//
+// PURE core: {@link slackReplierParams} decides WHAT to send; {@link postSlackMessage} is the thin
+// impure shell (resolve the bot's own name, dispatch, retry-on-reject). The `post` seam is injected
+// so the retry behaviour is unit-testable against a SCRIPTED bridge, without a live Slack token.
+
+/** Pure: the extra `chat.postMessage` params for a worker-turn reply. `username` is set to
+ *  "<agentName> [<taskLabel>]" only when BOTH a resolvable agent name and a replier label are
+ *  present; `{}` (no override — the bot's own default name renders, bare) for a supervisor/ambient
+ *  reply OR when the agent name can't be resolved — fail-open to today's behaviour, never blocks
+ *  the post over a cosmetic name. */
+export function slackReplierParams(agentName: string | undefined, replier: ReplierLabel | undefined): Record<string, string> {
+  if (!replier || !agentName || agentName.trim().length === 0) return {};
+  return { username: `${agentName} [${replier.taskLabel}]` };
+}
+
+/** The minimal shape {@link postSlackMessage} needs from a `chat.postMessage` response — the same
+ *  fields `slackForm` already returns, narrowed so a test double doesn't need the real client. */
+export interface SlackPostResult {
+  readonly ok?: boolean;
+  readonly ts?: unknown;
+  readonly error?: unknown;
+}
+
+/** The injectable `chat.postMessage` dispatch {@link postSlackMessage} calls — defaults to the live
+ *  `slackForm` client; a test supplies a scripted one. */
+export type SlackPostFn = (body: URLSearchParams) => Promise<SlackPostResult | undefined>;
+
+const livePost: SlackPostFn = (body) => slackForm("chat.postMessage", body.toString());
+
+/**
+ * POST `chat.postMessage` with the OPE-508 replier-tier fallback: `base` (channel/thread/text, no
+ * tier params) is the request that must ALWAYS have a chance to land. When `replier` resolves to
+ * non-empty params (a worker turn with a resolvable agent name), the FIRST attempt adds them; on
+ * any non-`ok` response to THAT attempt, retries ONCE with `base` alone. A response that was never
+ * tier-bearing (no replier, or an unresolvable agent name) gets no retry — a real failure there is
+ * real, not scope-shaped. `post` defaults to the live Slack client; `resolveDisplayName` defaults
+ * to the live `botDisplayName()`; a test injects scripted versions of both (the live
+ * `botDisplayName` reaches its own module-level memoized Slack call, which a `post`-only test
+ * double can't reach — see slack-replier-label-test.ts).
+ */
+export async function postSlackMessage(
+  base: URLSearchParams,
+  replier: ReplierLabel | undefined,
+  errPrefix: string,
+  post: SlackPostFn = livePost,
+  resolveDisplayName: () => Promise<string | undefined> = botDisplayName,
+): Promise<string> {
+  let usedReplierParams = false;
+  let attempt = base;
+  if (replier) {
+    const name = await resolveDisplayName().catch(() => undefined);
+    const params = slackReplierParams(name, replier);
+    if (Object.keys(params).length > 0) {
+      attempt = new URLSearchParams(base);
+      for (const [k, v] of Object.entries(params)) attempt.set(k, v);
+      usedReplierParams = true;
+    }
+  }
+  const res = await post(attempt);
+  const ts = typeof res?.ts === "string" ? res.ts : undefined;
+  if (res?.ok === true && ts) return ts;
+  if (usedReplierParams) {
+    // A rejected tier-signal param must never cost the reply itself — retry bare, exactly once.
+    const retry = await post(base);
+    const retryTs = typeof retry?.ts === "string" ? retry.ts : undefined;
+    if (retry?.ok === true && retryTs) return retryTs;
+    throw classifiedPostError(retry, `${errPrefix} — ${(retry?.error as string) ?? (res?.error as string) ?? "no ts returned (check SLACK_BOT_TOKEN)"}`);
+  }
+  throw classifiedPostError(res, `${errPrefix} — ${(res?.error as string) ?? "no ts returned (check SLACK_BOT_TOKEN)"}`);
+}
+
+/**
+ * The failure error for a `chat.postMessage` that did not return a usable ts, CLASSIFIED (OPE-821).
+ *
+ * `ok:false` IS DEFINITIVE, AND ONLY THAT. Slack answers HTTP 200 with `ok:false` when it read the
+ * request and refused it (`channel_not_found`, `not_in_channel`, `invalid_auth`) — nothing reached
+ * the room, so the post spine may release its dedupe claim and let an identical retry through. There
+ * is no HTTP status to carry that fact, so the arm states it (channels/platform-failure.ts).
+ *
+ * 🔴 `ok:true` WITH NO `ts` IS NOT DEFINITIVE, and the distinction is the whole point. Slack saying
+ * "ok" means the message DID post; a missing `ts` then means this host cannot name it, not that the
+ * room is empty. Marking that case would tell the spine to let a retry through and put the message
+ * in the room twice. A transport throw from `post()` never reaches here at all and stays AMBIGUOUS,
+ * which is the honest answer: a request that got no reply may still have applied.
+ */
+function classifiedPostError(res: SlackPostResult | undefined, message: string): Error {
+  const err = new Error(message);
+  return res?.ok === false ? markNotApplied(err) : err;
+}
+
+/** MID-TURN: post via chat.postMessage (returns `ts`), thread-anchored when the trigger was threaded. */
+async function dispatchSlackReply(target: SlackTarget, text: string, replier?: ReplierLabel): Promise<string> {
+  const body = new URLSearchParams({ channel: target.channelId, text: markdownToSlackMrkdwn(text) });
+  if (target.threadTs) body.set("thread_ts", target.threadTs);
+  return postSlackMessage(body, replier, "reply couldn't post to Slack");
+}
+
+/**
+ * The `thread_ts` a unified reply posts under, or undefined for a top-level post. PURE, and the ONE
+ * statement of Slack's reply placement:
+ *   • `threadTs` — the trigger was already in a thread, so the answer goes in that thread.
+ *   • `replyAnchorTs` — the trigger was a top-level channel message, so the answer opens a thread on
+ *     it (OPE-759; slack-events.ts mints the anchor for an addressed mention AND an ambient wake).
+ *   • neither — a post with no triggering message (a routine fire, a webhook post-back). It lands
+ *     top-level, which is the right placement for a message that answers nothing.
+ * Exported so the placement is pinned by a test rather than by reading one `??` inside an
+ * un-injectable network call (scripts/slack-replier-label-test.ts).
+ */
+export function slackThreadTarget(origin: Pick<SlackOrigin, "threadTs" | "replyAnchorTs">): string | undefined {
+  const anchor = origin.threadTs ?? origin.replyAnchorTs;
+  return anchor && anchor.length > 0 ? anchor : undefined;
+}
+
+/** UNIFIED: post into the wake origin's channel/thread (planSupervisorReply's exact semantics). */
+async function liveSlackPost(origin: SlackOrigin, text: string, replier?: ReplierLabel): Promise<string> {
+  const body = new URLSearchParams({ channel: origin.channelId, text: markdownToSlackMrkdwn(text) });
+  const threadTarget = slackThreadTarget(origin);
+  if (threadTarget) body.set("thread_ts", threadTarget);
+  return postSlackMessage(body, replier, "unified reply couldn't post to Slack");
+}
+
+/**
+ * UNIFIED, WITH BUTTONS (OPE-1720) — `liveSlackPost` plus one `actions` block, so an interactive card
+ * can reach a unified origin (a DM seat, a single-window channel) instead of only a DM.
+ *
+ * IDENTICAL GEOMETRY TO THE PLAIN POST: same channel, same `thread_ts` resolution, same replier
+ * fallback through {@link postSlackMessage} — the ONLY difference is the `blocks` field, so a card
+ * lands exactly where the same reply would have. An `actions` list that renders to NOTHING (every
+ * entry over Slack's caps) posts the plain message rather than a `blocks` array with an empty row.
+ */
+async function liveSlackPostWithActions(origin: SlackOrigin, text: string, actions: readonly DirectMessageAction[], replier?: ReplierLabel): Promise<string> {
+  return postSlackMessage(slackUnifiedActionForm(origin, text, actions), replier, "unified reply couldn't post to Slack");
+}
+
+/**
+ * PURE: the exact `chat.postMessage` form a unified card post sends. Split out from the dispatch so
+ * the BLOCK PAYLOAD itself is pinned by a contract test with no Slack token and no transport — the
+ * shape is the contract, and a shape Slack rejects costs the room the whole message, not just the
+ * buttons.
+ */
+export function slackUnifiedActionForm(origin: Pick<SlackOrigin, "channelId" | "threadTs" | "replyAnchorTs">, text: string, actions: readonly DirectMessageAction[]): URLSearchParams {
+  const rendered = markdownToSlackMrkdwn(text);
+  const body = new URLSearchParams({ channel: origin.channelId, text: rendered });
+  const threadTarget = slackThreadTarget(origin);
+  if (threadTarget) body.set("thread_ts", threadTarget);
+  const actionBlock = slackDirectMessageActionBlock(actions);
+  if (actionBlock !== undefined) {
+    // The text block rides ALONGSIDE the buttons, for the reason `deliverSlackDirectMessage` states:
+    // once `blocks` is present `text` is only the notification fallback, so without the section the
+    // room would see a row of buttons over an empty message.
+    body.set("blocks", JSON.stringify([{ text: { text: rendered, type: "mrkdwn" }, type: "section" }, actionBlock]));
+  }
+  return body;
+}
+
+/**
+ * THE COMPONENT PLANE (OPE-1060 S3) — the `actions` a {@link DirectMessageRequest} carries, rendered
+ * as ONE Slack `actions` block of buttons. Shared since OPE-1720 with the unified post above, so a
+ * bridged approval card and a DM card cannot drift in how a button is built or capped.
+ *
+ * 🔴 THE TEXT STILL STANDS ON ITS OWN. `post-arms.ts` states the contract: an arm with no component
+ * plane delivers the text alone and never fakes the buttons, so every caller's copy already says what
+ * the answers ARE in words. These buttons are a shortcut over that copy, never a replacement for it —
+ * which is also why the `text` field below stays the full message rather than a placeholder.
+ *
+ * 🔴 THE ACTION ID IS THE WHOLE DECISION AND THE LABEL IS HOST COPY. Neither is model-authored: the
+ * caller composes both (`access/credential-grant-card.ts`), and this arm only transports them. Slack
+ * caps an `action_id` at 255 characters and a button label at 75; an id or a label past its cap makes
+ * Slack reject the WHOLE `chat.postMessage`, which would cost the person the message as well as the
+ * buttons. So an over-long action drops out and the text still goes.
+ *
+ * `intent` maps to Slack's own button styles: `reject` renders `danger`, `affirm` renders default
+ * (never `primary` — four buttons of which three are primary reads as no emphasis at all, and the
+ * grant card's three affirms are genuinely equal choices).
+ */
+function slackDirectMessageActionBlock(actions: readonly DirectMessageAction[]): Record<string, unknown> | undefined {
+  const elements = actions
+    .filter((a) => a.id.length > 0 && a.id.length <= 255 && a.label.length > 0 && a.label.length <= 75)
+    .map((a) => ({
+      action_id: a.id,
+      text: { emoji: true, text: a.label, type: "plain_text" },
+      type: "button",
+      ...(a.intent === "reject" ? { style: "danger" } : {}),
+    }));
+  return elements.length > 0 ? { elements, type: "actions" } : undefined;
+}
+
+/**
+ * DM: open (or reuse) the 1:1 IM with a Slack member and post there (OPE-44's DM-delivery arm).
+ * `conversations.open` is idempotent — repeat calls return the SAME `im` channel id — so there is no
+ * "already open" branch to write. Needs the `im:write` bot scope on top of `chat:write`; without it
+ * Slack answers `missing_scope`, which this surfaces as a loud token-free throw so the governance
+ * arm refuses (and never falls back to rendering pane substance in the room).
+ *
+ * A request carrying `actions` also gets a row of buttons (OPE-1060 S3). The clicks come back on the
+ * app's interactivity URL, which the front route classifies by the action-id prefix.
+ */
+async function deliverSlackDirectMessage(input: DirectMessageRequest): Promise<DirectMessageDelivery> {
+  const opened = await slackForm("conversations.open", new URLSearchParams({ users: input.principalId }).toString());
+  const channel = opened?.channel as { id?: unknown } | undefined;
+  const dmChannelId = typeof channel?.id === "string" ? channel.id : undefined;
+  if (opened?.ok !== true || !dmChannelId) {
+    throw new Error(
+      `couldn't open a Slack DM with the requester — ${(opened?.error as string) ?? "no channel returned (check SLACK_BOT_TOKEN and the im:write bot scope)"}`,
+    );
+  }
+  const rendered = markdownToSlackMrkdwn(input.text);
+  const actionBlock = input.actions === undefined ? undefined : slackDirectMessageActionBlock(input.actions);
+  const form = new URLSearchParams({ channel: dmChannelId, text: rendered });
+  if (actionBlock !== undefined) {
+    // The text block rides ALONGSIDE the buttons. `text` alone is only the notification fallback once
+    // `blocks` is present, so without this section the person's Slack client would show a row of
+    // buttons over an empty message.
+    form.set("blocks", JSON.stringify([{ text: { text: rendered, type: "mrkdwn" }, type: "section" }, actionBlock]));
+  }
+  const posted = await slackForm("chat.postMessage", form.toString());
+  const ts = typeof posted?.ts === "string" ? posted.ts : undefined;
+  if (posted?.ok !== true || !ts) {
+    throw new Error(`couldn't post the Slack DM — ${(posted?.error as string) ?? "no ts returned (check SLACK_BOT_TOKEN)"}`);
+  }
+  return { surfaceId: dmChannelId, messageId: ts };
+}
+
+/**
+ * EDIT (OPE-793): rewrite one of our own posted messages via `chat.update` (channel + ts + text).
+ * Slack renders an "(edited)" marker on the message, so the room sees that it changed.
+ *
+ * Ownership is NOT decided here — channels/reply-edit.ts already refused anything outside the
+ * own-post ledger before this runs. Slack's own rule (an app may only update a message its own token
+ * posted) is the backstop under that, and its refusal arrives as a token-free throw the model reads.
+ * `chat.update` needs the same `chat:write` scope the post path already has.
+ */
+async function editSlackMessage(locus: EditLocus, messageId: string, text: string): Promise<void> {
+  const body = new URLSearchParams({ channel: locus.channelId, ts: messageId, text: markdownToSlackMrkdwn(text) });
+  const res = await slackForm("chat.update", body.toString());
+  if (res?.ok !== true) {
+    // DEFINITIVE (OPE-802): `chat.update` answers HTTP 200 with `ok:false`, so Slack read the request
+    // and decided against it — the message did not change. There is no status to carry that, so the
+    // arm says it. A transport throw from `slackForm` carries neither and stays AMBIGUOUS, which is
+    // the honest answer: a request that never got a reply may still have applied.
+    throw markNotApplied(
+      new Error(`edit_reply couldn't update the Slack message — ${(res?.error as string) ?? "chat.update returned no ok (check SLACK_BOT_TOKEN)"}`),
+    );
+  }
+}
+
+export const slackPostArm: PostArm = {
+  platform: "slack",
+  resolveTarget: (bag: TargetResolveBag): ReplyTarget | null => {
+    const channelId = bag.str("channelId");
+    // Slack threads its replies; bag.threadTs is the anchor (undefined ⇒ top-level).
+    return channelId ? { platform: "slack", channelId, threadTs: bag.threadTs } : null;
+  },
+  displayNameCapable: true,
+  dispatchReply: (target, text, replier) => dispatchSlackReply(target as SlackTarget, text, replier),
+  dispatchUnified: (origin, text, deps: UnifiedReplyDeps, replier) =>
+    deps.postSlack ? deps.postSlack(origin as SlackOrigin, text) : liveSlackPost(origin as SlackOrigin, text, replier),
+  // OPE-1720: Slack declares the unified component plane because the tap route exists on it —
+  // `slack-front.ts` classifies the `oe_input:` click and `slack-approval-card.ts` settles it. The
+  // injected `postSlack` override is honoured VERBATIM and drops the buttons: a test that scripted a
+  // text-only post must not start receiving a card it never asked for.
+  dispatchUnifiedActions: (origin, text, actions, deps: UnifiedReplyDeps, replier) =>
+    deps.postSlack ? deps.postSlack(origin as SlackOrigin, text) : liveSlackPostWithActions(origin as SlackOrigin, text, actions, replier),
+  describeRedriveTarget: (origin) => {
+    const o = origin as SlackOrigin;
+    return `slack ${o.threadTs ? `thread in ${o.channelId}` : `channel ${o.channelId}`}`;
+  },
+  redriveContainerId: (origin) => (origin as SlackOrigin).channelId,
+  deliverDirectMessage: deliverSlackDirectMessage,
+  editMessage: editSlackMessage,
+};