@open-everywhere/provider-slack 0.7.0 → 0.8.0

package/agent/channels/slack-memory-canvas.ts

@@ -24,14 +24,23 @@
 // reports, until the next memory write or trust event re-runs it (docs/capabilities/memory.md lists
 // every limit).
 //
-// 🔴 A CANVAS THE APP DID NOT CREATE IS NEVER TOUCHED. A channel has at most one channel canvas, and
-// people write their own. When the channel already has one, the app rewrites it only when
-// `files.info` names the app's own bot user as its creator. A person's canvas stays theirs, and the
-// refusal is logged and audited so an operator can see why a channel shows no memory.
+// 🔴 ONLY THE MEMORY CANVAS IS EVER TOUCHED (OPE-2587). A channel can show more than one canvas (the
+// channel canvas and its canvas tabs). People write their own, and the agent creates canvases for
+// people through `write_canvas`, with the app's own bot user as the creator. So the creator does not
+// mark the memory canvas. The app records the id `conversations.canvases.create` answers in the
+// `memory_canvas` row and rewrites only that canvas (core `memoryCanvasAmong` names the rule, and how
+// a canvas made before the row existed is adopted). Every other canvas stays as its owner left it,
+// unless a person types the memory canvas footer line into it by hand (core `memoryCanvasAmong` rule
+// 3). A channel whose canvas slot another canvas holds gets no memory canvas, and the refusal is logged
+// and audited so an operator can see why a channel shows no memory.
 //
 // 🔴 WHAT A CANVAS DOES NOT DO. It is a READ view. Members correct or forget a line by asking the
 // agent in the channel, which goes through the tools and the approval card like any other change.
 // An edit made directly in the canvas is overwritten on the next memory write — the canvas says so.
