@open-everywhere/provider-slack 0.8.0 → 0.9.0

package/agent/channels/slack.ts

@@ -10,11 +10,11 @@
 // (the defaults derive a thinner, workspace-scoped auth). The typing indicator shows
 // a code-owned STEP LABEL while a tool runs ("Searching Notion…", OPE-2449, see
 // slack-step-label.ts), and otherwise a random status VERB ("Tinkering…"),
-// configurable per org/domain — see statusVerb() below.
+// configurable per org/domain — see slackStatusVerb() in slack-working-signs.ts.
 //
 // Credentials: supplied to eve (OPE-2231), as a VERIFIER and a token FUNCTION rather than two
-// strings — agent/setup/eve-credentials.ts. Both resolve env-first and then this deployment's
-// encrypted credential store, which is where a `/setup` run puts them. They used to be omitted, which
+// strings — agent/setup/eve-credentials.ts. Both resolve the operator secret first (OPE-2650: the db
+// store, then its env var on-ramp), then the value a `/setup` run stored. They used to be omitted, which
 // left eve reading `process.env` on a path OE no longer does. Capturing channel_type/is_private is a RAW-fact job; the
 // security-critical interpretation (fail-closed to private) lives in the binding.
 
@@ -43,7 +43,6 @@ import {
   getOperationalStore,
   postOnce,
   outboundKey,
-  statusVerbsFor,
   getConfig,
   finalMessageActionForTurn,
   NO_REPLY_SENTINEL_REASON,
@@ -76,7 +75,6 @@ import {
   introMessage,
   instructionBullet,
   ONBOARDED_MARKER,
-  STATUS_REACTION,
   renderPinned,
   isPinnedStatusMessage,
   classifyWakeMapping,
@@ -89,7 +87,6 @@ import {
   type BindableContext,
   type ReactionState,
   dmTrustTtlMs,
-  swallowRoomOp,
   domainRoster,
   domainKeyOf,
   resolveWakeTrust,
@@ -105,7 +102,8 @@ import { admitSlackInputResponse } from "./slack-input-response.js";
 import { taskCardConfidentiality } from "./slack-task-card.js";
 import { turnEffectsFor, botDisplayName, slackForm, isSupervisorReplyTurn, deliverSupervisorReply, dmWakeThreadOverride, replyThreadTsForState, slackAuthorIsMember, slackWakeAuthorFacts, type SlackMemberProbe, type SupervisorReplyTarget } from "./slack-events.js";
 import { markdownToSlackMrkdwn } from "./slack-mrkdwn.js";
-import { stepStatusFor, type StepAction } from "./slack-step-label.js";
+import { type StepAction } from "./slack-step-label.js";
+import { setSlackStatusReaction, setSlackThreadStatus, SLACK_WORKING_STATUS, slackStatusVerb, slackStepStatus, type SlackSignRequest } from "./slack-working-signs.js";
 import type { AuditDetail } from "@open-everywhere/core/agent/adapter-api.js";
 
 // WARM_SILENT_LIMIT (the warm-thread shed threshold) now lives in channels/engagement.ts so
@@ -122,13 +120,8 @@ import type { AuditDetail } from "@open-everywhere/core/agent/adapter-api.js";
 // "working" from the inbound handlers we already own — so the HITL approval UI
 // (input.requested), reply rendering (message.completed), and typing all stay intact.
 
-// --- status verbs (the fun bit) ----------------------------------------------
-// "Tinkering…" / "Untangling…" instead of a flat "Thinking…"/"Working…" — a random
-// pick per status update from the channel's effective vocabulary (framework defaults
-// ← org ← role ← domain, extend-or-replace; memory/domain.ts statusVerbsFor — a
-// domain's ROLE preset contributes its themed verbs as its own rung). Orgs add house
-// verbs, a team adds its in-jokes. Cosmetic only, so ANY failure falls back to a
-// plain verb — the status line must never take a turn down.
+// --- status verbs: slack-working-signs.ts `slackStatusVerb` (OPE-2632 moved them there, so both doors
+// draw one vocabulary). ---------------------------------------------------------
 /** The team a channel belongs to per THIS deploy's domain config (`slack/<team>/<channel>` entries),
  *  or undefined when the channel is unmapped. Fail-soft: config errors read as "unknown", never
  *  throw into the inbound path. Used only as the last leg of onInbound's teamId heal. */
@@ -150,29 +143,15 @@ function teamIdFromDomainConfig(channelId: string | undefined): string | undefin
   return undefined;
 }
 
-function statusVerb(state: { channelId?: string | null; teamId?: string | null }): string {
-  try {
-    const p = resolvePartition({
-      channel: { kind: "slack" },
-      session: { auth: { current: { attributes: { team_id: state.teamId ?? "", channel_id: state.channelId ?? "" }, principalId: "", principalType: "slack-user" } } },
-    });
-    const cfg = getConfig();
-    const verbs = statusVerbsFor(p.surfaceKey, cfg.loadDomains(), cfg.loadRoles?.() ?? []);
-    return `${verbs[Math.floor(Math.random() * verbs.length)]}…`;
-  } catch {
-    return "Working…";
-  }
-}
-
 // Shared by `reasoning.appended` and `actions.requested`: the clean status verb, or a CODE-owned
 // step label (OPE-2449, `slack-step-label.ts`), and NEVER the model's own in-progress text. We used to show the model's pre-tool-call
 // preamble here (Tag-style, written for humans) — dropped 2026-07 (Tommy, live): that
 // text streams in mid-sentence, so it could flash a truncated fragment ("I'll go away and
 // look to setu…") for a moment before reverting to a verb, which read as broken. One
 // helper, one behaviour, so neither call site can drift back to surfacing partial text.
-async function refreshTypingStatus(channel: SlackEventContext, stepLabel?: string): Promise<void> {
+async function refreshTypingStatus(channel: SlackEventContext, actions?: readonly StepAction[]): Promise<void> {
   try {
-    await setWakeTyping(channel, stepLabel ?? statusVerb(channel.state));
+    await setWakeTyping(channel, slackStepStatus(actions, channel.state));
   } catch {
     /* typing indicator is best-effort */
   }
@@ -190,12 +169,7 @@ async function setWakeTyping(channel: SlackEventContext, status?: string): Promi
   const override = dmWakeThreadOverride(channel.state);
   const channelId = channel.state.channelId ?? undefined;
   if (override && channelId) {
-    try {
-      const body = new URLSearchParams({ channel_id: channelId, thread_ts: override, status: status ?? "" });
-      await slackForm("assistant.threads.setStatus", body.toString());
-    } catch {
-      /* thinking-status is best-effort */
-    }
+    await setSlackThreadStatus(formSign, { channelId, threadTs: override }, status ?? "");
     return;
   }
   await channel.thread.startTyping(status);
@@ -284,19 +258,31 @@ async function setStatusReaction(slack: SlackHandle, state: ReactionState | "non
   const timestamp = threadTsOverride ?? slack.threadTs;
   if (!channel || !timestamp) return;
   // The shared egress exit (core's channels/egress-spoof.ts, OPE-1132). This glyph is a room post,
-  // and it is the ONE Slack write in this bundle that does not travel through core's Slack bridge —
-  // `slack.request` is eve's own channel handle, so the bridge's gate never sees it. Gated here for
-  // that reason alone; every other Slack write this deployment makes is already covered upstream.
-  if (swallowRoomOp("a slack status reaction")) return;
-  for (const [s, name] of Object.entries(STATUS_REACTION)) {
-    try {
-      await slack.request(s === state ? "reactions.add" : "reactions.remove", { channel, name, timestamp });
-    } catch {
-      /* already-reacted / no-reaction / missing-scope are all non-fatal */
-    }
-  }
+  // and `slack.request` is eve's own channel handle, so core's Slack bridge gate never sees it.
+  // `setSlackStatusReaction` asks `swallowRoomOp` for that reason.
+  // OPE-2632: the shared implementation (slack-working-signs.ts), which the DM door's signs call too.
+  await setSlackStatusReaction(
+    async (method, params) => {
+      try {
+        await slack.request(method, { ...params });
+      } catch {
+        /* already-reacted / no-reaction / missing-scope are all non-fatal */
+      }
+    },
+    { channel, timestamp },
+    state,
+  );
 }
 
+/** The host-side sign seam for {@link setWakeTyping}'s per-wake override: `slackForm`, never throwing. */
+const formSign: SlackSignRequest = async (method, params) => {
+  try {
+    await slackForm(method, new URLSearchParams({ ...params }).toString());
+  } catch {
+    /* thinking-status is best-effort */
+  }
+};
+
 // Mirror surface-tier STATUS.md to a single pinned Slack message (find it via a
 // stable header marker so we don't persist a message ts across sessions).
 async function syncPinnedStatus(channel: SlackEventContext): Promise<void> {
@@ -712,7 +698,7 @@ async function onInbound(
   }
 
   try {
-    await ctx.thread.startTyping(statusVerb({ channelId: message.channelId, teamId: message.teamId }));
+    await ctx.thread.startTyping(slackStatusVerb({ channelId: message.channelId, teamId: message.teamId }));
   } catch {
     /* typing indicator is best-effort */
   }
@@ -934,7 +920,7 @@ const slackMentionChannel = slackChannel({
           channel.state.pendingTaskResults = null;
           channel.state.pendingToolCallMessage = null;
           (channel.state as unknown as Record<string, unknown>).oeReasoningTypingAtMs = null;
-          await setWakeTyping(channel, "Working...");
+          await setWakeTyping(channel, SLACK_WORKING_STATUS);
         },
         // Keep the model's REASONING out of the channel. GLM-5.2 runs with reasoning:"medium",
         // and Eve's default `reasoning.appended` handler pipes the chain-of-thought straight into
@@ -978,7 +964,7 @@ const slackMentionChannel = slackChannel({
         // so the indicator flashed a truncated fragment ("I'll go away and look to setu…"). That
         // stays dropped: no model text reaches the status line.
         "actions.requested": async (data, channel) => {
-          await refreshTypingStatus(channel, stepStatusFor(data.actions as readonly StepAction[] | undefined));
+          await refreshTypingStatus(channel, data.actions as readonly StepAction[] | undefined);
         },
         // 🔴 THE OUTPUT FENCE (OPE-2449). eve's defaults for these two events show
         // `presentation[callId].label`, which a tool's `label.complete`/`label.delta` builds from its

package/agent/docs-generated.ts

@@ -154,6 +154,21 @@ export const PROVIDER_DOCS: readonly DocEntry[] = [
       "the line they read as members. A workspace under a **different** Grid, or under no declaration, is",
       "still an outside author.",
       "",
+      "**An approval card in a 1:1 DM does not read the line (OPE-2630).** On a Grid, Slack can mark a DM",
+      "with `is_org_shared` (a share across the Grid's own workspaces) and `is_shared` (any share, a Slack",
+      "Connect one included). A DM does not count these two bits as an outside audience. A DM refuses an",
+      "approval card only on what Slack observes: the Slack Connect bits (`is_ext_shared`,",
+      "`is_pending_ext_shared`), or a partner whose `users.info` carries a guest flag. A group DM and a",
+      "channel still count all four share bits. The MCP-server propose card passes the same floor (OPE-2640).",
+      "Before that card, `propose_mcp_server` refuses a DM whose partner verdict from `users.info` is",
+      "external. That verdict does not read the share bits, but it does read the line. Without the line, a",
+      "full member at home in another workspace of the Grid is refused. The integration test",
+      "`tests/integration/approvals/grid-dm-card.test.ts` forges the Grid DM, with a Slack Connect DM as the",
+      "refused control. The live leg `S-DM-MCP-PROPOSE` posts the card in the board's own DM, which is not on",
+      "a Grid. The",
+      "**click** on that card is a member question, so it does read the line: a member-tier click from a",
+      "person whose home workspace is not the click's workspace counts as a guest click without it.",
+      "",
       "The member half needs no extra scope and no configuration beyond the line above: Open Everywhere",
       "reads the author's own workspace and Grid from the `users.info` lookup it already pays for, so it",
       "holds on every ingress, the channel-mention path included. A single-workspace install has no",
@@ -241,11 +256,13 @@ export const PROVIDER_DOCS: readonly DocEntry[] = [
       "[the control plane](../../security/control-plane.md)); a reopen keeps every stored credential, so the",
       "agent stays on Slack while you walk the page again.",
       "",
-      "🔴 **If `SLACK_BOT_TOKEN` or `SLACK_SIGNING_SECRET` is set in the environment, `/setup` answers 404.**",
-      "The resolver is env-first — deliberately, so that landing this page cannot change which Slack app a",
-      "working deployment speaks as — which means a run on such a deployment would store credentials nothing",
-      "would ever read. Rather than let you complete a run that changes nothing, the page refuses. To move an",
-      "existing deployment onto the credential store, unset both variables and redeploy; `/setup` then opens",
+      "🔴 **If `SLACK_BOT_TOKEN` or `SLACK_SIGNING_SECRET` is set — as an operator secret (`oe secret set`)",
+      "or as its env var on-ramp — `/setup` answers 404.** The resolver takes the operator secret first",
+      "(OPE-2650; before it, the env var) — deliberately, so that landing this page cannot change which Slack",
+      "app a working deployment speaks as — which means a run on such a deployment would store credentials",
+      "nothing would ever read. Rather than let you complete a run that changes nothing, the page refuses. To",
+      "move an existing deployment onto the `/setup` values, run `oe secret rm` for both names, unset both",
+      "variables and redeploy; `/setup` then opens",
       "and the deployment logs a setup code on that start.",
       "",
       "This is also why an existing deployment does **not** get an open setup page when it upgrades: it is",
@@ -275,7 +292,7 @@ export const PROVIDER_DOCS: readonly DocEntry[] = [
       "",
       "**2. The `/setup` window.** The page is open from the first start with a valid",
       "`OE_CREDENTIAL_ENCRYPTION_KEY` until the first Slack install, unless `SLACK_BOT_TOKEN` or",
-      "`SLACK_SIGNING_SECRET` is set in the environment. It answers 404 while the key is unset. In that",
+      "`SLACK_SIGNING_SECRET` is set (as an operator secret or its env var). It answers 404 while the key is unset. In that",
       "window, anyone who can read the deployment's logs can claim the page: every member of the Vercel",
       "team, and every reader of a log drain. The code is 128 bits, so a guess does not work. A claim lets",
       "the holder create a Slack app in their own workspace that points at this deployment, and lock",
@@ -666,20 +683,26 @@ export const PROVIDER_DOCS: readonly DocEntry[] = [
       "",
       "## Step 2 — Configure the environment",
       "",
-      "Set these on your instance:",
+      "Both Slack values are **operator secrets** (OPE-2650): store them in the deployment's encrypted",
+      "credential store, from your own terminal, with the same `DATABASE_URL` and",
+      "`OE_CREDENTIAL_ENCRYPTION_KEY` the deployment reads:",
       "",
       "```bash",
-      "SLACK_BOT_TOKEN=xoxb-…          # Bot User OAuth Token from Step 1.4",
-      "SLACK_SIGNING_SECRET=…          # Signing Secret from Step 1.5",
+      "npx oe secret set SLACK_BOT_TOKEN        # Bot User OAuth Token from Step 1.4 (value on stdin)",
+      "npx oe secret set SLACK_SIGNING_SECRET   # Signing Secret from Step 1.5 (value on stdin)",
       "```",
       "",
+      "A stored value takes effect within thirty seconds, with no redeploy. The env vars of the same names",
+      "still work as the on-ramp: the deployment reads one only when nothing is stored under its name.",
+      "",
       "Optional, but relevant to the silo model:",
       "",
       "```bash",
-      "OE_MEMORY_PROVIDER=git          # memory backend — git | sqlite",
       "OE_MEMORY_DIR=/abs/path/to/store",
       "```",
       "",
+      "The memory backend (`git` | `sqlite`) is the `memory.provider` setting in `agent/settings/settings.ts`, not an env var.",
+      "",
       "**Identity binds automatically.** You do **not** set workspace, surface, mode, or visibility by hand. The Slack channel reads `team_id`, `channel_id`, `channel_type`, and `is_private` straight off each inbound event into the session auth context, and `bindSlack` derives workspace = the Slack workspace, surface = the channel, plus mode and visibility. The `deploymentIdentity.workspace` / `.surface` declaration in `agent/identity/surfaces.ts` is only the `eve dev` (no-surface HTTP) gap-filler — once Slack is wired it is ignored.",
       "",
       "## Step 3 — Invoke it",
@@ -733,7 +756,12 @@ export const PROVIDER_DOCS: readonly DocEntry[] = [
       "     reaction via the `react` tool — a bare emoji ack (e.g. 👍) instead of a low-content reply in a",
       "     busy thread. It's a genuine alternative response, not a status indicator, and is audited like",
       "     any other tool call.",
-      "4. Test a DM: open a direct message with the bot and send a plain message (no `@mention` needed in a DM). It responds the same way. The DM surface's memory is isolated and `private`.",
+      "4. Test a DM: open a direct message with the bot and send a plain message (no `@mention` needed in a DM). The DM surface's memory is isolated and `private`. While the turn works, the bot shows the same signs a mention gets. A group DM with the bot shows them too.",
+      "   - **👀 on your message.** A message inside a DM thread gets it on the thread's first message, as in a channel. It goes away when the turn ends. A DM reply stays flat, as described above.",
+      "   - **The status line** under your message: `Working...` at the start, then a live step label while a tool runs (`Reading the thread…`), from the same code-owned table a mention uses. It goes away when the turn ends.",
+      "   - **🛑 when the turn fails for good.** The 👀 goes, 🛑 goes on your message, and the status line clears. In a 1:1 DM the agent session also leaves `processing`, so Slack takes its Stop button off the dead turn. The next turn on the same message takes the 🛑 off again.",
+      "   - **A group DM** has no agent session, so it has no Stop button and no session state. It shows every other sign.",
+      "   - **If a sign is missing**, the app lacks a scope or the agent view. The 👀 and the 🛑 need `reactions:write`. The status line needs `assistant:write` and the agent view (`features.agent_view`). All three come from the manifest: paste it again (App Manifest → Save Changes) and reinstall if Slack asks. The deployment logs the refused call once per process, with this fix in the line: search the logs for `[open-everywhere:slack-session]`.",
       "",
       "### What it can read on Slack",
       "",
@@ -990,6 +1018,7 @@ export const PROVIDER_DOCS: readonly DocEntry[] = [
       "| **A title.** A conversation that opens with a top-level message shows a short title from the words the person typed. | The DM door creates the session with that title before the turn starts. The title is the first typed line, cut to 60 characters at a word. A member mention is dropped, a channel shows as `#name` and a link shows as its label, so the title holds no raw id. The lines of a forwarded or quoted message are another conversation's words, so they never make the title: a forward with no typed text gets no title. A voice clip's transcript is not typed text either, so a clip with no typed words gets no title. The host writes the title in code; no model writes it. |",
       "| **Their own title.** The person can rename a session at any time. | Slack applies a title only when a call creates the session, so OE never overwrites a rename. |",
       "| **Working, with a Stop button.** | A turn's start sets the session `processing`. Slack then shows its Stop button, because the app subscribes to `agent_session_stopped`. |",
+      "| **👀 and the status line.** | The same start puts 👀 on the session's first message and shows `Working...` as Slack's assistant status there. The park removes both. The DM seat runs on the `unified` channel, so the Slack channel's own 👀 and status line (the mention door's) never reach it: these two calls are the DM's only working signs (OPE-2629). A forwarded job's settlement (next rows) sets the session state only and leaves the signs to the running turn. A turn that fails for good never parks, so its signs stay. |",
       "| **Stop.** | A press takes the same road as the ✋ reaction and `/oe stop`: it is decided at ingress, before any model call, so it is free and works over a spend cap. It stops the turn of the session's thread. In the DM it falls back to the DM's newest turn, because a top-level DM message keys its turn by the channel alone. The audit row is `turn.cancel_requested` with `via: \"stop-button\"`. Slack does not move the status itself, so OE sets the session `active`. |",
       "| **\"Needs you\".** | When the seat's turn reported through `update_status` that it waits on the person (`needs_input` or `blocked`), the agent session parks `suspended`. Otherwise it parks `active`. The person's next message clears it: that turn sets `processing`, then parks `active` unless it reports again that it waits on the person, or a job of the session still waits (next row). A job's result turn sets no state: the result wake names no agent session. |",
       "| **\"Needs you\", for a job.** | A job the DM seat forwards can end waiting on the person: its worker asked a question in the DM (`ask_room`) and finished, or it needs the person's own sign-in. The work session has no `update_status`, so the host sets the agent session the job came from `suspended` when the job's task settles. While the job waits, every turn of that session parks `suspended`. When the person answers and the seat forwards the answer to the same task, the job moves on in the session it came from, whichever agent session of the DM the answer came from. That session then parks `active`, unless another of its jobs still waits. After a sign-in, the resume forward sets the session `active`. The audit row is `work.surface_wait`: ids, the state and the reason, never the question. |",
@@ -1033,7 +1062,11 @@ export const PROVIDER_DOCS: readonly DocEntry[] = [
       "test `tests/integration/channels/slack-agent-session.test.ts` drives a booted agent through the",
       "signed DM door: the title before `processing`, `suspended` after `update_status(needs_input)`,",
       "`active` after the answer, no title for a forward with no typed text, and a signed Stop press that",
-      "stops a held turn and sets the session `active`. The integration test",
+      "stops a held turn and sets the session `active`. The same test proves the working signs: 👀 on the",
+      "person's top-level message before the park, `Working...` on the same message, and both cleared at the",
+      "park. The live e2e scenario `S-SESSION-STOP` reads `reactions.get` on the person's real DM message",
+      "while its turn runs (👀 present), and again after the stop (👀 gone). No API reads the status line",
+      "back, so no live leg proves it. The integration test",
       "`tests/integration/channels/slack-job-wait.test.ts` forwards a DM job whose worker asks with",
       "`ask_room`: the session goes `suspended` at the job's settlement, another message keeps it so, and the",
       "answer forwarded to the same task parks it `active`. The test holds the seat's result-wake",
@@ -1189,7 +1222,11 @@ export const PROVIDER_DOCS: readonly DocEntry[] = [
       "**What the tests prove.** The unit pack `test:slack-doc-write` (packages/core) pins the room fence, the",
       "cell encoding, the row match, the card text and the exact Slack calls an approval sends. The live e2e",
       "scenario `S-CANVAS-LIST` asks the agent for a canvas in a real channel, approves the card, and reads the",
-      "canvas back from Slack.",
+      "canvas back from Slack. The live e2e scenario `S-LIST-WRITE` asks the agent to add a row to a fixture",
+      "List in a real channel and then to change that row, approves each card, and reads the row back from",
+      "Slack. It needs a List titled \"OE e2e List fixture\", with a text column named \"Note\", shared in the e2e",
+      "channel, and a driver token with `lists:read`. The clean-up also needs `lists:write`: without it,",
+      "each run leaves its row in the List.",
       "",
       "## Slash commands: `/oe` (zero-inference control-plane)",
       "",

package/agent/ops.ts

@@ -31,6 +31,7 @@ import {
   configuredAgentName,
   declaredMcpServers,
   getSettings,
+  registerOperatorSecretNames,
   registerSurfaceAppManifest,
 } from "@open-everywhere/core/agent/adapter-api-ops.js";
 import { SLACK_AS_YOU_NAME } from "./slack-as-you.js";
@@ -60,6 +61,9 @@ export function slackManifestOptionsFromSettings(opts: { readonly appName?: stri
 
 /** Register the slack ops-plane arm (the app manifest). */
 export function registerSlackOps(): void {
+  // The two Slack credentials are operator secrets (OPE-2650): `scaffold_env` marks them, so the setup
+  // flow names `secret_set` as the step that stores them.
+  registerOperatorSecretNames(["SLACK_BOT_TOKEN", "SLACK_SIGNING_SECRET"]);
   // THE PASTE-READY APP MANIFEST (OPE-1603). Minting the Slack app stays human, so the ops plane's
   // job is to hand the operator the exact document. The bundle owns the document (agent/
   // app-manifest.ts); core substitutes this deployment's host into it.

package/agent/register.ts

@@ -59,7 +59,7 @@ import {
   registerBotAskProbe,
   registerSurfaceSessionState,
 } from "@open-everywhere/core/agent/adapter-api.js";
-import { slackSurfaceSessionPin, slackSurfaceSessionSetter } from "./channels/slack-agent-session.js";
+import { slackSurfaceSessionPin, slackSurfaceSessionSetter, slackSurfaceSessionStepper } from "./channels/slack-agent-session.js";
 import { slackFriendlyNameResolver } from "./channels/slack-friendly-names.js";
 import { PROVIDER_DOCS } from "./docs-generated.js";
 import { slackSurfaceStatus } from "./status.js";
@@ -125,7 +125,9 @@ export function registerSlackProvider(): void {
   // SLACK'S AGENT SESSION STATE (OPE-2519): `processing` while a turn runs (Slack then shows its Stop
   // button), and `active` or `suspended` at the park. Core's turn-anchor hook drives it; the setter
   // names the person's DM session from the wake's auth (channels/slack-agent-session.ts).
-  registerSurfaceSessionState("slack", slackSurfaceSessionSetter(), slackSurfaceSessionPin);
+  // OPE-2632: the same setter and the stepper draw a DM-door turn's working signs (1:1 and group DM):
+  // 👀, the status line with its step labels, and 🛑 when the turn fails for good.
+  registerSurfaceSessionState("slack", slackSurfaceSessionSetter(), slackSurfaceSessionPin, slackSurfaceSessionStepper());
   // The bot's own Slack display name (OPE-587) — the arm the instruction assembler renders as a
   // HANDLE line on a Slack-pinned session ("your mention/handle here appears as X"), never as
   // identity since OPE-610 settled the naming model. `botDisplayName` memoises one auth.test +

package/agent/setup/claim.ts

@@ -63,7 +63,7 @@ import {
 } from "@open-everywhere/core/agent/adapter-api.js";
 import { createHmac, randomBytes, timingSafeEqual } from "node:crypto";
 import { SLACK_COOKIE_KEY_REF, SLACK_SETUP_CODE_REF, readInstallRecord, type SlackInstallStateDeps } from "./install-state.js";
-import { slackSecretEnvPresent } from "./credentials.js";
+import { slackOperatorSecretPresent } from "./credentials.js";
 
 /** The cookie the page sets once the code matches. `__Host-` pins it to this exact host with no
  *  domain and a `/` path, which a subdomain cannot overwrite. */
@@ -192,13 +192,14 @@ export async function slackSetupOpen(deps: SlackClaimDeps = {}): Promise<boolean
   // stored credentials, lock the page behind themselves, and have `slackInstallFacts()` publish their
   // workspace as this deployment's install.
   //
-  // Closing on env presence costs nothing a real `/setup` operator wants: the resolver is env-first,
-  // so a deployment with either var set would IGNORE everything a run stored anyway — the page would
-  // have been a no-op with a credential write. An operator who wants to migrate onto the store unsets
-  // the vars and redeploys, which is what the runbook says and what makes the run meaningful.
-  // Screen 2's shadow notice still covers the case where one var is set after an install.
-  const env = slackSecretEnvPresent({ ...(deps.env ? { env: deps.env } : {}) });
-  if (env.botToken || env.signingSecret) return false;
+  // Closing on operator-secret presence costs nothing a real `/setup` operator wants: the resolver
+  // puts the operator secret first (OPE-2650 moved the two env vars there, with env as its on-ramp),
+  // so a deployment with either one set would IGNORE everything a run stored anyway — the page would
+  // have been a no-op with a credential write. An operator who wants to migrate onto the `/setup`
+  // values removes the operator secrets and the env vars, and redeploys. Screen 2's shadow notice
+  // still covers the case where one is set after an install.
+  const present = await slackOperatorSecretPresent({ ...(deps.env ? { env: deps.env } : {}) });
+  if (present.botToken || present.signingSecret) return false;
 
   // 🔴 ONLY AN ABSENT ROW OPENS THE PAGE, and the earlier draft got this backwards. It read through
   // `slackInstallState`, which collapses a store fault, a malformed row and an unknown record version