@cursor/july 0.1.48 → 0.1.51

package/docs/reference/cli.md

@@ -771,35 +771,27 @@ setup.
 agent-sdk slack setup
 agent-sdk slack create [--dir <path>] [--name <name>] [--prod]
                       [--slack-team <T…>] [--team <id>]
-                      [--icon <https-url-or-file>] [--force]
+                      [--icon <https-url-or-file>]
                       [--prefix <prefix> | --no-prefix] [--json]
 agent-sdk slack destroy [--dir <path>] [--prod] [--slack-team <T…>]
                        [--team <id>] [--json]
 agent-sdk slack icon <https-url-or-file> [--dir <path>] [--prod]
                     [--slack-team <T…>] [--team <id>] [--json]
-agent-sdk slack init [--dir <path>] [--name <name>]
-                    [--prefix <prefix> | --no-prefix] [--channel-posts]
-agent-sdk slack manifest [--dir <path>] [--name <name>]
-                        [--env dev|prod|both] [--channel-posts] [--print]
 agent-sdk slack doctor [--dir <path>] [--prefix <prefix> | --no-prefix] [--json]
 ```
 
-`slack setup` prints a guided checklist and doesn't change files.
+`slack setup` prints the two-product chooser and doesn't change files.
 
-`slack create` provisions a dedicated Socket Mode app through Cursor's
-Add to Slack API instead of the manual manifest import. It requires a
-signed-in host (`agent-sdk login` or `CURSOR_API_KEY`) and the
-provisioning feature to be enabled for the account. The command
-scaffolds the channel file when missing, opens the browser consent flow
-when the workspace isn't connected to Cursor yet, creates and installs
-the app, writes the bot and app-level tokens into `<dir>/.env.local`,
-and ends with a `doctor` pass. `--prod` provisions the production app;
-the default is the development app. When the install needs a Slack
-workspace admin's approval, the command prints the approval page and
-exits non-zero; re-run it after the approval to finish and mint the
-tokens. A re-run rebuilds the manifest from the command's flags and
-refuses to overwrite edits made by hand in Slack unless you pass
-`--force`.
+`slack create` opens the signed-in Cursor dashboard wizard. Finish Slack
+consent and the bot name there. The CLI writes the token pair into
+`<dir>/.env.local` and runs `doctor`. It requires a signed-in host
+(`agent-sdk login` or `CURSOR_API_KEY`). `--prod` provisions the
+production app; the default is the development app. `--name` / `--icon`
+/ `--channel-posts` prefill the wizard. A second create for the same
+slug and env overwrites the live Slack app. If Slack needs a workspace
+admin's approval, the wizard waits; keep the CLI running, open Slack's
+**Request approval** page (the CLI prints the link), and click **Retry**
+after the admin approves. Token values never print.
 
 `slack destroy` deletes the provisioned app for the selected
 environment. Tokens already written to `.env.local` stay in place and
@@ -808,23 +800,8 @@ stop working.
 `slack icon` sets the provisioned app's icon from an https image URL or
 a local png, jpg, or gif file of at most 512KB.
 
-`slack init` creates the channel file, development and production
-manifests, `env.example`, and setup status under the project. It refuses
-to overwrite a target file. If a collision occurs, it exits non-zero;
-files created earlier in the run remain. The token prefix defaults to
-the directory basename normalized to uppercase snake case. Explicit
-`--prefix` values use the same normalization when the Agent SDK builds token
-variable names. For example, `pr-approver` becomes
-`PR_APPROVER_SLACK_BOT_TOKEN`. `--no-prefix` uses shared
-`SLACK_BOT_TOKEN` and `SLACK_APP_TOKEN`. `--channel-posts` subscribes
-the manifests to channel-post events. The command always prints a JSON
-summary.
-
-`slack manifest` regenerates selected manifest files. `--env` defaults
-to `both`, and `--name` defaults to the directory name. `--print` writes
-the manifest JSON to stdout instead of changing files. With the default
-`--env both`, it prints development JSON, a `--- prod ---` separator,
-then production JSON.
+`slack init` is removed. It exits non-zero and writes no files. Use
+`slack create`.
 
 `slack doctor` checks both tokens, Socket Mode connectivity, and
 Slack's `auth.test`. It exits non-zero when any check fails.

package/docs/reference/http-api.md

@@ -208,9 +208,10 @@ Eval runs are asynchronous. Poll the run route for case progress and
 the final `completed` or `failed` status. Batch errors appear on the
 snapshot returned by the poll. Entries within `filterIds` and `tags`
 use OR semantics. When both fields are present, a case must match one
-entry from each field. Without a storage `evals` table in
-`agent/storage.ts` (see [Storage](../storage.md)), listed runs are
-process-memory only (capped by `maxPlaygroundRuns`).
+entry from each field. Listed runs persist across restarts whenever
+`agent/storage.ts` provides an `evals` table or a KV core with `delete`
+and `list` (the table is derived — see [Storage](../storage.md));
+otherwise they are process-memory only (capped by `maxPlaygroundRuns`).
 
 ## Dev-mode routes
 

package/docs/storage.md

@@ -52,17 +52,22 @@ export default defineStorage({
 
 ## Which fields to provide
 
+Implement the small KV core — `put`/`get`/`delete`/`list` plus the `cas`
+group — and you get **full functionality**: eval-run and A/B history are
+derived over the core automatically. The dedicated `evals` / `abs` groups
+are backend-native optimizations, not required-or-lose-history hooks.
+
 | Field | Required | Role |
 | --- | --- | --- |
 | `put` | Yes | Write or update a value |
 | `cas` | For coordination | Conditional writes; see [Conditional writes](#conditional-writes-the-cas-group) |
-| `get` | For restore | Look up one key |
-| `list` | For restore | Return entries under a prefix, in key order |
-| `delete` | For cleanup | Remove a key |
+| `get` | For restore | Look up one key (also: derived A/B snapshot backfill) |
+| `list` | For restore | Return entries under a prefix, in key order (also: derived eval-runs hydrate) |
+| `delete` | For cleanup | Remove a key (also: derived eval-runs pruning) |
 | `name` | No | Label surfaced on `GET /v1/info` diagnostics |
 | `policy` | No | Timing knobs; see [Policy](#policy) |
-| `evals` | No | Dedicated eval-runs table; see [Eval and A/B tables](#eval-and-a-b-tables) |
-| `abs` | No | Dedicated A/B metrics table; see [Eval and A/B tables](#eval-and-a-b-tables) |
+| `evals` | No | Backend-native eval-runs table; derived over the core when omitted — see [Eval and A/B tables](#eval-and-a-b-tables) |
+| `abs` | No | Backend-native A/B metrics table; derived over the core when omitted — see [Eval and A/B tables](#eval-and-a-b-tables) |
 
 A throwing `put` is logged and dropped. It never fails a turn. When
 resolving a missing continuation token, a throwing `get` fails the
@@ -71,23 +76,34 @@ follow-up so a store outage does not open a new session. Return
 
 ## Eval and A/B tables
 
-Two dedicated tables carry structured rows instead of opaque KV values.
-Both are optional and independent of `put` / `get` / `list`.
-
-`evals` keeps playground eval batches across restarts. Provide `put`,
-`delete`, and `list` over run snapshots keyed by `runId`. The Agent SDK
-upserts a snapshot as a batch starts, progresses, and finishes, prunes
-runs past the playground history window, and lists everything back at
-serve start. Without this table, eval history lives in process memory
-and a restart clears it. See [Evals](./evals.md#configure-eval-runs).
-
-`abs` exports live A/B metrics. Provide `putSample` to append one
-cumulative metric sample per enrolled experiment on each completed or
-failed turn. Optional `putSnapshot` and `getSnapshot` store and serve
-back the latest aggregate snapshot, so a replacement host with no local
-sessions can still serve the A/Bs surface. Without this table, samples
-only go where each experiment's `onSample` sends them; session event
-logs remain the assignment source of truth. See
+Two dedicated table groups carry structured rows instead of opaque KV
+values. Both are **optional optimizations**: when a group is not
+authored, `defineStorage` derives it over the KV core, so a backend that
+implements only the core loses nothing. Author a group only when the
+backend has a better native shape (a real database table, an analytics
+pipeline) — the built-in `fileKv` and `cursorHostedStorage` both do.
+
+`evals` keeps playground eval batches across restarts (`put`, `delete`,
+`list` over run snapshots keyed by `runId`). The Agent SDK upserts a
+snapshot as a batch starts, progresses, and finishes, prunes runs past
+the playground history window, and lists everything back at serve start.
+**Derived form**: one key per run under
+`agentkit/v1/{agent}/eval-runs/{runId}` — needs core `put` + `delete` +
+`list`. Only a core missing `delete` or `list` leaves eval history in
+process memory (cleared on restart). See
+[Evals](./evals.md#configure-eval-runs).
+
+`abs` exports live A/B metrics: `putSample` appends one cumulative
+metric sample per enrolled experiment on each completed or failed turn;
+optional `putSnapshot` / `getSnapshot` store and serve back the latest
+aggregate so a replacement host with no local sessions can still serve
+the A/Bs surface. **Derived form**: each sample lands as its own key
+(`agentkit/v1/{agent}/ab-samples/{experiment}/{sessionId}/{at}` — a
+blind append-only put, never a read-modify-write of one growing array)
+and the snapshot lives at the fixed `agentkit/v1/{agent}/ab-snapshot`
+key (last-write-wins is correct for "latest aggregate"). `putSample` and
+`putSnapshot` need only core `put`; `getSnapshot` needs core `get`.
+Session event logs remain the assignment source of truth either way. See
 [Live A/B metrics](./ab.md).
 
 ## Policy

package/docs/troubleshooting.md

@@ -60,9 +60,9 @@ Match your symptom below. Keep the commands as `agent-sdk`; see
 | What you see | What to do |
 | --- | --- |
 | Logs show `channel idle … missing credentials` | Expected when tokens are missing. Run `agent-sdk slack create --dir <agent>` to provision the app and write the tokens, or set `<PREFIX>_SLACK_BOT_TOKEN` and `<PREFIX>_SLACK_APP_TOKEN` per agent yourself, then run `agent-sdk slack doctor --prefix <PREFIX>`. |
-| `slack create` reports the app needs admin approval | The workspace requires admin approval for new apps. A Slack workspace admin approves it at the printed link (in the dashboard: **Approve in Slack**), then re-run `agent-sdk slack create` (or **Retry** in the dashboard). |
+| `slack create` reports the app needs admin approval | Open Slack's **Request approval** page (the CLI prints the link; the same URL is **Send a reminder** after you submit). Managed install does not file the request. Keep the CLI running, then click **Retry** in the dashboard after an admin approves. |
 | The bot ignores ordinary channel posts | Default engagement is mentions and DMs only. Enable `engagement.channelPosts` with an allowlist, and subscribe the app to `message.channels` / `message.groups`. |
-| Approve / Deny buttons do nothing | Re-import a Slack app manifest with interactivity enabled. Channels that post approval cards need `toolApprovals: true` (and `interactivity: true` when you compose events by hand). |
+| Approve / Deny buttons do nothing | Channels that post approval cards need `toolApprovals: true`. Recreate the app with `slack create` if interactivity is off. |
 
 ## What if host MCP OAuth fails?
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cursor/july",
-  "version": "0.1.48",
+  "version": "0.1.51",
   "description": "(early alpha) Filesystem-first framework for defining Cursor agents as markdown and TypeScript and serving them over channels with the Cursor SDK.",
   "license": "SEE LICENSE IN LICENSE.md",
   "repository": {

package/skills/create-agent/SKILL.md

@@ -97,7 +97,7 @@ Defaults that make first cuts good:
   `prompt\`…\`` / `prompt.lines\`…\`` from `@cursor/july` (dedents indented
   multi-line strings).
 - **Env prefix** for Slack tokens = upper-snake slug (`my-agent` →
-  `MY_AGENT_SLACK_*`); `agent-sdk slack init` derives it for you.
+  `MY_AGENT_SLACK_*`); `agent-sdk slack create` derives it for you.
   Dedicated-app path only — the Cursor-hosted connection has no tokens.
 - **Host prep beats model wandering — for evidence, not judgment.** When the
   purpose has a deterministic setup step (fetch a PR, seed files), do it in
