@cursor/july 0.1.109 → 0.1.112

package/src/internal/server.ts

@@ -54,6 +54,7 @@ import {
   parseCursorOriginRepoScope,
 } from "../channels/origin/cursor-account.js";
 import { findOriginChannelTargets } from "../channels/origin/origin-channel.js";
+import { appendSlackQuietHint } from "../channels/slack/agentic-posted.js";
 import { allowAll, bearerAuth, localDevStrict } from "../channels.js";
 import type {
   AgentProject,
@@ -145,6 +146,10 @@ import {
   readJsonObject,
   requireSessionOwner,
 } from "./http-channel.js";
+import {
+  incomingHeadersToFetch,
+  incomingRequestHost,
+} from "./incoming-headers-to-fetch.js";
 import { DEFAULT_SERVE_PORT, listenHttpServer } from "./listen-port.js";
 import {
   createLocalControlPlane,
@@ -233,13 +238,18 @@ import {
   unregisterSessionRunFatalFlush,
 } from "./session-run-log.js";
 import { sessionUrlsForRequest } from "./session-urls.js";
+import {
+  readSkillDetail,
+  skillListEntry,
+  UnknownSkillError,
+} from "./skill-catalog.js";
 import { flushLocalStartLog, selectStartLogStore } from "./start-log-store.js";
 import { catalogDetailEntry, catalogListEntry } from "./tool-catalog.js";
 
 function memoryHealthFields(engines: readonly SessionEngine[]) {
   return collectMemoryHealthFields({
     eventLog: () =>
-      sumEventLogStats(engines.map((engine) => engine.eventLogMemoryStats())),
+      sumEventLogStats(engines.map(engine => engine.eventLogMemoryStats())),
   });
 }
 
@@ -276,7 +286,7 @@ function localControlPlaneRoute(
 ): RouteLocalIngressContinuation | undefined {
   for (const runtime of runtimes) {
     if (runtime.controlPlane !== undefined) {
-      return (input) => runtime.controlPlane!.routeContinuation(input);
+      return input => runtime.controlPlane!.routeContinuation(input);
     }
   }
   return undefined;
@@ -285,7 +295,7 @@ function localControlPlaneRoute(
 function firstLocalControlPlane(
   runtimes: readonly MountedRuntime[]
 ): LocalControlPlane | undefined {
-  return runtimes.find((runtime) => runtime.controlPlane !== undefined)
+  return runtimes.find(runtime => runtime.controlPlane !== undefined)
     ?.controlPlane;
 }
 
@@ -324,7 +334,7 @@ export async function startServer(
       const label = slug === "" ? project.name : `${slug} (${project.name})`;
       throw new Error(
         `Refusing to serve agent ${label} — it has errors:\n${formatDiagnostics(
-          project.diagnostics.filter((d) => d.severity === "error")
+          project.diagnostics.filter(d => d.severity === "error")
         )}`
       );
     }
@@ -340,12 +350,9 @@ export async function startServer(
     noControlPlane?: boolean;
     /** `--cursor-scm-proxy`: every cursorAccount SCM pack routes via the backend forwarder. */
     cursorScmProxy?: boolean;
-    /** Deprecated alias (`--cursor-github-proxy`); same effect as cursorScmProxy. */
-    cursorGithubProxy?: boolean;
   };
   const noControlPlane = hosted.noControlPlane === true;
-  const scmProxyRequested =
-    hosted.cursorScmProxy === true || hosted.cursorGithubProxy === true;
+  const scmProxyRequested = hosted.cursorScmProxy === true;
   const runSchedules = options.schedules ?? !dev;
   const runReminders = options.reminders ?? !dev;
 
@@ -355,7 +362,7 @@ export async function startServer(
   process.env.CURSOR_AGENTKIT_VERSION ??= packageVersion();
 
   const authoredOtel = pickAuthoredOtel(
-    mounts.map((m) => ({
+    mounts.map(m => ({
       slug: m.slug,
       name: m.project.name,
       otel: m.project.otel,
@@ -419,8 +426,8 @@ export async function startServer(
     noControlPlane,
     config: effectiveCursorEvents,
     auth: cursorEventsAuth,
-    v1Mounts: mounts.filter((mount) => !isV2Project(mount.project)),
-    v2Mounts: mounts.filter((mount) => isV2Project(mount.project)),
+    v1Mounts: mounts.filter(mount => !isV2Project(mount.project)),
+    v2Mounts: mounts.filter(mount => isV2Project(mount.project)),
     githubRepos: cursorGithubConfig.cursorEvents?.repos ?? [],
     originRepos: cursorOriginScope?.repos ?? [],
   });
@@ -700,7 +707,7 @@ export async function startServer(
     await flushLocalStartLog({ store: startLogStore, startLogId });
   };
   if (sessionRunLog !== undefined) {
-    registerSessionRunFatalFlush(async (error) => {
+    registerSessionRunFatalFlush(async error => {
       await flushHostedExecutionProcessDeath({
         flushProcessDeath: (reason, flushError) =>
           sessionRunLog.flushProcessDeath(reason, flushError),
@@ -725,7 +732,7 @@ export async function startServer(
   // dispatching runner is only interposed when a mount needs it. An
   // injected test runner receives every turn, grokbot included.
   const hasGrokBotMounts = mounts.some(
-    (mount) => mount.project.agent.runtime === "grokbot"
+    mount => mount.project.agent.runtime === "grokbot"
   );
   // Fail closed like cursor-account GitHub/MCP: grokbot turns execute on the
   // signed-in account's hosted computer, so anonymous admission needs its
@@ -874,10 +881,10 @@ export async function startServer(
     const localControlPlane = noControlPlane
       ? undefined
       : await createLocalControlPlane({
-          fireSchedule: (name) => scheduleRunner.dispatch(name),
+          fireSchedule: name => scheduleRunner.dispatch(name),
           ...(useReminderCpProtocol
             ? {
-                executeReminder: (descriptor) =>
+                executeReminder: descriptor =>
                   reminderRunner.executeFire(descriptor),
               }
             : {
@@ -921,21 +928,21 @@ export async function startServer(
     // boot and makes /v1/dev/evals complete from the first request).
     await evalRuns.hydrate();
     engine.setReminders({
-      create: (input) => reminderRunner.create(input),
-      list: (filter) => reminderRunner.list(filter),
+      create: input => reminderRunner.create(input),
+      list: filter => reminderRunner.list(filter),
       cancel: (id, reason) => reminderRunner.cancel(id, reason),
       cancelForContinuation: (token, reason) =>
         reminderRunner.cancelForContinuation(token, reason),
       rekeyContinuation: (channelId, oldToken, newToken) =>
         reminderRunner.rekeyContinuation(channelId, oldToken, newToken),
-      dispatch: (id) => reminderRunner.dispatch(id),
+      dispatch: id => reminderRunner.dispatch(id),
     });
     engine.setEvals({
       list: () => evalRuns.list(),
-      get: (runId) => evalRuns.get(runId),
+      get: runId => evalRuns.get(runId),
       listRunsWithActive: () => evalRuns.listRunsWithActive(),
-      start: (input) => evalRuns.start(input),
-      cancel: (runId) => evalRuns.cancel(runId),
+      start: input => evalRuns.start(input),
+      cancel: runId => evalRuns.cancel(runId),
     });
     const runtime: MountedRuntime = {
       slug,
@@ -987,7 +994,7 @@ export async function startServer(
           send: (message, sendOptions) =>
             engine.send(channel.id, message, sendOptions),
           architecture: project.agent.architecture,
-          getSession: (sessionId) =>
+          getSession: sessionId =>
             engine.getChannelSession(channel.id, sessionId),
           receive: (target, input) => engine.receive(target, input),
           callTool: (toolName, input, callOptions) =>
@@ -995,23 +1002,23 @@ export async function startServer(
           emitAssistantMessage: (sessionId, text) =>
             engine.emitAssistantMessage(sessionId, text),
           host: engine.host,
-          waitUntil: (promise) => {
+          waitUntil: promise => {
             engine.trackBackground(promise);
           },
           resolveApproval: (sessionId, callId, decision, auth) =>
             engine.resolveApproval(sessionId, callId, decision, auth),
           resolveAuth: (sessionId, callId, decision, auth) =>
             engine.resolveAuth(sessionId, callId, decision, auth),
-          hasContinuationSession: (continuationToken) =>
+          hasContinuationSession: continuationToken =>
             engine.hasContinuationSession(channel.id, continuationToken),
-          isContinuationBusy: (continuationToken) =>
+          isContinuationBusy: continuationToken =>
             engine.isContinuationBusy(channel.id, continuationToken),
-          getContinuationLastBotMessageTs: (continuationToken) =>
+          getContinuationLastBotMessageTs: continuationToken =>
             engine.getContinuationLastBotMessageTs(
               channel.id,
               continuationToken
             ),
-          interruptContinuation: (continuationToken) =>
+          interruptContinuation: continuationToken =>
             engine.interruptContinuation(channel.id, continuationToken),
           logger,
           artifacts: engine.artifacts,
@@ -1075,7 +1082,7 @@ export async function startServer(
             slug,
             name: project.name,
           })),
-          ...memoryHealthFields(runtimes.map((runtime) => runtime.engine)),
+          ...memoryHealthFields(runtimes.map(runtime => runtime.engine)),
         }),
     });
   }
@@ -1114,34 +1121,32 @@ export async function startServer(
   // to run via their onPullRequest / onComment / … hooks.
   const collectGitHubTargetsFrom = (selected: readonly MountedRuntime[]) =>
     collectGitHubTriggerTargets({
-      mounts: selected.map((runtime) => ({
+      mounts: selected.map(runtime => ({
         slug: runtime.slug,
         channels: runtime.project.channels,
-        buildHandlerArgs: (channelId) =>
+        buildHandlerArgs: channelId =>
           buildChannelHandlerArgs({ runtime, channelId }),
       })),
     });
   const collectOriginTargetsFrom = (selected: readonly MountedRuntime[]) =>
     collectOriginTriggerTargets({
-      mounts: selected.map((runtime) => ({
+      mounts: selected.map(runtime => ({
         slug: runtime.slug,
         channels: runtime.project.channels,
-        buildHandlerArgs: (channelId) =>
+        buildHandlerArgs: channelId =>
           buildChannelHandlerArgs({ runtime, channelId }),
       })),
     });
   const collectGitHubTargets = () => collectGitHubTargetsFrom(runtimes);
-  const v1Runtimes = runtimes.filter(
-    (runtime) => !isV2Project(runtime.project)
-  );
-  const v2Runtimes = runtimes.filter((runtime) => isV2Project(runtime.project));
-  const v1Mounts = mounts.filter((mount) => !isV2Project(mount.project));
-  const v2Mounts = mounts.filter((mount) => isV2Project(mount.project));
+  const v1Runtimes = runtimes.filter(runtime => !isV2Project(runtime.project));
+  const v2Runtimes = runtimes.filter(runtime => isV2Project(runtime.project));
+  const v1Mounts = mounts.filter(mount => !isV2Project(mount.project));
+  const v2Mounts = mounts.filter(mount => isV2Project(mount.project));
   router.add({
     method: "POST",
     pattern: "/v1/webhooks/github",
     auth: [localDevStrict()],
-    handler: async (request) => {
+    handler: async request => {
       const bodyText = await request.text();
       const routeContinuation = localControlPlaneRoute(runtimes);
       const result = await handleAgentServeTrigger({
@@ -1285,8 +1290,8 @@ export async function startServer(
     );
     if (accountBridge !== undefined && accountRefs !== undefined) {
       const bridge = accountBridge;
-      runtime.engine.setCursorAccountAuthProbe(async (connection) => {
-        const ref = accountRefs.find((entry) => entry.name === connection);
+      runtime.engine.setCursorAccountAuthProbe(async connection => {
+        const ref = accountRefs.find(entry => entry.name === connection);
         if (ref === undefined) {
           return undefined;
         }
@@ -1294,7 +1299,7 @@ export async function startServer(
       });
     }
     const hasServerTools = runtime.project.agent.tools.some(
-      (tool) => tool.execution === "server"
+      tool => tool.execution === "server"
     );
     // Host-bridged connections ride the same endpoint as server tools, so
     // the cloud tools connection is set whenever either needs it.
@@ -1352,7 +1357,7 @@ export async function startServer(
     runtime.evalRuns.loopbackUrl =
       runtime.slug === "" ? url : `${url}/${runtime.slug}`;
   }
-  const runtimeBySlug = new Map(runtimes.map((r) => [r.slug, r]));
+  const runtimeBySlug = new Map(runtimes.map(r => [r.slug, r]));
 
   // --dev: spawn Vite HMR. Single-agent infers the slug base; multi-agent
   // serves `/<slug>/playground` on the HMR origin (optional AGENT_SERVE_BASE
@@ -1424,8 +1429,7 @@ export async function startServer(
     close: async () => {
       if (sessionRunLog !== undefined) {
         await flushHostedExecutionProcessDeath({
-          flushProcessDeath: (reason) =>
-            sessionRunLog.flushProcessDeath(reason),
+          flushProcessDeath: reason => sessionRunLog.flushProcessDeath(reason),
           flushStartLog,
           startLogId: lastStartLogId,
           reason: "process_exit",
@@ -1460,7 +1464,7 @@ export async function startServer(
       server.close();
       server.closeAllConnections();
       try {
-        await Promise.all(runtimes.map((runtime) => runtime.engine.close()));
+        await Promise.all(runtimes.map(runtime => runtime.engine.close()));
       } finally {
         cursorGithubCredentials?.stop();
         await shutdownOtelRuntime(otelRuntime);
@@ -1532,7 +1536,7 @@ function mountAgentRoutes(
   // loopback-only + per-boot bearer secret, never on the public auth chain.
   if (args.accountBridge !== undefined && args.accountRefs !== undefined) {
     const bridge = args.accountBridge;
-    const refByName = new Map(args.accountRefs.map((ref) => [ref.name, ref]));
+    const refByName = new Map(args.accountRefs.map(ref => [ref.name, ref]));
     router.add({
       method: "POST",
       pattern: `${base}${cursorAccountMcpPath(":connection")}`,
@@ -1546,7 +1550,7 @@ function mountAgentRoutes(
             `No Cursor account MCP connection named "${ctx.params.connection ?? ""}" on this agent.`
           );
         }
-        return bridge.handle(request, ref);
+        return bridge.handle(request, ref, appendSlackQuietHint);
       },
     });
   }
@@ -1559,7 +1563,7 @@ function mountAgentRoutes(
   const httpAuth = project.httpChannel.auth ?? defaultAuth;
   // Temporal posts this marker on a direct pod port-token fetch. The alias
   // proxy strips it, so webhook/playground tokens cannot present it.
-  const platformTimerFireAuth: AuthPolicy = (request) => {
+  const platformTimerFireAuth: AuthPolicy = request => {
     if (request.headers.get("x-agent-serve-timed-work") === "1") {
       return {
         authenticator: "app",
@@ -1569,7 +1573,15 @@ function mountAgentRoutes(
     }
     return null;
   };
-  if (noControlPlane === true && isV2Project(project)) {
+  // A v2 mount served under `--no-control-plane` is a hosted v2 guest: the
+  // hosted control plane drives it through the hosted delivery route below.
+  // Session HTTP is a control-plane surface, so such a guest mounts no
+  // `/v1/session*` or `/v1/sessions` routes — session starts arrive as hosted
+  // admissions (`agentsdk.session` on the built-in http channel) and session
+  // reads come from the control plane's runs surface and durable storage.
+  // Local dev, self-hosted serve, and hosted v1 keep the engine mounts.
+  const hostedV2Guest = noControlPlane === true && isV2Project(project);
+  if (hostedV2Guest) {
     registerHostedDeliveryRoute({
       router,
       base,
@@ -1587,7 +1599,7 @@ function mountAgentRoutes(
         }),
       fireReminder: (reminderId, fireCount) =>
         reminderRunner.dispatch(reminderId, { expectedFireCount: fireCount }),
-      executeReminderDescriptor: async (descriptor) => {
+      executeReminderDescriptor: async descriptor => {
         if (reminderControlPlane === undefined) {
           throw new Error("hosted reminder CP client is not configured");
         }
@@ -1614,7 +1626,7 @@ function mountAgentRoutes(
           outcome: "fired" as const,
         };
       },
-      drainSessionDurability: (sessionId) =>
+      drainSessionDurability: sessionId =>
         engine.drainSessionDurability(sessionId),
       flushOtel: args.flushOtel,
       ...(args.diagStateRoot === undefined
@@ -1623,7 +1635,7 @@ function mountAgentRoutes(
       ...(sessionRunLog === undefined
         ? {}
         : {
-            persistSessionRun: async (document) => {
+            persistSessionRun: async document => {
               await sessionRunLog.persist(document);
             },
             flushStartLog,
@@ -1651,7 +1663,7 @@ function mountAgentRoutes(
     method: "GET",
     pattern: `${base}${mcpOauthServeCallbackPath()}`,
     auth: "none",
-    handler: (request) => engine.oauthCallbackHub.handleCallback(request),
+    handler: request => engine.oauthCallbackHub.handleCallback(request),
   });
 
   router.add({
@@ -1729,7 +1741,7 @@ function mountAgentRoutes(
     method: "GET",
     pattern: `${base}/v1/logs`,
     auth: httpAuth,
-    handler: (request) => {
+    handler: request => {
       const url = new URL(request.url);
       const afterRaw = url.searchParams.get("after");
       const after =
@@ -1748,34 +1760,38 @@ function mountAgentRoutes(
     },
   });
 
-  router.add({
-    method: "GET",
-    pattern: `${base}/v1/sessions`,
-    auth: httpAuth,
-    handler: async (request, ctx) => {
-      // Same gate as requireSessionOwner / relaxSessionReadAuth: never with
-      // bearer or custom channel auth (strict per-principal isolation).
-      // `--allow-anonymous` alone is a shared-principal trust boundary (corp
-      // Okta ALB); `--dev` alone stays loopback-only.
-      const includeAll =
-        relaxSessionReadAuth &&
-        (relaxSessionReadAuthBeyondLoopback ||
-          (typeof ctx.requestIp === "string" &&
-            isLoopbackAddress(ctx.requestIp)));
-      // `?latest=1` — only the newest visible session. Clients binding a
-      // default session (agsh) do not need the whole list, and on hosted
-      // storage the whole list is a database scan.
-      const latest = new URL(request.url).searchParams.get("latest");
-      const listed =
-        latest === "1" || latest === "true"
-          ? await engine.latestSessionWithSource(ctx.auth, { includeAll })
-          : await engine.listSessionsWithSource(ctx.auth, { includeAll });
-      return jsonResponse({
-        sessions: listed.sessions,
-        source: listed.source,
-      });
-    },
-  });
+  // Session list is session surface: not mounted on a hosted v2 guest (the
+  // control plane owns session reads there; see hostedV2Guest above).
+  if (!hostedV2Guest) {
+    router.add({
+      method: "GET",
+      pattern: `${base}/v1/sessions`,
+      auth: httpAuth,
+      handler: async (request, ctx) => {
+        // Same gate as requireSessionOwner / relaxSessionReadAuth: never with
+        // bearer or custom channel auth (strict per-principal isolation).
+        // `--allow-anonymous` alone is a shared-principal trust boundary (corp
+        // Okta ALB); `--dev` alone stays loopback-only.
+        const includeAll =
+          relaxSessionReadAuth &&
+          (relaxSessionReadAuthBeyondLoopback ||
+            (typeof ctx.requestIp === "string" &&
+              isLoopbackAddress(ctx.requestIp)));
+        // `?latest=1` — only the newest visible session. Clients binding a
+        // default session (agsh) do not need the whole list, and on hosted
+        // storage the whole list is a database scan.
+        const latest = new URL(request.url).searchParams.get("latest");
+        const listed =
+          latest === "1" || latest === "true"
+            ? await engine.latestSessionWithSource(ctx.auth, { includeAll })
+            : await engine.listSessionsWithSource(ctx.auth, { includeAll });
+        return jsonResponse({
+          sessions: listed.sessions,
+          source: listed.source,
+        });
+      },
+    });
+  }
 
   // Durable artifacts (ctx.artifacts / tag_artifact), newest-updated first.
   router.add({
@@ -2085,6 +2101,45 @@ function mountAgentRoutes(
     },
   });
 
+  // Deterministic skill reads: the body the harness would receive, plus
+  // resolved sibling files. Read-only, so plain GETs with no session binding.
+  router.add({
+    method: "GET",
+    pattern: `${base}/v1/skills`,
+    auth: httpAuth,
+    handler: async () =>
+      jsonResponse({
+        skills: project.agent.skills.map(skillListEntry),
+      }),
+  });
+
+  router.add({
+    method: "GET",
+    pattern: `${base}/v1/skills/:skillName`,
+    auth: httpAuth,
+    handler: async (_request, ctx) => {
+      const skillName = ctx.params.skillName ?? "";
+      try {
+        return jsonResponse(
+          await readSkillDetail(project.agent.skills, skillName)
+        );
+      } catch (error) {
+        if (error instanceof UnknownSkillError) {
+          return jsonResponse(
+            {
+              ok: false,
+              error: "unknown_skill",
+              message: error.message,
+              availableSkills: error.availableSkillNames,
+            },
+            { status: 404 }
+          );
+        }
+        throw error;
+      }
+    },
+  });
+
   if (playground) {
     // Serve the built Vite SPA. `<base href>` is injected so the SPA's relative
     // asset URLs resolve under this mount regardless of the trailing slash the
@@ -2108,18 +2163,25 @@ function mountAgentRoutes(
     });
   }
 
-  for (const route of buildHttpChannelRoutes({
-    engine,
-    config: project.httpChannel,
-    auth: httpAuth,
-    basePath: base,
-    // Dev playground lists every session (`includeAll`); allow opening them
-    // (see relaxSessionReadAuth above).
-    relaxSessionReadAuth,
-    relaxSessionReadAuthBeyondLoopback,
-    relaxSessionApprovalAuth,
-  })) {
-    router.add(route);
+  // The built-in HTTP session channel (`/v1/session*`, including the
+  // session-scoped approvals/auths routes) is session surface: not mounted on
+  // a hosted v2 guest (see hostedV2Guest above). The `http` channel itself
+  // stays registered with the hosted delivery route, which is how the control
+  // plane's session starts reach it.
+  if (!hostedV2Guest) {
+    for (const route of buildHttpChannelRoutes({
+      engine,
+      config: project.httpChannel,
+      auth: httpAuth,
+      basePath: base,
+      // Dev playground lists every session (`includeAll`); allow opening them
+      // (see relaxSessionReadAuth above).
+      relaxSessionReadAuth,
+      relaxSessionReadAuthBeyondLoopback,
+      relaxSessionApprovalAuth,
+    })) {
+      router.add(route);
+    }
   }
 
   // Playground eval list/run — available without `--dev` (corp / allow-anonymous).
@@ -2142,7 +2204,7 @@ function mountAgentRoutes(
     method: "POST",
     pattern: `${base}/v1/dev/evals/runs`,
     auth: httpAuth,
-    handler: async (request) => {
+    handler: async request => {
       const body = await readJsonObject(request);
       const filterIds = asStringArray(body?.filterIds);
       const tags = asStringArray(body?.tags);
@@ -2340,9 +2402,9 @@ function mountAgentRoutes(
         const reminderId = ctx.params.reminderId ?? "";
         try {
           const listed = await reminderRunner.list();
-          const reminder = listed.find((r) => r.id === reminderId);
+          const reminder = listed.find(r => r.id === reminderId);
           if (reminder === undefined) {
-            const ids = listed.map((r) => r.id);
+            const ids = listed.map(r => r.id);
             throw new UnknownReminderError(reminderId, ids);
           }
           const ownership = await assertReminderReadable({
@@ -2476,17 +2538,17 @@ function collectCursorEventSubscriptions(input: {
   const githubTargets = findGitHubChannelTargets(input.mounts);
   const originTargets = findOriginChannelTargets(input.mounts);
   const githubEvents = [
-    ...new Set(githubTargets.flatMap((target) => target.events)),
+    ...new Set(githubTargets.flatMap(target => target.events)),
   ];
   const originEvents = [
-    ...new Set(originTargets.flatMap((target) => target.events)),
+    ...new Set(originTargets.flatMap(target => target.events)),
   ];
   const githubRepos = [
-    ...new Set(input.githubRepos.map((repo) => repo.trim().toLowerCase())),
-  ].filter((repo) => repo.length > 0);
+    ...new Set(input.githubRepos.map(repo => repo.trim().toLowerCase())),
+  ].filter(repo => repo.length > 0);
   const originRepos = [
-    ...new Set(input.originRepos.map((repo) => repo.trim().toLowerCase())),
-  ].filter((repo) => repo.length > 0);
+    ...new Set(input.originRepos.map(repo => repo.trim().toLowerCase())),
+  ].filter(repo => repo.length > 0);
 
   const subscriptions: CursorScmSubscription[] = [];
   if (githubEvents.length > 0 && githubRepos.length > 0) {
@@ -2586,8 +2648,8 @@ function startCursorEventRelay(input: {
     } else if (input.lane === "control-plane") {
       return undefined;
     } else if (
-      input.githubRepos.every((repo) => repo.trim() === "") &&
-      input.originRepos.every((repo) => repo.trim() === "")
+      input.githubRepos.every(repo => repo.trim() === "") &&
+      input.originRepos.every(repo => repo.trim() === "")
     ) {
       logger(
         "[agent-sdk] cursor-events: no repos configured (pass --repo owner/name); relay disabled"
@@ -2608,9 +2670,9 @@ function startCursorEventRelay(input: {
     subscriptions,
     stateDir: join(baseStateRoot, input.stateDirName ?? "cursor-events"),
     logger,
-    dispatch: async (event) => {
+    dispatch: async event => {
       if (event.provider === "origin") {
-        const targets = input.collectOriginTargets().filter((target) => {
+        const targets = input.collectOriginTargets().filter(target => {
           const cursorAccount = target.options.cursorAccount;
           if (
             input.cursorAccountOnly &&
@@ -2622,7 +2684,7 @@ function startCursorEventRelay(input: {
           return typeof cursorAccount !== "object"
             ? true
             : cursorAccount.repos.some(
-                (repo) => repo.toLowerCase() === event.repo.toLowerCase()
+                repo => repo.toLowerCase() === event.repo.toLowerCase()
               );
         });
         const result = await handleAgentServeTrigger({
@@ -2637,7 +2699,7 @@ function startCursorEventRelay(input: {
         return;
       }
       if (event.provider !== "github") return;
-      const targets = input.collectGitHubTargets().filter((target) => {
+      const targets = input.collectGitHubTargets().filter(target => {
         const cursorAccount = target.options.cursorAccount;
         if (
           input.cursorAccountOnly &&
@@ -2649,7 +2711,7 @@ function startCursorEventRelay(input: {
         return typeof cursorAccount !== "object"
           ? true
           : cursorAccount.repos.some(
-              (repo) => repo.toLowerCase() === event.repo.toLowerCase()
+              repo => repo.toLowerCase() === event.repo.toLowerCase()
             );
       });
       const result = await handleAgentServeTrigger({
@@ -2681,9 +2743,9 @@ function logCursorScmDispatch(
   result: Awaited<ReturnType<typeof handleAgentServeTrigger>>
 ): void {
   const outcomes = result.targets
-    .map((target) => formatCursorScmDispatchOutcome(target))
+    .map(target => formatCursorScmDispatchOutcome(target))
     .join(", ");
-  const rejected = result.targets.filter((target) => target.status >= 400);
+  const rejected = result.targets.filter(target => target.status >= 400);
   if (rejected.length > 0) {
     logger(
       `[agent-sdk] cursor-events: dropped ${formatCursorScmEventLog(event)} before hook: ${rejected.map(formatCursorScmDispatchOutcome).join(", ")}`
@@ -2751,7 +2813,7 @@ function resolveCursorGithubEventConfig(input: {
   }
   const repos = [
     ...(input.configured?.repos ?? []),
-    ...input.targets.flatMap((target) => [
+    ...input.targets.flatMap(target => [
       ...(target.accountRuntime.scope?.repos ?? []),
     ]),
   ];
@@ -2813,12 +2875,12 @@ function resolveCursorOriginRepoScope(input: {
     return undefined;
   }
   const wantsHostRepos = input.targets.some(
-    (target) => target.accountRuntime.options.cursorAccount === true
+    target => target.accountRuntime.options.cursorAccount === true
   );
   const repos = [
     ...(wantsHostRepos ? input.explicitRepos : []),
     ...input.targets.flatMap(
-      (target) => target.accountRuntime.scope?.repos ?? []
+      target => target.accountRuntime.scope?.repos ?? []
     ),
   ];
   if (repos.length === 0) {
@@ -2830,7 +2892,7 @@ function resolveCursorOriginRepoScope(input: {
 function buildAgentIndexEntries(runtimes: MountedRuntime[]): AgentIndexEntry[] {
   return runtimes.map(({ slug, project }) => {
     const hasSlack = project.channels.some(
-      (channel) => channel.definition.meta?.kind === "slack"
+      channel => channel.definition.meta?.kind === "slack"
     );
     return {
       slug,
@@ -2877,7 +2939,7 @@ function liveDeploymentSubscriptionUnion(
   targets: readonly CursorDeploymentTarget[]
 ): ResolvedSubscription[] {
   return mergeResolvedSubscriptions(
-    targets.map((target) => resolveDeploymentSubscriptions(target.options))
+    targets.map(target => resolveDeploymentSubscriptions(target.options))
   );
 }
 
@@ -2918,7 +2980,7 @@ function startCursorDeploymentRelay(input: {
     logger(
       `[agent-sdk] deployment-events: no deploy sources yet on ${targets
         .map(
-          (target) =>
+          target =>
             `${target.runtime.slug || target.runtime.project.name}/${target.channelId}`
         )
         .join(", ")}; the relay will register when a channel lists some`
@@ -2935,14 +2997,14 @@ function startCursorDeploymentRelay(input: {
     stateDir: join(baseStateRoot, "deployment-events"),
     subscriptions: () => liveDeploymentSubscriptionUnion(targets),
     logger,
-    dispatch: async (event) =>
+    dispatch: async event =>
       fanOutDeploymentEvent({
         event,
         logger,
-        targets: targets.map((target) => ({
+        targets: targets.map(target => ({
           name: `${target.runtime.slug || target.runtime.project.name}/${target.channelId}`,
           subscriptions: resolveDeploymentSubscriptions(target.options),
-          deliver: (delivered) =>
+          deliver: delivered =>
             dispatchDeploymentEvent({
               options: target.options,
               event: delivered,
@@ -2984,17 +3046,28 @@ function buildChannelHandlerArgs(input: {
         auth: sendOptions.auth !== undefined ? sendOptions.auth : auth,
         hostedSessionId: input.hostedSessionId,
       }),
-    getSession: (sessionId) =>
+    getSession: sessionId =>
       runtime.engine.getChannelSession(channelId, sessionId),
     receive: (target, inputReceive) =>
       runtime.engine.receive(target, inputReceive),
     callTool: (toolName, toolInput, callOptions) =>
       runtime.engine.callTool(toolName, toolInput, callOptions),
-    waitUntil: (promise) => {
+    waitUntil: promise => {
       runtime.engine.trackBackground(promise);
     },
     sessionUrls: (req, sessionId) =>
       sessionUrlsForRequest(req, base, sessionId),
+    hasContinuationSession: continuationToken =>
+      runtime.engine.hasContinuationSession(channelId, continuationToken),
+    isContinuationBusy: continuationToken =>
+      runtime.engine.isContinuationBusy(channelId, continuationToken),
+    getContinuationLastBotMessageTs: continuationToken =>
+      runtime.engine.getContinuationLastBotMessageTs(
+        channelId,
+        continuationToken
+      ),
+    interruptContinuation: continuationToken =>
+      runtime.engine.interruptContinuation(channelId, continuationToken),
   };
 }
 
@@ -3120,22 +3193,10 @@ async function resolveAuth(
 
 async function toFetchRequest(req: IncomingMessage): Promise<Request> {
   const method = req.method ?? "GET";
-  const hostHeader = req.headers.host ?? "127.0.0.1";
+  const hostHeader = incomingRequestHost(req.headers);
   const url = new URL(req.url ?? "/", `http://${hostHeader}`);
-
-  const headers = new Headers();
-  for (const [key, value] of Object.entries(req.headers)) {
-    if (value === undefined) {
-      continue;
-    }
-    if (Array.isArray(value)) {
-      for (const item of value) {
-        headers.append(key, item);
-      }
-    } else {
-      headers.set(key, value);
-    }
-  }
+  // Drop HTTP/2 pseudo-headers (`:method`, …) — Fetch `Headers` rejects them.
+  const headers = incomingHeadersToFetch(req.headers);
 
   if (method === "GET" || method === "HEAD") {
     return new Request(url, { method, headers });
@@ -3192,7 +3253,7 @@ async function writeFetchResponse(
 
   const reader = response.body.getReader();
   let clientGone = false;
-  const closed = new Promise<void>((resolve) => {
+  const closed = new Promise<void>(resolve => {
     res.once("close", () => {
       if (!res.writableFinished) {
         clientGone = true;