@cursor/july 0.1.90 → 0.1.92

package/skills/framework-map/SKILL.md

@@ -16,6 +16,9 @@ over HTTP/Slack/GitHub channels, with the Cursor SDK + harness as the
 execution engine. Ground truth is the package `README.md` (full reference)
 and `AGENTS.md` (coding-agent loop) — this skill is the map, not the spec.
 
+Public docs index: `node_modules/@cursor/july/dist/docs/llms.txt`. A running
+host serves the same index at `/docs/llms.txt`.
+
 Run the CLI as `agent-sdk <cmd>`. In the everysphere monorepo there is no
 installed bin — use:
 
@@ -77,10 +80,11 @@ the serve host; `runtime: "cloud"` runs them on Cursor cloud agents
 
 | Capability | local | cloud |
 | --- | --- | --- |
-| Server tools (`execution: "server"`), approvals | yes | **no** |
+| Server tools (`execution: "server"`) | yes | yes on managed hosting; self-hosted needs `--public-url` |
+| Tool approvals | yes | no |
 | Agent tools (`execution: "agent"` scripts) | yes | yes |
-| Skills | yes | yes (Agent Store native discovery) |
-| sandbox seeds | yes | only if in the cloud repo |
+| Skills | yes | yes |
+| sandbox seeds | yes | no |
 | Instructions | `AGENTS.md` in session workspace | prepended to first prompt |
 | Checkout of a repo/PR | you arrange it | the VM carries it |
 
@@ -93,9 +97,8 @@ scale, use cloud and keep the host to routing, briefs, and bookkeeping.
 
 Two handles, two owners:
 
-- **continuationToken** — channel-owned conversation key. Same token =
-  same durable session (a Slack `channelId:threadTs`, a `pr:owner/repo#N`).
-  Rotates on each accepted HTTP follow-up; stale tokens get `409`.
+- **continuationToken:** credential for continuing a conversation. HTTP
+  follow-ups rotate it; stale tokens get `409`.
 - **sessionId** — runtime-owned handle for streaming/inspection
   (`GET /v1/session/:id/stream?startIndex=N`, durable NDJSON replay).
 

package/skills/github/SKILL.md

@@ -9,6 +9,9 @@ description: >-
 
 # GitHub channels in the Agent SDK
 
+Public docs index: `node_modules/@cursor/july/dist/docs/llms.txt`. A running
+host serves the same index at `/docs/llms.txt`.
+
 Author `agent/channels/github.ts` with `githubChannel()` from
 `@cursor/july/channels/github`. It mounts
 `POST /<slug>/v1/channels/github` and publishes the events it dispatches on

package/skills/hillclimb/SKILL.md

@@ -11,6 +11,9 @@ paths:
 
 # Agent SDK hillclimb
 
+Public docs index: `node_modules/@cursor/july/dist/docs/llms.txt`. A running
+host serves the same index at `/docs/llms.txt`.
+
 Optimize one Agent SDK agent project
 with a tight measure → change → remeasure loop. Do not redesign the
 whole framework; climb one concrete failure mode at a time. Sibling skills:

package/skills/mcp-auth/SKILL.md

@@ -8,6 +8,9 @@ description: >-
 
 # Host MCP OAuth (mcp auth)
 
+Public docs index: `node_modules/@cursor/july/dist/docs/llms.txt`. A running
+host serves the same index at `/docs/llms.txt`.
+
 Use this skill when a human asks to authorize a remote MCP server on an
 Agent SDK host, store credentials for Cursor-managed hosting, or debug
 `host.mcp` auth failures for `oauth: true` connections.

package/skills/otel/SKILL.md

@@ -8,6 +8,9 @@ description: >-
 
 # Agent SDK OpenTelemetry (`defineOtel`)
 
+Public docs index: `node_modules/@cursor/july/dist/docs/llms.txt`. A running
+host serves the same index at `/docs/llms.txt`.
+
 Push session, turn, tool, and subagent traces, plus token and cost
 metrics, from the serve process to an OTLP collector. Logs are off
 until you opt in.