@@ -159,10 +159,9 @@ plan:
    short hand-written `agent/channels/slack.ts`
    (`slackChannel({ cursorAccount: true, agentName: "<Name>" })` — no
    tokens, no manifests); for a dedicated Socket Mode app do not hand-write
-   the channel — `agent-sdk slack init --dir ./<slug> --name "<Name>"`
-   generates `agent/channels/slack.ts` (with the env prefix) plus manifests
-   and `env.example`; customize the generated file (e.g. `suggestedPrompts`)
-   afterwards.
+   the channel — `agent-sdk slack create --dir ./<slug> --name "<Name>"`
+   opens the dashboard wizard (env prefix from the directory name);
+   customize `agent/channels/slack.ts` afterwards (e.g. `suggestedPrompts`).
 5. `evals/evals.config.ts` — `defineEvalConfig({ maxConcurrency: 20 })`
    (playground runs are memory-only unless you add `persistRuns`)
    (`maxConcurrency` is required; hard-capped at 200 due to model provider

package/skills/setup-slack/SKILL.md

@@ -1,34 +1,34 @@
 ---
 name: agentkit-setup-slack
 description: >-
-  Put an Agent SDK agent in Slack. Covers the required connection decision
-  (Cursor-hosted connection vs dedicated Socket Mode Slack app) with an
-  AskQuestion gate, then both setup paths end to end — cursorAccount
-  sign-in + smoke, or manifests, tokens, doctor, smoke test, and opt-in
-  Slack tool approvals (HITL). Read this skill when wiring Slack for an
-  Agent SDK project.
+  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.
 ---
 
 # Setup Slack for the Agent SDK
 
 Use this skill when a human asks to wire Slack to an Agent SDK agent.
 
-There are **two ways to connect**, and they differ mostly in setup cost:
+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
-  manifests, no tokens, no Slack admin. Live in minutes.
+  tokens, no Slack admin. Live in minutes.
 - **Path B — Dedicated Slack app** (Socket Mode): the agent's own bot
-  user, created from generated manifests with an `xoxb-…` + `xapp-…`
-  token pair. Required for channel watching, approval buttons, or a
-  distinct bot handle. When the workspace is enrolled in Cursor's
-  **Add to Slack** (feature gate + a workspace-manager consent),
-  `agent-sdk slack create` provisions all of it in one command.
+  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.
 
-**Do not generate manifests or ask for tokens until the decision below
-is made.** Defaulting into Path B buries the user in Slack admin work
-(two app creations, token minting, env wiring) they may not need.
+Do not generate manifests or ask anyone to paste tokens. Defaulting into
+Path B buries the user in Slack admin work they may not need.
+
+Existing DIY 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)
 
