@cursor/july 0.1.92 → 0.1.94

package/skills/setup-slack/SKILL.md

@@ -1,10 +1,10 @@
 ---
 name: agentsdk-setup-slack
 description: >-
-  Wire Slack to an Agent SDK agent. Gate Cursor-hosted vs a dedicated
-  Socket Mode app, then finish that path: cursorAccount sign-in + smoke,
-  or slack create via the dashboard wizard, doctor, and optional HITL.
-  Use when adding Slack to an agent.
+  Wire Slack to an Agent SDK agent. Mint a dedicated Socket Mode app with
+  slack create (dashboard wizard), then doctor and smoke. Use the manual
+  manifest path only when the user owns the Slack app. Use when adding
+  Slack to an agent.
 ---
 
 # Setup Slack for the Agent SDK
@@ -14,132 +14,19 @@ host serves the same index at `/docs/llms.txt`.
 
 Use this skill when a human asks to wire Slack to an Agent SDK agent.
 
-There are **two ways to connect**:
-
-- **Path A — Cursor-hosted connection**
-  (`slackChannel({ cursorAccount: true })`): rides the Cursor Slack
-  integration already installed in the workspace. No Slack app, no
-  tokens, no Slack admin. Live in minutes.
-- **Path B — Dedicated Slack app** (Socket Mode): the agent's own bot
-  user. `agent-sdk slack create` opens a signed-in Cursor dashboard
-  wizard; Slack consent and the bot name happen there. Tokens land in
-  `.env.local` and as deployment secrets. Required for channel watching,
-  approval buttons, or a distinct bot handle.
+`slackChannel()` is a dedicated Socket Mode Slack app: the agent's own
+bot user. `agent-sdk slack create` opens a signed-in Cursor dashboard
+wizard; Slack consent and the bot name happen there. Tokens land in
+`.env.local` and as deployment secrets.
 
 Do not generate manifests or ask anyone to paste tokens unless they
-asked for a custom Slack app (`slack init --manual`). Defaulting into
-Path B buries the user in Slack admin work they may not need.
+asked for a custom Slack app (`slack init --manual`).
 
 Existing bots that already have `<PREFIX>_SLACK_BOT_TOKEN` and
 `_SLACK_APP_TOKEN` in `.env.local` keep working. Do not force them onto
 the wizard.
 