package/skills/setup-slack/SKILL.md

@@ -9,6 +9,9 @@ description: >-
 
 # Setup Slack for the Agent SDK
 
+Public docs index: `node_modules/@cursor/july/dist/docs/llms.txt`. A running
+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**:
@@ -303,7 +306,7 @@ a mention), opt in explicitly:
 export default slackChannel({
   engagement: {
     channelPosts: {
-      allow: ["#issues-cursor-desktop"], // explicit allowlist; no wildcard exists
+      allow: ["#issues-cursor-desktop"], // use ["*"] for every joined channel
       posts: "top-level",       // default — thread replies never dispatch
       debounceMs: 15_000,       // optional: edits settle, deletes cancel
     },

package/src/channels/slack/channel-watch.ts

@@ -2,7 +2,7 @@
  * Opt-in channel watch: dispatch on posts in allowlisted channels.
  *
  * Filtering rules (the anti-slop guarantees):
- * - Only explicitly allowlisted channels are watched — no wildcard.
+ * - Only configured channels are watched; `"*"` opts into every channel.
  * - Top-level posts only by default; thread replies never dispatch unless
  *   `posts: "all"` is configured.
  * - Posts that @mention the bot are skipped here (the `app_mention` path

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

@@ -233,7 +233,7 @@ export function slackChannel<const Name extends string = string>(
     const entries = channelPosts.allow.filter((entry) => entry.trim() !== "");
     if (entries.length === 0) {
       throw new Error(
-        "slackChannel engagement.channelPosts.allow must list at least one channel (id or #name); there is no wildcard watch."
+        'slackChannel engagement.channelPosts.allow must list at least one channel (id, #name, or "*").'
       );
     }
   }

package/src/channels/slack/types.ts

@@ -324,10 +324,8 @@ export type SlackBlockActionHandler = (
   | Promise<SlackDispatchDecision | null | undefined>;
 
 /**
- * Opt-in channel watch: dispatch on posts in explicitly allowlisted
- * channels without requiring an @mention. There is deliberately no
- * "every channel the bot is in" wildcard — watching a channel is a
- * per-channel decision.
+ * Opt-in channel watch: dispatch on posts in configured channels without an
+ * @mention. Use `"*"` for every channel the bot has joined.
  */
 export interface SlackChannelPostsOptions {
   /**

package/src/internal/cli-deploy.ts

@@ -28,6 +28,7 @@ import { readDeployTemplate } from "./cursor-agent-template.js";
 import {
   type AgentkitDeployAccepted,
   type AgentkitDeployStatus,
+  type AgentkitStopAccepted,
   AgentServeDeployClient,
   type DeleteAccepted,
   type DeployAccepted,
@@ -1187,11 +1188,25 @@ export async function cmdStop(
   if (typeof ctx === "number") {
     return ctx;
   }
-  let accepted: StopAccepted;
+  // Stop takes only a slug, so there is no manifest to dispatch on (unlike
+  // deploy). The v2 agentkit control plane goes first: v1 endpoints refuse
+  // `architecture: "v2"` slugs with a 409 rather than a 404, so v1-first
+  // could not fall through. A v2 404 (including an older backend without
+  // the agentkit mount) falls back to the v1 stop.
+  let architecture: "v1" | "v2" = "v2";
+  let accepted: StopAccepted | AgentkitStopAccepted;
   try {
-    accepted = await ctx.client.stopDeployment({ teamId: ctx.teamId, slug });
+    accepted = await ctx.client.stopAgentkit({ teamId: ctx.teamId, slug });
   } catch (error) {
-    return renderApiError(error, ctx.err);
+    if (!(error instanceof DeployApiError) || error.status !== 404) {
+      return renderApiError(error, ctx.err);
+    }
+    try {
+      accepted = await ctx.client.stopDeployment({ teamId: ctx.teamId, slug });
+      architecture = "v1";
+    } catch (v1Error) {
+      return renderApiError(v1Error, ctx.err);
+    }
   }
   if (ctx.noWait) {
     if (ctx.json) {
@@ -1201,11 +1216,16 @@ export async function cmdStop(
     }
     return 0;
   }
-  let detail: DeploymentDetail;
+  let detail: DeploymentDetail | AgentkitDeployStatus;
   try {
-    detail = await pollUntil(ctx, slug, new Set(["stopped"]), () =>
-      ctx.client.getDeployment({ teamId: ctx.teamId, slug })
-    );
+    detail =
+      architecture === "v2"
+        ? await pollUntil(ctx, slug, new Set(["stopped"]), () =>
+            ctx.client.getAgentkitDeploy({ teamId: ctx.teamId, slug })
+          )
+        : await pollUntil(ctx, slug, new Set(["stopped"]), () =>
+            ctx.client.getDeployment({ teamId: ctx.teamId, slug })
+          );
   } catch (error) {
     return renderApiError(error, ctx.err);
   }

package/src/internal/cursor-agent-template.ts

@@ -6,6 +6,7 @@ const TEMPLATE_NAMES = [
   "agentic-owners",
   "demo",
   "pr-autofixer",
+  "security-help",
   "security-reviewer",
   "triage-linear",
   "triage-jira",

package/src/internal/deploy-client.ts

@@ -255,6 +255,17 @@ export interface AgentkitDeployStatus {
 export const TERMINAL_AGENTKIT_DEPLOY_STATUSES: ReadonlySet<AgentkitCustomerStatus> =
   new Set(["running", "failed", "stopped"]);
 
+/**
+ * `POST /internal/agentkit/deployments/:slug/stop` 202 body. Like v1
+ * {@link StopAccepted} but keyed by catalog ids instead of the numeric
+ * deployment row id.
+ */
+export interface AgentkitStopAccepted {
+  applicationId: string;
+  releaseId: string;
+  status: string;
+}
+
 /** One secret's metadata from the list endpoint — names only, never values. */
 export interface SecretInfo {
   name: string;
@@ -332,6 +343,14 @@ const agentkitDeployStatusSchema = z
   })
   .passthrough();
 
+const agentkitStopAcceptedSchema = z
+  .object({
+    applicationId: z.string().min(1),
+    releaseId: z.string().min(1),
+    status: z.string(),
+  })
+  .passthrough();
+
 const deploymentSchema = z.object({
   id: z.number(),
   slug: z.string(),
@@ -602,6 +621,22 @@ export class AgentServeDeployClient {
     return agentkitDeployStatusSchema.parse(raw);
   }
 
+  /**
+   * Stop a v2 deployment (`POST /internal/agentkit/deployments/:slug/stop`).
+   * 202 means accepted; poll {@link getAgentkitDeploy} until `stopped`.
+   */
+  async stopAgentkit(args: {
+    teamId: number;
+    slug: string;
+  }): Promise<AgentkitStopAccepted> {
+    const raw = await this.request({
+      method: "POST",
+      path: `/internal/agentkit/deployments/${encodeURIComponent(args.slug)}/stop?teamId=${args.teamId}`,
+      context: { verb: "stop", slug: args.slug },
+    });
+    return agentkitStopAcceptedSchema.parse(raw);
+  }
+
   async listDeployments(args: { teamId: number }): Promise<Deployment[]> {
     const raw = await this.request({
       method: "GET",
@@ -888,8 +923,12 @@ function mapErrorResponse(
       );
     }
     case 409:
+      // The server's 409 body distinguishes real conflicts (CAS races,
+      // "still deploying", architecture-v2 slugs on the v1 surface); keep
+      // its message when present.
       return new DeployApiError(
-        `A concurrent deploy or stop is changing deployment${slugPart}; retry in a moment.`,
+        serverError ??
+          `A concurrent deploy or stop is changing deployment${slugPart}; retry in a moment.`,
         409
       );
     case 429: {

package/src/internal/deploy-manifest.ts

@@ -40,7 +40,10 @@ import {
   handshakeChannelContinuation,
 } from "./continuation-channel.js";
 import { CONTINUATION_SELECTORS } from "./continuation-identity.js";
-import { projectInfo } from "./discovery.js";
+import {
+  projectInfo,
+  runtimeArchitectureCompatibilityError,
+} from "./discovery.js";
 import { packageVersion } from "./distribution.js";
 
 export const DEPLOY_MANIFEST_VERSION: 1 = 1;
@@ -125,6 +128,12 @@ export function buildAgentDeployManifest(
   project: AgentProject,
   options?: { nowMs?: number; cliVersion?: string }
 ): AgentDeployManifestV1 {
+  const runtimeArchitectureError = runtimeArchitectureCompatibilityError(
+    project.agent
+  );
+  if (runtimeArchitectureError !== undefined) {
+    throw new Error(runtimeArchitectureError);
+  }
   applyAgentContinuationDefaults(project);
   const channels = project.channels.map((channel) => {
     const handshake = handshakeChannelContinuation(channel);

package/src/internal/discovery.ts

@@ -524,6 +524,17 @@ async function loadAgent(
   const hosting = resolveHosting(ctx, agentDir, config?.hosting);
   const concurrency = resolveConcurrency(ctx, agentDir, config?.concurrency);
   const architecture = resolveArchitecture(ctx, agentDir, config?.architecture);
+  const runtimeArchitectureError = runtimeArchitectureCompatibilityError({
+    runtime,
+    architecture,
+  });
+  if (runtimeArchitectureError !== undefined) {
+    ctx.diagnostics.push({
+      severity: "error",
+      path: displayPath(ctx, join(agentDir, "agent.ts")),
+      message: runtimeArchitectureError,
+    });
+  }
 
   if (runtime === "cloud") {
     warnCloudRuntimeLimitations(ctx, agentDir, {
@@ -570,6 +581,15 @@ async function loadAgent(
   };
 }
 
+export function runtimeArchitectureCompatibilityError(agent: {
+  runtime: AgentRuntime;
+  architecture?: AgentArchitecture;
+}): string | undefined {
+  return agent.architecture === "v2" && agent.runtime === "grokbot"
+    ? 'architecture: "v2" cannot use runtime: "grokbot": the grokbot runtime executes through the signed-in account\'s hosted /v0/grokbot box, not a deployment-scoped v2 runtime.'
+    : undefined;
+}
+
 function resolveArchitecture(
   ctx: DiscoveryContext,
   agentDir: string,

package/src/internal/http-channel.ts

@@ -7,8 +7,8 @@
  * Continuation semantics: `POST /v1/session` returns a `continuationToken`;
  * each accepted follow-up rotates it and returns the replacement, and a
  * stale token is rejected with 409. Follow-ups address any chat session by
- * id (including custom channels such as `drive`) when the token matches
- * that session's channel + key; task sessions stay fire-and-forget.
+ * id (including custom channels such as `drive`) when the token matches its
+ * active HTTP follow-up key; task sessions stay fire-and-forget.
  */
 
 import type {
@@ -20,11 +20,7 @@ import type {
   SessionRecord,
 } from "../types.js";
 import { samePrincipal } from "./auth.js";
-import {
-  formatContinuationToken,
-  newContinuationKey,
-  parseContinuationToken,
-} from "./ids.js";
+import { formatContinuationToken, parseContinuationToken } from "./ids.js";
 import { isLoopbackAddress } from "./net.js";
 import type { ServerRoute } from "./router.js";
 import {
@@ -32,7 +28,6 @@ import {
   ApprovalNotFoundError,
   HTTP_CHANNEL_ID,
   SessionAuthError,
-  SessionBusyError,
   type SessionEngine,
 } from "./session-engine.js";
 import {
@@ -143,10 +138,8 @@ export function buildHttpChannelRoutes(args: {
           `Unknown session ${sessionId}.`
         );
       }
-      // Playground (and other HTTP clients) may follow up on any chat
-      // session — including custom channels like `drive` — using that
-      // session's own continuation token. Task/schedule sessions stay
-      // fire-and-forget.
+      // HTTP can follow any chat session. Its credential is separate from the
+      // owning channel's continuation key.
       if (record.mode === "task") {
         return errorResponse(
           409,
@@ -178,12 +171,7 @@ export function buildHttpChannelRoutes(args: {
         );
       }
       const presented = parseContinuationToken(body.continuationToken);
-      if (
-        presented === null ||
-        presented.channelId !== record.channelId ||
-        record.continuationKey === null ||
-        presented.key !== record.continuationKey
-      ) {
+      if (presented === null) {
         return errorResponse(
           409,
           "stale_continuation_token",
@@ -192,34 +180,19 @@ export function buildHttpChannelRoutes(args: {
       }
 
       const message = await transformMessage(body.message, ctx.auth);
-      try {
-        // Continue as the session owner after the HTTP ownership gate so
-        // `--dev` relaxed reads can follow up on channel-owned sessions
-        // (drive/slack/…) without failing SessionAuthError.
-        await engine.send(record.channelId, message, {
-          auth: record.auth,
-          continuationToken: record.continuationKey,
-        });
-      } catch (error) {
-        if (error instanceof SessionBusyError) {
-          return errorResponse(
-            409,
-            "session_busy",
-            "A turn is already running; wait for session.waiting before sending a follow-up."
-          );
-        }
-        throw error;
+      const rotated = await engine.followUpHttp(sessionId, presented, message);
+      if (rotated === undefined) {
+        return errorResponse(
+          409,
+          "stale_continuation_token",
+          "The continuation token does not address this session's active continuation."
+        );
       }
-
-      // Rotate only after the message is accepted so a rejected send leaves
-      // the caller's token valid for retry.
-      const rotated = newContinuationKey();
-      await engine.setContinuationToken(sessionId, rotated);
       return jsonResponse(
         {
           ok: true,
           sessionId,
-          continuationToken: formatContinuationToken(record.channelId, rotated),
+          continuationToken: formatContinuationToken(HTTP_CHANNEL_ID, rotated),
         },
         { headers: { [SESSION_ID_HEADER]: sessionId } }
       );

package/src/internal/init-project.ts

@@ -76,6 +76,7 @@ const TEMPLATES: Readonly<Record<TemplateName, TemplateEntry>> = {
   "agentic-owners": { dir: "agentic-owners" },
   demo: { dir: "demo" },
   "pr-autofixer": { dir: "pr-autofixer" },
+  "security-help": { dir: "security-help" },
   "security-reviewer": { dir: "security-reviewer" },
   "triage-linear": { dir: "triage", overlay: "linear" },
   "triage-jira": { dir: "triage", overlay: "jira" },
@@ -709,6 +710,7 @@ Scaffold a project, then open the playground:
   npx ${PACKAGE_NAME} init ./my-agent   # installs deps + links agent-sdk onto PATH
   npx ${PACKAGE_NAME} init ./my-demo --template demo              # record a PR walkthrough
   npx ${PACKAGE_NAME} init ./my-reviewer --template security-reviewer   # review PRs for security bugs
+  npx ${PACKAGE_NAME} init ./security-help --template security-help   # answer security questions in Slack
   npx ${PACKAGE_NAME} init ./my-triage --template triage-linear   # comment on Linear issues
   npx ${PACKAGE_NAME} init ./my-triage --template triage-jira     # comment on Jira issues
   npx ${PACKAGE_NAME} init ./my-owners --template agentic-owners  # review PRs via owners policies

package/src/internal/init-scaffold.ts

@@ -103,6 +103,7 @@ Run the CLI under Node, never Bun.
 - Package loop: \`node_modules/${PACKAGE_NAME}/AGENTS.md\`
 - Skills: \`node_modules/${PACKAGE_NAME}/skills/\` (\`create-agent\`, \`evals\`, \`hillclimb\`, \`debug\`)
 - Docs: \`npx ${PACKAGE_NAME} docs\`
+- LLM docs index: \`node_modules/${PACKAGE_NAME}/dist/docs/llms.txt\`
 `;
 }
 

package/src/internal/playground/static.ts

@@ -27,6 +27,7 @@ const ASSETS_DIR = join(DIST_DIR, "assets");
 export const STATIC_CONTENT_TYPES: Record<string, string> = {
   ".html": "text/html; charset=utf-8",
   ".js": "text/javascript; charset=utf-8",
+  ".md": "text/markdown; charset=utf-8",
   ".mjs": "text/javascript; charset=utf-8",
   ".css": "text/css; charset=utf-8",
   ".map": "application/json; charset=utf-8",
@@ -41,6 +42,7 @@ export const STATIC_CONTENT_TYPES: Record<string, string> = {
   ".woff": "font/woff",
   ".woff2": "font/woff2",
   ".ttf": "font/ttf",
+  ".txt": "text/plain; charset=utf-8",
 };
 
 /** Whether `pnpm run build:playground` has produced the SPA bundle. */

package/src/internal/session-engine.ts

@@ -925,6 +925,51 @@ export class SessionEngine {
     return this.channelSession(record.sessionId, record, true, false, since);
   }
 
+  /**
+   * Atomically validate and rotate an HTTP follow-up credential, then admit
+   * the message to its exact session without changing the owning channel key.
+   */
+  async followUpHttp(
+    sessionId: string,
+    token: { channelId: string; key: string },
+    message: string
+  ): Promise<string | undefined> {
+    const next = newContinuationKey();
+    const stale = new Error("stale HTTP continuation");
+    let previous: string | undefined;
+    try {
+      await this.updateRecord(sessionId, (record) => {
+        const expectedChannel =
+          record.httpContinuationKey === undefined
+            ? record.channelId
+            : HTTP_CHANNEL_ID;
+        const expectedKey =
+          record.httpContinuationKey ?? record.continuationKey;
+        if (token.channelId !== expectedChannel || token.key !== expectedKey) {
+          throw stale;
+        }
+        previous = record.httpContinuationKey;
+        return { ...record, httpContinuationKey: next };
+      });
+    } catch (error) {
+      if (error === stale) {
+        return undefined;
+      }
+      throw error;
+    }
+    try {
+      await this.startTurn(sessionId, message);
+      return next;
+    } catch (error) {
+      await this.updateRecord(sessionId, (record) =>
+        record.httpContinuationKey === next
+          ? { ...record, httpContinuationKey: previous }
+          : record
+      );
+      throw error;
+    }
+  }
+
   /** Whether a continuation token already maps to a session on this channel. */
   async hasContinuationSession(
     channelId: string,
@@ -2339,14 +2384,12 @@ export class SessionEngine {
       tools[tool.name] = {
         description: tool.description,
         inputSchema: tool.inputSchema as SDKCustomTool["inputSchema"],
-        // `SDKCustomTool.outputSchema` ships in the next published
-        // @cursor/sdk; the conditional spread carries the field through the
-        // pinned SDK's type until the dependency bumps, at which point local
-        // runs start advertising it.
         ...(tool.outputSchema === undefined
           ? {}
-          : { outputSchema: tool.outputSchema }),
-        // Same pinned-SDK carry for `SDKCustomTool.annotations`: an advertised
+          : {
+              outputSchema: tool.outputSchema as SDKCustomTool["outputSchema"],
+            }),
+        // Pinned-SDK carry for `SDKCustomTool.annotations`: an advertised
         // MCP passthrough's server-declared hints (bounded at listing time)
         // ride into the harness listing once the dependency bumps.
         ...(tool.annotations === undefined
@@ -3315,12 +3358,17 @@ export class SessionEngine {
           createdAt: record.createdAt,
           updatedAt: record.updatedAt,
           continuationToken:
-            record.continuationKey === null
-              ? null
-              : formatContinuationToken(
-                  record.channelId,
-                  record.continuationKey
-                ),
+            record.httpContinuationKey !== undefined
+              ? formatContinuationToken(
+                  HTTP_CHANNEL_ID,
+                  record.httpContinuationKey
+                )
+              : record.continuationKey === null
+                ? null
+                : formatContinuationToken(
+                    record.channelId,
+                    record.continuationKey
+                  ),
           externalUrl: links.slack ?? links.github,
           prUrl: links.github,
         };
@@ -3606,8 +3654,8 @@ export class SessionEngine {
       ...current,
       continuationKey: token,
     }));
-    // Keep armed reminders addressed at the conversation across rotation
-    // (the built-in HTTP channel rotates after every follow-up).
+    // Keep armed reminders addressed at the conversation across channel
+    // continuation rotation.
     if (
       previous?.continuationKey != null &&
       token !== null &&

package/src/types.ts

@@ -1201,10 +1201,8 @@ export type ConnectionConfig = (
    *
    * Derive the identity from durable session facts — `session.auth`,
    * `session.id`, or your channel's own session state. Do **not** key it
-   * off `session.continuationKey`: the HTTP channel rotates the
-   * continuation key after every accepted follow-up, so a tenant mapping
-   * keyed on it silently breaks mid-conversation. (Channels that mint
-   * stable, parseable tokens by design are the exception.)
+   * off `session.continuationKey`: it is a channel routing key, and channels
+   * may re-key it independently of the authenticated principal.
    *
    * Works attached or advertised. Advertised connections
    * ({@link advertiseTools}) open per-operation clients with the
@@ -1593,6 +1591,11 @@ export interface SessionRecord {
   abs?: Record<string, string | null>;
   /** Channel-local continuation key; null when the session is not addressable. */
   continuationKey: string | null;
+  /**
+   * Rotating HTTP follow-up credential for a channel-owned session.
+   * Omitted until HTTP accepts the first follow-up.
+   */
+  httpContinuationKey?: string;
   auth: AuthContext | null;
   title?: string;
   channelState?: JsonValue;
@@ -1668,7 +1671,7 @@ export interface SessionSummary {
   queued?: boolean;
   createdAt: string;
   updatedAt: string;
-  /** `<channelId>:<key>` wire token, or null when not addressable. */
+  /** Active wire token for HTTP follow-ups, or null when not addressable. */
   continuationToken: string | null;
   /**
    * Conversation permalink (Slack thread, else GitHub PR).

package/templates/security-help/README.md

@@ -0,0 +1,37 @@
+# Security help
+
+Answers security questions in Slack from your FAQ files and takes a first
+look when someone pastes a GitHub pull request.
+
+```bash
+npx @cursor/july init ./security-help --template security-help
+```
+
+`init` asks which repos it may read. Skip the prompt with
+`--var repos=owner/repo`.
+
+## Run
+
+```bash
+agent-sdk login
+agent-sdk slack create --name "Security Help" --channel-posts
+agent-sdk dev
+```
+
+Slack is a dedicated bot (`@Security Help`). Mentions, DMs, and channel
+watch go through that app. GitHub reads use your Cursor GitHub connection
+for the repos in `agent/lib/repos.ts`. Paste a PR URL in Slack, or replay
+one in the playground.
+
+## Edit
+
+- `agent/lib/repos.ts`: repos it may read
+- `agent/channels/slack.ts`: channel ids to watch (`watch`)
+- `agent/knowledge/faq/`: answers for your company
+- `agent/skills/`: how to look at a PR, a leak, or an access ask
+- `agent/instructions.md`: routing
+
+`--channel-posts` is required to watch channels. Mentions and DMs work
+without it.
+
+`agent-sdk eval` runs three smoke turns and writes nothing to Slack or GitHub.