@@ -36,8 +36,8 @@ 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 | Enrolled in Cursor's Add to Slack: one `agent-sdk slack create` per env (app + install + tokens, signed-in host). Otherwise: a Slack admin creates **two** apps (dev + prod) from manifests, installs them, mints `xoxb-…` + `xapp-…` for each |
-| Prereq | Cursor Slack integration installed in the workspace and linked to the Cursor account | Permission to create Slack apps; token storage/rotation is on you |
+| 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 |
@@ -45,7 +45,7 @@ Walk the user through the tradeoffs before touching files:
 | 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:
+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.
@@ -56,19 +56,19 @@ Decision shortcuts — skip the question when the request already decides:
 
 ### Collect the decision with AskQuestion
 
-Otherwise ask — one single-select question via the `AskQuestion` tool,
+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; needs a Slack admin to create two apps
-  and mint tokens.
+  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
+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.
@@ -80,8 +80,8 @@ threaded reply. No Slack app, no tokens, no manifests.
 
 ### A1 — Author the channel (agent)
 
-Write `agent/channels/slack.ts` by hand — do **not** run
-`agent-sdk slack init` (that scaffolds the Path B manifests + env):
+Write `agent/channels/slack.ts` by hand. Do not run `slack create` for
+this path:
 
 ```ts
 import { slackChannel } from "@cursor/july/channels/slack";
@@ -94,7 +94,7 @@ export default slackChannel({
 ```
 
 `agentName` defaults from the mount slug (PascalCase) and must be a
