@cursor/july 0.1.19 → 0.1.21

package/src/internal/cli-slack.test.ts

@@ -0,0 +1,1647 @@
+/**
+ * Slack provisioning client + `slack create` / `slack destroy` CLI
+ * handlers against an injected-fetch fake of the Agent Serve Slack API
+ * (backend/server/src/agentServe/agentServeSlackEndpoints): status,
+ * connect, app provision, app delete, the stable error codes, and the
+ * gate-off 404. Temp dirs play the agent project; the Slack doctor is
+ * stubbed (the real one calls slack.com).
+ */
+
+import {
+  mkdir,
+  mkdtemp,
+  readFile,
+  rm,
+  stat,
+  writeFile,
+} from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import type { SlackDoctorResult } from "../channels/slack/index.js";
+import { cmdSlack, cmdSlackCreate, cmdSlackDestroy } from "./cli-slack.js";
+import {
+  AgentServeSlackClient,
+  SlackProvisionApiError,
+} from "./slack-provision-client.js";
+
+const TEAM_ID = 7;
+const API_KEY = "crsr_test_key";
+const BACKEND_URL = "http://backend.test";
+const CONNECT_URL = "https://slack.com/oauth/agentkit-consent";
+const AGENT_NAME = "approval-buddy";
+const BOT_KEY = "APPROVAL_BUDDY_SLACK_BOT_TOKEN";
+const APP_KEY = "APPROVAL_BUDDY_SLACK_APP_TOKEN";
+
+interface FakeWorkspace {
+  slackTeamId: string;
+  /** Absent on workspaces connected before the backend captured names. */
+  slackTeamName?: string;
+  slackUserId: string;
+  connectedAt: string;
+}
+
+interface FakeApp {
+  slackAppId: string;
+  slackTeamId: string;
+  slug: string;
+  env: string;
+  installStatus: string;
+  createdAt: string;
+  updatedAt: string;
+}
+
+interface ScriptedResponse {
+  status: number;
+  body: unknown;
+  retryAfterSeconds?: number;
+}
+
+interface FakeSlackBackend {
+  fetchImpl: typeof fetch;
+  workspaces: FakeWorkspace[];
+  apps: FakeApp[];
+  /**
+   * Upserted into `workspaces` after this many status calls once /connect
+   * was hit (the consent completing in the browser).
+   */
+  pendingWorkspace?: { workspace: FakeWorkspace; afterStatusCalls: number };
+  /** Scripted `POST /apps` outcomes; the last one repeats. */
+  provisionQueue: ScriptedResponse[];
+  /** When set, the next matching request answers with this and clears it. */
+  nextError?: ScriptedResponse;
+  /** When set, the next icon call answers with this and clears it. */
+  nextIconError?: ScriptedResponse;
+  statusCalls: number;
+  connectCalls: number;
+  provisionBodies: Array<Record<string, unknown>>;
+  iconRequests: Array<{
+    slackAppId: string;
+    body: Record<string, unknown>;
+  }>;
+  deletedAppIds: string[];
+  seenAuth: string[];
+}
+
+function workspaceRow(
+  slackTeamId: string,
+  connectedAt = "2026-07-01T00:00:00.000Z"
+): FakeWorkspace {
+  return { slackTeamId, slackUserId: `U-${slackTeamId}`, connectedAt };
+}
+
+function appRow(overrides: Partial<FakeApp> & { slackAppId: string }): FakeApp {
+  return {
+    slackTeamId: "T0AAAA",
+    slug: AGENT_NAME,
+    env: "dev",
+    installStatus: "installed",
+    createdAt: "2026-07-01T00:00:00.000Z",
+    updatedAt: "2026-07-01T00:00:00.000Z",
+    ...overrides,
+  };
+}
+
+const INSTALLED_RESPONSE: ScriptedResponse = {
+  status: 200,
+  body: {
+    status: "installed",
+    appId: "A0001",
+    botToken: "xoxb-fake-1",
+    appToken: "xapp-fake-1",
+  },
+};
+
+function createFakeSlackBackend(): FakeSlackBackend {
+  const state: FakeSlackBackend = {
+    fetchImpl: fetch,
+    workspaces: [],
+    apps: [],
+    provisionQueue: [INSTALLED_RESPONSE],
+    statusCalls: 0,
+    connectCalls: 0,
+    provisionBodies: [],
+    iconRequests: [],
+    deletedAppIds: [],
+    seenAuth: [],
+  };
+
+  const json = (scripted: ScriptedResponse): Response => {
+    const headers: Record<string, string> = {
+      "content-type": "application/json",
+    };
+    if (scripted.retryAfterSeconds !== undefined) {
+      headers["retry-after"] = String(scripted.retryAfterSeconds);
+    }
+    return new Response(JSON.stringify(scripted.body), {
+      status: scripted.status,
+      headers,
+    });
+  };
+
+  state.fetchImpl = (async (
+    input: string | URL | Request,
+    init?: RequestInit
+  ): Promise<Response> => {
+    const url = new URL(String(input));
+    const method = init?.method ?? "GET";
+    const headers = init?.headers as Record<string, string> | undefined;
+    state.seenAuth.push(headers?.authorization ?? "");
+
+    if (!url.pathname.startsWith("/internal/agent-serve/slack")) {
+      return json({ status: 404, body: { error: "Not found" } });
+    }
+    if (state.nextError !== undefined) {
+      const scripted = state.nextError;
+      state.nextError = undefined;
+      return json(scripted);
+    }
+
+    const rest = url.pathname.slice("/internal/agent-serve/slack".length);
+
+    if (method === "GET" && rest === "/status") {
+      state.statusCalls += 1;
+      const pending = state.pendingWorkspace;
+      if (pending !== undefined && state.connectCalls > 0) {
+        pending.afterStatusCalls -= 1;
+        if (pending.afterStatusCalls <= 0) {
+          state.workspaces = [
+            ...state.workspaces.filter(
+              (workspace) =>
+                workspace.slackTeamId !== pending.workspace.slackTeamId
+            ),
+            pending.workspace,
+          ];
+          state.pendingWorkspace = undefined;
+        }
+      }
+      return json({
+        status: 200,
+        body: { workspaces: state.workspaces, apps: state.apps },
+      });
+    }
+
+    if (method === "POST" && rest === "/connect") {
+      state.connectCalls += 1;
+      return json({ status: 200, body: { url: CONNECT_URL } });
+    }
+
+    if (method === "POST" && rest === "/apps") {
+      state.provisionBodies.push(
+        JSON.parse(String(init?.body)) as Record<string, unknown>
+      );
+      const scripted =
+        state.provisionQueue.length > 1
+          ? state.provisionQueue.shift()
+          : state.provisionQueue[0];
+      if (scripted === undefined) {
+        return json({
+          status: 500,
+          body: { error: "no scripted provision outcome" },
+        });
+      }
+      return json(scripted);
+    }
+
+    if (method === "POST" && /^\/apps\/[^/]+\/icon$/.test(rest)) {
+      const slackAppId = decodeURIComponent(
+        rest.slice("/apps/".length, -"/icon".length)
+      );
+      state.iconRequests.push({
+        slackAppId,
+        body: JSON.parse(String(init?.body)) as Record<string, unknown>,
+      });
+      if (state.nextIconError !== undefined) {
+        const scripted = state.nextIconError;
+        state.nextIconError = undefined;
+        return json(scripted);
+      }
+      return json({ status: 200, body: { ok: true } });
+    }
+
+    if (method === "DELETE" && rest.startsWith("/apps/")) {
+      const slackAppId = decodeURIComponent(
+        rest.slice("/apps/".length).split("?")[0] ?? ""
+      );
+      state.deletedAppIds.push(slackAppId);
+      state.apps = state.apps.filter((app) => app.slackAppId !== slackAppId);
+      return json({ status: 200, body: { deleted: true } });
+    }
+
+    return json({ status: 404, body: { error: "Not found" } });
+  }) as typeof fetch;
+
+  return state;
+}
+
+/** Capture out/err streams for a handler invocation. */
+function capture(): {
+  out: (text: string) => void;
+  err: (text: string) => void;
+  stdout: () => string;
+  stderr: () => string;
+} {
+  let stdout = "";
+  let stderr = "";
+  return {
+    out: (text) => {
+      stdout += text;
+    },
+    err: (text) => {
+      stderr += text;
+    },
+    stdout: () => stdout,
+    stderr: () => stderr,
+  };
+}
+
+const passingDoctor = async (): Promise<SlackDoctorResult> => ({
+  ok: true,
+  checks: [
+    { id: "app_token", ok: true, message: `${APP_KEY} present` },
+    { id: "bot_token", ok: true, message: `${BOT_KEY} present` },
+  ],
+  envKeys: { bot: BOT_KEY, app: APP_KEY },
+});
+
+const tempDirs: string[] = [];
+
+afterEach(async () => {
+  while (tempDirs.length > 0) {
+    const dir = tempDirs.pop();
+    if (dir !== undefined) {
+      await rm(dir, { recursive: true, force: true });
+    }
+  }
+  // create exports minted tokens for the doctor run; scrub them.
+  delete process.env[BOT_KEY];
+  delete process.env[APP_KEY];
+});
+
+async function makeAgentDir(): Promise<string> {
+  const parent = await mkdtemp(join(tmpdir(), "agentkit-slack-cli-"));
+  tempDirs.push(parent);
+  const dir = join(parent, AGENT_NAME);
+  await mkdir(dir, { recursive: true });
+  return dir;
+}
+
+function makeClient(backend: FakeSlackBackend): AgentServeSlackClient {
+  return new AgentServeSlackClient({
+    backendUrl: BACKEND_URL,
+    apiKey: API_KEY,
+    fetchImpl: backend.fetchImpl,
+  });
+}
+
+type CliIo = ReturnType<typeof capture>;
+
+function provisionOptions(
+  backend: FakeSlackBackend,
+  dir: string,
+  io: CliIo,
+  extra?: Partial<Parameters<typeof cmdSlackCreate>[0]>
+): Parameters<typeof cmdSlackCreate>[0] {
+  return {
+    dir,
+    team: String(TEAM_ID),
+    apiKey: API_KEY,
+    fetchImpl: backend.fetchImpl,
+    openBrowserImpl: () => {},
+    connectPollIntervalMs: 2,
+    connectPollTimeoutMs: 2_000,
+    doctorImpl: passingDoctor,
+    out: io.out,
+    err: io.err,
+    ...extra,
+  };
+}
+
+describe("AgentServeSlackClient", () => {
+  it("sends the API key as the bearer", async () => {
+    const backend = createFakeSlackBackend();
+    await makeClient(backend).status(TEAM_ID);
+    expect(backend.seenAuth.at(-1)).toBe(`Bearer ${API_KEY}`);
+  });
+
+  it("maps the gate-off 404 to a feature-flag explanation", async () => {
+    const backend = createFakeSlackBackend();
+    backend.nextError = { status: 404, body: { error: "Not found" } };
+    const error = await makeClient(backend)
+      .status(TEAM_ID)
+      .then(
+        () => undefined,
+        (e: unknown) => e
+      );
+    expect(error).toBeInstanceOf(SlackProvisionApiError);
+    expect((error as SlackProvisionApiError).status).toBe(404);
+    expect((error as SlackProvisionApiError).message).toMatch(
+      /Add to Slack.*agent_serve_slack_provisioning.*not enabled/
+    );
+  });
+
+  it("maps Fastify route-not-found 404s to a wrong-host hint", async () => {
+    const backend = createFakeSlackBackend();
+    backend.nextError = {
+      status: 404,
+      body: {
+        message: "Route POST:/internal/agent-serve/slack/apps not found",
+        error: "Not Found",
+        statusCode: 404,
+      },
+    };
+    await expect(makeClient(backend).connect(TEAM_ID)).rejects.toThrow(
+      /api\.cursor\.com|CURSOR_API_BASE_URL/
+    );
+  });
+
+  it("maps 429 with the code and Retry-After seconds", async () => {
+    const backend = createFakeSlackBackend();
+    backend.provisionQueue = [
+      {
+        status: 429,
+        body: {
+          error: "Slack rate limited the provisioning call; retry later",
+          code: "ratelimited",
+          retryAfterSeconds: 42,
+        },
+        retryAfterSeconds: 42,
+      },
+    ];
+    const error = await makeClient(backend)
+      .provisionApp({
+        teamId: TEAM_ID,
+        slackTeamId: "T0AAAA",
+        slug: AGENT_NAME,
+        env: "dev",
+        manifest: "{}",
+      })
+      .then(
+        () => undefined,
+        (e: unknown) => e
+      );
+    expect(error).toBeInstanceOf(SlackProvisionApiError);
+    expect((error as SlackProvisionApiError).status).toBe(429);
+    expect((error as SlackProvisionApiError).code).toBe("ratelimited");
+    expect((error as SlackProvisionApiError).retryAfterSeconds).toBe(42);
+    expect((error as SlackProvisionApiError).message).toMatch(/retry in 42s/);
+  });
+
+  it("passes manifest_drift changedPaths through on the error", async () => {
+    const backend = createFakeSlackBackend();
+    backend.provisionQueue = [
+      {
+        status: 409,
+        body: {
+          error:
+            "The Slack app's manifest was modified outside Cursor; re-run with force to overwrite those changes",
+          code: "manifest_drift",
+          changedPaths: ["display_information.name", "oauth_config.scopes.bot"],
+        },
+      },
+    ];
+    const error = await makeClient(backend)
+      .provisionApp({
+        teamId: TEAM_ID,
+        slackTeamId: "T0AAAA",
+        slug: AGENT_NAME,
+        env: "dev",
+        manifest: "{}",
+      })
+      .then(
+        () => undefined,
+        (e: unknown) => e
+      );
+    expect(error).toBeInstanceOf(SlackProvisionApiError);
+    expect((error as SlackProvisionApiError).status).toBe(409);
+    expect((error as SlackProvisionApiError).code).toBe("manifest_drift");
+    expect((error as SlackProvisionApiError).changedPaths).toEqual([
+      "display_information.name",
+      "oauth_config.scopes.bot",
+    ]);
+  });
+
+  it("sends force only when requested", async () => {
+    const backend = createFakeSlackBackend();
+    const client = makeClient(backend);
+    const args = {
+      teamId: TEAM_ID,
+      slackTeamId: "T0AAAA",
+      slug: AGENT_NAME,
+      env: "dev" as const,
+      manifest: "{}",
+    };
+    await client.provisionApp(args);
+    expect(backend.provisionBodies[0]).not.toHaveProperty("force");
+
+    await client.provisionApp({ ...args, force: true });
+    expect(backend.provisionBodies[1]!.force).toBe(true);
+  });
+
+  it("passes stable backend codes through on 4xx errors", async () => {
+    const backend = createFakeSlackBackend();
+    for (const [status, code] of [
+      [409, "app_conflict"],
+      [400, "app_cap_reached"],
+      [400, "invalid_app_id"],
+      [409, "insufficient_scopes"],
+      [409, "manager_reauth_required"],
+    ] as const) {
+      backend.provisionQueue = [
+        { status, body: { error: `backend says ${code}`, code } },
+      ];
+      const error = await makeClient(backend)
+        .provisionApp({
+          teamId: TEAM_ID,
+          slackTeamId: "T0AAAA",
+          slug: AGENT_NAME,
+          env: "dev",
+          manifest: "{}",
+        })
+        .then(
+          () => undefined,
+          (e: unknown) => e
+        );
+      expect(error).toBeInstanceOf(SlackProvisionApiError);
+      expect((error as SlackProvisionApiError).status).toBe(status);
+      expect((error as SlackProvisionApiError).code).toBe(code);
+      expect((error as SlackProvisionApiError).message).toContain(code);
+    }
+  });
+});
+
+describe("cmdSlackCreate", () => {
+  it("provisions, scaffolds, writes both tokens, and runs the doctor", async () => {
+    const backend = createFakeSlackBackend();
+    backend.workspaces = [workspaceRow("T0AAAA")];
+    const dir = await makeAgentDir();
+    const io = capture();
+
+    const code = await cmdSlackCreate(provisionOptions(backend, dir, io));
+    expect(code).toBe(0);
+
+    // The provision request carried the slug/env/manifest the backend expects.
+    expect(backend.provisionBodies).toHaveLength(1);
+    const body = backend.provisionBodies[0]!;
+    expect(body).toMatchObject({
+      teamId: TEAM_ID,
+      slackTeamId: "T0AAAA",
+      slug: AGENT_NAME,
+      env: "dev",
+    });
+    const manifest = JSON.parse(String(body.manifest)) as {
+      features: { bot_user: { display_name: string } };
+      settings: { socket_mode_enabled: boolean };
+    };
+    expect(manifest.features.bot_user.display_name).toBe("approval-buddy-dev");
+    expect(manifest.settings.socket_mode_enabled).toBe(true);
+
+    // Channel scaffold + token delivery.
+    const channel = await readFile(
+      join(dir, "agent/channels/slack.ts"),
+      "utf8"
+    );
+    expect(channel).toContain('envPrefix: "APPROVAL_BUDDY"');
+    const envLocal = await readFile(join(dir, ".env.local"), "utf8");
+    expect(envLocal).toContain(`${BOT_KEY}=xoxb-fake-1\n`);
+    expect(envLocal).toContain(`${APP_KEY}=xapp-fake-1\n`);
+    expect(process.env[BOT_KEY]).toBe("xoxb-fake-1");
+    expect(process.env[APP_KEY]).toBe("xapp-fake-1");
+
+    // Rendered summary, doctor table, and next steps (tokens never printed).
+    expect(io.stdout()).toContain("Provisioned the dev Slack app");
+    expect(io.stdout()).toContain("doctor: pass");
+    expect(io.stdout()).toContain("Next steps");
+    expect(io.stdout()).toContain("@approval-buddy-dev");
+    expect(io.stdout()).not.toContain("xoxb-fake-1");
+    expect(io.stdout()).not.toContain("xapp-fake-1");
+  });
+
+  it("replaces existing token lines on rerun instead of appending duplicates", async () => {
+    const backend = createFakeSlackBackend();
+    backend.workspaces = [workspaceRow("T0AAAA")];
+    const dir = await makeAgentDir();
+    await writeFile(
+      join(dir, ".env.local"),
+      `EXISTING=keepme\n${BOT_KEY}=xoxb-old\n`
+    );
+
+    const first = capture();
+    expect(await cmdSlackCreate(provisionOptions(backend, dir, first))).toBe(0);
+    backend.provisionQueue = [
+      {
+        status: 200,
+        body: {
+          status: "installed",
+          appId: "A0001",
+          botToken: "xoxb-fake-2",
+          appToken: "xapp-fake-2",
+        },
+      },
+    ];
+    const second = capture();
+    expect(await cmdSlackCreate(provisionOptions(backend, dir, second))).toBe(
+      0
+    );
+
+    const lines = (await readFile(join(dir, ".env.local"), "utf8"))
+      .trim()
+      .split("\n");
+    expect(lines.filter((line) => line.startsWith(`${BOT_KEY}=`))).toEqual([
+      `${BOT_KEY}=xoxb-fake-2`,
+    ]);
+    expect(lines.filter((line) => line.startsWith(`${APP_KEY}=`))).toEqual([
+      `${APP_KEY}=xapp-fake-2`,
+    ]);
+    expect(lines).toContain("EXISTING=keepme");
+  });
+
+  it("runs the connect flow when no workspace is connected, then provisions", async () => {
+    const backend = createFakeSlackBackend();
+    backend.pendingWorkspace = {
+      workspace: workspaceRow("T0AAAA"),
+      afterStatusCalls: 2,
+    };
+    const dir = await makeAgentDir();
+    const io = capture();
+    const opened: string[] = [];
+
+    const code = await cmdSlackCreate(
+      provisionOptions(backend, dir, io, {
+        openBrowserImpl: (url: string) => void opened.push(url),
+      })
+    );
+    expect(code).toBe(0);
+    expect(opened).toEqual([CONNECT_URL]);
+    expect(backend.connectCalls).toBe(1);
+    // Initial status + at least two polls before the workspace appeared.
+    expect(backend.statusCalls).toBeGreaterThanOrEqual(3);
+    expect(io.stderr()).toContain(CONNECT_URL);
+    expect(io.stderr()).toContain("Connected Slack workspace T0AAAA");
+    expect(backend.provisionBodies[0]).toMatchObject({
+      slackTeamId: "T0AAAA",
+    });
+  });
+
+  it("waits only for the --slack-team workspace during connect", async () => {
+    const backend = createFakeSlackBackend();
+    backend.workspaces = [workspaceRow("T0OTHER")];
+    backend.pendingWorkspace = {
+      workspace: workspaceRow("T0WANTED"),
+      afterStatusCalls: 1,
+    };
+    const dir = await makeAgentDir();
+    const io = capture();
+    const code = await cmdSlackCreate(
+      provisionOptions(backend, dir, io, { slackTeam: "T0WANTED" })
+    );
+    expect(code).toBe(0);
+    expect(backend.connectCalls).toBe(1);
+    expect(backend.provisionBodies[0]).toMatchObject({
+      slackTeamId: "T0WANTED",
+    });
+  });
+
+  it("times out the connect poll with a rerun hint", async () => {
+    const backend = createFakeSlackBackend();
+    const dir = await makeAgentDir();
+    const io = capture();
+    const code = await cmdSlackCreate(
+      provisionOptions(backend, dir, io, {
+        connectPollIntervalMs: 1,
+        connectPollTimeoutMs: 10,
+      })
+    );
+    expect(code).toBe(1);
+    expect(io.stderr()).toContain("consent link stays valid");
+    expect(io.stderr()).toContain("slack create");
+    expect(backend.provisionBodies).toHaveLength(0);
+  });
+
+  it("loops back to connect once on not_connected, then retries the provision", async () => {
+    const backend = createFakeSlackBackend();
+    backend.workspaces = [workspaceRow("T0AAAA", "2026-07-01T00:00:00.000Z")];
+    backend.pendingWorkspace = {
+      workspace: workspaceRow("T0AAAA", "2026-07-02T00:00:00.000Z"),
+      afterStatusCalls: 1,
+    };
+    backend.provisionQueue = [
+      {
+        status: 409,
+        body: { error: "Slack workspace not connected", code: "not_connected" },
+      },
+      INSTALLED_RESPONSE,
+    ];
+    const dir = await makeAgentDir();
+    const io = capture();
+    const code = await cmdSlackCreate(provisionOptions(backend, dir, io));
+    expect(code).toBe(0);
+    expect(backend.connectCalls).toBe(1);
+    expect(backend.provisionBodies).toHaveLength(2);
+    expect(io.stderr()).toContain("not connected to Cursor");
+  });
+
+  it("does not accept a stale status row as the not_connected re-grant", async () => {
+    const backend = createFakeSlackBackend();
+    // Status keeps listing the pre-existing row, so no fresh grant lands.
+    backend.workspaces = [workspaceRow("T0AAAA", "2026-07-01T00:00:00.000Z")];
+    backend.provisionQueue = [
+      {
+        status: 409,
+        body: { error: "Slack workspace not connected", code: "not_connected" },
+      },
+      INSTALLED_RESPONSE,
+    ];
+    const dir = await makeAgentDir();
+    const io = capture();
+    const code = await cmdSlackCreate(
+      provisionOptions(backend, dir, io, {
+        connectPollIntervalMs: 1,
+        connectPollTimeoutMs: 10,
+      })
+    );
+    expect(code).toBe(1);
+    expect(io.stderr()).toContain("consent link stays valid");
+    expect(backend.provisionBodies).toHaveLength(1);
+  });
+
+  it("re-consents on insufficient_scopes (waits for a fresh grant), then retries", async () => {
+    const backend = createFakeSlackBackend();
+    backend.workspaces = [workspaceRow("T0AAAA", "2026-07-01T00:00:00.000Z")];
+    backend.pendingWorkspace = {
+      workspace: workspaceRow("T0AAAA", "2026-07-02T00:00:00.000Z"),
+      afterStatusCalls: 1,
+    };
+    backend.provisionQueue = [
+      {
+        status: 409,
+        body: {
+          error:
+            "Slack manager authorization is missing scopes managed_apps:install; re-connect the workspace",
+          code: "insufficient_scopes",
+        },
+      },
+      INSTALLED_RESPONSE,
+    ];
+    const dir = await makeAgentDir();
+    const io = capture();
+    const code = await cmdSlackCreate(provisionOptions(backend, dir, io));
+    expect(code).toBe(0);
+    expect(backend.connectCalls).toBe(1);
+    expect(backend.provisionBodies).toHaveLength(2);
+    expect(io.stderr()).toContain("missing scopes");
+  });
+
+  function reauthRequired(slackTeamId: string): ScriptedResponse {
+    return {
+      status: 409,
+      body: {
+        error: `Slack no longer accepts Cursor's authorization for workspace ${slackTeamId} (token_revoked); reconnect the workspace to manage its apps`,
+        code: "manager_reauth_required",
+        slackTeamId,
+      },
+    };
+  }
+
+  it("re-consents on manager_reauth_required (waits for a fresh grant), then retries", async () => {
+    const backend = createFakeSlackBackend();
+    backend.workspaces = [workspaceRow("T0AAAA", "2026-07-01T00:00:00.000Z")];
+    backend.pendingWorkspace = {
+      workspace: workspaceRow("T0AAAA", "2026-07-02T00:00:00.000Z"),
+      afterStatusCalls: 1,
+    };
+    backend.provisionQueue = [reauthRequired("T0AAAA"), INSTALLED_RESPONSE];
+    const dir = await makeAgentDir();
+    const io = capture();
+
+    const code = await cmdSlackCreate(provisionOptions(backend, dir, io));
+
+    expect(code).toBe(0);
+    expect(backend.connectCalls).toBe(1);
+    expect(backend.provisionBodies).toHaveLength(2);
+    expect(io.stderr()).toContain(
+      "Slack revoked Cursor's authorization for workspace T0AAAA"
+    );
+  });
+
+  it("names the re-auth command when the reconnect does not fix it", async () => {
+    const backend = createFakeSlackBackend();
+    backend.workspaces = [workspaceRow("T0AAAA", "2026-07-01T00:00:00.000Z")];
+    backend.pendingWorkspace = {
+      workspace: workspaceRow("T0AAAA", "2026-07-02T00:00:00.000Z"),
+      afterStatusCalls: 1,
+    };
+    backend.provisionQueue = [reauthRequired("T0AAAA")];
+    const dir = await makeAgentDir();
+    const io = capture();
+
+    const code = await cmdSlackCreate(provisionOptions(backend, dir, io));
+
+    expect(code).toBe(1);
+    expect(backend.provisionBodies).toHaveLength(2);
+    expect(io.stderr()).toContain("workspace T0AAAA (token_revoked)");
+    expect(io.stderr()).toContain("slack create");
+  });
+
+  it("exits 1 on pending_admin_approval with the approval link", async () => {
+    const backend = createFakeSlackBackend();
+    backend.workspaces = [workspaceRow("T0AAAA")];
+    backend.provisionQueue = [
+      {
+        status: 200,
+        body: {
+          status: "pending_admin_approval",
+          appId: "A0009",
+          oauthAuthorizeUrl: "https://slack.com/admin-approve/A0009",
+        },
+      },
+    ];
+    const dir = await makeAgentDir();
+    const io = capture();
+    const code = await cmdSlackCreate(provisionOptions(backend, dir, io));
+    expect(code).toBe(1);
+    expect(io.stderr()).toContain("workspace-admin approval");
+    expect(io.stderr()).toContain("https://slack.com/admin-approve/A0009");
+    expect(io.stderr()).toContain("re-run");
+    await expect(readFile(join(dir, ".env.local"), "utf8")).rejects.toThrow();
+  });
+
+  it("names the workspaces in the picker, falling back to the raw id", async () => {
+    const backend = createFakeSlackBackend();
+    backend.workspaces = [
+      { ...workspaceRow("T0AAAA"), slackTeamName: "Acme Corp" },
+      workspaceRow("T0BBBB"),
+    ];
+    const dir = await makeAgentDir();
+    const io = capture();
+
+    const code = await cmdSlackCreate(provisionOptions(backend, dir, io));
+
+    expect(code).toBe(1);
+    expect(io.stderr()).toContain("Acme Corp (T0AAAA)");
+    expect(io.stderr()).toContain("- T0BBBB (Slack user");
+  });
+
+  it("errors on multiple connected workspaces without --slack-team", async () => {
+    const backend = createFakeSlackBackend();
+    backend.workspaces = [workspaceRow("T0AAAA"), workspaceRow("T0BBBB")];
+    const dir = await makeAgentDir();
+    const io = capture();
+    const code = await cmdSlackCreate(provisionOptions(backend, dir, io));
+    expect(code).toBe(1);
+    expect(io.stderr()).toContain("T0AAAA");
+    expect(io.stderr()).toContain("T0BBBB");
+    expect(io.stderr()).toContain("--slack-team");
+    expect(backend.provisionBodies).toHaveLength(0);
+
+    const picked = capture();
+    const pickedCode = await cmdSlackCreate(
+      provisionOptions(backend, dir, picked, { slackTeam: "T0BBBB" })
+    );
+    expect(pickedCode).toBe(0);
+    expect(backend.provisionBodies[0]).toMatchObject({
+      slackTeamId: "T0BBBB",
+    });
+  });
+
+  it("provisions the prod app with --prod", async () => {
+    const backend = createFakeSlackBackend();
+    backend.workspaces = [workspaceRow("T0AAAA")];
+    const dir = await makeAgentDir();
+    const io = capture();
+    const code = await cmdSlackCreate(
+      provisionOptions(backend, dir, io, { prod: true })
+    );
+    expect(code).toBe(0);
+    expect(backend.provisionBodies[0]).toMatchObject({ env: "prod" });
+    const manifest = JSON.parse(
+      String(backend.provisionBodies[0]!.manifest)
+    ) as { features: { bot_user: { display_name: string } } };
+    expect(manifest.features.bot_user.display_name).toBe("approval-buddy");
+  });
+
+  it("renders actionable errors for app_cap_reached and invalid_app_id", async () => {
+    const backend = createFakeSlackBackend();
+    backend.workspaces = [workspaceRow("T0AAAA")];
+    const dir = await makeAgentDir();
+
+    backend.provisionQueue = [
+      {
+        status: 400,
+        body: {
+          error: "You already provisioned 25 live Slack apps (limit 25)",
+          code: "app_cap_reached",
+        },
+      },
+    ];
+    const capReached = capture();
+    expect(
+      await cmdSlackCreate(provisionOptions(backend, dir, capReached))
+    ).toBe(1);
+    expect(capReached.stderr()).toContain("limit 25");
+    expect(capReached.stderr()).toContain("slack destroy");
+
+    backend.provisionQueue = [
+      {
+        status: 400,
+        body: {
+          error: "Slack rejected the provisioning call: invalid_app_id",
+          code: "invalid_app_id",
+        },
+      },
+    ];
+    const invalidApp = capture();
+    expect(
+      await cmdSlackCreate(provisionOptions(backend, dir, invalidApp))
+    ).toBe(1);
+    expect(invalidApp.stderr()).toContain("deleted outside Cursor");
+    expect(invalidApp.stderr()).toContain("slack destroy");
+  });
+
+  it("surfaces the gate-off 404 through the CLI", async () => {
+    const backend = createFakeSlackBackend();
+    backend.nextError = { status: 404, body: { error: "Not found" } };
+    const dir = await makeAgentDir();
+    const io = capture();
+    const code = await cmdSlackCreate(provisionOptions(backend, dir, io));
+    expect(code).toBe(1);
+    expect(io.stderr()).toContain("agent_serve_slack_provisioning");
+  });
+
+  it("emits machine-readable JSON with --json (no tokens)", async () => {
+    const backend = createFakeSlackBackend();
+    backend.workspaces = [workspaceRow("T0AAAA")];
+    const dir = await makeAgentDir();
+    const io = capture();
+    const code = await cmdSlackCreate(
+      provisionOptions(backend, dir, io, { json: true })
+    );
+    expect(code).toBe(0);
+    const parsed = JSON.parse(io.stdout()) as Record<string, unknown>;
+    expect(parsed).toMatchObject({
+      ok: true,
+      appId: "A0001",
+      status: "installed",
+      slackTeamId: "T0AAAA",
+      envKeys: { bot: BOT_KEY, app: APP_KEY },
+    });
+    expect(parsed.wrote).toContain(".env.local");
+    expect(parsed.wrote).toContain("agent/channels/slack.ts");
+    expect(io.stdout()).not.toContain("xoxb-fake-1");
+    expect(io.stdout()).not.toContain("xapp-fake-1");
+  });
+});
+
+describe("cmdSlackCreate manifest drift", () => {
+  const DRIFT_RESPONSE: ScriptedResponse = {
+    status: 409,
+    body: {
+      error:
+        "The Slack app's manifest was modified outside Cursor; re-run with force to overwrite those changes",
+      code: "manifest_drift",
+      changedPaths: [
+        "display_information.name",
+        "settings.event_subscriptions.bot_events",
+      ],
+    },
+  };
+
+  it("renders the changed paths and the --force hint, exiting 1", async () => {
+    const backend = createFakeSlackBackend();
+    backend.workspaces = [workspaceRow("T0AAAA")];
+    backend.provisionQueue = [DRIFT_RESPONSE];
+    const dir = await makeAgentDir();
+    const io = capture();
+
+    const code = await cmdSlackCreate(provisionOptions(backend, dir, io));
+
+    expect(code).toBe(1);
+    expect(io.stderr()).toContain("modified outside Cursor");
+    expect(io.stderr()).toContain("  - display_information.name\n");
+    expect(io.stderr()).toContain(
+      "  - settings.event_subscriptions.bot_events\n"
+    );
+    expect(io.stderr()).toContain("slack create --force");
+    expect(backend.provisionBodies[0]).not.toHaveProperty("force");
+    await expect(readFile(join(dir, ".env.local"), "utf8")).rejects.toThrow();
+  });
+
+  it("re-running with --force sends force: true and completes the create", async () => {
+    const backend = createFakeSlackBackend();
+    backend.workspaces = [workspaceRow("T0AAAA")];
+    backend.provisionQueue = [DRIFT_RESPONSE, INSTALLED_RESPONSE];
+    const dir = await makeAgentDir();
+
+    const refused = capture();
+    expect(await cmdSlackCreate(provisionOptions(backend, dir, refused))).toBe(
+      1
+    );
+    const forced = capture();
+    expect(
+      await cmdSlackCreate(
+        provisionOptions(backend, dir, forced, { force: true })
+      )
+    ).toBe(0);
+
+    expect(backend.provisionBodies).toHaveLength(2);
+    expect(backend.provisionBodies[1]!.force).toBe(true);
+    expect(await readFile(join(dir, ".env.local"), "utf8")).toContain(BOT_KEY);
+  });
+
+  it("keeps the --json shape on a forced create", async () => {
+    const backend = createFakeSlackBackend();
+    backend.workspaces = [workspaceRow("T0AAAA")];
+    const dir = await makeAgentDir();
+    const io = capture();
+
+    const code = await cmdSlackCreate(
+      provisionOptions(backend, dir, io, { force: true, json: true })
+    );
+
+    expect(code).toBe(0);
+    expect(backend.provisionBodies[0]!.force).toBe(true);
+    expect(JSON.parse(io.stdout())).toMatchObject({
+      ok: true,
+      appId: "A0001",
+      status: "installed",
+      slackTeamId: "T0AAAA",
+    });
+  });
+});
+
+describe("cmdSlackDestroy", () => {
+  it("deletes the matching app and leaves .env.local alone", async () => {
+    const backend = createFakeSlackBackend();
+    backend.workspaces = [workspaceRow("T0AAAA")];
+    backend.apps = [
+      appRow({ slackAppId: "A0100" }),
+      appRow({ slackAppId: "A0101", env: "prod" }),
+    ];
+    const dir = await makeAgentDir();
+    await writeFile(join(dir, ".env.local"), `${BOT_KEY}=xoxb-live\n`);
+    const io = capture();
+
+    const code = await cmdSlackDestroy(provisionOptions(backend, dir, io));
+    expect(code).toBe(0);
+    expect(backend.deletedAppIds).toEqual(["A0100"]);
+    expect(io.stdout()).toContain("Deleted the dev Slack app");
+    expect(io.stdout()).toContain("left in place");
+    // Stale tokens are deliberately untouched.
+    expect(await readFile(join(dir, ".env.local"), "utf8")).toBe(
+      `${BOT_KEY}=xoxb-live\n`
+    );
+  });
+
+  it("targets the prod app with --prod", async () => {
+    const backend = createFakeSlackBackend();
+    backend.workspaces = [workspaceRow("T0AAAA")];
+    backend.apps = [
+      appRow({ slackAppId: "A0100" }),
+      appRow({ slackAppId: "A0101", env: "prod" }),
+    ];
+    const dir = await makeAgentDir();
+    const io = capture();
+    const code = await cmdSlackDestroy(
+      provisionOptions(backend, dir, io, { prod: true })
+    );
+    expect(code).toBe(0);
+    expect(backend.deletedAppIds).toEqual(["A0101"]);
+  });
+
+  it("errors listing candidates when several workspaces match, then --slack-team picks one", async () => {
+    const backend = createFakeSlackBackend();
+    backend.workspaces = [workspaceRow("T0AAAA"), workspaceRow("T0BBBB")];
+    backend.apps = [
+      appRow({ slackAppId: "A0100", slackTeamId: "T0AAAA" }),
+      appRow({ slackAppId: "A0200", slackTeamId: "T0BBBB" }),
+    ];
+    const dir = await makeAgentDir();
+    const ambiguous = capture();
+    const code = await cmdSlackDestroy(
+      provisionOptions(backend, dir, ambiguous)
+    );
+    expect(code).toBe(1);
+    expect(ambiguous.stderr()).toContain("A0100");
+    expect(ambiguous.stderr()).toContain("A0200");
+    expect(ambiguous.stderr()).toContain("--slack-team");
+    expect(backend.deletedAppIds).toEqual([]);
+
+    const picked = capture();
+    const pickedCode = await cmdSlackDestroy(
+      provisionOptions(backend, dir, picked, { slackTeam: "T0BBBB" })
+    );
+    expect(pickedCode).toBe(0);
+    expect(backend.deletedAppIds).toEqual(["A0200"]);
+  });
+
+  it("reports when no app matches, listing the agent's other apps", async () => {
+    const backend = createFakeSlackBackend();
+    backend.workspaces = [workspaceRow("T0AAAA")];
+    backend.apps = [appRow({ slackAppId: "A0101", env: "prod" })];
+    const dir = await makeAgentDir();
+    const io = capture();
+    const code = await cmdSlackDestroy(provisionOptions(backend, dir, io));
+    expect(code).toBe(1);
+    expect(io.stderr()).toContain("No provisioned dev Slack app");
+    expect(io.stderr()).toContain("A0101");
+    expect(backend.deletedAppIds).toEqual([]);
+  });
+});
+
+async function writeIconFile(
+  dir: string,
+  name = "icon.png",
+  bytes: Buffer = Buffer.from("png-bytes")
+): Promise<string> {
+  const path = join(dir, name);
+  await writeFile(path, bytes);
+  return path;
+}
+
+describe("create --icon", () => {
+  const ICON_URL = "https://example.com/icon.png";
+  const INSTALLED_WITH_ICON: ScriptedResponse = {
+    status: 200,
+    body: { ...(INSTALLED_RESPONSE.body as object), iconStatus: "set" },
+  };
+
+  it("sends an https --icon inline on the provision and reports it in --json", async () => {
+    const backend = createFakeSlackBackend();
+    backend.workspaces = [workspaceRow("T0AAAA")];
+    backend.provisionQueue = [INSTALLED_WITH_ICON];
+    const dir = await makeAgentDir();
+    const io = capture();
+
+    const code = await cmdSlackCreate(
+      provisionOptions(backend, dir, io, { icon: ICON_URL, json: true })
+    );
+
+    expect(code).toBe(0);
+    expect(backend.provisionBodies[0]!.icon).toEqual({ url: ICON_URL });
+    // URL icons ride the provision request; nothing posts to the endpoint.
+    expect(backend.iconRequests).toEqual([]);
+    const parsed = JSON.parse(io.stdout()) as Record<string, unknown>;
+    expect(parsed.iconStatus).toBe("set");
+    expect(io.stderr()).not.toContain("warning");
+  });
+
+  it("warns without failing when the backend reports the URL icon failed", async () => {
+    const backend = createFakeSlackBackend();
+    backend.workspaces = [workspaceRow("T0AAAA")];
+    backend.provisionQueue = [
+      {
+        status: 200,
+        body: { ...(INSTALLED_RESPONSE.body as object), iconStatus: "failed" },
+      },
+    ];
+    const dir = await makeAgentDir();
+    const io = capture();
+
+    const code = await cmdSlackCreate(
+      provisionOptions(backend, dir, io, { icon: ICON_URL })
+    );
+
+    expect(code).toBe(0);
+    expect(io.stderr()).toContain("warning: setting the Slack app icon");
+    expect(io.stderr()).toContain(`slack icon ${ICON_URL}`);
+  });
+
+  it("posts a file --icon to the icon endpoint after the install", async () => {
+    const backend = createFakeSlackBackend();
+    backend.workspaces = [workspaceRow("T0AAAA")];
+    const dir = await makeAgentDir();
+    const iconPath = await writeIconFile(dir);
+    const io = capture();
+
+    const code = await cmdSlackCreate(
+      provisionOptions(backend, dir, io, { icon: iconPath, json: true })
+    );
+
+    expect(code).toBe(0);
+    expect(backend.provisionBodies[0]!.icon).toBeUndefined();
+    expect(backend.iconRequests).toEqual([
+      {
+        slackAppId: "A0001",
+        body: {
+          teamId: TEAM_ID,
+          icon: {
+            base64: Buffer.from("png-bytes").toString("base64"),
+            contentType: "image/png",
+          },
+        },
+      },
+    ]);
+    const parsed = JSON.parse(io.stdout()) as Record<string, unknown>;
+    expect(parsed.iconStatus).toBe("set");
+  });
+
+  it("warns without failing the create when the icon endpoint rejects", async () => {
+    const backend = createFakeSlackBackend();
+    backend.workspaces = [workspaceRow("T0AAAA")];
+    backend.nextIconError = {
+      status: 400,
+      body: {
+        error: "Slack rejected the provisioning call: invalid_parameters",
+        code: "invalid_parameters",
+      },
+    };
+    const dir = await makeAgentDir();
+    const iconPath = await writeIconFile(dir);
+    const io = capture();
+
+    const code = await cmdSlackCreate(
+      provisionOptions(backend, dir, io, { icon: iconPath })
+    );
+
+    expect(code).toBe(0);
+    expect(io.stderr()).toContain("warning: setting the Slack app icon");
+    expect(io.stderr()).toContain("invalid_parameters");
+    expect(io.stderr()).toContain(`slack icon ${iconPath}`);
+    // Tokens were still written.
+    expect(await readFile(join(dir, ".env.local"), "utf8")).toContain(BOT_KEY);
+  });
+
+  it("warns without failing the create when the icon endpoint returns a malformed 200", async () => {
+    const backend = createFakeSlackBackend();
+    backend.workspaces = [workspaceRow("T0AAAA")];
+    backend.nextIconError = { status: 200, body: { unexpected: "shape" } };
+    const dir = await makeAgentDir();
+    const iconPath = await writeIconFile(dir);
+    const io = capture();
+
+    const code = await cmdSlackCreate(
+      provisionOptions(backend, dir, io, { icon: iconPath })
+    );
+
+    expect(code).toBe(0);
+    expect(io.stderr()).toContain("warning: setting the Slack app icon");
+    expect(io.stderr()).toContain(`slack icon ${iconPath}`);
+    expect(await readFile(join(dir, ".env.local"), "utf8")).toContain(BOT_KEY);
+  });
+
+  it("still sets a file icon on pending_admin_approval (the app exists)", async () => {
+    const backend = createFakeSlackBackend();
+    backend.workspaces = [workspaceRow("T0AAAA")];
+    backend.provisionQueue = [
+      {
+        status: 200,
+        body: {
+          status: "pending_admin_approval",
+          appId: "A0009",
+          oauthAuthorizeUrl: "https://slack.com/admin-approve/A0009",
+        },
+      },
+    ];
+    const dir = await makeAgentDir();
+    const iconPath = await writeIconFile(dir);
+    const io = capture();
+
+    const code = await cmdSlackCreate(
+      provisionOptions(backend, dir, io, { icon: iconPath, json: true })
+    );
+
+    expect(code).toBe(1);
+    expect(backend.iconRequests.map((req) => req.slackAppId)).toEqual([
+      "A0009",
+    ]);
+    const parsed = JSON.parse(io.stdout()) as Record<string, unknown>;
+    expect(parsed).toMatchObject({
+      ok: false,
+      status: "pending_admin_approval",
+      iconStatus: "set",
+    });
+  });
+
+  it("rejects a non-image icon path before provisioning", async () => {
+    const backend = createFakeSlackBackend();
+    backend.workspaces = [workspaceRow("T0AAAA")];
+    const dir = await makeAgentDir();
+    const iconPath = await writeIconFile(dir, "icon.bmp");
+    const io = capture();
+
+    const code = await cmdSlackCreate(
+      provisionOptions(backend, dir, io, { icon: iconPath })
+    );
+
+    expect(code).toBe(1);
+    expect(io.stderr()).toContain(".png, .jpg/.jpeg, or .gif");
+    expect(backend.provisionBodies).toEqual([]);
+  });
+
+  it("rejects an oversized icon file before provisioning", async () => {
+    const backend = createFakeSlackBackend();
+    backend.workspaces = [workspaceRow("T0AAAA")];
+    const dir = await makeAgentDir();
+    const iconPath = await writeIconFile(
+      dir,
+      "icon.png",
+      Buffer.alloc(524_289)
+    );
+    const io = capture();
+
+    const code = await cmdSlackCreate(
+      provisionOptions(backend, dir, io, { icon: iconPath })
+    );
+
+    expect(code).toBe(1);
+    expect(io.stderr()).toContain("at most 524288 bytes");
+    expect(backend.provisionBodies).toEqual([]);
+  });
+
+  it("rejects a non-https icon URL", async () => {
+    const backend = createFakeSlackBackend();
+    backend.workspaces = [workspaceRow("T0AAAA")];
+    const dir = await makeAgentDir();
+    const io = capture();
+
+    const code = await cmdSlackCreate(
+      provisionOptions(backend, dir, io, {
+        icon: "http://example.com/icon.png",
+      })
+    );
+
+    expect(code).toBe(1);
+    expect(io.stderr()).toContain("must be https");
+    expect(backend.provisionBodies).toEqual([]);
+  });
+});
+
+describe("cmdSlack icon", () => {
+  const ICON_URL = "https://example.com/icon.png";
+
+  it("resolves the app like destroy and posts the url form", async () => {
+    const backend = createFakeSlackBackend();
+    backend.workspaces = [workspaceRow("T0AAAA")];
+    backend.apps = [
+      appRow({ slackAppId: "A0100" }),
+      appRow({ slackAppId: "A0101", env: "prod" }),
+    ];
+    const dir = await makeAgentDir();
+    const io = capture();
+
+    const code = await cmdSlack(
+      "icon",
+      provisionOptions(backend, dir, io, { iconSource: ICON_URL })
+    );
+
+    expect(code).toBe(0);
+    expect(backend.iconRequests).toEqual([
+      {
+        slackAppId: "A0100",
+        body: { teamId: TEAM_ID, icon: { url: ICON_URL } },
+      },
+    ]);
+    expect(io.stdout()).toContain("Set the icon for the dev Slack app");
+  });
+
+  it("targets the prod app with --prod and reads a file source with --json", async () => {
+    const backend = createFakeSlackBackend();
+    backend.workspaces = [workspaceRow("T0AAAA")];
+    backend.apps = [
+      appRow({ slackAppId: "A0100" }),
+      appRow({ slackAppId: "A0101", env: "prod" }),
+    ];
+    const dir = await makeAgentDir();
+    const iconPath = await writeIconFile(
+      dir,
+      "icon.gif",
+      Buffer.from("gif-bytes")
+    );
+    const io = capture();
+
+    const code = await cmdSlack(
+      "icon",
+      provisionOptions(backend, dir, io, {
+        iconSource: iconPath,
+        prod: true,
+        json: true,
+      })
+    );
+
+    expect(code).toBe(0);
+    expect(backend.iconRequests).toEqual([
+      {
+        slackAppId: "A0101",
+        body: {
+          teamId: TEAM_ID,
+          icon: {
+            base64: Buffer.from("gif-bytes").toString("base64"),
+            contentType: "image/gif",
+          },
+        },
+      },
+    ]);
+    expect(JSON.parse(io.stdout())).toEqual({
+      ok: true,
+      appId: "A0101",
+      slackTeamId: "T0AAAA",
+      slug: AGENT_NAME,
+      env: "prod",
+      iconStatus: "set",
+    });
+  });
+
+  it("reports when no app matches", async () => {
+    const backend = createFakeSlackBackend();
+    backend.workspaces = [workspaceRow("T0AAAA")];
+    const dir = await makeAgentDir();
+    const io = capture();
+
+    const code = await cmdSlack(
+      "icon",
+      provisionOptions(backend, dir, io, { iconSource: ICON_URL })
+    );
+
+    expect(code).toBe(1);
+    expect(io.stderr()).toContain("No provisioned dev Slack app");
+    expect(backend.iconRequests).toEqual([]);
+  });
+
+  it("renders icon API errors and exits 1 (no warn-don't-fail here)", async () => {
+    const backend = createFakeSlackBackend();
+    backend.workspaces = [workspaceRow("T0AAAA")];
+    backend.apps = [appRow({ slackAppId: "A0100" })];
+    backend.nextIconError = {
+      status: 429,
+      body: {
+        error: "Slack rate limited the provisioning call; retry later",
+        code: "ratelimited",
+        retryAfterSeconds: 30,
+      },
+      retryAfterSeconds: 30,
+    };
+    const dir = await makeAgentDir();
+    const io = capture();
+
+    const code = await cmdSlack(
+      "icon",
+      provisionOptions(backend, dir, io, { iconSource: ICON_URL })
+    );
+
+    expect(code).toBe(1);
+    expect(io.stderr()).toContain("retry in 30s");
+  });
+
+  // No standalone connect command exists; create runs the consent flow.
+  it("points manager_reauth_required at the re-auth command", async () => {
+    const backend = createFakeSlackBackend();
+    backend.workspaces = [workspaceRow("T0AAAA")];
+    backend.apps = [appRow({ slackAppId: "A0100" })];
+    backend.nextIconError = {
+      status: 409,
+      body: {
+        error:
+          "Slack no longer accepts Cursor's authorization for workspace T0AAAA (invalid_auth); reconnect the workspace to manage its apps",
+        code: "manager_reauth_required",
+        slackTeamId: "T0AAAA",
+      },
+    };
+    const dir = await makeAgentDir();
+    const io = capture();
+
+    const code = await cmdSlack(
+      "icon",
+      provisionOptions(backend, dir, io, { iconSource: ICON_URL })
+    );
+
+    expect(code).toBe(1);
+    expect(io.stderr()).toContain("workspace T0AAAA (invalid_auth)");
+    expect(io.stderr()).toContain("Re-approve the Slack consent");
+    expect(io.stderr()).toContain("slack create");
+  });
+
+  it("rejects an over-long icon URL before hitting the backend", async () => {
+    const backend = createFakeSlackBackend();
+    backend.workspaces = [workspaceRow("T0AAAA")];
+    backend.apps = [appRow({ slackAppId: "A0100" })];
+    const dir = await makeAgentDir();
+    const io = capture();
+
+    const code = await cmdSlack(
+      "icon",
+      provisionOptions(backend, dir, io, {
+        iconSource: `https://example.com/${"x".repeat(3000)}`,
+      })
+    );
+
+    expect(code).toBe(1);
+    expect(io.stderr()).toContain("at most 3000 characters");
+    expect(backend.iconRequests).toEqual([]);
+  });
+
+  it("prints usage when the source argument is missing", async () => {
+    const backend = createFakeSlackBackend();
+    const dir = await makeAgentDir();
+    const io = capture();
+
+    const code = await cmdSlack("icon", provisionOptions(backend, dir, io));
+
+    expect(code).toBe(1);
+    expect(io.stderr()).toContain("Usage:");
+    expect(io.stderr()).toContain("slack icon");
+  });
+});
+
+describe("cmdSlackCreate hardening", () => {
+  it("provisions channel-post events when --channel-posts is set", async () => {
+    const backend = createFakeSlackBackend();
+    backend.workspaces = [workspaceRow("T0AAAA")];
+    const io = capture();
+    const dir = await makeAgentDir();
+
+    const code = await cmdSlackCreate(
+      provisionOptions(backend, dir, io, { channelPosts: true })
+    );
+    expect(code).toBe(0);
+    const manifest = JSON.parse(
+      String(backend.provisionBodies[0]!.manifest)
+    ) as { settings: { event_subscriptions: { bot_events: string[] } } };
+    expect(manifest.settings.event_subscriptions.bot_events).toContain(
+      "message.channels"
+    );
+  });
+
+  it("replaces stale export-prefixed token lines instead of duplicating", async () => {
+    const backend = createFakeSlackBackend();
+    backend.workspaces = [workspaceRow("T0AAAA")];
+    const io = capture();
+    const dir = await makeAgentDir();
+    await writeFile(
+      join(dir, ".env.local"),
+      `export ${BOT_KEY}=xoxb-stale\nOTHER=keep\n`
+    );
+
+    expect(await cmdSlackCreate(provisionOptions(backend, dir, io))).toBe(0);
+    const envLocal = await readFile(join(dir, ".env.local"), "utf8");
+    expect(envLocal).toContain("OTHER=keep");
+    expect(envLocal).toContain(`${BOT_KEY}=xoxb-fake-1`);
+    expect(envLocal).not.toContain("xoxb-stale");
+    expect(envLocal.match(new RegExp(BOT_KEY, "g"))).toHaveLength(1);
+  });
+
+  it("writes .env.local owner-only and gitignores it", async () => {
+    const backend = createFakeSlackBackend();
+    backend.workspaces = [workspaceRow("T0AAAA")];
+    const io = capture();
+    const dir = await makeAgentDir();
+
+    expect(await cmdSlackCreate(provisionOptions(backend, dir, io))).toBe(0);
+    const mode = (await stat(join(dir, ".env.local"))).mode & 0o777;
+    expect(mode).toBe(0o600);
+    const gitignore = await readFile(join(dir, ".gitignore"), "utf8");
+    expect(gitignore).toContain(".env.local");
+  });
+
+  it("clamps a pre-existing group-readable .env.local to owner-only", async () => {
+    const backend = createFakeSlackBackend();
+    backend.workspaces = [workspaceRow("T0AAAA")];
+    const io = capture();
+    const dir = await makeAgentDir();
+    await writeFile(join(dir, ".env.local"), "OTHER=keep\n", { mode: 0o644 });
+
+    expect(await cmdSlackCreate(provisionOptions(backend, dir, io))).toBe(0);
+    const mode = (await stat(join(dir, ".env.local"))).mode & 0o777;
+    expect(mode).toBe(0o600);
+  });
+
+  it("leaves an existing .gitignore alone when it already covers env files", async () => {
+    const backend = createFakeSlackBackend();
+    backend.workspaces = [workspaceRow("T0AAAA")];
+    const io = capture();
+    const dir = await makeAgentDir();
+    await writeFile(join(dir, ".gitignore"), "node_modules/\n.env*\n");
+
+    expect(await cmdSlackCreate(provisionOptions(backend, dir, io))).toBe(0);
+    const gitignore = await readFile(join(dir, ".gitignore"), "utf8");
+    expect(gitignore).toBe("node_modules/\n.env*\n");
+  });
+
+  it("appends .env.local when .gitignore has only a bare .env line", async () => {
+    // The gitignore pattern `.env` matches only the file literally named
+    // .env — .env.local would stay committable without the append.
+    const backend = createFakeSlackBackend();
+    backend.workspaces = [workspaceRow("T0AAAA")];
+    const io = capture();
+    const dir = await makeAgentDir();
+    await writeFile(join(dir, ".gitignore"), ".env\n");
+
+    expect(await cmdSlackCreate(provisionOptions(backend, dir, io))).toBe(0);
+    const gitignore = await readFile(join(dir, ".gitignore"), "utf8");
+    expect(gitignore).toBe(".env\n.env.local\n");
+  });
+
+  it("tolerates transient status-poll failures during the consent wait", async () => {
+    const backend = createFakeSlackBackend();
+    backend.pendingWorkspace = {
+      workspace: workspaceRow("T0AAAA"),
+      afterStatusCalls: 2,
+    };
+    const io = capture();
+    const dir = await makeAgentDir();
+
+    const inner = backend.fetchImpl;
+    let failedOnce = false;
+    backend.fetchImpl = (async (
+      input: string | URL | Request,
+      init?: RequestInit
+    ): Promise<Response> => {
+      const url = new URL(String(input));
+      if (
+        !failedOnce &&
+        backend.connectCalls > 0 &&
+        url.pathname.endsWith("/status")
+      ) {
+        failedOnce = true;
+        return new Response(JSON.stringify({ error: "boom" }), {
+          status: 500,
+          headers: { "content-type": "application/json" },
+        });
+      }
+      return inner(input, init);
+    }) as typeof fetch;
+
+    expect(await cmdSlackCreate(provisionOptions(backend, dir, io))).toBe(0);
+    expect(io.stderr()).toContain("status poll failed, retrying");
+  });
+
+  it("terminates after a second insufficient_scopes instead of looping", async () => {
+    const backend = createFakeSlackBackend();
+    backend.workspaces = [workspaceRow("T0AAAA", "2026-07-01T00:00:00.000Z")];
+    backend.pendingWorkspace = {
+      workspace: workspaceRow("T0AAAA", "2026-07-02T00:00:00.000Z"),
+      afterStatusCalls: 1,
+    };
+    backend.provisionQueue = [
+      {
+        status: 409,
+        body: {
+          error: "Slack manager authorization is missing scopes",
+          code: "insufficient_scopes",
+        },
+      },
+    ];
+    const io = capture();
+    const dir = await makeAgentDir();
+
+    expect(await cmdSlackCreate(provisionOptions(backend, dir, io))).toBe(1);
+    expect(backend.connectCalls).toBe(1);
+    expect(backend.provisionBodies.length).toBe(2);
+  });
+});
+
+describe("cmdSlack doctor", () => {
+  async function runDoctorSpy(
+    dir: string,
+    extra?: Partial<Parameters<typeof cmdSlack>[1]>
+  ): Promise<{ code: number; prefixes: Array<string | undefined> }> {
+    const prefixes: Array<string | undefined> = [];
+    const code = await cmdSlack("doctor", {
+      dir,
+      doctorImpl: async (options?: { envPrefix?: string }) => {
+        prefixes.push(options?.envPrefix);
+        return passingDoctor();
+      },
+      ...extra,
+    });
+    return { code, prefixes };
+  }
+
+  it("defaults to the directory-derived prefix when create's keys are set", async () => {
+    const dir = await makeAgentDir();
+    await writeFile(
+      join(dir, ".env.local"),
+      `${BOT_KEY}=xoxb-x\n${APP_KEY}=xapp-x\n`
+    );
+
+    const { code, prefixes } = await runDoctorSpy(dir);
+
+    expect(code).toBe(0);
+    expect(prefixes).toEqual(["APPROVAL_BUDDY"]);
+  });
+
+  it("keeps the bare SLACK_* default when no prefixed keys are set", async () => {
+    const dir = await makeAgentDir();
+
+    const { prefixes } = await runDoctorSpy(dir);
+
+    expect(prefixes).toEqual([undefined]);
+  });
+
+  it("forces the bare keys with --no-prefix", async () => {
+    const dir = await makeAgentDir();
+    await writeFile(join(dir, ".env.local"), `${BOT_KEY}=xoxb-x\n`);
+
+    const { prefixes } = await runDoctorSpy(dir, { noPrefix: true });
+
+    expect(prefixes).toEqual([undefined]);
+  });
+
+  it("lets an explicit --prefix win over the derived default", async () => {
+    const dir = await makeAgentDir();
+    await writeFile(join(dir, ".env.local"), `${BOT_KEY}=xoxb-x\n`);
+
+    const { prefixes } = await runDoctorSpy(dir, { prefix: "CUSTOM" });
+
+    expect(prefixes).toEqual(["CUSTOM"]);
+  });
+});