@cursor/july 0.1.104 → 0.1.107

package/docs/guides/grokbot-agents.md

@@ -0,0 +1,93 @@
+---
+title: "Cursor Grok Bot agents"
+description: "Let an agent-sdk agent talk to your Grok Bot agents: mount the extension, name the bots it may reach, and decide what needs approval."
+---
+
+# Cursor Grok Bot agents
+
+The `cursor-grokbot-agents` extension lets an agent send a message to
+one of your Grok Bot agents and read the reply. The Grok Bot keeps its
+own conversation, memory, and tools. Your agent stays where it is and
+consults that bot the way you would in the Grok Bot app.
+
+This is different from moving this agent's turns onto a hosted Grok Bot.
+The extension keeps the agent where it is and lets it talk to *other*
+Grok Bot agents.
+
+## Mount it
+
+The extension ships with `@cursor/july`. Mount it with one file.
+
+```ts
+// agent/extensions/grokbot.ts
+import cursorGrokBotAgents from "@cursor/july/extensions/cursor-grokbot-agents";
+
+export default cursorGrokBotAgents({
+  agents: [
+    { name: "Plan Keeper", description: "Keeps or moves outdoor plans." },
+    { name: "Chief of Staff", description: "Routes work and tracks priorities." },
+  ],
+});
+```
+
+`agents` is the allowlist. List every Grok Bot the model may talk to;
+a name outside the list is refused. Calls run under the host's
+signed-in account (`agent-sdk login` or `CURSOR_API_KEY`). Keep
+approval on when you can't.
+
+Start from the [Grok Bot agents template](../templates/grokbot-agents.md)
+when you want a project that already mounts this.
+
+## What the agent can do
+
+With the extension mounted, the agent can consult a Grok Bot and stay
+in its own conversation:
+
+- **Ask.** Send a self-contained message to a Grok Bot by the name
+  shown in the Grok Bot app. The message lands in your conversation
+  with that bot. The tool waits for the bot's reply.
+- **Keep waiting.** A long turn returns `status: "running"`. Call check
+  with the same name to read what arrived since the last look.
+- **Stop a turn.** Interrupt the bot's current work. The conversation
+  stays; a later ask continues it.
+- **See who you can talk to.** List the configured bots and the ones
+  this caller has already asked. Add a name to `agents` when you want
+  the model to reach another bot.
+
+A skill teaches the model when to bring a Grok Bot in, how to write a
+message the bot can act on alone, and how to wait or interrupt. The
+reply is what the Grok Bot sent to the person. If a turn finishes with
+no reply, the bot sent nothing; ask again with a clearer request, or
+open the bot in the Grok Bot app.
+
+The tools reach Grok Bot agents on the signed-in account. A bot another
+user owns is out of reach. That separation is only as fine as your
+host's auth; a shared bearer token or `--allow-anonymous` makes every
+caller one principal, so use
+[authored auth](../reference/channels.md#auth-policies) when callers
+need their own.
+
+## Configure it
+
+| Option | What it controls |
+| --- | --- |
+| `agents` | The Grok Bot agents the model may talk to, by the name shown in the app. A lone entry is the default when a call names none. Omit `agents` to allow any name; an unknown name creates an empty Grok Bot on the account. |
+| `needsApproval` | Park asks for a [human decision](./human-in-the-loop.md). Defaults to `true` when no `agents` are configured, `false` otherwise. |
+| `apiKey` | A Cursor API key to call with instead of the host's own. |
+
+## Adjust it
+
+To take a capability away, such as interrupting a turn, mount as a
+directory and disable that tool; see
+[overlays](../reference/extensions.md#adjust-a-mounted-extension).
+
+## What's next
+
+Continue with these pages:
+
+- [Grok Bot agents template](../templates/grokbot-agents.md): scaffold
+  an agent that already mounts this
+- [Extensions](../reference/extensions.md): how mounts, namespaces, and
+  overrides work
+- [Human-in-the-loop approvals](./human-in-the-loop.md): where parked
+  asks get approved

package/docs/guides/opentelemetry.md

@@ -92,10 +92,9 @@ is `serve({ otel })` over `agent/otel.ts` over env. An empty
 `defineOtel()` still records traces; export starts when
 `OTEL_EXPORTER_OTLP_*` or a factory-returned `exporters` list appears.
 
-Hosted v2 binds deployment secrets after bake, onto the already-listening
-process. Pass a factory so flush can re-read them. Spans record from
-bake; the hosted handler flush constructs the OTLP client and sends the
-queued batch.
+Hosted deployments can bind secrets after startup. Pass a factory so
+flush can re-read them. The hosted handler constructs the OTLP client
+when it flushes and sends the queued batch.
 
 ```ts
 export default defineOtel(() => resolveMyOtelConfig());

package/docs/reference/channels.md

@@ -222,20 +222,16 @@ events. Declare `events` and handle each one in `onEvent`. Each event
 carries `deploySourceUri` and `deployVersion`. Author
 `agent/channels/deployments.ts` with `deploymentsChannel()`.
 
-Omit `deploySourceUris` on hosted v2. The control plane binds
-`deploy_source` edges from the deploy's watched `repositories` and the
-channel admits what it is sent, which is what makes it multi-tenant
-safe.
-
-Name sources to narrow below that scope, or to drive the self-hosted
-pull relay, which has no deploy scope to inherit. There, subscribe per
-deploy source with `deploySourceUris` and narrow with `environments` /
-`events`. Each entry must match `Deployment.deploy_source_uri` as your
-deployment writer records it; matching is case-insensitive but
+On Cursor-managed hosting, omit `deploySourceUris`. The deployment's
+watched repositories bind the event scope automatically. Name sources
+to narrow the scope or to drive the self-hosted pull relay. Subscribe
+per deploy source with `deploySourceUris` and narrow with `environments`
+or `events`. Each entry must match `Deployment.deploy_source_uri` as
+your deployment writer records it. Matching is case-insensitive but
 otherwise literal. It uses the host credential. A restart resumes
-rather than dropping events. An empty `deploySourceUris` list mounts
-the channel but starts no pull, so an env-configured agent stays inert
-until its deploy sources are set.
+rather than dropping events. An empty `deploySourceUris` list mounts the
+channel but starts no pull, so an env-configured agent stays inert until
+its deploy sources are set.
 
 **Change Monitors** (`@cursor/july/channels/change-monitors`): Change
 Monitor Checkpoint events. The channel publishes Factory
@@ -244,18 +240,14 @@ result (for example to the `issues` arm). The payload contains the
 full Checkpoint resource. This channel is scoped to Change Monitors,
 not generic Factory Checkpoints. There is no repository filter or
 resource filter. Author `agent/channels/change-monitors.ts` with
-`changeMonitorsChannel()`. It uses the host credential. The v1 omitted
-continuation is `none/v1`. A v2 agent defaults to
-`change_monitors.checkpoint/v2`, which keys the session as
-`cont:change_monitors:{checkpointName}`.
+`changeMonitorsChannel()`. It uses the host credential.
 
 **Issues** (`@cursor/july/channels/issues`): Factory issue events.
 The channel publishes `issue.created` for every Issue create. The
 agent filters if it needs a subset. The payload contains the full
 Issue resource. There is no repository filter or resource filter.
 Author `agent/channels/issues.ts` with `issuesChannel()`. It uses the
-host credential. The v1 omitted continuation is `none/v1`. A v2 agent
-defaults to `issues.issue/v2`, which keys the session by issue name.
+host credential.
 
 For other platforms like Discord or Teams, use the authored
 `defineChannel` webhook form.

package/docs/reference/cli.md

@@ -414,6 +414,7 @@ non-zero when the reconstructed trajectory failed.
 ```bash
 agent-sdk init ./my-agent          # scaffold package.json, tsconfig.json, agent/ + a demo tool
 agent-sdk init ./my-demo --template demo              # record a PR walkthrough
+agent-sdk init ./grokbot --template grokbot-agents    # talk to Grok Bot agents
 agent-sdk init ./code-wiki --template code-wiki       # keep wiki pages current after merge
 agent-sdk init ./agents-md --template agents-md       # keep AGENTS.md current from last week's PRs and Slack
 agent-sdk init ./my-reviewer --template security-reviewer   # review PRs for security bugs
@@ -435,7 +436,7 @@ agent-sdk init                     # no directory: print the setup guide
 Templates may ship `init.json`. On a TTY, `init` asks those questions
 before writing files. `code-wiki`, `pr-autofixer`, `security-help`, and
 `agents-md` ask for GitHub repos. `agents-md` also asks for Slack
-channels. Repeat
+channels. `grokbot-agents` asks for Grok Bot names. Repeat
 `--var id=value` to answer without a prompt.
 `--json` and non-TTY hosts skip the interview unless `--var` is set.
 
@@ -673,14 +674,17 @@ The command polls for up to ten minutes until the status reaches
 
 ## delete
 
-`delete` removes a deployment.
+`delete` removes a hosted deployment. You can delete a deployment that
+still runs. The command frees the slug. A later deploy can use the same
+name. Spend stays on the archived service account.
 
 ```bash
 agent-sdk delete <slug> [--team <id>] [--no-wait] [--json]
 ```
 
 The command waits until the deployment is gone. `--no-wait` returns after
-the delete request is accepted.
+the delete request is accepted. Architecture v2 slugs use the Agent SDK
+control plane. Architecture v1 slugs use the Agent Serve control plane.
 
 ## rotate-token
 

package/docs/reference/extensions.md

@@ -263,6 +263,8 @@ Continue with these pages:
 
 - [Cursor cloud agents](../guides/cloud-agents.md): the extension that
   lets an agent launch and steer cloud agents
+- [Cursor Grok Bot agents](../guides/grokbot-agents.md): the extension
+  that lets an agent talk to Grok Bot agents
 - [Tools](./tools.md): the tool contract extensions contribute to
 - [Skills](./skills.md): the skill forms an extension can carry
 - [Project layout](./project-layout.md): where `agent/extensions/` sits

package/docs/templates/grokbot-agents.md

@@ -0,0 +1,53 @@
+---
+title: "Talk to your Grok Bot agents"
+description: "Scaffold the agent, name the Grok Bot agents it may reach, and consult them from its own conversation."
+---
+
+# Talk to your Grok Bot agents
+
+This agent sends a message to a Grok Bot you already use and reads the
+reply. The Grok Bot keeps its conversation. This agent stays where it
+is.
+
+## Scaffold
+
+```bash
+npx @cursor/july init ./grokbot --template grokbot-agents
+```
+
+`init` asks for the names shown in the Grok Bot app. Every name is an
+allowlist entry. Pass `--var agents="Plan Keeper, Chief of Staff"` to
+skip the prompt.
+
+The names land in `agent/extensions/grokbot.ts`. A name outside that
+list is refused.
+
+## Log in
+
+Asks run under the signed-in account.
+
+```bash
+cd grokbot
+agent-sdk login
+agent-sdk dev
+```
+
+In the playground, ask it to talk to one of the names you entered.
+
+## What to edit
+
+- `agent/extensions/grokbot.ts`: who it may talk to. Add `needsApproval: true` to park each ask.
+- `agent/instructions.md`: when to consult them
+
+See [Cursor Grok Bot agents](../guides/grokbot-agents.md) for the
+extension, and [Human-in-the-loop approvals](../guides/human-in-the-loop.md)
+for where a parked ask gets approved.
+
+## Evals
+
+```bash
+agent-sdk eval
+```
+
+The smoke case asks who it can talk to. It must list the configured
+bots and not send a message.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cursor/july",
-  "version": "0.1.104",
+  "version": "0.1.107",
   "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": {
@@ -23,14 +23,16 @@
     "!dist/playground-central/**",
     "!dist/internal/tenant-mcp/**",
     "!dist/internal/grokbot/**",
-    "!dist/internal/review-comments.*",
+    "!dist/extensions/cursor-grokbot-agents/**",
+    "!dist/internal/review-comments*",
     "!dist/internal/shallow-clone.*",
     "!dist/internal/managed-delivery.*",
     "src/**/*",
     "!src/**/*.test.ts",
     "!src/internal/tenant-mcp/**",
     "!src/internal/grokbot/**",
-    "!src/internal/review-comments.ts",
+    "!src/extensions/cursor-grokbot-agents/**",
+    "!src/internal/review-comments*",
     "!src/internal/shallow-clone.ts",
     "!src/internal/managed-delivery.ts",
     "skills/**/*",
@@ -137,6 +139,13 @@
       "import": "./dist/extensions/cursor-cloud-agents/extension.js",
       "default": "./dist/extensions/cursor-cloud-agents/extension.js"
     },
+    "./extensions/cursor-grokbot-agents": {
+      "anysphere-source": "./src/extensions/cursor-grokbot-agents/extension.ts",
+      "bun": "./dist/extensions/cursor-grokbot-agents/extension.js",
+      "types": "./dist/extensions/cursor-grokbot-agents/extension.d.ts",
+      "import": "./dist/extensions/cursor-grokbot-agents/extension.js",
+      "default": "./dist/extensions/cursor-grokbot-agents/extension.js"
+    },
     "./schedules": {
       "anysphere-source": "./src/schedules.ts",
       "types": "./dist/schedules.d.ts",

package/skills/otel/SKILL.md

@@ -33,9 +33,9 @@ export default defineOtel({
 3. `serve(dir, { otel: { … } })`. `otel: false` disables env and
    authored config.
 
-Hosted v2 secrets arrive after bake. Use `defineOtel(() => …)` so flush
-re-resolves exporters. Authored `agent/otel.ts` records from process
-start even when the factory returns no exporters yet.
+Hosted secrets can arrive after startup. Use `defineOtel(() => …)` so
+flush re-resolves exporters. Authored `agent/otel.ts` records from
+process start even when the factory returns no exporters yet.
 
 | Signal | Default |
 | --- | --- |

package/src/bin/agent-serve.ts

@@ -341,9 +341,6 @@ Options:
                      the Cursor backend's per-forge forwarder instead of
                      minting raw tokens into this process
                      (AGENT_SERVE_<FORGE>_PROXY_URL overrides a base URL).
-  --cursor-github-proxy
-                     serve: deprecated alias for --cursor-scm-proxy; removed
-                     one release after --cursor-scm-proxy ships.
   --public-url       serve: base URL where this host is reachable from outside
                      (e.g. https://agent-serve.example.com). Required for peer
                      connections (defineConnection({ agent })) on cloud-runtime
@@ -519,7 +516,6 @@ async function main(argv: string[]): Promise<number> {
       "allow-anonymous-cursor-account-mcp": { type: "boolean", default: false },
       "allow-anonymous-grokbot": { type: "boolean", default: false },
       "cursor-scm-proxy": { type: "boolean", default: false },
-      "cursor-github-proxy": { type: "boolean", default: false },
       "no-schedules": { type: "boolean", default: false },
       "no-control-plane": { type: "boolean", default: false },
       "no-playground": { type: "boolean", default: false },
@@ -1353,11 +1349,7 @@ async function main(argv: string[]): Promise<number> {
             : undefined,
         allowAnonymousGrokbot:
           values["allow-anonymous-grokbot"] === true ? true : undefined,
-        cursorScmProxy:
-          values["cursor-scm-proxy"] === true ||
-          values["cursor-github-proxy"] === true
-            ? true
-            : undefined,
+        cursorScmProxy: values["cursor-scm-proxy"] === true ? true : undefined,
         schedules: values["no-schedules"] === true ? false : undefined,
         noControlPlane: values["no-control-plane"] === true ? true : undefined,
         playground: values["no-playground"] === true ? false : undefined,

package/src/channels/bitbucket/types.ts

@@ -229,10 +229,8 @@ export interface BitbucketChannelOptions {
    */
   webhookEvents?: readonly string[];
   /**
-   * Continuation selector. Omitted inherits {@link AgentConfig.architecture}:
-   * engine-minted per-PR continuation unless the agent set
-   * `architecture: "v2"` (then `bitbucket.pr/v2`, or `bitbucket.none/v2`
-   * when a non-PR event is declared).
+   * Continuation selector. Omit this to inherit the agent architecture's
+   * default. Set it explicitly only when migrating persisted identities.
    */
   continuation?: ContinuationIdentity;
   /**

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

@@ -25,6 +25,7 @@ const deploymentEventSchema = z.object({
   environment: z.string().min(1),
   service: z.string().min(1).optional(),
   deployVersion: z.string().min(1),
+  previousVersion: z.string().min(1).optional(),
   status: z.enum(["pending", "in_progress", "success", "failed"]),
   occurredAtMs: z.number(),
 });

package/src/channels/deployments/types.ts

@@ -28,6 +28,8 @@ export interface DeploymentEvent {
   /** Absent when the deployment records no service. */
   service?: string;
   deployVersion: string;
+  /** Last succeeded different SHA; omitted on the first ship. */
+  previousVersion?: string;
   status: DeploymentStatus;
   occurredAtMs: number;
 }
@@ -54,10 +56,9 @@ export interface DeploymentsChannelOptions {
    * and then receives nothing. A bare string takes the default environment and
    * event filters.
    *
-   * Omit on hosted v2. The control plane then binds `deploy_source` edges
-   * from the deploy's watched `repositories` and the channel admits what it
-   * is sent. That is the multi-tenant shape: an agent cannot enumerate
-   * sources for a tenant it has never seen.
+   * Omit on Cursor-managed hosting. The control plane binds sources from the
+   * deployment's watched repositories, and the channel admits only what it
+   * receives. An agent cannot enumerate sources for an unseen tenant.
    *
    * Name sources to narrow below that scope, or to drive the self-hosted
    * relay, which has no deploy scope to inherit. On that wire `[]` means
@@ -87,10 +88,8 @@ export interface DeploymentsChannelOptions {
   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 selector. Omit this to inherit the agent architecture's
+   * default. Set it explicitly only when migrating persisted identities.
    */
   continuation?: ContinuationIdentity;
 }

package/src/channels/github/types.ts

@@ -480,10 +480,8 @@ export interface GitHubChannelOptions {
    */
   botName?: string;
   /**
-   * Continuation selector. Omitted inherits {@link AgentConfig.architecture}:
-   * `"github.pr/v1"` unless the agent set `architecture: "v2"` (then
-   * `"github.pr/v2"`). Override type with `"github.issue/v2"` or
-   * `"github.none/v2"` for events outside PR membership.
+   * Continuation selector. Omit this to inherit the agent architecture's
+   * default. Set it explicitly only when migrating persisted identities.
    */
   continuation?: ContinuationIdentity;
   /**

package/src/channels/gitlab/types.ts

@@ -219,11 +219,8 @@ export interface GitLabChannelOptions {
    */
   webhookEvents?: readonly string[];
   /**
-   * Continuation selector. Omitted inherits {@link AgentConfig.architecture}:
-   * engine-minted per-MR continuation unless the agent set
-   * `architecture: "v2"` (then `gitlab.mr/v2`, or `gitlab.none/v2` when a
-   * non-MR event is declared). Override with `"gitlab.none/v2"` for one-shot
-   * events.
+   * Continuation selector. Omit this to inherit the agent architecture's
+   * default. Set it explicitly only when migrating persisted identities.
    */
   continuation?: ContinuationIdentity;
   /**

package/src/channels/origin/types.ts

@@ -246,9 +246,8 @@ export interface OriginChannelOptions {
    */
   webhookEvents?: readonly string[];
   /**
-   * Continuation selector. Omitted inherits {@link AgentConfig.architecture}:
-   * `"origin.pr/v1"` unless the agent set `architecture: "v2"` (then
-   * `"origin.pr/v2"`). Override with `"origin.none/v2"` for one-shot events.
+   * Continuation selector. Omit this to inherit the agent architecture's
+   * default. Set it explicitly only when migrating persisted identities.
    */
   continuation?: ContinuationIdentity;
   /**

package/src/channels/slack/defaults.ts

@@ -362,6 +362,9 @@ export function buildDefaultEvents(
       channel.state.streamTs = null;
       channel.state.streamChannelId = null;
       channel.state.streamFull = false;
+      // A stream failure downgrades the rest of its own turn, not the thread.
+      channel.state.streamingUnavailable = false;
+      channel.state.streamAppendedChunks = 0;
       channel.state.lastPostedText = null;
       channel.state.streamBlockText = null;
       channel.state.reasoningCard = undefined;

package/src/channels/slack/dispatch.ts

@@ -132,6 +132,7 @@ export function emptySlackChannelState(
     lastBotMessageTs: null,
     streamingUnavailable: false,
     streamFull: false,
+    streamAppendedChunks: 0,
     progressTs: null,
     approvalMessageByCallId: {},
     reasoningCard: undefined,

package/src/channels/slack/live-delivery.ts

@@ -147,6 +147,7 @@ export function createStreamDeliveryStrategy(
     channel.state.streamTs = started.ts;
     channel.state.streamChannelId = started.channel;
     channel.state.streamFull = false;
+    channel.state.streamAppendedChunks = 0;
     channel.state.lastPostedText = openingText;
     channel.state.streamBlockText = openingText;
     log.info("chat.startStream ok", {
@@ -193,6 +194,21 @@ export function createStreamDeliveryStrategy(
       highlightCodeFences(text)
     );
 
+  /**
+   * The reply does not extend what the stream already holds, so there is no
+   * delta to append and the text on Slack is not the reply.
+   */
+  const rewound = (channel: SlackChannel, text: string): boolean =>
+    streamDelta(channel, text) === "" &&
+    !highlightCodeFences(text).startsWith(
+      highlightCodeFences(channel.state.streamBlockText ?? "")
+    );
+
+  const countAppended = (channel: SlackChannel, chunks: number): void => {
+    channel.state.streamAppendedChunks =
+      (channel.state.streamAppendedChunks ?? 0) + chunks;
+  };
+
   const stopWithSuffix = async (args: {
     channel: SlackChannel;
     channelId: string;
@@ -246,25 +262,25 @@ export function createStreamDeliveryStrategy(
   };
 
   /**
-   * The streamed message is full. Close it as it stands so it stops spinning
-   * and post the rest as a new thread message. Most of the answer is on Slack
-   * either way, so the reply counts as delivered even if that post fails: a
-   * duplicate would be worse than a lost tail.
+   * The open stream cannot carry the rest of the reply — it is full, or the
+   * reply no longer extends what it holds. Close it as it stands so it stops
+   * spinning and post the remainder as a new thread message.
    */
-  const continueOverflow = async (args: {
+  const continueInNewMessage = async (args: {
     channel: SlackChannel;
     channelId: string;
     ts: string;
     remainder: string;
+    reason: string;
     sessionId: string;
-  }): Promise<void> => {
-    const { channel, channelId, ts, remainder, sessionId } = args;
+  }): Promise<boolean> => {
+    const { channel, channelId, ts, remainder, reason, sessionId } = args;
     const log = getLog();
     await stopChatStream({ botToken, channel: channelId, ts });
     channel.state.streamTs = null;
     const threadTs = channel.state.threadTs;
     if (remainder === "" || threadTs === null || threadTs === "") {
-      return;
+      return true;
     }
     try {
       const posted = await postMessage({
@@ -275,19 +291,23 @@ export function createStreamDeliveryStrategy(
         plainText: remainder.length >= SLACK_MARKDOWN_TEXT_MAX_LEN,
       });
       channel.state.lastBotMessageTs = posted.ts;
-      log.info("reply overflowed the stream; continued in a new message", {
+      log.info("reply continued in a new message", {
+        reason,
         channel: channelId,
         stream_ts: ts,
         session: sessionId,
         continued_chars: remainder.length,
       });
+      return true;
     } catch (error) {
-      log.warn("stream overflow continuation failed", {
+      log.warn("stream continuation failed", {
+        reason,
         error: error instanceof Error ? error.message : String(error),
         channel: channelId,
         stream_ts: ts,
         session: sessionId,
       });
+      return false;
     }
   };
 
@@ -328,6 +348,7 @@ export function createStreamDeliveryStrategy(
         noteAppendFailure(channel, result);
         return;
       }
+      countAppended(channel, 1);
       channel.state.lastPostedText = text;
       channel.state.streamBlockText = text;
     },
@@ -364,8 +385,10 @@ export function createStreamDeliveryStrategy(
           chunks: chunks.length,
         });
         noteAppendFailure(channel, result);
+        return false;
       }
-      return result.ok;
+      countAppended(channel, chunks.length);
+      return true;
     },
 
     async finalize({ channel, channelId, text, sessionId }) {
@@ -381,6 +404,22 @@ export function createStreamDeliveryStrategy(
       }
       // Measured before the stop attempt mutates stream state.
       const remainder = streamDelta(channel, text);
+      // Nothing to append and the stream does not hold the reply: closing it
+      // here would leave the answer nowhere and report it as delivered.
+      if (rewound(channel, text)) {
+        const posted = await continueInNewMessage({
+          channel,
+          channelId,
+          ts,
+          remainder: text,
+          reason: "rewound",
+          sessionId,
+        });
+        if (posted) {
+          channel.state.lastPostedText = text;
+        }
+        return { delivered: posted };
+      }
       const stopped =
         channel.state.streamFull === true
           ? { ok: false, error: "msg_too_long" }
@@ -391,15 +430,17 @@ export function createStreamDeliveryStrategy(
           stream_ts: ts,
           session: sessionId,
           chars: text.length,
+          appends: channel.state.streamAppendedChunks ?? 0,
         });
         return { delivered: true };
       }
       if (stopped.error === "msg_too_long") {
-        await continueOverflow({
+        await continueInNewMessage({
           channel,
           channelId,
           ts,
           remainder,
+          reason: "msg_too_long",
           sessionId,
         });
         channel.state.lastPostedText = text;

package/src/channels/slack/types.ts

@@ -81,6 +81,8 @@ export interface SlackChannelState {
   streamingUnavailable?: boolean;
   /** The open stream hit Slack's size cap; appends stop until it closes. */
   streamFull?: boolean;
+  /** Chunks Slack accepted on the open stream, reported when it closes. */
+  streamAppendedChunks?: number;
   /** Editable progress message ts when `chat.startStream` is unavailable. */
   progressTs: string | null;
   /**
@@ -597,9 +599,8 @@ export interface SlackAccessPolicy {
 export interface SlackChannelOptions {
   credentials?: SlackCredentials;
   /**
-   * Continuation selector. Omitted inherits {@link AgentConfig.architecture}:
-   * `"slack.thread/v1"` unless the agent set `architecture: "v2"` (then
-   * `"slack.thread/v2"`). Override with `"slack.none/v2"` for one-shot events.
+   * Continuation selector. Omit this to inherit the agent architecture's
+   * default. Set it explicitly only when migrating persisted identities.
    */
   continuation?: ContinuationIdentity;
   /** Defaults to `{ respondTo: "thread", blockExternals: true }`. */