-single token — string literals with spaces fail typecheck; runtime
+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
@@ -117,7 +117,7 @@ An unsigned host fails `serve` with a sign-in hint naming the channel.
    `@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
+3. Reply in the thread without re-mentioning; it stays with the agent
 
 ### Path A limits (enforced at construction)
 
@@ -135,109 +135,47 @@ cursor-account channel and add a Path B channel file beside it.
 
 ## Path B — Dedicated Slack app (Socket Mode)
 
-Goal:
-
-- Importable **dev** and **prod** Slack app manifests (Socket Mode on)
-- App-level Token (`xapp-…`, `connections:write`) + Bot token (`xoxb-…`)
-- No public Request URL (Socket Mode only)
-- Thread ↔ session via `continuationToken = channelId:threadTs`
-- One Slack app (token pair) **per agent** when serving multiple demos
-
-Update `.agent-serve/slack/setup-status.json` as you complete phases.
-
-### Provisioned variant — `agent-sdk slack create` (primary when enrolled)
-
-When the Slack workspace is enrolled in Cursor's **Add to Slack**
-(the provisioning feature gate plus a workspace-manager consent), one
-command collapses Phases 0–3 — manifest import, app creation, install,
-and token minting:
+Goal: one dedicated bot per agent, tokens in `.env.local`, local serve
+without a cloud deploy. The dashboard wizard is the only first-run.
 
 ```bash