-## Step 0 — Choose the connection (required gate)
-
-Walk the user through the tradeoffs before touching files:
-
-| | A: Cursor-hosted | B: Dedicated Slack app |
-| --- | --- | --- |
-| Setup | Zero Slack admin: sign the host in (`agent-sdk login` / `CURSOR_API_KEY`) and serve | One `agent-sdk slack create` per env. Finish in the dashboard wizard (Slack consent + bot name). Tokens are never shown. |
-| Prereq | Cursor Slack integration installed in the workspace and linked to the Cursor account | Agent Serve access (`agent-sdk login`) and permission to approve a Slack app |
-| How users reach it | `@Cursor <AgentName> …`, DMs to @Cursor, replies in claimed threads | Its own bot user: @mention, DM, channel invites |
-| Identity | Posts as the Cursor app under the agent's name + icon | Own app name, avatar, and handle |
-| Channel watching (dispatch without a mention) | Not available | `engagement.channelPosts` allowlist |
-| Tool approvals / Block Kit interactivity | Not available (construction throws) | `toolApprovals: true` Approve/Deny cards |
-| Reply delivery | Status while working, then one final post (no streaming edits) | Streaming replies with postMessage fallback |
-| Multi-agent hosts | Any number of agents, unique `agentName` each, no extra Slack apps | One Slack app + token pair **per agent** |
-
-Decision shortcuts; skip the question when the request already decides:
-
-- Needs channel watching, Approve/Deny buttons, `onBlockAction`, or its
-  own bot user / handle → **Path B**. Say which requirement forced it.
-- Workspace has no Cursor Slack integration and won't install it →
-  **Path B**.
-- Asked for a custom Slack app they own at api.slack.com, or to paste a
-  manifest → **Path C** (`slack init --manual`).
-- "Just get it into Slack", a first bring-up, or the user already said
-  to use the Cursor Slack integration, with none of the above → **Path A**.
-
-### Collect the decision with AskQuestion
-
-Otherwise ask. One single-select question via the `AskQuestion` tool,
-recommended option first so one click accepts it:
-
-- **Cursor-hosted Slack connection (recommended)** — zero Slack setup;
-  sign in and mention `@Cursor <AgentName>`. No channel watching or
-  approval buttons.
-- **Dedicated Slack app (Socket Mode)** — own bot user, channel
-  watching, approval buttons. `agent-sdk slack create` opens the
-  dashboard wizard.
-
-If `AskQuestion` is unavailable in your environment, or the user does
-not answer, **default to Path A (Cursor-hosted)**: state the assumption
-in one line and proceed. It is the reversible choice. A dedicated app
-can be added later as a *second* channel file without losing anything.
-Never mix both in one channel definition: `cursorAccount: true` rejects
-`credentials` / `envPrefix` at construction.
-
-## Path A — Cursor-hosted connection
-
-Goal: mention `@Cursor <AgentName>` in the linked workspace and get a
-threaded reply. No Slack app, no tokens, no manifests.
-
-### A1 — Author the channel (agent)
-
-Write `agent/channels/slack.ts` by hand. Do not run `slack create` for
-this path:
-
-```ts
-import { slackChannel } from "@cursor/july/channels/slack";
-
-export default slackChannel({
-  cursorAccount: true,
-  agentName: "MyAgent", // single token, no whitespace; prefer PascalCase
-  agentIcon: { emoji: ":robot_face:" },
-});
-```
-
-`agentName` defaults from the mount slug (PascalCase) and must be a
-single token. String literals with spaces fail typecheck; runtime
-values throw at construction/serve. Names must be unique on the host;
-an unmatched `@Cursor <name>` stays with Cursor's normal Slack agent.
-External senders (Slack Connect / guests / other workspaces) are
-blocked by default; see `policy.blockExternals` in
-[docs/guides/slack.md](../../docs/guides/slack.md).
-
-### A2 — Sign in + serve (agent)
-
-```bash
-agent-sdk login   # or export CURSOR_API_KEY
-agent-sdk dev .
-```
-
-Confirm log: `[agent-sdk] cursor-slack: relaying Slack for <AgentName> …`.
-An unsigned host fails `serve` with a sign-in hint naming the channel.
-
-### A3 — Smoke (human)
-
-1. In the Slack workspace linked to the Cursor account, post
-   `@Cursor MyAgent <question>` (or DM @Cursor)
-2. Confirm a working status while the turn runs, then a threaded reply
-   posted under the agent's name and icon
-3. Reply in the thread without re-mentioning; it stays with the agent
-
-### Path A limits (enforced at construction)
-
-- `credentials` / `envPrefix` → throw (author a second channel file for
-  a dedicated app instead)
-- `engagement.channelPosts`, `toolApprovals`, `interactivity`,
-  `onBlockAction` → throw (Socket Mode only)
-- `engagement.mentions: false` / `directMessages: false` → throw (the
-  relay always delivers those)
-- Streaming is forced off: rotating status while thinking, one final
-  reply post
-
-When one of these limits becomes a real requirement, keep the
-cursor-account channel and add a Path B channel file beside it.
-
-## Path B — Dedicated Slack app (Socket Mode)
+## Dedicated Slack app (Socket Mode)
 
 Goal: one dedicated bot per agent, tokens in `.env.local`, local serve
 without a cloud deploy. The dashboard wizard is the only first-run.
@@ -167,7 +54,8 @@ install does not file the request. After an admin approves, click
 
 `create` scaffolds `agent/channels/slack.ts` when missing. Do not paste
 a manifest at api.slack.com for this path. `slack init` without
-`--manual` hard-errors; see Path C for a hand-imported app.
+`--manual` hard-errors; see the manual path below for a hand-imported
+app.
 
 Existing tokens in `.env.local` keep working. Skip the wizard for those
 agents unless you want a Cursor-managed app.
