@cursor/july 0.1.92 → 0.1.94

package/src/internal/authored-loaders.ts

@@ -8,12 +8,13 @@
  * ESM loader itself on startup.
  *
  * On compiled runs it additionally registers alias hooks so authored bare
- * imports of the framework resolve against the running package: the
- * historical `@anysphere/agent-serve[/x]` name always, and
- * `@cursor/july[/x]` / `@cursor/agentkit[/x]` as fallbacks when the user's
- * project has no local install (npx / global). The same hooks retry bare
- * npm specifiers from monorepo `packages/agent-serve/` source against this
- * package (hosted factory engines install only the agent directory).
+ * imports of the framework resolve against the running package's `dist/` —
+ * `@anysphere/agent-serve[/x]`, `@cursor/july[/x]`, and `@cursor/agentkit[/x]`
+ * all short-circuit to the same files the CLI loaded. Channel option WeakMaps
+ * (`getGitHubChannelOptions`, …) require that identity; letting tsx path-map
+ * or a second install win loads a duplicate module and breaks continuation /
+ * hosted-delivery lookups. Bare npm deps from monorepo `packages/agent-serve/`
+ * source still retry against this package (hosted factory engines).
  * Source runs (tsx from the monorepo) skip both — the host loader and
  * tsconfig paths already cover them.
  */
@@ -168,18 +169,21 @@ function registerFrameworkAliases(): void {
   }
   const distDir = join(packageRootDir(), "dist");
   const directAliases: Record<string, string> = {};