-agent-sdk slack create --dir <agent>          # dev app (default)
-agent-sdk slack create --dir <agent> --prod   # prod app
+agent-sdk login
+agent-sdk slack create --dir .
 ```
 
-`create` scaffolds `agent/channels/slack.ts` + the `.agent-serve/slack`
-files when missing (never overwriting existing ones), runs the browser
-consent flow when the workspace is not connected yet, provisions +
-installs the app, writes `<PREFIX>_SLACK_BOT_TOKEN` /
-`<PREFIX>_SLACK_APP_TOKEN` into `<dir>/.env.local` (replacing stale
-lines), and finishes with `doctor`. It needs a signed-in host
-(`agent-sdk login` / `CURSOR_API_KEY`). Pass `--slack-team <id>` when
-several workspaces are connected. If the install lands in
-`pending_admin_approval`, a Slack workspace admin must approve the
-printed link — then re-run `create` to finish and mint the tokens.
-`agent-sdk slack destroy` deletes the provisioned app (tokens left in
-`.env.local` simply stop working). Skip to Phase 4 when `create`
-succeeds — `dev`/`serve` load the agent's `.env.local` (real env wins).
-Note: re-running `create` rebuilds the app manifest from the command's
-flags, so any customization made outside the CLI resets to it.
-
-If the command reports the feature gate is not enabled (the workspace
-is not enrolled), fall back to the manual manifest-import flow below
-(Phases 0–3).
-
-### Phase 0 — Generate (agent)
-
-```bash
-pnpm exec tsx packages/agent-serve/src/bin/agent-serve.ts slack init \
-  --dir <agent> --name "My Agent"
-```
-
-Creates:
-
-- `agent/channels/slack.ts` with `envPrefix` from the directory name
-- `.agent-serve/slack/manifest.{dev,prod}.json`
-- `.agent-serve/slack/env.example` (`<PREFIX>_SLACK_BOT_TOKEN` / `_APP_TOKEN`)
-
-Use `--no-prefix` for the shared `SLACK_BOT_TOKEN` / `SLACK_APP_TOKEN` globals
-(single-agent only). Use `--prefix CUSTOM` to override the default prefix.
-
-These files deliberately omit `settings.managed_app_settings` — Slack accepts
-that block only from a manager app's user token, so it belongs to the
-`slack create` path, not to a manifest a human pastes in.
-
-### Phase 1 — Create apps (human)
+That opens the signed-in Cursor dashboard. Sign in as the same Cursor
+account that ran the command. Click **Add Slack to this agent**, approve
+Slack's consent screen, pick the bot name, and continue. The CLI waits
+and writes `<PREFIX>_SLACK_BOT_TOKEN` / `<PREFIX>_SLACK_APP_TOKEN` into
+`<dir>/.env.local`, then runs `doctor`. Token values never print.
 
-1. Open https://api.slack.com/apps → **Create New App** → **From a manifest**
-2. Paste `manifest.dev.json` → create the *dev* app
-3. Repeat with `manifest.prod.json` for prod
+`--prod` provisions the prod app (default is dev). `--name` / `--icon` /
+`--channel-posts` prefill the wizard. `--prefix` / `--no-prefix` set the
+env-var names.
 
-Stop and ask the human to complete this gate.
+If Slack asks a workspace admin to approve the app, keep the CLI
+running. Open Slack's **Request approval** page (the CLI prints the
+link; the same URL is **Send a reminder** after you submit). Managed
+install does not file the request. After an admin approves, click
+**Retry** in the wizard.
 
-### Phase 2 — Install + tokens (human)
+`create` scaffolds `agent/channels/slack.ts` when missing. Do not paste
+a manifest at api.slack.com. `slack init` is removed.
 
-For each app:
+Existing tokens in `.env.local` keep working. Skip the wizard for those
+agents unless you want a Cursor-managed app.
 
-1. **Install to Workspace** — copy Bot User OAuth Token (`xoxb-…`)
-2. **Basic Information → App-Level Tokens** — Create Token with scope `connections:write` → copy (`xapp-…`)
-
-### Phase 3 — Env (agent)
-
-Write into `.env.local` (dev app), using the keys from `env.example`:
-
-```bash
-MY_AGENT_SLACK_BOT_TOKEN=xoxb-…
-MY_AGENT_SLACK_APP_TOKEN=xapp-…
-```
+Then:
 
 ```bash
 agent-sdk slack doctor --prefix MY_AGENT
