@cursor/july 0.1.49 → 0.1.51

package/src/internal/cli-slack.ts

@@ -1,13 +1,11 @@
 /**
- * `agent-serve slack …` CLI — manifests, setup, doctor (Socket Mode), and
- * managed provisioning (`create` / `destroy`) through Cursor's
- * "Add to Slack" API (`slack-provision-client.ts`).
+ * `agent-serve slack …` CLI — doctor, destroy/icon, and `create` as a
+ * dashboard-wizard launcher (`slack-provision-client.ts`).
  */
 
 import { access, chmod, mkdir, readFile, writeFile } from "node:fs/promises";
 import { basename, extname, join, resolve as resolvePath } from "node:path";
 import {
-  buildSlackManifest,
   buildSlackManifestPair,
   envPrefixFromName,
   formatSlackSetupGuide,
@@ -19,6 +17,7 @@ import {
 import { resolveDeployAuth } from "./cli-deploy.js";
 import { cursorExternalApiUrl } from "./cursor/credentials.js";
 import { slugFromDirectoryName } from "./deploy-client.js";
+import { inferDeployGitSource } from "./deploy-source.js";
 import { describeError } from "./describe-error.js";
 import { CLI_COMMAND_NAME as CLI } from "./distribution.js";
 import { loadAgentLocalEnv } from "./local-env.js";
@@ -28,11 +27,11 @@ import {
   type SlackAppEnv,
   type SlackAppIconContentType,
   type SlackAppIconInput,
-  type SlackAppProvisionResult,
-  type SlackConnectedWorkspace,
   type SlackManagedAppInfo,
   SlackProvisionApiError,
   type SlackProvisionStatus,
+  type SlackWizardMintResult,
+  type SlackWizardPollResult,
 } from "./slack-provision-client.js";
 
 export interface SlackCliOptions {
@@ -57,7 +56,7 @@ export interface SlackCliOptions {
   apiKey?: string;
   /** create: app icon — an https image URL or a local png/jpg/gif ≤512KB. */
   icon?: string;
-  /** create: overwrite manifest edits made in Slack (skip the drift check). */
+  /** create: accepted for compatibility; live-app updates always overwrite. */
   force?: boolean;
   /** `slack icon <source>` positional (same URL-or-file forms as --icon). */
   iconSource?: string;
@@ -82,33 +81,26 @@ Usage:
                                 [--team <id>] [--json]
   ${CLI} slack icon      <URL-or-FILE> [--dir .] [--slack-team T0123ABCD]
                                 [--prod] [--team <id>] [--json]
-  ${CLI} slack init      [--dir .] [--name NAME] [--prefix PREFIX | --no-prefix]
-                                [--channel-posts]
-  ${CLI} slack manifest --env dev|prod|both [--dir .] [--name NAME]
-                                [--print]
   ${CLI} slack doctor [--dir .] [--prefix PREFIX | --no-prefix] [--json]
 
-create/destroy/icon — Cursor "Add to Slack" managed provisioning:
-  create   One-command Path B setup: connects the Slack workspace (browser
-           consent) when needed, creates + installs this agent's dedicated
-           Socket Mode app from the generated manifest, writes the token
-           pair into <dir>/.env.local, then runs doctor (prose mode; --json
-           reports without the doctor pass). Requires
-           \`${CLI} login\` (or CURSOR_API_KEY) and the feature gate.
-           --prod provisions the prod app (default dev); --slack-team picks
-           the workspace when several are connected. --icon sets the app's
-           icon (best-effort: a bad icon warns, never fails the create).
-           A re-run refuses to overwrite manifest edits made by hand at
-           api.slack.com (manifest_drift); --force overwrites them.
+create/destroy/icon — dedicated Socket Mode app via the Cursor dashboard:
+  create   Opens the signed-in dashboard wizard. Finish name, workspace,
+           and Slack consent there. The CLI writes the token pair into
+           <dir>/.env.local and runs doctor. Requires \`${CLI} login\`
+           (or CURSOR_API_KEY). --prod provisions the prod app (default
+           dev). --name / --icon / --channel-posts prefill the wizard.
   destroy  Delete the provisioned Slack app for this agent (+env). Tokens
            already in .env.local are left in place (they just stop working).
   icon     Set the provisioned app's icon: an https image URL or a local
            png/jpg/gif file (at most 512KB).
 
+\`slack init\` is removed. Use \`slack create\`. Do not paste a manifest
+at api.slack.com.
+
 Env tokens:
   single agent:  SLACK_BOT_TOKEN + SLACK_APP_TOKEN
   multi-agent:   <PREFIX>_SLACK_BOT_TOKEN + <PREFIX>_SLACK_APP_TOKEN
-                 (init/create default PREFIX from the directory name;
+                 (create default PREFIX from the directory name;
                   doctor defaults to it too when those keys are set)
 
 See also: skills/setup-slack/SKILL.md
@@ -148,48 +140,15 @@ export async function cmdSlack(
 }
 
 async function cmdSlackInit(options: SlackCliOptions): Promise<number> {
-  const dir = resolvePath(options.dir);
-  try {
-    const result = await initSlackChannel({
-      dir,
-      ...(options.name === undefined ? {} : { name: options.name }),
-      ...(options.noPrefix === true
-        ? { envPrefix: "" }
-        : options.prefix === undefined
-          ? {}
-          : { envPrefix: options.prefix }),
-      ...(options.channelPosts === true ? { channelPosts: true } : {}),
-    });
-    process.stdout.write(
-      `${JSON.stringify(
-        {
-          ok: true,
-          directory: result.rootDir,
-          created: result.files,
-          envPrefix: result.envPrefix ?? null,
-          envKeys: result.envKeys,
-          next: [
-            "Open https://api.slack.com/apps → Create from manifest",
-            "Import .agent-serve/slack/manifest.dev.json (then prod)",
-            `Install apps; set ${result.envKeys.bot} + ${result.envKeys.app}`,
-            result.envPrefix === undefined
-              ? "agent-serve slack doctor"
-              : `agent-serve slack doctor --prefix ${result.envPrefix}`,
-            "agent-serve serve --dir . --dev",
-            "agent-serve slack setup",
-          ],
-        },
-        null,
-        2
-      )}\n`
-    );
-    return 0;
-  } catch (error) {
-    process.stderr.write(
-      `${error instanceof Error ? error.message : String(error)}\n`
-    );
-    return 1;
-  }
+  errStream(options)(
+    `\`slack init\` is removed. Socket Mode apps are created with:
+
+  ${CLI} slack create --dir .
+
+That opens the Cursor dashboard wizard. Do not paste a manifest at api.slack.com.
+`
+  );
+  return 1;
 }
 
 async function runManifest(options: SlackCliOptions): Promise<number> {
@@ -198,10 +157,8 @@ async function runManifest(options: SlackCliOptions): Promise<number> {
   const name = options.name ?? basename(dir);
   const pair = buildSlackManifestPair({
     name,
-    // These files are pasted into api.slack.com by hand, so they must not
-    // carry the manager-token-only managed_app_settings block.
     managedByCursor: false,
-    ...(options.channelPosts === true ? { channelPosts: true } : {}),
+    channelPosts: options.channelPosts === true ? true : undefined,
   });
 
   if (options.print) {
@@ -276,8 +233,8 @@ function resolveDoctorEnvPrefix(
 // create / destroy — Cursor "Add to Slack" managed provisioning
 // ============================================================================
 
-const DEFAULT_CONNECT_POLL_INTERVAL_MS = 3_000;
-const DEFAULT_CONNECT_POLL_TIMEOUT_MS = 5 * 60 * 1000;
+const DEFAULT_WIZARD_POLL_INTERVAL_MS = 3_000;
+const DEFAULT_WIZARD_POLL_TIMEOUT_MS = 60 * 60 * 1000;
 
 interface SlackProvisionContext {
   client: AgentServeSlackClient;
@@ -402,41 +359,30 @@ function toSlackAppIconInput(source: SlackIconSource): SlackAppIconInput {
 }
 
 /**
- * URL icons ride the provision request; file icons post to the icon
- * endpoint afterwards. Best-effort: failures warn, never fail the create.
+ * File icons post after the wizard finishes. URL icons ride the mint
+ * payload. Best-effort: failures warn, never fail the create.
  */
-async function applySlackCreateIcon(
+async function applySlackCreateFileIcon(
   ctx: SlackProvisionContext,
   source: SlackIconSource | undefined,
-  result: SlackAppProvisionResult
+  appId: string
 ): Promise<"set" | "failed" | undefined> {
-  if (source === undefined) {
+  if (source === undefined || source.kind === "url") {
     return undefined;
   }
-  let failure: string | undefined;
-  if (source.kind === "url") {
-    if (result.iconStatus !== "set") {
-      failure = "Slack did not accept the icon URL";
-    }
-  } else {
-    try {
-      await ctx.client.setAppIcon({
-        teamId: ctx.teamId,
-        slackAppId: result.appId,
-        icon: toSlackAppIconInput(source),
-      });
-    } catch (error) {
-      failure = describeError(error);
-    }
-  }
-  if (failure === undefined) {
+  try {
+    await ctx.client.setAppIcon({
+      teamId: ctx.teamId,
+      slackAppId: appId,
+      icon: toSlackAppIconInput(source),
+    });
     return "set";
+  } catch (error) {
+    ctx.err(
+      `warning: setting the Slack app icon failed: ${describeError(error)}\nRetry with \`${CLI} slack icon ${source.path}\`.\n`
+    );
+    return "failed";
   }
-  const retryWith = source.kind === "url" ? source.url : source.path;
-  ctx.err(
-    `warning: setting the Slack app icon failed: ${failure}\nRetry with \`${CLI} slack icon ${retryWith}\`.\n`
-  );
-  return "failed";
 }
 
 /**
@@ -473,123 +419,12 @@ async function prepareProvision(
     err,
     openBrowserImpl: options.openBrowserImpl ?? openBrowser,
     pollIntervalMs:
-      options.connectPollIntervalMs ?? DEFAULT_CONNECT_POLL_INTERVAL_MS,
+      options.connectPollIntervalMs ?? DEFAULT_WIZARD_POLL_INTERVAL_MS,
     pollTimeoutMs:
-      options.connectPollTimeoutMs ?? DEFAULT_CONNECT_POLL_TIMEOUT_MS,
+      options.connectPollTimeoutMs ?? DEFAULT_WIZARD_POLL_TIMEOUT_MS,
   };
 }
 
-/** What the connect poll waits for in `GET /status`. */
-interface ConnectWaitTarget {
-  /** Wait for this workspace to be connected (else: any workspace). */
-  slackTeamId?: string;
-  /**
-   * Wait for connectedAt to move past this value — a fresh grant. Used
-   * whenever the workspace row already exists and only the new approval
-   * bumps its timestamp.
-   */
-  notConnectedAt?: string;
-}
-
-/**
- * Slack's team-scoped admin page listing pending app-install requests.
- * Provisioned apps have no OAuth flow (no redirect URLs, install-from-Slack
- * disabled), so the oauth_authorize_url Slack returns from
- * apps.manifest.create dead-ends; approval happens here instead.
- */
-function slackAppRequestsUrl(slackTeamId: string): string {
-  return `https://app.slack.com/apps-manage/${encodeURIComponent(slackTeamId)}/integrations/requests`;
-}
-
-/** "Name (T0123ABCD)", or the bare id when the backend has no name. */
-function formatWorkspace(workspace: SlackConnectedWorkspace): string {
-  const name = workspace.slackTeamName ?? "";
-  return name === ""
-    ? workspace.slackTeamId
-    : `${name} (${workspace.slackTeamId})`;
-}
-
-function matchConnectedWorkspace(
-  workspaces: SlackConnectedWorkspace[],
-  wait: ConnectWaitTarget
-): SlackConnectedWorkspace | undefined {
-  const candidates =
-    wait.slackTeamId === undefined
-      ? workspaces
-      : workspaces.filter(
-          (workspace) => workspace.slackTeamId === wait.slackTeamId
-        );
-  if (wait.notConnectedAt === undefined) {
-    return candidates[0];
-  }
-  return candidates.find(
-    (workspace) => workspace.connectedAt !== wait.notConnectedAt
-  );
-}
-
-/**
- * Mint the browser consent URL, open it, and poll `GET /status` until the
- * awaited workspace shows up (or the poll times out). Returns the
- * connected workspace, or an exit code with the error already rendered.
- */
-async function runConnectFlow(
-  ctx: SlackProvisionContext,
-  wait: ConnectWaitTarget
-): Promise<SlackConnectedWorkspace | number> {
-  let url: string;
-  try {
-    url = await ctx.client.connect(ctx.teamId);
-  } catch (error) {
-    return renderSlackApiError(error, ctx.err);
-  }
-  ctx.err(
-    `\nConnect your Slack workspace to Cursor — approve in the browser:\n\n  ${url}\n\n` +
-      `After approving in Slack you land on cursor.com, which links the workspace to your Cursor account — sign in there if the browser is not already signed in as you.\n\n` +
-      `(waiting for the Slack consent to complete, up to ${Math.round(ctx.pollTimeoutMs / 60_000)} minutes)\n`
-  );
-  ctx.openBrowserImpl(url);
-  const deadline = Date.now() + ctx.pollTimeoutMs;
-  let lastPollFailure: string | undefined;
-  for (;;) {
-    let workspace: SlackConnectedWorkspace | undefined;
-    let sleepMs = ctx.pollIntervalMs;
-    try {
-      const status = await ctx.client.status(ctx.teamId);
-      workspace = matchConnectedWorkspace(status.workspaces, wait);
-      lastPollFailure = undefined;
-    } catch (error) {
-      // Transient poll failures must not abort a minted consent flow; only
-      // a still-failing poll at the deadline surfaces the error.
-      if (Date.now() >= deadline) {
-        return renderSlackApiError(error, ctx.err);
-      }
-      const failure = describeError(error);
-      if (failure !== lastPollFailure) {
-        lastPollFailure = failure;
-        ctx.err(`(status poll failed, retrying: ${failure})\n`);
-      }
-      if (
-        error instanceof SlackProvisionApiError &&
-        error.retryAfterSeconds !== undefined
-      ) {
-        // Respect backend backpressure instead of hammering at the poll rate.
-        sleepMs = Math.max(sleepMs, error.retryAfterSeconds * 1000);
-      }
-    }
-    if (workspace !== undefined) {
-      ctx.err(`Connected Slack workspace ${workspace.slackTeamId}.\n`);
-      return workspace;
-    }
-    if (Date.now() >= deadline) {
-      ctx.err(
-        `Timed out waiting for the Slack workspace connection. The consent link stays valid for ~10 minutes — approve it, finish the sign-in on cursor.com, then re-run \`${CLI} slack create\`.\n`
-      );
-      return 1;
-    }
-    await sleep(sleepMs);
-  }
-}
-
 export async function cmdSlackCreate(
   options: SlackCliOptions
 ): Promise<number> {
@@ -597,7 +432,6 @@ export async function cmdSlackCreate(
   if (typeof target === "number") {
     return target;
   }
-  // Resolved before any network I/O so a bad path/type/size fails fast.
   let iconSource: SlackIconSource | undefined;
   if (options.icon !== undefined) {
     const resolved = await resolveSlackIconSource(
@@ -614,43 +448,6 @@ export async function cmdSlackCreate(
     return ctx;
   }
 
-  // Workspace: --slack-team wins; one → use it; none → connect; several → ask.
-  let status: SlackProvisionStatus;
-  try {
-    status = await ctx.client.status(ctx.teamId);
-  } catch (error) {
-    return renderSlackApiError(error, ctx.err);
-  }
-  let workspace: SlackConnectedWorkspace | undefined;
-  if (options.slackTeam !== undefined) {
-    workspace = status.workspaces.find(
-      (candidate) => candidate.slackTeamId === options.slackTeam
-    );
-  } else if (status.workspaces.length === 1) {
-    workspace = status.workspaces[0];
-  } else if (status.workspaces.length > 1) {
-    ctx.err(
-      `Multiple Slack workspaces are connected:\n` +
-        status.workspaces
-          .map(
-            (candidate) =>
-              `  - ${formatWorkspace(candidate)} (Slack user ${candidate.slackUserId}, connected ${candidate.connectedAt})\n`
-          )
-          .join("") +
-        `Pass --slack-team <id> to pick one.\n`
-    );
-    return 1;
-  }
-  if (workspace === undefined) {
-    const connected = await runConnectFlow(ctx, {
-      slackTeamId: options.slackTeam,
-    });
-    if (typeof connected === "number") {
-      return connected;
-    }
-    workspace = connected;
-  }
-
   let wrote: string[];
   try {
     wrote = await scaffoldSlackChannelFiles(options, target);
@@ -661,106 +458,93 @@ export async function cmdSlackCreate(
   if (wrote.length > 0 && !ctx.json) {
     ctx.err(`Scaffolded the Slack channel: ${wrote.join(", ")}\n`);
   }
-  // A re-run rebuilds this manifest from flags, so backend-side
-  // customizations reset to it (documented in the skill).
-  const manifest = buildSlackManifest({
-    name: target.name,
-    env: target.env,
-    channelPosts: options.channelPosts === true,
-  });
-  const manifestJson = JSON.stringify(manifest);
 
-  // One connect-and-retry for not_connected / insufficient_scopes /
-  // manager_reauth_required (all fixed by a fresh consent grant).
-  let result: SlackAppProvisionResult;
-  let connectRetried = false;
+  const source = await inferDeployGitSource(target.dir);
+  let minted: SlackWizardMintResult;
+  try {
+    minted = await ctx.client.mintWizard({
+      teamId: ctx.teamId,
+      slug: target.slug,
+      env: target.env,
+      envPrefix: target.envPrefix,
+      name: options.name ?? target.name,
+      gitRepoUrl: source.gitRepoUrl,
+      gitRef: source.gitRef,
+      agentPath: source.agentPath,
+      channelPosts: options.channelPosts === true ? true : undefined,
+      slackTeamId: options.slackTeam,
+      iconUrl: iconSource?.kind === "url" ? iconSource.url : undefined,
+      force: options.force === true ? true : undefined,
+    });
+  } catch (error) {
+    return renderSlackApiError(error, ctx.err);
+  }
+
+  ctx.err(
+    `Finish Slack setup in the browser:\n\n  ${minted.url}\n\n` +
+      `Sign in as the same Cursor account that ran this command. ` +
+      `The CLI waits here (up to ${Math.round(ctx.pollTimeoutMs / 60_000)} minutes).\n`
+  );
+  ctx.openBrowserImpl(minted.url);
+
+  const deadline = Date.now() + ctx.pollTimeoutMs;
+  let sawPendingAdmin = false;
+  let poll: SlackWizardPollResult | undefined;
   for (;;) {
     try {
-      result = await ctx.client.provisionApp({
-        teamId: ctx.teamId,
-        slackTeamId: workspace.slackTeamId,
-        slug: target.slug,
-        env: target.env,
-        manifest: manifestJson,
-        icon: iconSource?.kind === "url" ? { url: iconSource.url } : undefined,
-        force: options.force === true ? true : undefined,
-      });
-      break;
+      poll = await ctx.client.pollWizard(minted.wizardId);
     } catch (error) {
+      if (Date.now() >= deadline) {
+        return renderSlackApiError(error, ctx.err);
+      }
+      await sleep(ctx.pollIntervalMs);
+      continue;
+    }
+    if (poll.status === "complete") {
+      break;
+    }
+    if (poll.status === "failed") {
+      ctx.err(`${poll.error ?? "Slack setup failed"}\n`);
+      return 1;
+    }
+    if (poll.status === "pending_admin_approval" && !sawPendingAdmin) {
+      sawPendingAdmin = true;
+      const appSuffix = poll.appId === undefined ? "" : ` (${poll.appId})`;
+      ctx.err(
+        `Waiting for a Slack admin to approve the app${appSuffix}. Keep this command running.\n` +
+          `Managed install does not file the request. Open Slack to submit it; that same page lets you send a reminder to workspace owners.\n`
+      );
       if (
-        error instanceof SlackProvisionApiError &&
-        (error.code === "not_connected" ||
-          error.code === "insufficient_scopes" ||
-          error.code === "manager_reauth_required") &&
-        !connectRetried
+        poll.oauthAuthorizeUrl !== undefined &&
+        poll.oauthAuthorizeUrl.length > 0
       ) {
-        connectRetried = true;
-        // All three codes arrive holding a row that GET /status already
-        // lists, so the poll waits for a fresh grant instead of re-matching
-        // that row.
-        const wait: ConnectWaitTarget = {
-          slackTeamId: workspace.slackTeamId,
-          notConnectedAt: workspace.connectedAt,
-        };
-        if (error.code === "insufficient_scopes") {
-          ctx.err(
-            `The Slack connection is missing scopes provisioning needs; approving the consent link again grants them.\n`
-          );
-        } else if (error.code === "manager_reauth_required") {
-          ctx.err(
-            `Slack revoked Cursor's authorization for workspace ${workspace.slackTeamId}; re-approving the consent link restores it.\n`
-          );
-        } else {
-          ctx.err(
-            `The Slack workspace is not connected to Cursor; starting the connect flow.\n`
-          );
-        }
-        const connected = await runConnectFlow(ctx, wait);
-        if (typeof connected === "number") {
-          return connected;
-        }
-        workspace = connected;
-        continue;
+        ctx.err(`  ${poll.oauthAuthorizeUrl}\n`);
       }
-      return renderCreateProvisionError(error, ctx.err);
+      ctx.err("After an admin approves, click Retry in the dashboard.\n");
     }
-  }
-
-  const iconStatus = await applySlackCreateIcon(ctx, iconSource, result);
-
-  if (result.status === "pending_admin_approval") {
-    const approveUrl = slackAppRequestsUrl(workspace.slackTeamId);
-    if (ctx.json) {
-      ctx.out(
-        `${JSON.stringify(
-          {
-            ok: false,
-            appId: result.appId,
-            status: result.status,
-            slackTeamId: workspace.slackTeamId,
-            envKeys: target.envKeys,
-            wrote,
-            approveUrl,
-            iconStatus,
-          },
-          null,
-          2
-        )}\n`
-      );
-    } else {
+    if (Date.now() >= deadline) {
       ctx.err(
-        `The Slack app was created (app ${result.appId}), but installing it needs a Slack workspace-admin approval.\n` +
-          `\n  A workspace admin can approve it here:\n\n    ${approveUrl}\n\n` +
-          `Once an admin approves the app, re-run \`${CLI} slack create\` to finish the install and mint the tokens.\n`
+        `Timed out waiting for Slack setup. Finish it in the browser, then re-run \`${CLI} slack create\`.\n  ${minted.url}\n`
       );
+      return 1;
     }
+    await sleep(ctx.pollIntervalMs);
+  }
+
+  if (poll === undefined || poll.localEnv === undefined) {
+    ctx.err(
+      poll.localEnvClaimed === true
+        ? "Tokens were already claimed by another poll; re-run create to rotate them.\n"
+        : "Slack setup finished but no tokens were returned; re-run create.\n"
+    );
     return 1;
   }
 
-  // Tokens come back exactly once and are never printed.
-  const envEntries = [{ key: target.envKeys.bot, value: result.botToken }];
-  if (result.appToken !== undefined) {
-    envEntries.push({ key: target.envKeys.app, value: result.appToken });
+  const envEntries = [
+    { key: target.envKeys.bot, value: poll.localEnv.botToken },
+  ];
+  if (poll.localEnv.appToken !== undefined) {
+    envEntries.push({ key: target.envKeys.app, value: poll.localEnv.appToken });
   }
   const envFile = join(target.dir, ".env.local");
   try {
@@ -776,20 +560,24 @@ export async function cmdSlackCreate(
   for (const { key, value } of envEntries) {
     process.env[key] = value;
   }
-  if (result.appToken === undefined) {
+  if (poll.localEnv.appToken === undefined) {
     ctx.err(
-      `warning: Slack did not return an app-level token, so ${target.envKeys.app} was not written (an existing value was left as-is and may belong to an older app); re-run \`${CLI} slack create\` to recover it.\n`
+      `warning: Slack did not return an app-level token, so ${target.envKeys.app} was not written; re-run \`${CLI} slack create\` to recover it.\n`
     );
   }
 
+  let iconStatus: "set" | "failed" | undefined;
+  if (poll.appId !== undefined) {
+    iconStatus = await applySlackCreateFileIcon(ctx, iconSource, poll.appId);
+  }
+
   if (ctx.json) {
     ctx.out(
       `${JSON.stringify(
         {
           ok: true,
-          appId: result.appId,
-          status: result.status,
-          slackTeamId: workspace.slackTeamId,
+          appId: poll.appId,
+          status: poll.status,
           envKeys: target.envKeys,
           wrote,
           iconStatus,
@@ -802,8 +590,9 @@ export async function cmdSlackCreate(
   }
 
   ctx.out(
-    `Provisioned the ${target.env} Slack app for ${target.slug} (app ${result.appId}) in workspace ${workspace.slackTeamId}.\n` +
-      `  wrote ${envEntries.map((entry) => entry.key).join(" + ")} to ${envFile}\n\n`
+    `Slack is connected for ${target.slug}` +
+      (poll.appId === undefined ? "" : ` (app ${poll.appId})`) +
+      `.\n  wrote ${envEntries.map((entry) => entry.key).join(" + ")} to ${envFile}\n\n`
   );
 
   const doctor = options.doctorImpl ?? runSlackDoctor;
@@ -811,11 +600,10 @@ export async function cmdSlackCreate(
     target.envPrefix === undefined ? {} : { envPrefix: target.envPrefix }
   );
   ctx.out(renderDoctorReport(doctorResult));
-
   ctx.out(
     `\nNext steps:\n` +
-      `  1. ${CLI} dev ${options.dir}\n` +
-      `  2. In Slack, invite @${manifest.features.bot_user.display_name} to a channel and @mention it (or DM it).\n`
+      `  1. ${CLI} serve --dir ${options.dir} --dev\n` +
+      `  2. Invite the bot in Slack and @mention it.\n`
   );
   return 0;
 }
@@ -988,10 +776,8 @@ function formatAppList(
 }
 
 /**
- * Scaffold the channel files when the channel file is absent. Existing
- * files are never overwritten: initSlackChannel writes with `wx`, and
- * EEXIST means "already scaffolded" (provisioning builds its manifest in
- * memory and does not need the on-disk copies).
+ * Scaffold `agent/channels/slack.ts` when absent. Existing files are
+ * never overwritten: initSlackChannel writes with `wx`.
  */
 async function scaffoldSlackChannelFiles(
   options: SlackCliOptions,
@@ -1109,43 +895,6 @@ function renderDoctorReport(result: SlackDoctorResult): string {
   return text;
 }
 
-/**
- * Actionable rendering for `POST /apps` failures the create flow does not
- * retry itself (the connect-and-retry codes are handled by the caller).
- */
-function renderCreateProvisionError(
-  error: unknown,
-  err: (text: string) => void
-): number {
-  if (!(error instanceof SlackProvisionApiError)) {
-    throw error;
-  }
-  switch (error.code) {
-    case "app_conflict":
-      err(
-        `${error.message}\nA concurrent \`${CLI} slack create\` for this agent won the race; re-run create to pick up that app.\n`
-      );
-      return 1;
-    case "ratelimited":
-      err(`${error.message}\nRe-run \`${CLI} slack create\` after the wait.\n`);
-      return 1;
-    case "invalid_app_id":
-      err(
-        `${error.message}\nThe provisioned Slack app seems to have been deleted outside Cursor. Run \`${CLI} slack destroy\` to drop the stale record, then re-run \`${CLI} slack create\`.\n`
-      );
-      return 1;
-    case "manifest_drift":
-      err(
-        `${error.message}\n` +
-          (error.changedPaths ?? []).map((path) => `  - ${path}\n`).join("") +
-          `Re-run \`${CLI} slack create --force\` to overwrite those edits.\n`
-      );
-      return 1;
-    default:
-      return renderSlackApiError(error, err);
-  }
-}
-
 function renderSlackApiError(
   error: unknown,
   err: (text: string) => void
@@ -1155,9 +904,7 @@ function renderSlackApiError(
   }
   err(
     error.code === "manager_reauth_required"
-      ? // There is no standalone connect command: create runs the consent
-        // flow before provisioning.
-        `${error.message}\nRe-approve the Slack consent by re-running \`${CLI} slack create\`, which reconnects the workspace first.\n`
+      ? `${error.message}\nRe-run \`${CLI} slack create\` and finish Slack consent in the dashboard.\n`
       : `${error.message}\n`
   );
   return 1;