@@ -203,7 +91,7 @@ app. It keeps the Slack app id and replaces the manifest and tokens.
 `agent-sdk slack destroy` deletes the provisioned app. Tokens left in
 `.env.local` simply stop working.
 
-## Path C — Manual Slack app (`slack init --manual`)
+## Manual Slack app (`slack init --manual`)
 
 Use this when the user wants a Slack app they own at api.slack.com, not
 a Cursor-managed app. Not the default. Do not offer it unless they
@@ -287,7 +175,7 @@ Human:
 
 ## Features (defaults ON)
 
-- Chat streaming (`chat.startStream` / `appendStream` / `stopStream`) with postMessage fallback (Path B; Path A posts one final reply)
+- Chat streaming (`chat.startStream` / `appendStream` / `stopStream`) with postMessage fallback
 - Thinking / task cards for tool calls
 - `assistant.threads.setStatus` with rotating `loading_messages`
 - Thread title + suggested prompts
@@ -296,7 +184,7 @@ Human:
 
 If a Slack API is unavailable (`method_not_found` / `missing_scope`), the pack falls back to postMessage + setStatus.
 
-## Engagement: mentions by default, channel watch opt-in (Path B only)
+## Engagement: mentions by default, channel watch opt-in
 
 The pack dispatches only on `app_mention` + DMs unless told otherwise:
 summoned, never proactive. To watch channels (dispatch on new posts without
@@ -323,7 +211,7 @@ each watched channel. Posts mentioning the bot stay on the
 thread. `engagement.mentions` / `engagement.directMessages` can be set to
 `false` to turn those surfaces off.
 
-## Tool approvals over Slack (opt-in HITL, Path B only)
+## Tool approvals over Slack (opt-in HITL)
 
 Tools with `needsApproval` park until a human approves or denies. To route
 that through Slack, set `toolApprovals: true` on `slackChannel`. It posts
@@ -357,20 +245,16 @@ Requirements and caveats:
 
 ## Notes
 
-- Dev and prod are **separate Slack apps** (separate tokens) on Path B.
-  Path A has no per-env app split; the host's Cursor account decides
-  where it relays.
-- Socket Mode / the Cursor relay are outbound only. No Events HTTP /
-  Request URL path on either connection.
+- Dev and prod are **separate Slack apps** (separate tokens).
+- Socket Mode is outbound only. No Events HTTP / Request URL path.
 - Do not `await waitForCompletion()` inside Slack dispatch handlers. The pack uses `waitUntil`.
 - Do not share one token pair across multiple agents in the same process.
 
 ## CLI reference
 
-Path B tooling is `create` / `destroy` / `icon` / `doctor`. Path C is
-`init --manual` / `manifest` / `doctor`. Path A needs only `login`.
-`slack setup` prints this chooser. `slack init` hard-errors unless
-`--manual`.
+Wizard tooling is `create` / `destroy` / `icon` / `doctor`. Manual is
+`init --manual` / `manifest` / `doctor`. `slack setup` prints this
+guide. `slack init` hard-errors unless `--manual`.
 
 ```bash
 agent-sdk slack setup

package/src/channels/deployments/deployments-channel.ts

@@ -2,6 +2,7 @@ import { z } from "zod";
 
 import { defineChannel, localDevStrict, POST } from "../../channels.js";
 import { resolveDeploymentSubscriptions } from "../../internal/cursor-deployment-relay.js";
+import { bindLocalIngressSend } from "../../internal/local-ingress.js";
 import type { ChannelDefinition, ChannelHandlerArgs } from "../../types.js";
 import {
   DEPLOYMENT_EVENT_TYPES,
@@ -39,6 +40,24 @@ export function getDeploymentsChannelOptions(
   return deploymentsChannelOptionsByDefinition.get(definition);
 }
 
+/**
+ * Events a {@link deploymentsChannel} dispatches on, unioned from its
+ * subscriptions. Published as `meta.deploymentEventTypes` so the deploy
+ * manifest can extract `eventTypes`. An empty deploy-source list is an
+ * inert channel and yields no events.
+ */
+export function deriveDeploymentEventTypes(
+  options: Pick<DeploymentsChannelOptions, "deploySourceUris" | "events">
+): string[] {
+  const events = new Set<string>();
+  for (const subscription of resolveDeploymentSubscriptions(options)) {
+    for (const event of subscription.events) {
+      events.add(event);
+    }
+  }
+  return [...events].sort();
+}
+
 /**
  * Core deployment-event dispatch, used by the channel's replay route and by
  * the serve host's relay fan-out. Whether the event matches this channel's
@@ -49,7 +68,15 @@ export async function dispatchDeploymentEvent(input: {
   event: DeploymentEvent;
   args: ChannelHandlerArgs;
 }): Promise<Response> {
-  await input.options.onEvent(input.event, input.args);
+  await input.options.onEvent(
+    input.event,
+    bindLocalIngressSend(input.args, {
+      identity: input.options.continuation,
+      kind: DEPLOYMENTS_CHANNEL_KIND,
+      eventType: input.event.eventType,
+      payload: input.event,
+    })
+  );
   return Response.json({ ok: true });
 }
 
@@ -89,7 +116,10 @@ export function deploymentsChannel(
 
   const definition = defineChannel({
     auth: options.auth ?? [localDevStrict()],
-    meta: { kind: DEPLOYMENTS_CHANNEL_KIND },
+    meta: {
+      kind: DEPLOYMENTS_CHANNEL_KIND,
+      deploymentEventTypes: deriveDeploymentEventTypes(options),
+    },
     ...(options.onStart === undefined ? {} : { onStart: options.onStart }),
     ...(options.onStop === undefined ? {} : { onStop: options.onStop }),
     routes: [

package/src/channels/deployments/types.ts

@@ -1,3 +1,4 @@
+import type { ContinuationIdentity } from "../../continuation.js";
 import type { ChannelDefinition, ChannelHandlerArgs } from "../../types.js";
 
 /** {@link ChannelMeta.kind} value used by {@link deploymentsChannel}. */
@@ -77,4 +78,11 @@ export interface DeploymentsChannelOptions {
   auth?: ChannelDefinition["auth"];
   onStart?: ChannelDefinition["onStart"];
   onStop?: ChannelDefinition["onStop"];
+  /**
+   * Continuation selector. Omitted inherits {@link AgentConfig.architecture}:
+   * `"deployments.none/v1"` unless the agent set `architecture: "v2"` (then
+   * `"deployments.deployment/v2"`). Override with `"deployments.none/v2"`
+   * for one-shot events.
+   */
+  continuation?: ContinuationIdentity;
 }

package/src/channels/github/github-channel.ts

@@ -480,6 +480,39 @@ function verifyWebhookSha256Signature(args: {
  * Run authored GitHub hooks and `send()`. Does not extract a v2 mailbox —
  * the local CP (or hosted verified ingress) stamps before this runs.
  */
+export type GitHubDispatchOutcome = "skip" | "send" | "task";
+
+const dispatchOutcomeByResponse = new WeakMap<
+  Response,
+  GitHubDispatchOutcome
+>();
+
+function withDispatchOutcome(
+  response: Response,
+  outcome: GitHubDispatchOutcome
+): Response {
+  dispatchOutcomeByResponse.set(response, outcome);
+  return response;
+}
+
+export function getGitHubDispatchOutcome(
+  response: Response
+): GitHubDispatchOutcome | undefined {
+  return dispatchOutcomeByResponse.get(response);
+}
+
+const PROPAGATE_BACKGROUND_ERRORS = Symbol("propagateBackgroundErrors");
+
+type GitHubHandlerArgs = ChannelHandlerArgs & {
+  [PROPAGATE_BACKGROUND_ERRORS]?: true;
+};
+
+export function withPropagatingGitHubBackgroundErrors(
+  args: ChannelHandlerArgs
+): ChannelHandlerArgs {
+  return Object.assign(args, { [PROPAGATE_BACKGROUND_ERRORS]: true as const });
+}
+
 export async function dispatchGitHubWebhook(input: {
   options: GitHubChannelOptions;
   eventName: string | null;
@@ -1589,25 +1622,25 @@ async function startTurn(input: {
     scheduleAfterAck(input.args, async () => {
       await sendTurn();
     });
-    return Response.json(
-      { ok: true, dispatched: true, mode: "turn" },
-      { status: 202 }
+    return withDispatchOutcome(
+      Response.json(
+        { ok: true, dispatched: true, mode: "turn" },
+        { status: 202 }
+      ),
+      "send"
     );
   }
 
   const session = await sendTurn();
-  return Response.json({
-    ok: true,
-    sessionId: session.id,
-    isNew: session.isNew,
-    continuationToken: session.continuationToken,
-  });
-}
-
-function reportBackgroundFailure(error: unknown): void {
-  const detail =
-    error instanceof Error ? (error.stack ?? error.message) : String(error);
-  console.error(`[github] background dispatch failed: ${detail}`);
+  return withDispatchOutcome(
+    Response.json({
+      ok: true,
+      sessionId: session.id,
+      isNew: session.isNew,
+      continuationToken: session.continuationToken,
+    }),
+    "send"
+  );
 }
 
 function scheduleAfterAck(
@@ -1617,14 +1650,25 @@ function scheduleAfterAck(
   // Defer past the current turn so the 202 can flush before work starts
   // (and so tests can assert scheduling without racing microtasks).
   args.waitUntil(
-    new Promise<void>((resolve) => {
+    new Promise<void>((resolve, reject) => {
       setImmediate(() => {
         Promise.resolve()
           .then(work)
           .then(
             () => resolve(),
             (error: unknown) => {
-              reportBackgroundFailure(error);
+              if (
+                (args as GitHubHandlerArgs)[PROPAGATE_BACKGROUND_ERRORS] ===
+                true
+              ) {
+                reject(error);
+                return;
+              }
+              const detail =
+                error instanceof Error
+                  ? (error.stack ?? error.message)
+                  : String(error);
+              console.error(`[github] background dispatch failed: ${detail}`);
               resolve();
             }
           );
@@ -1639,9 +1683,12 @@ function acknowledgeTask(
   extra: Record<string, unknown>
 ): Response {
   scheduleAfterAck(args, dispatch.task);
-  return Response.json(
-    { ok: true, dispatched: true, mode: "task", ...extra },
-    { status: 202 }
+  return withDispatchOutcome(
+    Response.json(
+      { ok: true, dispatched: true, mode: "task", ...extra },
+      { status: 202 }
+    ),
+    "task"
   );
 }
 
@@ -1649,7 +1696,10 @@ function skipped(
   reason: string,
   extra: Record<string, unknown> = {}
 ): Response {
-  return Response.json({ ok: true, skipped: true, reason, ...extra });
+  return withDispatchOutcome(
+    Response.json({ ok: true, skipped: true, reason, ...extra }),
+    "skip"
+  );
 }
 
 function formatCiMessage(

package/src/channels/slack/attachments.ts

@@ -381,8 +381,8 @@ async function downloadSlackFileBytes(args: {
   maxBytes: number;
   downloadTimeoutMs: number;
 }): Promise<{ data: Uint8Array; mimeType: string; filename: string } | null> {
-  // cursorAccount transport cannot mint a Bearer for files.slack.com; the
-  // relay must pre-attach `dataBase64` on the file ref instead.
+  // Transport callers cannot mint a Bearer for files.slack.com; they
+  // must pre-attach `dataBase64` on the file ref instead.
   if (isSlackApiTransport(args.botToken)) {
     return null;
   }

package/src/channels/slack/dispatch.ts

@@ -162,8 +162,6 @@ export interface SlackInboundDispatchDeps extends SlackContinuationProbes {
    * `host.evals` is present.
    */
   evalCommandsEnabled?: boolean;
-  /** cursorAccount agent name stripped before `eval` directive parsing. */
-  cursorAgentName?: string;
   /**
    * Drop external senders before the handler. Defaults to `true`; pass
    * `false` to admit them (or when an upstream gate already refused them).
@@ -245,11 +243,6 @@ export async function dispatchInboundMessage(args: {
   evalCommandsEnabled?: boolean;
   /** See {@link SlackInboundDispatchDeps.followUpStatus}. Defaults to `true`. */
   followUpStatus?: boolean;
-  /**
-   * cursorAccount agent display name — stripped before parsing `eval …`
-   * (`OncallBuddy eval list`).
-   */
-  cursorAgentName?: string;
   blockExternals?: boolean;
   continuation?: ContinuationIdentity;
 }): Promise<void> {
@@ -342,14 +335,10 @@ export async function dispatchInboundMessage(args: {
 
   // Built-in eval directive: run playground batches without an agent turn.
   const evalCommandsEnabled = args.evalCommandsEnabled !== false;
-  const evalParseOptions =
-    args.cursorAgentName === undefined || args.cursorAgentName === ""
-      ? undefined
-      : { agentName: args.cursorAgentName };
   const evalDirective =
     evalCommandsEnabled && args.host.evals !== undefined
-      ? (parseSlackEvalDirective(message.text, evalParseOptions) ??
-        parseSlackEvalDirective(message.markdown, evalParseOptions))
+      ? (parseSlackEvalDirective(message.text) ??
+        parseSlackEvalDirective(message.markdown))
       : null;
   if (evalDirective !== null && args.host.evals !== undefined) {
     log.info("eval directive", {
@@ -657,7 +646,6 @@ export function dispatchInboundFromEventBody(
         artifacts: deps.artifacts,
         log,
         evalCommandsEnabled: deps.evalCommandsEnabled,
-        cursorAgentName: deps.cursorAgentName,
         followUpStatus: deps.followUpStatus,
         blockExternals: deps.blockExternals,
         ...continuationArg(deps.continuation),
@@ -701,7 +689,6 @@ export function dispatchInboundFromEventBody(
         artifacts: deps.artifacts,
         log,
         evalCommandsEnabled: deps.evalCommandsEnabled,
-        cursorAgentName: deps.cursorAgentName,
         followUpStatus: deps.followUpStatus,
         blockExternals: deps.blockExternals,
         ...continuationArg(deps.continuation),
@@ -739,7 +726,6 @@ export function dispatchInboundFromEventBody(
         artifacts: deps.artifacts,
         log,
         evalCommandsEnabled: false,
-        cursorAgentName: deps.cursorAgentName,
         followUpStatus: deps.followUpStatus,
         blockExternals: deps.blockExternals,
         ...continuationArg(deps.continuation),

package/src/channels/slack/eval-directive.ts

@@ -2,7 +2,7 @@
  * Built-in Slack `eval` directive — run playground evals from a mention/DM
  * without per-agent custom handlers (parity with CLI / playground runs).
  *
- * Examples (after stripping @mentions / cursorAccount agent name):
+ * Examples (after stripping @mentions):
  *   eval
  *   eval triage/open-incidents smoke
  *   eval --tag oncall
@@ -29,29 +29,15 @@ export type SlackEvalDirective =
   | { kind: "cancel"; runId: string }
   | { kind: "run"; filterIds?: string[]; tags?: string[] };
 
-function escapeRegExp(value: string): string {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-
 /**
  * Normalize inbound Slack text for directive parsing: strip leading
- * `<@U…>` mentions, leading `@U…` markdown mentions, and an optional
- * cursorAccount agentName prefix (`OncallBuddy eval …`).
+ * `<@U…>` mentions and leading `@U…` markdown mentions.
  */
-export function normalizeSlackEvalDirectiveBody(
-  text: string,
-  options?: { agentName?: string }
-): string {
+export function normalizeSlackEvalDirectiveBody(text: string): string {
   let body = stripLeadingSlackMentions(text);
-  // markdown form from slackTextToMarkdown / cursorAccount envelopes
   while (/^@[A-Za-z0-9._-]+\s+/.test(body)) {
     body = body.replace(/^@[A-Za-z0-9._-]+\s+/, "").trim();
   }
-  const agentName = options?.agentName?.trim();
-  if (agentName !== undefined && agentName.length > 0) {
-    const prefix = new RegExp(`^${escapeRegExp(agentName)}\\s+`, "i");
-    body = body.replace(prefix, "").trim();
-  }
   return body;
 }
 
@@ -60,10 +46,9 @@ export function normalizeSlackEvalDirectiveBody(
  * eval command (falls through to the normal agent handler).
  */
 export function parseSlackEvalDirective(
-  text: string,
-  options?: { agentName?: string }
+  text: string
 ): SlackEvalDirective | null {
-  const body = normalizeSlackEvalDirectiveBody(text, options);
+  const body = normalizeSlackEvalDirectiveBody(text);
   if (body.length === 0) {
     return null;
   }
@@ -141,14 +126,10 @@ export function parseSlackEvalDirective(
 }
 
 /** True when either raw Slack text or markdown form is an eval directive. */
-export function isSlackEvalDirective(
-  text: string,
-  markdown: string,
-  options?: { agentName?: string }
-): boolean {
+export function isSlackEvalDirective(text: string, markdown: string): boolean {
   return (
-    parseSlackEvalDirective(text, options) !== null ||
-    parseSlackEvalDirective(markdown, options) !== null
+    parseSlackEvalDirective(text) !== null ||
+    parseSlackEvalDirective(markdown) !== null
   );
 }
 

package/src/channels/slack/index.ts

@@ -10,11 +10,6 @@
  * // Multi-agent serve: one Slack app per agent
  * export default slackChannel({ envPrefix: "MY_AGENT" });
  * // → MY_AGENT_SLACK_BOT_TOKEN + MY_AGENT_SLACK_APP_TOKEN
- *
- * // No Slack app at all: ride the signed-in Cursor account's Slack
- * // connection (`@Cursor <agent name> …` routes here; replies post as
- * // this agent through the Cursor Slack app)
- * export default slackChannel({ cursorAccount: true });
  * ```
  */
 
@@ -28,7 +23,6 @@ export * from "./bot-mentions.js";
 export * from "./channel-watch.js";
 export * from "./constants.js";
 export * from "./credentials.js";
-export * from "./cursor-account.js";
 export * from "./defaults.js";
 export * from "./dispatch.js";
 export * from "./doctor.js";

package/src/channels/slack/setup.ts

@@ -1,10 +1,10 @@
 /**
  * Slack setup guide printed by `agent-serve slack setup`.
  *
- * Two products: Cursor-hosted (`cursorAccount`) vs a dedicated Socket
- * Mode app via `slack create` (dashboard wizard). `slack init --manual`
- * is the unmanaged paste-at-api.slack.com path. {@link SLACK_SETUP_PHASES}
- * is that checklist; its ids key `.agent-serve/slack/setup-status.json`.
+ * Dedicated Socket Mode app via `slack create` (dashboard wizard).
+ * `slack init --manual` is the unmanaged paste-at-api.slack.com path.
+ * {@link SLACK_SETUP_PHASES} is that checklist; its ids key
+ * `.agent-serve/slack/setup-status.json`.
  */
 
 export interface SlackSetupPhase {
@@ -101,17 +101,10 @@ export function formatSlackSetupGuide(): string {
   const lines: string[] = [
     "agent-serve — Slack setup",
     "",
-    "Two products. Pick one.",
-    "",
-    "  A) Cursor-hosted (recommended default, zero Slack admin):",
-    '     slackChannel({ cursorAccount: true, agentName: "MyAgent" })',
-    "     Sign in (agent-serve login / CURSOR_API_KEY), serve, then mention",
-    '     "@Cursor MyAgent ..." in the linked workspace. No app, no tokens.',
-    "  B) Dedicated Slack app (Socket Mode) via the dashboard wizard:",
-    "     agent-serve slack create --dir .",
-    "     Finish Slack consent and the bot name there. The CLI writes",
-    "     tokens into .env.local. Use this when you need your own bot",
-    "     user, channel watching, or approval buttons.",
+    "Dedicated Slack app (Socket Mode) via the dashboard wizard:",
+    "  agent-serve slack create --dir .",
+    "  Finish Slack consent and the bot name there. The CLI writes",
+    "  tokens into .env.local.",
     "",
     "Manual Slack app: `slack init --manual`. Phases below.",
     "Goal: importable dev + prod Slack apps over Socket Mode (no public URL).",