-```
-
-Stop when `app_token`, `connections_open`, `bot_token`, and `auth_test` are green.
-
-### Phase 4 — Serve + smoke (agent + human)
-
-```bash
 agent-sdk dev .
 ```
 
 Confirm log: `[agent-sdk/slack] Socket Mode connected`.
 
 When tokens are missing the channel logs
-`channel idle reason=missing credentials need=…` and `serve` continues — useful
-when mounting a folder of agents where only some have tokens.
+`channel idle reason=missing credentials need=…` and `serve` continues.
 
 Human:
 
@@ -249,6 +187,15 @@ Human:
    - `session start …`
    - `reply delivered via postMessage|stream …`
 
+The dashboard lists a first-run agent as **Not deployed yet**. Local
+serve does not need a hosted engine. The next `agent-sdk deploy` (or
+dashboard **Deploy**) injects the stored secrets.
+
+A second `slack create` for the same agent and env overwrites that Slack
+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.
+
 ## Features (defaults ON)
 
 - Chat streaming (`chat.startStream` / `appendStream` / `stopStream`) with postMessage fallback (Path B; Path A posts one final reply)
@@ -262,7 +209,7 @@ If a Slack API is unavailable (`method_not_found` / `missing_scope`), the pack f
 
 ## Engagement: mentions by default, channel watch opt-in (Path B only)
 
-The pack dispatches only on `app_mention` + DMs unless told otherwise —
+The pack dispatches only on `app_mention` + DMs unless told otherwise:
 summoned, never proactive. To watch channels (dispatch on new posts without
 a mention), opt in explicitly:
 
@@ -270,7 +217,7 @@ a mention), opt in explicitly:
 export default slackChannel({
   engagement: {
     channelPosts: {
-      allow: ["#issues-glass"], // explicit allowlist; no wildcard exists
+      allow: ["#issues-cursor-desktop"], // explicit allowlist; no wildcard exists
       posts: "top-level",       // default — thread replies never dispatch
       debounceMs: 15_000,       // optional: edits settle, deletes cancel
     },
@@ -279,9 +226,9 @@ export default slackChannel({
 });
 ```
 