-  const fallbackAliases: Record<string, string> = {};
   for (const [subpath, file] of AUTHORING_ENTRY_FILES) {
     const target = pathToFileURL(join(distDir, file)).href;
     const suffix = subpath === "" ? "" : `/${subpath}`;
+    // Always pin framework imports to this process's dist. Channel factories
+    // stash options in module-local WeakMaps; a second copy (tsx tsconfig
+    // paths → src/, or a mismatched node_modules install) makes
+    // getGitHubChannelOptions miss and hosted-delivery return 422.
     directAliases[`${LEGACY_PACKAGE_NAME}${suffix}`] = target;
-    fallbackAliases[`${PACKAGE_NAME}${suffix}`] = target;
-    fallbackAliases[`${AGENTKIT_PACKAGE_NAME}${suffix}`] = target;
+    directAliases[`${PACKAGE_NAME}${suffix}`] = target;
+    directAliases[`${AGENTKIT_PACKAGE_NAME}${suffix}`] = target;
   }
   const hooksUrl = new URL("./authored-alias-hooks.js", import.meta.url);
   const data: AuthoredAliasHookData = {
     directAliases,
-    fallbackAliases,
+    fallbackAliases: {},
     // Hosted factory agents relative-import this package's src/ from a
     // monorepo checkout while npm install ran only in the agent directory.
     // Bare specifiers from that tree retry against this package.json.

package/src/internal/cli-deploy.ts

@@ -6,7 +6,7 @@
  * All intelligence is server-side (backend/server/src/agentServe/); these
  * handlers resolve parameters (credentials, team, slug, the project's
  * `hosting` / `architecture` manifest block), call the v1 agent-serve or
- * v2 agentkit management API through `deploy-client.ts`, poll status, and
+ * v2 agentsdk management API through `deploy-client.ts`, poll status, and
  * render.
  */
 
@@ -658,7 +658,7 @@ async function deployOne(
     if (!ctx.json) {
       ctx.err("  architecture: v2\n");
     }
-    return deployOneAgentkit(ctx, extras, {
+    return deployOneAgentsdk(ctx, extras, {
       slug,
       gitRepoUrl,
       gitRef,
@@ -782,7 +782,7 @@ async function deployOne(
  * poll the matching GET. The v2 accept path starts freeze bake; it does
  * not mint an engine alias or alias token.
  */
-async function deployOneAgentkit(
+async function deployOneAgentsdk(
   ctx: DeployCliContext,
   extras: { jsonCollect?: unknown[] } | undefined,
   args: {
@@ -1189,10 +1189,10 @@ export async function cmdStop(
     return ctx;
   }
   // 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
+  // deploy). The v2 agentsdk 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.
+  // the `/internal/agentkit` mount) falls back to the v1 stop.
   let architecture: "v1" | "v2" = "v2";
   let accepted: StopAccepted | AgentkitStopAccepted;
   try {

package/src/internal/cli-mcp-oauth.ts

@@ -68,13 +68,15 @@ export async function cmdMcpOauth(
   const err = options.err ?? ((text) => process.stderr.write(text));
   const out = options.out ?? ((text) => process.stdout.write(text));
   const project = await loadAgentProject(options.dir);
-  const connection = project.agent.connections.find(
+  const authored = [
+    ...project.agent.connections,
+    ...(project.agent.hostConnections ?? []),
+  ];
+  const connection = authored.find(
     (entry) => entry.name === options.connection
   );
   if (connection === undefined) {
-    const known =
-      project.agent.connections.map((entry) => entry.name).join(", ") ||
-      "(none)";
+    const known = authored.map((entry) => entry.name).join(", ") || "(none)";
     err(
       `${LOG_PREFIX} Unknown MCP connection "${options.connection}". Authored: ${known}.\n`
     );

package/src/internal/continuation-channel.ts

@@ -1,9 +1,11 @@
+import { getDeploymentsChannelOptions } from "../channels/deployments/deployments-channel.js";
 import { getGitHubChannelOptions } from "../channels/github/github-channel.js";
 import { getOriginChannelOptions } from "../channels/origin/origin-channel.js";
 import { getSlackChannelOptions } from "../channels/slack/slack-channel.js";
 import type {
   AgentArchitecture,
   ChannelDefinition,
+  ChannelMeta,
   HttpChannelDefinition,
 } from "../types.js";
 import {
@@ -14,23 +16,48 @@ import {
   normalizeIdentity,
 } from "./continuation-identity.js";
 
+type ContinuationChannelOptions = {
+  continuation?: ContinuationIdentity;
+};
+
+const CONTINUATION_CHANNEL_PACKS: ReadonlyArray<{
+  kind: "github" | "slack" | "origin" | "deployments";
+  getOptions: (definition: object) => ContinuationChannelOptions | undefined;
+  usesDeclaredEvents: boolean;
+}> = [
+  {
+    kind: "github",
+    getOptions: getGitHubChannelOptions,
+    usesDeclaredEvents: true,
+  },
+  {
+    kind: "slack",
+    getOptions: getSlackChannelOptions,
+    usesDeclaredEvents: false,
+  },
+  {
+    kind: "origin",
+    getOptions: getOriginChannelOptions,
+    usesDeclaredEvents: true,
+  },
+  {
+    kind: "deployments",
+    getOptions: getDeploymentsChannelOptions,
+    usesDeclaredEvents: true,
+  },
+];
+
 export function channelContinuationIdentity(
   definition: object | undefined
 ): ContinuationIdentity {
   if (definition === undefined) {
     return defaultContinuationSelector();
   }
-  const github = getGitHubChannelOptions(definition);
-  if (github !== undefined) {
-    return normalizeIdentity(github.continuation, "github");
-  }
-  const slack = getSlackChannelOptions(definition);
-  if (slack !== undefined) {
-    return normalizeIdentity(slack.continuation, "slack");
-  }
-  const origin = getOriginChannelOptions(definition);
-  if (origin !== undefined) {
-    return normalizeIdentity(origin.continuation, "origin");
+  for (const pack of CONTINUATION_CHANNEL_PACKS) {
+    const options = pack.getOptions(definition);
+    if (options !== undefined) {
+      return normalizeIdentity(options.continuation, pack.kind);
+    }
   }
   return defaultContinuationSelector();
 }
@@ -44,8 +71,9 @@ export function httpContinuationIdentity(
 /**
  * Stamp `/v2` continuation defaults onto channel constructors that omitted
  * `continuation` when the agent deploys onto v2 architecture. GitHub/Origin
- * type (`pr` / `issue` / `none`) follows declared webhook events. Explicit
- * per-channel selectors are left alone. Idempotent.
+ * type (`pr` / `issue` / `none`) follows declared webhook events.
+ * Deployments default to `deployments.deployment/v2`. Explicit per-channel
+ * selectors are left alone. Idempotent.
  */
 export function applyAgentContinuationDefaults(project: {
   agent: { architecture?: AgentArchitecture };
@@ -70,42 +98,34 @@ function stampOmittedChannelContinuation(
   definition: object,
   version: ContinuationProtocolVersion
 ): void {
-  const events = declaredChannelEventTypes(definition);
-  const github = getGitHubChannelOptions(definition);
-  if (github !== undefined) {
-    if (github.continuation === undefined) {
-      github.continuation = defaultContinuationSelector(
-        "github",
-        version,
-        events
-      );
+  const events = channelDeclaredEventTypes(
+    (definition as ChannelDefinition).meta
+  );
+  for (const pack of CONTINUATION_CHANNEL_PACKS) {
+    const options = pack.getOptions(definition);
+    if (options === undefined) {
+      continue;
     }
-    return;
-  }
-  const slack = getSlackChannelOptions(definition);
-  if (slack !== undefined) {
-    if (slack.continuation === undefined) {
-      slack.continuation = defaultContinuationSelector("slack", version);
-    }
-    return;
-  }
-  const origin = getOriginChannelOptions(definition);
-  if (origin !== undefined) {
-    if (origin.continuation === undefined) {
-      origin.continuation = defaultContinuationSelector(
-        "origin",
+    if (options.continuation === undefined) {
+      options.continuation = defaultContinuationSelector(
+        pack.kind,
         version,
-        events
+        pack.usesDeclaredEvents ? events : undefined
       );
     }
+    return;
   }
 }
 
-function declaredChannelEventTypes(
-  definition: object
+/** Kind-specific event lists on `ChannelMeta`; a definition sets at most one. */
+export function channelDeclaredEventTypes(
+  meta: ChannelMeta | undefined
 ): readonly string[] | undefined {
-  const meta = (definition as ChannelDefinition).meta;
-  return meta?.githubWebhookEvents ?? meta?.originWebhookEvents;
+  return (
+    meta?.githubWebhookEvents ??
+    meta?.originWebhookEvents ??
+    meta?.deploymentEventTypes
+  );
 }
 
 export function handshakeChannelContinuation(input: {
@@ -113,10 +133,7 @@ export function handshakeChannelContinuation(input: {
   definition: ChannelDefinition;
 }): { ok: true } | { ok: false; error: string } {
   const kind = input.definition.meta?.kind;
-  const eventTypes = [
-    ...(input.definition.meta?.githubWebhookEvents ?? []),
-    ...(input.definition.meta?.originWebhookEvents ?? []),
-  ];
+  const eventTypes = channelDeclaredEventTypes(input.definition.meta);
   const result = handshakeContinuation({
     kind,
     eventTypes,

package/src/internal/continuation-identity.ts

@@ -2,20 +2,27 @@
  * Continuation identity is a closed selector string. Omitted `continuation`
  * on a channel constructor stays `/v1` (engine pack minting) so existing
  * agents do not change: `githubChannel()` → `github.pr/v1`, `slackChannel()`
- * → `slack.thread/v1`, `originChannel()` → `origin.pr/v1`, `httpChannel()`
- * → `none/v1`.
+ * → `slack.thread/v1`, `originChannel()` → `origin.pr/v1`,
+ * `deploymentsChannel()` → `deployments.none/v1`, `httpChannel()` →
+ * `none/v1`.
  *
  * Opt the whole agent into the v2 control plane with
  * `defineAgent({ architecture: "v2" })`. That stamps `/v2` defaults from
  * the channel kind and declared events (`github.pr/v2`, `github.issue/v2`,
- * `github.none/v2`, `slack.thread/v2`, …) onto every channel that omitted
- * a selector. An explicit per-channel selector still overrides. JSONPath
+ * `github.none/v2`, `slack.thread/v2`, `origin.pr/v2`,
+ * `deployments.deployment/v2`, …) onto every channel that omitted a
+ * selector. An explicit per-channel selector still overrides. JSONPath
  * and per-agent format strings are rejected.
  */
 
 import { randomBytes } from "node:crypto";
 
-export type ConversationType = "pr" | "issue" | "thread" | "origin-pr";
+export type ConversationType =
+  | "pr"
+  | "issue"
+  | "thread"
+  | "origin-pr"
+  | "deployment";
 
 export const CONTINUATION_SELECTORS = [
   "github.pr/v1",
@@ -29,6 +36,9 @@ export const CONTINUATION_SELECTORS = [
   "origin.pr/v1",
   "origin.pr/v2",
   "origin.none/v2",
+  "deployments.none/v1",
+  "deployments.none/v2",
+  "deployments.deployment/v2",
   "none/v1",
   "none/v2",
 ] as const;
@@ -42,7 +52,7 @@ export type ParsedContinuation = {
   selector: ContinuationSelector;
   version: 1 | 2;
   type: ConversationType | "none";
-  kind: "github" | "slack" | "origin" | "http";
+  kind: "github" | "slack" | "origin" | "deployments" | "http";
 };
 
 export type ContinuationClaim = {
@@ -50,7 +60,8 @@ export type ContinuationClaim = {
   resource:
     | { owner: string; repo: string; number: number }
     | { channelId: string; threadTs: string }
-    | { fullName: string; number: number };
+    | { fullName: string; number: number }
+    | { deploymentId: string };
 };
 
 export type MailboxContinuation = {
@@ -59,7 +70,7 @@ export type MailboxContinuation = {
 
 export type ContinuationBuiltin = {
   type: ConversationType;
-  kind: "github" | "slack" | "origin";
+  kind: "github" | "slack" | "origin" | "deployments";
   events: readonly string[];
   format: string;
 };
@@ -105,6 +116,12 @@ export const BUILTINS: readonly ContinuationBuiltin[] = [
     ],
     format: "origin-pr:{fullName}#{number}",
   },
+  {
+    type: "deployment",
+    kind: "deployments",
+    events: ["deployment.created", "deployment.succeeded"],
+    format: "deployments:{deploymentId}",
+  },
 ] as const;
 
 export class V2EngineError extends Error {
@@ -128,6 +145,13 @@ const SELECTOR_FIELDS: {
   "origin.pr/v1": { version: 1, type: "origin-pr", kind: "origin" },
   "origin.pr/v2": { version: 2, type: "origin-pr", kind: "origin" },
   "origin.none/v2": { version: 2, type: "none", kind: "origin" },
+  "deployments.none/v1": { version: 1, type: "none", kind: "deployments" },
+  "deployments.none/v2": { version: 2, type: "none", kind: "deployments" },
+  "deployments.deployment/v2": {
+    version: 2,
+    type: "deployment",
+    kind: "deployments",
+  },
   "none/v1": { version: 1, type: "none", kind: "http" },
   "none/v2": { version: 2, type: "none", kind: "http" },
 };
@@ -151,6 +175,8 @@ export function defaultContinuationSelector(
         return "slack.thread/v1";
       case "origin":
         return "origin.pr/v1";
+      case "deployments":
+        return "deployments.none/v1";
       default:
         return "none/v1";
     }
@@ -162,6 +188,8 @@ export function defaultContinuationSelector(
       return "slack.thread/v2";
     case "origin":
       return originV2Default(eventTypes);
+    case "deployments":
+      return deploymentsV2Default(eventTypes);
     default:
       return "none/v2";
   }
@@ -189,6 +217,17 @@ function originV2Default(eventTypes?: readonly string[]): ContinuationSelector {
   return "origin.pr/v2";
 }
 
+function deploymentsV2Default(
+  eventTypes?: readonly string[]
+): ContinuationSelector {
+  const events = eventTypes ?? [];
+  const deploymentEvents = new Set(builtinForType("deployment")?.events ?? []);
+  if (events.some((event) => !deploymentEvents.has(event))) {
+    return "deployments.none/v2";
+  }
+  return "deployments.deployment/v2";
+}
+
 export function parseContinuationSelector(
   selector: string
 ): ParsedContinuation | undefined {
@@ -249,6 +288,7 @@ export function formatConversationKey(
     number?: number;
     channelId?: string;
     threadTs?: string;
+    deploymentId?: string;
   }
 ): string {
   switch (type) {
@@ -260,30 +300,51 @@ export function formatConversationKey(
       return `origin-pr:${fields.fullName}#${fields.number}`;
     case "thread":
       return `${fields.channelId}:${fields.threadTs}`;
+    case "deployment":
+      return `deployments:${fields.deploymentId}`;
   }
 }
 
 export function mintClaim(claim: ContinuationClaim): string {
-  const resource = claim.resource;
-  if ("channelId" in resource && "threadTs" in resource) {
-    if (claim.type !== "thread") {
-      throw new V2EngineError(
-        `v2: claim type ${claim.type} does not match thread resource`
-      );
+  switch (claim.type) {
+    case "thread": {
+      const resource = claim.resource;
+      if (!("channelId" in resource && "threadTs" in resource)) {
+        throw new V2EngineError(
+          "v2: thread claim requires channelId and threadTs"
+        );
+      }
+      return `cont:${formatConversationKey("thread", resource)}`;
+    }
+    case "deployment": {
+      const resource = claim.resource;
+      if (!("deploymentId" in resource)) {
+        throw new V2EngineError("v2: deployment claim requires deploymentId");
+      }
+      return `cont:${formatConversationKey("deployment", resource)}`;
+    }
+    case "pr":
+    case "issue":
+    case "origin-pr": {
+      const resource = claim.resource;
+      const fullName =
+        "fullName" in resource
+          ? resource.fullName
+          : "owner" in resource
+            ? `${resource.owner}/${resource.repo}`
+            : undefined;
+      const number = "number" in resource ? resource.number : undefined;
+      if (fullName === undefined || number === undefined) {
+        throw new V2EngineError(
+          `v2: ${claim.type} claim requires repository and number`
+        );
+      }
+      return `cont:${formatConversationKey(claim.type, {
+        fullName,
+        number,
+      })}`;
     }
-    return `cont:${formatConversationKey("thread", resource)}`;
-  }
-  const fullName =
-    "fullName" in resource
-      ? resource.fullName
-      : `${resource.owner}/${resource.repo}`;
-  if (claim.type === "thread") {
-    throw new V2EngineError("v2: thread claim requires channelId and threadTs");
   }
-  return `cont:${formatConversationKey(claim.type, {
-    fullName,
-    number: resource.number,
-  })}`;
 }
 
 export function handshakeContinuation(input: {
@@ -358,18 +419,16 @@ export function extractContinuation(
       return extractSlack(payload);
     case "origin-pr":
       return extractOrigin(payload);
+    case "deployment":
+      return extractDeployment(payload);
   }
 }
 
 /**
- * Extract primitive used by the control plane (hosted
- * `routeVerifiedIngressContinuation` and local
- * `routeLocalIngressContinuation`). Channel adapters must not call this.
- */
-/**
- * Extract primitive used by the control plane (hosted
- * `routeVerifiedIngressContinuation` and local
- * `routeLocalIngressContinuation`). Channel adapters must not call this.
+ * CP mailbox stamp. Hosted `routeVerifiedIngressContinuation` and local
+ * `routeLocalIngressContinuation` call this; channel adapters must not.
+ * Membership miss or missing identity fields stamp `evt:` instead of
+ * joining the conversation index.
  */
 export function stampMailboxContinuation(
   identity: ContinuationIdentity,
@@ -533,15 +592,13 @@ function extractSlack(payload: unknown): string | undefined {
 }
 
 function extractOrigin(payload: unknown): string | undefined {
-  const record = asRecord(payload);
+  const record = originExtractRecord(payload);
   if (record === undefined) {
     return undefined;
   }
   const inner = asRecord(record.pullRequest) ?? asRecord(record.pull_request);
   const number = positiveInt(inner?.number);
-  const repository =
-    asRecord(record.repository) ??
-    asRecord(asRecord(asRecord(record.event)?.payload)?.repository);
+  const repository = asRecord(record.repository) ?? asRecord(inner?.repository);
   const fullName =
     nonEmpty(asRecord(repository)?.fullName) ??
     nonEmpty(asRecord(repository)?.full_name) ??
@@ -552,6 +609,33 @@ function extractOrigin(payload: unknown): string | undefined {
   return `cont:${formatConversationKey("origin-pr", { fullName, number })}`;
 }
 
+/**
+ * Mailbox stores the Origin delivery envelope; local/hosted CP extract
+ * also accepts the compact `{ pullRequest, repository }` shape.
+ */
+function originExtractRecord(
+  payload: unknown
+): Record<string, unknown> | undefined {
+  const record = asRecord(payload);
+  if (record === undefined) {
+    return undefined;
+  }
+  const nested = asRecord(asRecord(record.event)?.payload);
+  if (nested !== undefined && asRecord(record.pullRequest) === undefined) {
+    return nested;
+  }
+  return record;
+}
+
+function extractDeployment(payload: unknown): string | undefined {
+  const record = asRecord(payload);
+  const deploymentId = nonEmpty(record?.deploymentId);
+  if (deploymentId === undefined) {
+    return undefined;
+  }
+  return `cont:${formatConversationKey("deployment", { deploymentId })}`;
+}
+
 function githubFullName(payload: Record<string, unknown>): string | undefined {
   const repository = asRecord(payload.repository);
   return nonEmpty(repository?.full_name) ?? originFullName(repository);
@@ -564,6 +648,7 @@ function originFullName(
     return undefined;
   }
   const owner =
+    nonEmpty(asRecord(repository.owner)?.slug) ??
     nonEmpty(repository.owner) ??
     nonEmpty(asRecord(repository.owner)?.login) ??
     nonEmpty(asRecord(repository.owner)?.name);

package/src/internal/convert-automation/convert-workflow.ts

@@ -6,9 +6,10 @@
  * clock — `exportedAt` comes from the caller.
  */
 
+import { envPrefixFromName } from "../../channels/slack/credentials.js";
 import { CLI_COMMAND_NAME, PACKAGE_NAME } from "../distribution.js";
 import { MEMORY_TS } from "../init-scaffold.js";
-import { pascalCase, SlugRegistry, slugify } from "./slug.js";
+import { SlugRegistry, slugify } from "./slug.js";
 import type {
   ActionJson,
   ConvertedFile,
@@ -998,11 +999,11 @@ function emitSlackChannel(
       "The Slack trigger marked triggering messages with a completion reaction; agentsdk has no completion-reaction option, so that signal is lost unless agent/instructions.md tells the agent to add the reaction itself via Slack tools."
     );
   }
-  if (socketMode) {
-    out.setupSteps.push(
-      `Slack channel-watch / reaction / channel-created triggers need a dedicated Socket Mode Slack app (not the Cursor connection): run \`${CLI_COMMAND_NAME} slack create --channel-posts\`, then finish in the dashboard wizard.`
-    );
-  }
+  out.setupSteps.push(
+    socketMode
+      ? `Slack channel-watch / reaction / channel-created triggers need a dedicated Socket Mode Slack app: run \`${CLI_COMMAND_NAME} slack create --channel-posts\`, then finish in the dashboard wizard.`
+      : `Slack mentions need a dedicated Socket Mode Slack app: run \`${CLI_COMMAND_NAME} slack create\`, then finish in the dashboard wizard.`
+  );
 
   const header = [
     `import { slackChannel } from "${PACKAGE_NAME}/channels/slack";`,
@@ -1069,26 +1070,37 @@ function emitSlackChannel(
     }
     body = [
       "//",
-      "// This channel needs a dedicated Socket Mode Slack app (not the Cursor",
-      `// connection): run \`${CLI_COMMAND_NAME} slack create --channel-posts\`.`,
-      "export default slackChannel({",
-      ...engagement,
-      "});",
+      `// Run \`${CLI_COMMAND_NAME} slack create --channel-posts\` for a dedicated Slack app.`,
+      ...slackChannelExport(automation.name, engagement),
     ];
   } else {
-    const agentName = pascalCase(automation.name, "ExportedAgent");
     body = [
       "//",
-      `// Mention this agent in Slack with \`@Cursor ${agentName} ...\`.`,
-      "export default slackChannel({",
-      "  cursorAccount: true,",
-      `  agentName: ${JSON.stringify(agentName)},`,
-      "});",
+      `// Run \`${CLI_COMMAND_NAME} slack create\` for a dedicated Slack app.`,
+      ...slackChannelExport(automation.name, []),
     ];
   }
   out.files.push({ path, contents: `${[...header, ...body].join("\n")}\n` });
 }
 
+/**
+ * `slack create` writes `<DIR>_SLACK_*` from the project directory. Convert
+ * names that directory from the automation (`Nightly Triage` →
+ * `nightly-triage` → `NIGHTLY_TRIAGE`). Emit the same prefix so minted
+ * tokens bind.
+ */
+function slackChannelExport(name: string, optionLines: string[]): string[] {
+  const prefix = envPrefixFromName(slugify(name, "automation"));
+  const options = [
+    ...(prefix === "" ? [] : [`  envPrefix: ${JSON.stringify(prefix)},`]),
+    ...optionLines,
+  ];
+  if (options.length === 0) {
+    return ["export default slackChannel();"];
+  }
+  return ["export default slackChannel({", ...options, "});"];
+}
+
 function slackChannelList(
   trigger: SlackChannelsTriggerJson | undefined
 ): string[] {

package/src/internal/convert-automation/slug.ts

@@ -9,15 +9,6 @@ export function slugify(name: string, fallback: string): string {
   return slug === "" ? fallback : slug;
 }
 
-/** Single-token PascalCase (Slack cursorAccount agentName). */
-export function pascalCase(name: string, fallback: string): string {
-  const words = name.split(/[^a-zA-Z0-9]+/).filter((word) => word !== "");
-  if (words.length === 0) {
-    return fallback;
-  }
-  return words.map((word) => word[0]?.toUpperCase() + word.slice(1)).join("");
-}
-
 /** Dedupes slugs with numeric suffixes: `linear`, `linear-2`, `linear-3`, … */
 export class SlugRegistry {
   private readonly used = new Set<string>();

package/src/internal/cursor/account-mcp.ts

@@ -85,7 +85,10 @@ export function collectCursorAccountConnections(
   const bySlug = new Map<string, CursorAccountConnectionRef[]>();
   for (const { slug, project } of mounts) {
     const refs: CursorAccountConnectionRef[] = [];
-    for (const connection of project.agent.connections) {
+    for (const connection of [
+      ...project.agent.connections,
+      ...(project.agent.hostConnections ?? []),
+    ]) {
       if (!isCursorAccountTransport(connection.transport)) {
         continue;
       }