@cursor/july 0.1.93 → 0.1.95

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/github/github-channel.ts

@@ -11,6 +11,7 @@ import {
   continuationSource,
   normalizeIdentity,
 } from "../../internal/continuation-identity.js";
+import { isDeferredChannelSession } from "../../internal/deferred-channel-session.js";
 import { isDevMode } from "../../internal/dev-mode.js";
 import { bindLocalIngressSend } from "../../internal/local-ingress.js";
 import type {
@@ -1622,16 +1623,15 @@ async function startTurn(input: {
     scheduleAfterAck(input.args, async () => {
       await sendTurn();
     });
-    return withDispatchOutcome(
-      Response.json(
-        { ok: true, dispatched: true, mode: "turn" },
-        { status: 202 }
-      ),
-      "send"
-    );
+    return acknowledgeTurn();
   }
 
   const session = await sendTurn();
+  if (isDeferredChannelSession(session)) {
+    // Hosted admission captured the send; the control plane allocates the
+    // session after acknowledgement, so there is nothing to report yet.
+    return acknowledgeTurn();
+  }
   return withDispatchOutcome(
     Response.json({
       ok: true,
@@ -1677,12 +1677,27 @@ function scheduleAfterAck(
   );
 }
 
+/** 202 ack for a turn whose send completes after the response flushes. */
+function acknowledgeTurn(): Response {
+  return withDispatchOutcome(
+    Response.json(
+      { ok: true, dispatched: true, mode: "turn" },
+      { status: 202 }
+    ),
+    "send"
+  );
+}
+
 function acknowledgeTask(
   args: ChannelHandlerArgs,
   dispatch: GitHubTaskDispatch,
   extra: Record<string, unknown>
 ): Response {
-  scheduleAfterAck(args, dispatch.task);
+  // Hand the task the per-delivery send/waitUntil so hosted admission can
+  // capture task-initiated sends; startup-captured sends bypass capture.
+  scheduleAfterAck(args, () =>
+    dispatch.task({ send: args.send, waitUntil: args.waitUntil })
+  );
   return withDispatchOutcome(
     Response.json(
       { ok: true, dispatched: true, mode: "task", ...extra },

package/src/channels/github/types.ts

@@ -7,6 +7,7 @@ import type {
   ChannelEventHandlers,
   ChannelStartArgs,
   HostContext,
+  SendMessageFn,
   SendMessageOptions,
 } from "../../types.js";
 import type { GitHubApiOptions } from "./api.js";
@@ -370,13 +371,29 @@ export interface GitHubTurnDispatch {
         | Promise<GitHubWorkspaceFiles | undefined>);
 }
 
+/** Bound per-delivery helpers passed to a {@link GitHubTaskDispatch.task}. */
+export interface GitHubTaskArgs {
+  /**
+   * Start (or resume) a session for this delivery. Locally this runs a real
+   * turn and returns the live session. In hosted admission it captures the
+   * send for the control plane to execute after `ses_…` is allocated and
+   * returns an inert deferred handle, so the task body keeps running.
+   * Always use this over a send captured at `onStart` — a startup-captured
+   * send bypasses hosted capture and is rejected during hosted admission.
+   */
+  send: SendMessageFn;
+  /** Extend the delivery's background window past the task promise. */
+  waitUntil: (promise: Promise<unknown>) => void;
+}
+
 /**
  * Run a host-side handler for the event instead of a model turn. The task
  * runs in the background (`waitUntil`) after the webhook is acknowledged
- * with a 202, so it can outlive GitHub's ~10s delivery timeout.
+ * with a 202, so it can outlive GitHub's ~10s delivery timeout. The callback
+ * receives {@link GitHubTaskArgs}; zero-argument tasks remain valid.
  */
 export interface GitHubTaskDispatch {
-  task: () => void | Promise<void>;
+  task: (args: GitHubTaskArgs) => void | Promise<void>;
 }
 
 export type GitHubDispatchResult =

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

@@ -26,6 +26,7 @@ import {
 import { deriveOriginWebhookEvents, ORIGIN_CHANNEL_KIND } from "./events.js";
 import {
   DEFAULT_ORIGIN_API_BASE_URL,
+  OriginJwksUnavailableError,
   type OriginWebhookHeaders,
   verifyOriginWebhook,
 } from "./origin-webhook.js";
@@ -300,10 +301,12 @@ export function parseOriginPullRequestEvent(input: {
     ctx: {
       deliveryId: input.envelope.deliveryId,
       eventType,
+      eventTime: input.envelope.event.eventTime,
       installationId: input.envelope.installationId,
       repository,
       pullRequestNumber: number,
       pullRequestUrl: url,
+      payload,
       sender: originSender(input.envelope, payload),
     },
     pullRequest: {
@@ -687,7 +690,16 @@ export async function handleOriginWebhookRequest(input: {
       await verifyOriginWebhook(bodyText, originHeaders(input.request), {
         apiBaseUrl: resolveApiBaseUrl(input.options),
       });
-    } catch {
+    } catch (error) {
+      // A JWKS outage means the delivery was never checked: answer 503 so
+      // Origin's delivery worker retries. Only a real signature mismatch
+      // is the terminal 401.
+      if (error instanceof OriginJwksUnavailableError) {
+        return Response.json(
+          { ok: false, error: "signature_verification_unavailable" },
+          { status: 503 }
+        );
+      }
       return Response.json(
         { ok: false, error: "invalid_signature" },
         { status: 401 }

package/src/channels/origin/origin-webhook.ts

@@ -247,7 +247,31 @@ export interface VerifyOriginWebhookOptions {
 }
 
 /**
- * Verify a Standard-Webhooks v1ed Origin payload. Throws on failure.
+ * The signing JWKS could not be fetched (and no cached copy applies), so
+ * the delivery was never actually checked. Callers must answer retryably
+ * (5xx) — a 401 would make Origin's delivery worker drop the wake as
+ * terminal on what is only a transient outage.
+ */
+export class OriginJwksUnavailableError extends Error {}
+
+async function fetchJwksOrUnavailable(
+  apiBaseUrl: string,
+  fetchImpl: typeof fetch,
+  options?: FetchOriginJwksOptions
+): Promise<readonly OriginJwk[]> {
+  try {
+    return await fetchOriginJwks(apiBaseUrl, fetchImpl, options);
+  } catch (error) {
+    throw new OriginJwksUnavailableError(
+      `Origin JWKS unavailable: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+
+/**
+ * Verify a Standard-Webhooks v1ed Origin payload. Throws
+ * {@link OriginJwksUnavailableError} when the keys cannot be fetched, and a
+ * plain error when the signature does not verify against them.
  */
 export async function verifyOriginWebhook(
   body: string | Buffer,
@@ -256,7 +280,7 @@ export async function verifyOriginWebhook(
 ): Promise<void> {
   const apiBaseUrl = options?.apiBaseUrl ?? DEFAULT_ORIGIN_API_BASE_URL;
   const fetchImpl = options?.fetchImpl ?? fetch;
-  const keys = await fetchOriginJwks(apiBaseUrl, fetchImpl);
+  const keys = await fetchJwksOrUnavailable(apiBaseUrl, fetchImpl);
   if (
     verifyV1edWebhookPayload({
       publicJwks: keys,
@@ -267,7 +291,7 @@ export async function verifyOriginWebhook(
   ) {
     return;
   }
-  const refreshed = await fetchOriginJwks(apiBaseUrl, fetchImpl, {
+  const refreshed = await fetchJwksOrUnavailable(apiBaseUrl, fetchImpl, {
     force: true,
   });
   if (

package/src/channels/origin/types.ts

@@ -51,11 +51,19 @@ export interface OriginReview {
 export interface OriginEventContext {
   deliveryId?: string;
   eventType: string;
+  /** Delivery envelope `event.eventTime`, when present. */
+  eventTime?: string;
   /** Origin app installation id from the delivery envelope, when present. */
   installationId?: string;
   repository: OriginRepositoryRef;
   pullRequestNumber: number;
   pullRequestUrl: string;
+  /**
+   * Raw parsed `event.payload` record (`{}` when absent), for consumers
+   * whose normalization needs more than the typed event — the GitHub
+   * channel's hook ctx exposes the same.
+   */
+  payload: Record<string, unknown>;
   sender?: OriginActor;
   host: HostContext;
   artifacts: ArtifactsApi;

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";