+// The agent's own `write_canvas` refuses this canvas for the same reason (core
+// channels/slack-canvas-list.ts `refuseMemoryCanvasWrite`, OPE-2585): both sides find the memory
+// canvas through the one core rule, `memoryCanvasAmong`. It reads the `properties.canvas` field AND
+// every canvas tab (`properties.tabs[]`, OPE-2587), because Slack can hold a channel canvas only as a tab.
 
 import {
   agentDisplayName,
@@ -39,11 +48,21 @@ import {
   domainForChannel,
   domainsNamingSilo,
   getConfig,
+  getOperationalStore,
+  MEMORY_CANVAS_MARKER,
+  memoryCanvasAmong,
+  memoryCanvasSurfaceKey,
   readDomainMemory,
+  storedMemoryCanvas,
   memoryLineForReader,
   renderMemoryMarkdown,
+  scrubAuditText,
+  type AuditDetail,
   type Domain,
+  type MemoryCanvasMatch,
   type MemoryWriteEvent,
+  type OperationalStore,
+  type SlackCanvasRead,
 } from "@open-everywhere/core/agent/adapter-api.js";
 import { confirmChannelInternalFresh, slackAuthorIsMember, slackForm } from "./slack-events.js";
 import { encodeSlackForm } from "./slack-web-api.js";
@@ -86,6 +105,68 @@ export interface MemoryCanvasDeps {
    *  `users.info` probe (slack-events.ts `slackAuthorIsMember`). */
   readonly authorIsMember: (userId: string, teamId: string | undefined) => Promise<boolean | undefined>;
   readonly now?: () => Date;
+  /** The `memory_canvas` row (OPE-2587). The live dep is the operational store. */
+  readonly store?: Pick<OperationalStore, "getMemoryCanvas" | "setMemoryCanvas">;
+}
+
+/** The Slack refusal behind a `failed` or `clear-failed` outcome, for the audit row (OPE-2600). `error`
+ *  is Slack's error code (`missing_scope`, `channel_not_found`, …), or `no_response` when the call gave
+ *  no answer at all. `needed` is the scope Slack names on a `missing_scope`. Operator data only: no
+ *  person-facing text carries it. */
+interface CanvasSlackError {
+  readonly method: string;
+  readonly error: string;
+  readonly needed?: string;
+}
+
+/** The longest Slack-supplied string the audit row keeps. Slack's codes and scope lists are far shorter. */
+const SLACK_ERROR_TEXT_MAX = 120;
+
+/** Slack's own text, kept only when it is a short code or scope list: never a free-text blob. */
+function slackCode(v: unknown): string | undefined {
+  return typeof v === "string" && v.length > 0 && v.length <= SLACK_ERROR_TEXT_MAX && /^[A-Za-z0-9_.:,-]+$/.test(v) ? v : undefined;
+}
+
+/**
+ * Wrap the deps of ONE canvas decision so the decision's last Slack refusal is kept (OPE-2600). Every
+ * lookup on the canvas path is fail-soft, and core's {@link memoryCanvasAmong} reads only `ok`, so
+ * without this a scope gap and a product defect both reach the audit row as a bare `failed`. The
+ * LAST refusal of the decision is kept. On most paths that is the call that decided the outcome. An
+ * earlier refusal can also have only shaped the path: a refused `auth.test` leaves the bot unknown, and
+ * a refused `conversations.members` sends the decision to the take-down. A throw is never a Slack
+ * refusal, so the callers drop the refusal on their throw path.
+ */
+function recordSlackRefusals(deps: MemoryCanvasDeps): { deps: MemoryCanvasDeps; refusal: () => CanvasSlackError | undefined } {
+  let last: CanvasSlackError | undefined;
+  return {
+    deps: {
+      ...deps,
+      call: async (method, body) => {
+        const res = await deps.call(method, body);
+        if (res === undefined) last = { method, error: "no_response" };
+        else if (res.ok !== true) {
+          const needed = slackCode(res.needed);
+          last = { method, error: slackCode(res.error) ?? "unknown", ...(needed ? { needed } : {}) };
+        }
+        return res;
+      },
+    },
+    refusal: () => last,
+  };
+}
+
+/** The Slack refusal behind an outcome, when it has one: present only on `failed` and `clear-failed`,
+ *  and only when a Slack call was refused. A failure with no Slack refusal (a store read, a throw)
+ *  answers undefined. */
+function refusalFor(outcome: CanvasOutcome, refusal: CanvasSlackError | undefined): CanvasSlackError | undefined {
+  return outcome === "failed" || outcome === "clear-failed" ? refusal : undefined;
+}
+
+/** The audit detail fields for a refusal: `slackError` (Slack's code, through the audit scrub, as every
+ *  error-named key must be), `slackMethod`, and `slackNeeded` when Slack names a scope. */
+function slackErrorDetail(e: CanvasSlackError | undefined): AuditDetail {
+  if (!e) return {};
+  return { slackError: scrubAuditText(e.error), slackMethod: e.method, ...(e.needed ? { slackNeeded: scrubAuditText(e.needed) } : {}) };
 }
 
 /** The live deps: every call through `slackForm` (the one Web API seam, fail-soft), the room verdict
@@ -113,7 +194,7 @@ function memoryCanvasMarkdown(domain: Domain, groups: Parameters<typeof renderMe
   const body = renderMemoryMarkdown(`What ${name} knows — ${domain.title ?? domain.name}`, groups, nowIso);
   const footer =
     `\n---\n${name} keeps this canvas up to date. To correct or forget a line, ask ${name} in this channel. ` +
-    `Edits made directly to this canvas get replaced.\n`;
+    `${MEMORY_CANVAS_MARKER}\n`;
   // OPE-2486 — the memory provenance carriers read as plain words on a canvas a whole channel reads.
   const text = defuseCanvasText(memoryLineForReader(body));
   const cut = text.length > CANVAS_MARKDOWN_MAX ? text.slice(0, CANVAS_MARKDOWN_MAX) + "\n\n_This canvas is full. Ask in this channel for the rest._\n" : text;
@@ -184,7 +265,9 @@ function withdrawnCanvasMarkdown(): string {
   return (
     `# ${name}'s memory canvas was withdrawn\n\n` +
     `This channel includes guests or people from outside your organisation, so ${name} no longer shows its memory here. ` +
-    `The memory itself is unchanged. Members can still ask ${name} about it in an internal channel.\n`
+    `The memory itself is unchanged. Members can still ask ${name} about it in an internal channel. ` +
+    // The marker keeps the withdrawn canvas the memory canvas, so a later refresh rewrites it in place.
+    `${MEMORY_CANVAS_MARKER}\n`
   );
 }
 
@@ -192,78 +275,121 @@ function withdrawnCanvasMarkdown(): string {
  *  longer belongs to a domain that shows one (`memoryCanvas: false`, no `memory`, or no domain). */
 type WithdrawReason = "external" | "guest" | "disabled";
 
+/** The channel one canvas decision is about, and the org and team its `memory_canvas` row is keyed by. */
+export interface CanvasRoom {
+  readonly org: string;
+  readonly teamId: string;
+  readonly channelId: string;
+}
+
+/** Slack's answer when it answered `ok`, else undefined: the read shape core's rule takes. */
+function readOk(deps: MemoryCanvasDeps): SlackCanvasRead {
+  return async (method, params) => {
+    const res = await deps.call(method, params);
+    return res?.ok === true ? res : undefined;
+  };
+}
+
+/** The memory canvas among the channel's canvases, by core's one rule (OPE-2587). */
+async function findMemoryCanvas(room: CanvasRoom, info: Record<string, unknown>, botUserId: string | undefined, deps: MemoryCanvasDeps): Promise<MemoryCanvasMatch> {
+  const stored = await storedMemoryCanvas(deps.store ?? getOperationalStore(), room.org, memoryCanvasSurfaceKey(room.teamId, room.channelId));
+  return memoryCanvasAmong(readOk(deps), info, stored, botUserId);
+}
+
+/** Record the room's memory canvas id. A failed write is not an outcome: the row then names an older id
+ *  or none, the canvas carries {@link MEMORY_CANVAS_MARKER}, and core's rule scans for the marker
+ *  whenever the row's id is not on screen. So the next decision finds this canvas again. */
+async function recordMemoryCanvas(room: CanvasRoom, canvasId: string, deps: MemoryCanvasDeps): Promise<void> {
+  const at = (deps.now?.() ?? new Date()).toISOString();
+  await (deps.store ?? getOperationalStore()).setMemoryCanvas(room.org, memoryCanvasSurfaceKey(room.teamId, room.channelId), canvasId, at).catch(() => undefined);
+}
+
 /**
- * Take the app's OWN canvas down in one channel, if it has one. FAIL-CLOSED ON EVERY LOOKUP: a failed
- * `conversations.info`, a failed `files.info`, or an unknown bot identity answers `clear-failed`, never
- * a skip — the caller cannot rule out that the app's canvas is still on screen, and the audit row must
- * say so. `skipped-*` is kept for the two answers that PROVE nothing of ours is there: no channel
- * canvas at all, or a canvas whose creator is somebody else.
+ * Take the memory canvas down in one channel, if it has one. FAIL-CLOSED ON EVERY LOOKUP: a failed
+ * `conversations.info`, store read, `files.info` or section lookup, or an unknown bot identity, answers
+ * `clear-failed`, never a skip — the caller cannot rule out that the memory canvas is still on screen,
+ * and the audit row must say so. `skipped-*` is kept for the answer that PROVES no memory canvas is on
+ * screen ({@link memoryCanvasAmong} answers `none`). Only the memory canvas is cleared: a person's
+ * canvas, and a canvas the agent made for a person through `write_canvas`, are not touched (OPE-2587),
+ * unless a person typed the memory canvas footer line into one by hand ({@link memoryCanvasAmong} rule 3).
  */
-async function withdrawIfOurs(channelId: string, reason: WithdrawReason, botUserId: string | undefined, deps: MemoryCanvasDeps): Promise<CanvasOutcome> {
-  const info = await deps.call("conversations.info", { channel: channelId });
+async function withdrawIfOurs(room: CanvasRoom, reason: WithdrawReason, botUserId: string | undefined, deps: MemoryCanvasDeps): Promise<CanvasOutcome> {
+  const info = await deps.call("conversations.info", { channel: room.channelId });
   if (info?.ok !== true) return "clear-failed";
-  const existing = canvasIdOf(info);
-  if (!existing) return `skipped-${reason}`;
-  const file = await deps.call("files.info", { file: existing });
-  if (file?.ok !== true) return "clear-failed";
-  const creator = (file.file as { user?: unknown } | undefined)?.user;
-  if (botUserId === undefined) return "clear-failed";
-  if (creator !== botUserId) return `skipped-${reason}`;
+  const match = await findMemoryCanvas(room, info, botUserId, deps);
+  if (match.kind === "unsure") return "clear-failed";
+  if (match.kind === "none") return `skipped-${reason}`;
   const cleared = await deps.call("canvases.edit", {
-    canvas_id: existing,
+    canvas_id: match.canvasId,
     changes: [{ operation: "replace", document_content: { type: "markdown", markdown: withdrawnCanvasMarkdown() } }],
   });
-  return cleared?.ok === true ? `cleared-${reason}` : "clear-failed";
+  if (cleared?.ok !== true) return "clear-failed";
+  if (match.adopt) await recordMemoryCanvas(room, match.canvasId, deps);
+  return `cleared-${reason}`;
 }
 
-function canvasIdOf(info: Record<string, unknown>): string | undefined {
-  const props = (info.channel as { properties?: { canvas?: { file_id?: unknown } } } | undefined)?.properties;
-  return typeof props?.canvas?.file_id === "string" ? props.canvas.file_id : undefined;
-}
+/** Slack's refusals of `conversations.canvases.create` that mean the channel's canvas slot holds a
+ *  canvas that is not the memory canvas: a person's channel canvas, or the one tab a free plan allows,
+ *  which a person's canvas or a canvas the agent made through `write_canvas` can hold. */
+const CANVAS_SLOT_TAKEN = new Set(["channel_canvas_already_exists", "free_team_canvas_tab_already_exists"]);
 
 /**
  * Write one channel's canvas — or, with `markdown: null`, only RECHECK it. Never throws.
  *
- * 🔴 THE GATE RUNS BEFORE EVERY DECISION, AND A FAILED GATE TAKES THE APP'S OWN CANVAS DOWN (OPE-2451,
+ * 🔴 THE GATE RUNS BEFORE EVERY DECISION, AND A FAILED GATE TAKES THE MEMORY CANVAS DOWN (OPE-2451,
  * the brain's security review). A canvas the app wrote while the channel passed outlives the room's
  * trust otherwise: once the channel is shared, or a guest joins, a refresh that merely SKIPS leaves
  * every line of the domain's memory on screen for the new audience. So on either refusal the app
- * replaces its own canvas with {@link withdrawnCanvasMarkdown} ({@link withdrawIfOurs}). A canvas a
- * PERSON made is never touched, in either direction.
+ * replaces the memory canvas with {@link withdrawnCanvasMarkdown} ({@link withdrawIfOurs}).
+ *
+ * 🔴 ONLY THE MEMORY CANVAS IS WRITTEN (OPE-2587). Slack shows a channel's canvases as tabs, and the
+ * canvas a person approves through `write_canvas` has the app's bot user as its creator too. So the app
+ * rewrites only the canvas core's {@link memoryCanvasAmong} finds: the id its `memory_canvas` row
+ * holds, or, for a canvas made before the row existed, the rule that function names. A channel with no
+ * memory canvas gets one, and the row records its id. A person's canvas and a `write_canvas` canvas are
+ * not touched, in either direction, unless a person typed the memory canvas footer line into one by
+ * hand ({@link memoryCanvasAmong} rule 3). A lookup that leaves the answer open writes nothing (`failed`),
+ * because a new canvas could then duplicate the memory canvas.
  *
  * `null` markdown is the recheck the trust EVENTS run: it takes the canvas down on a failed gate and
  * writes nothing on a passing one (`unchanged`). `joinedUserId` is the person a join event named: they
  * are probed DIRECTLY, because Slack's member list may not carry them yet when the event arrives.
  */
 export async function publishChannelCanvas(
-  channelId: string,
+  room: CanvasRoom,
   markdown: string | null,
   botUserId: string | undefined,
   deps: MemoryCanvasDeps,
-  teamId?: string,
   joinedUserId?: string,
 ): Promise<CanvasOutcome> {
+  const { channelId, teamId } = room;
   const blocked: "external" | "guest" | undefined = !(await deps.channelInternal(channelId))
     ? "external"
     : (joinedUserId !== undefined && joinedUserId !== botUserId && (await deps.authorIsMember(joinedUserId, teamId)) !== true) ||
         !(await everyMemberIsFull(channelId, teamId, botUserId, deps))
       ? "guest"
       : undefined;
-  if (blocked) return withdrawIfOurs(channelId, blocked, botUserId, deps);
+  if (blocked) return withdrawIfOurs(room, blocked, botUserId, deps);
   if (markdown === null) return "unchanged";
   const info = await deps.call("conversations.info", { channel: channelId });
   if (info?.ok !== true) return "failed";
-  const existing = canvasIdOf(info);
-  if (!existing) {
+  const match = await findMemoryCanvas(room, info, botUserId, deps);
+  if (match.kind === "unsure") return "failed";
+  if (match.kind === "none") {
     const created = await deps.call("conversations.canvases.create", { channel_id: channelId, document_content: { type: "markdown", markdown } });
-    return created?.ok === true ? "created" : "failed";
+    if (created?.ok !== true) return typeof created?.error === "string" && CANVAS_SLOT_TAKEN.has(created.error) ? "skipped-foreign" : "failed";
+    if (typeof created.canvas_id === "string" && created.canvas_id.length > 0) await recordMemoryCanvas(room, created.canvas_id, deps);
+    return "created";
   }
-  // Ownership before any write: only a canvas the app's own bot user created is the app's to replace.
-  const file = await deps.call("files.info", { file: existing });
-  const creator = file?.ok === true ? (file.file as { user?: unknown } | undefined)?.user : undefined;
-  if (botUserId === undefined || creator !== botUserId) return "skipped-foreign";
-  const edited = await deps.call("canvases.edit", { canvas_id: existing, changes: [{ operation: "replace", document_content: { type: "markdown", markdown } }] });
-  return edited?.ok === true ? "updated" : "failed";
+  const edited = await deps.call("canvases.edit", { canvas_id: match.canvasId, changes: [{ operation: "replace", document_content: { type: "markdown", markdown } }] });
+  if (edited?.ok !== true) return "failed";
+  if (match.adopt) await recordMemoryCanvas(room, match.canvasId, deps);
+  return "updated";
+}
+
+/** The deploy-log tail for a Slack refusal: the method and code, and the scope Slack names. */
+function slackErrorLog(e: CanvasSlackError | undefined): string {
+  return e ? ` (${e.method}: ${e.error}${e.needed ? `, needs ${e.needed}` : ""})` : "";
 }
 
 /** What woke a canvas decision: a memory write, or one of the two trust events. */
@@ -290,16 +416,24 @@ export async function recheckChannelCanvas(
   deps: MemoryCanvasDeps,
 ): Promise<CanvasOutcome> {
   const surfaceKey = `slack/${input.teamId}/${input.channelId}`;
+  const room: CanvasRoom = { org: input.org, teamId: input.teamId, channelId: input.channelId };
   const domain = domainForChannel(surfaceKey, getConfig().loadDomains());
   const shows = domain !== undefined && domain.memory !== undefined && domain.memoryCanvas !== false;
-  const auth = await deps.call("auth.test", {});
+  // The recorder starts before `auth.test`: an unknown bot identity is a refusal the row should name.
+  const recorded = recordSlackRefusals(deps);
+  const auth = await recorded.deps.call("auth.test", {});
   const botUserId = auth?.ok === true && typeof auth.user_id === "string" ? auth.user_id : undefined;
+  let threw = false;
   const outcome = await (shows
-    ? publishChannelCanvas(input.channelId, null, botUserId, deps, input.teamId, input.joinedUserId)
-    : withdrawIfOurs(input.channelId, "disabled", botUserId, deps)
-  ).catch((): CanvasOutcome => "clear-failed");
+    ? publishChannelCanvas(room, null, botUserId, recorded.deps, input.joinedUserId)
+    : withdrawIfOurs(room, "disabled", botUserId, recorded.deps)
+  ).catch((): CanvasOutcome => {
+    threw = true;
+    return "clear-failed";
+  });
+  const refusal = threw ? undefined : refusalFor(outcome, recorded.refusal());
   if (outcome !== "unchanged" && outcome !== "skipped-disabled") {
-    console.log(`[open-everywhere:slack-canvas] ${input.trigger} recheck, channel ${input.channelId}: ${outcome}`);
+    console.log(`[open-everywhere:slack-canvas] ${input.trigger} recheck, channel ${input.channelId}: ${outcome}${slackErrorLog(refusal)}`);
   }
   await appendAudit({
     org: input.org,
@@ -307,7 +441,7 @@ export async function recheckChannelCanvas(
     workspace: input.teamId,
     surface: input.channelId,
     action: MEMORY_CANVAS_ACTION,
-    detail: { domain: domain?.name ?? null, trigger: input.trigger, outcome },
+    detail: { domain: domain?.name ?? null, trigger: input.trigger, outcome, ...slackErrorDetail(refusal) },
   }).catch(() => undefined);
   return outcome;
 }
@@ -337,11 +471,18 @@ export async function refreshMemoryCanvases(event: MemoryWriteEvent, deps: Memor
     const markdown = shows ? memoryCanvasMarkdown(domain, await readDomainMemory(event.org, domain), nowIso) : "";
     for (const room of rooms) {
       // A throw on the clear-only path cannot rule out that the old canvas is still up, so it says so.
-      const outcome = await (shows ? publishChannelCanvas(room.channelId, markdown, botUserId, deps, teamId) : withdrawIfOurs(room.channelId, "disabled", botUserId, deps)).catch(
-        (): CanvasOutcome => (shows ? "failed" : "clear-failed"),
+      const canvasRoom: CanvasRoom = { org: event.org, teamId, channelId: room.channelId };
+      const recorded = recordSlackRefusals(deps);
+      let threw = false;
+      const outcome = await (shows ? publishChannelCanvas(canvasRoom, markdown, botUserId, recorded.deps) : withdrawIfOurs(canvasRoom, "disabled", botUserId, recorded.deps)).catch(
+        (): CanvasOutcome => {
+          threw = true;
+          return shows ? "failed" : "clear-failed";
+        },
       );
+      const refusal = threw ? undefined : refusalFor(outcome, recorded.refusal());
       if (outcome !== "created" && outcome !== "updated") {
-        console.log(`[open-everywhere:slack-canvas] domain "${domain.name}" channel ${room.channelId}: ${outcome}`);
+        console.log(`[open-everywhere:slack-canvas] domain "${domain.name}" channel ${room.channelId}: ${outcome}${slackErrorLog(refusal)}`);
       }
       const [platform, workspace, surface] = room.surfaceKey.split("/");
       await appendAudit({
@@ -350,7 +491,7 @@ export async function refreshMemoryCanvases(event: MemoryWriteEvent, deps: Memor
         workspace: workspace!,
         surface: surface!,
         action: MEMORY_CANVAS_ACTION,
-        detail: { domain: domain.name, trigger: "memory-write", silo: event.silo, outcome, chars: markdown.length },
+        detail: { domain: domain.name, trigger: "memory-write", silo: event.silo, outcome, chars: markdown.length, ...slackErrorDetail(refusal) },
       }).catch(() => undefined);
     }
   }

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

@@ -63,6 +63,15 @@ export const slackWakeOriginCodec: WakeOriginCodec<SlackOrigin> = {
     const ts = typeof origin.threadTs === "string" && origin.threadTs.length > 0 ? origin.threadTs : typeof origin.replyAnchorTs === "string" && origin.replyAnchorTs.length > 0 ? origin.replyAnchorTs : undefined;
     return ts === undefined ? undefined : { channelId: origin.channelId, messageId: ts };
   },
+  // THE THREAD A REPLY OPENS (OPE-2532). A post that is already in a thread answers undefined, because its
+  // own `threadTs` is the key. A post placed under an anchor lands in the anchor's thread (the post arm
+  // reads `threadTs ?? replyAnchorTs`), and Slack threads do not nest, so a reply carries the anchor. A
+  // top-level post opens a thread under its own ts.
+  replyThreadUnder: (origin, messageId) => {
+    if (typeof origin.threadTs === "string" && origin.threadTs.length > 0) return undefined;
+    const anchor = typeof origin.replyAnchorTs === "string" && origin.replyAnchorTs.length > 0 ? origin.replyAnchorTs : messageId;
+    return { platform: "slack", channelId: origin.channelId, threadTs: anchor };
+  },
   // 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

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

@@ -6,9 +6,11 @@
 
 import { slackForm, botDisplayName } from "./slack-events.js";
 import { markdownToSlackMrkdwn } from "./slack-mrkdwn.js";
+import { isSlackBlocksRefusal, slackReplyBlocks } from "./slack-reply-blocks.js";
 import { markNotApplied } from "@open-everywhere/core/agent/adapter-api.js";
 import type {
   PostArm,
+  PostIntent,
   TargetResolveBag,
   ReplyTarget,
   ReplierLabel,
@@ -131,11 +133,39 @@ function classifiedPostError(res: SlackPostResult | undefined, message: string):
   return res?.ok === false ? markNotApplied(err) : err;
 }
 
+/**
+ * Post an ANSWER (OPE-2520): `base` carries the channel, the thread and the mrkdwn `text`; when the
+ * intent asks for source links or the native thumbs, the first attempt adds the answer's `blocks`
+ * (slack-reply-blocks.ts). A post Slack refuses FOR ITS BLOCKS is retried once without them, so a
+ * workspace that rejects a block still gets the answer. Only that refusal retries: Slack answered
+ * `ok:false`, so nothing posted and the plain retry cannot double the message.
+ */
+export async function postSlackAnswer(
+  base: URLSearchParams,
+  intent: PostIntent | undefined,
+  replier: ReplierLabel | undefined,
+  errPrefix: string,
+  post: SlackPostFn = livePost,
+  resolveDisplayName: () => Promise<string | undefined> = botDisplayName,
+): Promise<string> {
+  const blocks = slackReplyBlocks(base.get("text") ?? "", intent);
+  if (blocks === undefined) return postSlackMessage(base, replier, errPrefix, post, resolveDisplayName);
+  const withBlocks = new URLSearchParams(base);
+  withBlocks.set("blocks", JSON.stringify(blocks));
+  try {
+    return await postSlackMessage(withBlocks, replier, errPrefix, post, resolveDisplayName);
+  } catch (err) {
+    if (!isSlackBlocksRefusal(err)) throw err;
+    console.warn("[open-everywhere:slack-post-arm] Slack refused the answer's blocks; posting the text alone");
+    return postSlackMessage(base, replier, errPrefix, post, resolveDisplayName);
+  }
+}
+
 /** 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> {
+async function dispatchSlackReply(target: SlackTarget, text: string, replier?: ReplierLabel, intent?: PostIntent): 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");
+  return postSlackAnswer(body, intent, replier, "reply couldn't post to Slack");
 }
 
 /**
@@ -155,11 +185,11 @@ export function slackThreadTarget(origin: Pick<SlackOrigin, "threadTs" | "replyA
 }
 
 /** UNIFIED: post into the wake origin's channel/thread (planSupervisorReply's exact semantics). */
-async function liveSlackPost(origin: SlackOrigin, text: string, replier?: ReplierLabel): Promise<string> {
+async function liveSlackPost(origin: SlackOrigin, text: string, replier?: ReplierLabel, intent?: PostIntent): 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");
+  return postSlackAnswer(body, intent, replier, "unified reply couldn't post to Slack");
 }
 
 /**
@@ -238,9 +268,29 @@ async function deliverSlackDirectMessage(input: DirectMessageRequest): Promise<D
  * 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());
+export async function editSlackMessage(
+  locus: EditLocus,
+  messageId: string,
+  text: string,
+  intent?: PostIntent,
+  /** The `chat.update` write — the live `slackForm` client; a test supplies a scripted one. */
+  form: (method: string, body: string) => Promise<Record<string, unknown> | undefined> = slackForm,
+): Promise<void> {
+  const rendered = markdownToSlackMrkdwn(text);
+  const body = new URLSearchParams({ channel: locus.channelId, ts: messageId, text: rendered });
+  // OPE-2520: an edit sends the answer's blocks too. A message posted with blocks shows its blocks,
+  // not its `text`, so an edit that sent `text` alone would leave the old answer on screen.
+  const blocks = slackReplyBlocks(rendered, intent);
+  if (blocks !== undefined) body.set("blocks", JSON.stringify(blocks));
+  let res = await form("chat.update", body.toString());
+  if (res?.ok !== true && blocks !== undefined && isSlackBlocksRefusal(String(res?.error))) {
+    // Slack refused the BLOCKS, so the message did not change. Retry once with the text alone and an
+    // EMPTY block list: `chat.update` keeps a message's existing blocks unless new ones are sent
+    // (surface-message-ops.ts), so a retry that only dropped the field would leave the old answer on
+    // screen while Slack answered `ok`.
+    body.set("blocks", "[]");
+    res = await form("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
@@ -260,14 +310,21 @@ export const slackPostArm: PostArm = {
     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),
+  dispatchReply: (target, text, replier, intent) => dispatchSlackReply(target as SlackTarget, text, replier, intent),
+  // OPE-2558: a Slack target and a Slack origin name the same two facts, a channel and a thread.
+  originOfTarget: (target) => {
+    const t = target as SlackTarget;
+    return { platform: "slack", channelId: t.channelId, ...(t.threadTs !== undefined && t.threadTs.length > 0 ? { threadTs: t.threadTs } : {}) };
+  },
+  dispatchUnified: (origin, text, deps: UnifiedReplyDeps, replier, intent) =>
+    deps.postSlack ? deps.postSlack(origin as SlackOrigin, text) : liveSlackPost(origin as SlackOrigin, text, replier, intent),
+  // OPE-2520: a `D…` channel is a 1:1 DM between the app and one person. A group DM is `G…`/`C…`.
+  isDirectConversation: (locus) => locus.channelId.startsWith("D"),
   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,
+  editMessage: (locus, messageId, text, intent) => editSlackMessage(locus, messageId, text, intent),
 };

package/agent/channels/slack-read.ts

@@ -25,6 +25,7 @@ import {
   markNotApplied,
   type BindableContext,
   type ReadScopeAuditDeps,
+  type ReadFile,
   type RenderedLine,
   type WakeReadAddress,
   domainRoster,
@@ -137,6 +138,27 @@ export interface RenderedMessage {
   /** A machine author (`bot_id` present). Excluded from the probe: a bot is below a member but is
    *  not a person outside the org — the same exclusion access/taint-signal.ts makes for `relay`. */
   readonly bot?: boolean;
+  /** The message's files: id, name and media type only (core channel-read.ts `ReadFile`). */
+  readonly files?: readonly ReadFile[];
+}
+
+/**
+ * A Slack message's `files` array, reduced to what a reader needs: the file id (`F…`, the id
+ * `describe_image` resolves as an attachment), the name (else the title) and the `mimetype`.
+ * Every other field is dropped, `url_private` and the permalinks above all: a reader that held a
+ * URL could fetch outside the governed attachment seam. A deleted file (`mode: "tombstone"`) and an
+ * entry with no id are skipped. PURE.
+ */
+export function slackMessageFiles(raw: unknown): ReadFile[] {
+  if (!Array.isArray(raw)) return [];
+  const out: ReadFile[] = [];
+  for (const f of raw as Array<Record<string, unknown>>) {
+    if (typeof f !== "object" || f === null) continue;
+    if (typeof f.id !== "string" || f.id.length === 0 || f.mode === "tombstone") continue;
+    const name = typeof f.name === "string" && f.name.length > 0 ? f.name : typeof f.title === "string" ? f.title : "";
+    out.push({ id: f.id, name, ...(typeof f.mimetype === "string" && f.mimetype.length > 0 ? { mimetype: f.mimetype } : {}) });
+  }
+  return out;
 }
 
 /**
@@ -155,9 +177,11 @@ export function renderMessages(raw: unknown, opts: { oldestFirst?: boolean } = {
   if (!Array.isArray(raw)) return [];
   const out: RenderedMessage[] = [];
   for (const m of raw as Array<Record<string, unknown>>) {
-    if (typeof m.subtype === "string" && m.subtype.length > 0) continue; // skip joins/edits/system
+    const files = slackMessageFiles(m.files);
+    // Skip joins, edits and system lines. A `file_share` line is a person's upload, so it stays.
+    if (typeof m.subtype === "string" && m.subtype.length > 0 && !(m.subtype === "file_share" && files.length > 0)) continue;
     const text = typeof m.text === "string" ? m.text : "";
-    if (!text) continue;
+    if (!text && files.length === 0) continue;
     const user = typeof m.user === "string" && m.user.length > 0 ? m.user : undefined;
     const botId = typeof m.bot_id === "string" && m.bot_id.length > 0 ? m.bot_id : undefined;
     out.push({
@@ -165,6 +189,7 @@ export function renderMessages(raw: unknown, opts: { oldestFirst?: boolean } = {
       ts: (m.ts as string) ?? "",
       text,
       ...(botId !== undefined ? { bot: true } : user !== undefined ? { authorId: user } : {}),
+      ...(files.length > 0 ? { files } : {}),
     });
   }
   // conversations.history returns newest-first; replies returns oldest-first.