-Requirements: generate manifests with `slack init --channel-posts` (or add
-`message.channels` / `message.groups` events + re-import), and invite the
-bot to each watched channel. Posts mentioning the bot stay on the
+Pass `--channel-posts` on `slack create` so the wizard-built app
+subscribes to `message.channels` / `message.groups`. Invite the bot to
+each watched channel. Posts mentioning the bot stay on the
 `app_mention` path; watch sessions reuse the thread-scoped principal with an
 `engagement: "channel_post"` attribute, so a later mention continues the
 thread. `engagement.mentions` / `engagement.directMessages` can be set to
@@ -290,7 +237,7 @@ thread. `engagement.mentions` / `engagement.directMessages` can be set to
 ## Tool approvals over Slack (opt-in HITL, Path B only)
 
 Tools with `needsApproval` park until a human approves or denies. To route
-that through Slack, set `toolApprovals: true` on `slackChannel` — it posts
+that through Slack, set `toolApprovals: true` on `slackChannel`. It posts
 Block Kit Approve/Deny cards and routes Socket Mode `interactive` clicks
 back to the parked call:
 
@@ -303,10 +250,9 @@ export default slackChannel({
 
 Requirements and caveats:
 
-- The Slack app manifest needs **interactivity** enabled
-  (`buildSlackManifest({ interactivity: true })`; `toolApprovals: true`
-  implies the Socket Mode routing, but the app must allow it). Re-import
-  the manifest after changing this.
+- The Slack app needs **interactivity** enabled. The wizard turns this
+  on when `toolApprovals` is in play; `buildSlackManifest({ interactivity: true })`
+  is the same switch for existing apps.
 - Composing by hand: spread `buildToolApprovalEvents({ credentials })` into
   `events` **and** set `interactivity: true` on the channel.
 - Cards show **redacted / truncated** args (Block Kit limits); execution
@@ -323,27 +269,23 @@ 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
+  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 /
+- Socket Mode / the Cursor relay are outbound only. No Events HTTP /
   Request URL path on either connection.
-- Do not `await waitForCompletion()` inside Slack dispatch handlers — the pack uses `waitUntil`.
+- 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
 
-`slack create` / `destroy` / `init` / `manifest` / `doctor` are Path B
-tooling; Path A needs only `login`.
+Path B tooling is `create` / `destroy` / `icon` / `doctor`. Path A needs
+only `login`. `slack setup` prints this chooser. `slack init` hard-errors.
 
 ```bash
 agent-sdk slack setup
-agent-sdk slack create --dir .                     # provision via Add to Slack (dev app)
+agent-sdk slack create --dir .                     # dashboard wizard (dev app)
 agent-sdk slack create --dir . --prod              # prod app
 agent-sdk slack create --dir . --slack-team T0123ABCD
 agent-sdk slack destroy --dir . [--prod] [--slack-team T0123ABCD]
-agent-sdk slack init --dir . --name "My Agent"
-agent-sdk slack init --dir . --no-prefix
-agent-sdk slack init --dir . --channel-posts   # + message.channels/groups events
-agent-sdk slack manifest --env both
 agent-sdk slack doctor --prefix MY_AGENT
 ```