@cursor/july 0.1.104 → 0.1.107

package/src/internal/hosted-delivery-protocol.ts

@@ -2,6 +2,43 @@ export const HOSTED_DELIVERY_PROTOCOL_VERSION = 2;
 export const HOSTED_DELIVERY_HEADER = "x-agent-sdk-hosted-delivery";
 export const HOSTED_ADMISSION_PATH = "/v1/internal/hosted-admission";
 export const HOSTED_EXECUTION_PATH = "/v1/internal/hosted-execution";
+export const HOSTED_GUEST_RETRY_TRANSIENT = "transient";
+export const HOSTED_GUEST_RETRY_TERMINAL = "terminal";
+
+export type HostedGuestRetryDisposition =
+  | typeof HOSTED_GUEST_RETRY_TRANSIENT
+  | typeof HOSTED_GUEST_RETRY_TERMINAL;
+
+export type HostedGuestError = {
+  ok: false;
+  error: string;
+  retry: HostedGuestRetryDisposition;
+  message?: string;
+  turnStatus?: string;
+};
+
+/**
+ * Hosted delivery is the only HTTP surface whose failures drive Temporal
+ * retries. Keep its retry disposition explicit instead of making the shared
+ * HTTP error helper guess from a status code.
+ */
+export function hostedGuestErrorResponse(input: {
+  status: number;
+  error: string;
+  retry: HostedGuestRetryDisposition;
+  message?: string;
+  turnStatus?: string;
+}): Response {
+  const body: HostedGuestError = {
+    ok: false,
+    error: input.error,
+    retry: input.retry,
+    message: input.message,
+    turnStatus: input.turnStatus,
+  };
+  return Response.json(body, { status: input.status });
+}
+
 /**
  * Filename under the serve `--state-root` (not the per-slug SessionEngine
  * dir). Hosted freeze uses `/workspace/.agent-serve`; the Temporal host
@@ -10,6 +47,25 @@ export const HOSTED_EXECUTION_PATH = "/v1/internal/hosted-execution";
  */
 export const HOSTED_EXECUTION_DIAG_FILENAME = "hosted-execution.json";
 
+/**
+ * Reserved hosted-admission `channelKind` for durable reminder fires.
+ * Bypasses authored channel admission and invokes ReminderRunner.dispatch.
+ * Backend builds envelopes with this constant + {@link HOSTED_REMINDER_EVENT_TYPE}.
+ */
+export const HOSTED_REMINDER_CHANNEL_KIND = "agent-sdk:reminder";
+
+/**
+ * Reserved hosted-admission `eventType` for durable reminder fires.
+ * Payload is {@link HostedReminderFirePayload}.
+ */
+export const HOSTED_REMINDER_EVENT_TYPE = "agent-sdk.reminder/fire";
+
+/** Compact reminder-fire payload on the reserved hosted-admission path. */
+export type HostedReminderFirePayload = {
+  reminderId: string;
+  fireCount: number;
+};
+
 export type HostedAdmissionManagedAutomation = {
   automationUuid: string;
   mcpServerNames: string[];
@@ -171,6 +227,46 @@ export function parseHostedExecution(
   return body as HostedExecution;
 }
 
+/**
+ * True when the admission envelope is the reserved internal reminder fire
+ * path (not an authored channel event).
+ */
+export function isHostedReminderAdmission(delivery: HostedAdmission): boolean {
+  return (
+    delivery.channelKind === HOSTED_REMINDER_CHANNEL_KIND &&
+    delivery.eventType === HOSTED_REMINDER_EVENT_TYPE
+  );
+}
+
+/**
+ * Parse `{ reminderId, fireCount }` from a reserved reminder admission
+ * payload. Rejects unknown keys and non-integer fireCount.
+ */
+export function parseHostedReminderFirePayload(
+  value: unknown
+): HostedReminderFirePayload | undefined {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return undefined;
+  }
+  const body = value as Record<string, unknown>;
+  const keys = Object.keys(body);
+  if (
+    keys.length !== 2 ||
+    !Object.hasOwn(body, "reminderId") ||
+    !Object.hasOwn(body, "fireCount") ||
+    !boundedString(body.reminderId, 128) ||
+    typeof body.fireCount !== "number" ||
+    !Number.isInteger(body.fireCount) ||
+    body.fireCount < 0
+  ) {
+    return undefined;
+  }
+  return {
+    reminderId: body.reminderId,
+    fireCount: body.fireCount,
+  };
+}
+
 export function parseHostedAdmissionOutcome(
   value: unknown
 ): HostedAdmissionOutcome | undefined {

package/src/internal/hosted-delivery.ts

@@ -36,9 +36,15 @@ import {
   HOSTED_DELIVERY_HEADER,
   HOSTED_DELIVERY_PROTOCOL_VERSION,
   HOSTED_EXECUTION_PATH,
+  HOSTED_GUEST_RETRY_TERMINAL,
+  HOSTED_GUEST_RETRY_TRANSIENT,
   type HostedAdmission,
+  type HostedGuestRetryDisposition,
+  hostedGuestErrorResponse,
+  isHostedReminderAdmission,
   parseHostedAdmission,
   parseHostedExecution,
+  parseHostedReminderFirePayload,
 } from "./hosted-delivery-protocol.js";
 import {
   abortReasonFromTurnStatus,
@@ -50,9 +56,13 @@ import {
   type HostedExecutionFlushSinks,
 } from "./hosted-execution-flush.js";
 import { recordHostedManagedAutomation } from "./hosted-managed-automation.js";
-import { errorResponse, readJsonObject } from "./http-channel.js";
+import { readJsonObject } from "./http-channel.js";
 import type { LogRingEntry } from "./log-ring.js";
 import { endActiveHttpSpan } from "./otel/http.js";
+import {
+  ReminderValidationError,
+  UnknownReminderError,
+} from "./reminder-runner.js";
 import { statusForThrownRequestError } from "./request-error-status.js";
 import type { Router } from "./router.js";
 import type { SessionRunExecutionWrite } from "./session-run-log.js";
@@ -108,6 +118,32 @@ function boundedMessage(text: string): string {
     : text;
 }
 
+function terminalHostedError(
+  status: number,
+  error: string,
+  message?: string
+): Response {
+  return hostedGuestErrorResponse({
+    status,
+    error,
+    retry: HOSTED_GUEST_RETRY_TERMINAL,
+    message,
+  });
+}
+
+function transientHostedError(
+  status: number,
+  error: string,
+  message?: string
+): Response {
+  return hostedGuestErrorResponse({
+    status,
+    error,
+    retry: HOSTED_GUEST_RETRY_TRANSIENT,
+    message,
+  });
+}
+
 /**
  * Classify deterministic authored protocol violations as non-retryable 422
  * admissions. Anything else returns `undefined` so callers fall through to
@@ -126,7 +162,7 @@ function nonRetryableRejection(error: unknown): AdmissionDispatch | undefined {
     return undefined;
   }
   return {
-    response: errorResponse(
+    response: terminalHostedError(
       422,
       code,
       boundedMessage((error as Error).message)
@@ -150,10 +186,7 @@ export async function dispatchHostedAdmission(
   const adapter = getHostedAdmissionAdapter(input.definition);
   if (adapter === undefined || adapter.kind !== input.delivery.channelKind) {
     return {
-      response: Response.json(
-        { ok: false, error: "channel_kind_mismatch" },
-        { status: 422 }
-      ),
+      response: terminalHostedError(422, "channel_kind_mismatch"),
     };
   }
   // The admission window marker follows the async graph into task bodies so
@@ -161,6 +194,70 @@ export async function dispatchHostedAdmission(
   return runDuringHostedAdmission(() => runAdmission(input, adapter));
 }
 
+/**
+ * Reserved reminder admission: parse the compact payload and invoke
+ * ReminderRunner.dispatch. Returns a standard hosted outcome (`task` /
+ * `skip`) and never opens the send-capture / model-session path here —
+ * prompt-form fires still follow up inside the runner.
+ */
+async function dispatchHostedReminderAdmission(
+  input: {
+    fireReminder?(
+      reminderId: string,
+      expectedFireCount: number
+    ): Promise<{
+      reminderId: string;
+      outcome: "fired" | "noop";
+      reason?: string;
+    }>;
+  },
+  delivery: HostedAdmission
+): Promise<Response> {
+  if (input.fireReminder === undefined) {
+    return transientHostedError(
+      503,
+      "reminder_dispatch_unavailable",
+      "This guest has no reminder runner wired for hosted admission."
+    );
+  }
+  const payload = parseHostedReminderFirePayload(delivery.payload);
+  if (payload === undefined) {
+    return terminalHostedError(
+      400,
+      "invalid_reminder_payload",
+      "Expected reminder payload { reminderId, fireCount }."
+    );
+  }
+  try {
+    const result = await input.fireReminder(
+      payload.reminderId,
+      payload.fireCount
+    );
+    const outcome = result.outcome === "noop" ? "skip" : "task";
+    return Response.json({
+      ok: true,
+      v: HOSTED_DELIVERY_PROTOCOL_VERSION,
+      outcome,
+    });
+  } catch (error) {
+    if (error instanceof UnknownReminderError) {
+      return terminalHostedError(
+        404,
+        "unknown_reminder",
+        boundedMessage(error.message)
+      );
+    }
+    if (error instanceof ReminderValidationError) {
+      return terminalHostedError(
+        400,
+        "invalid_reminder",
+        boundedMessage(error.message)
+      );
+    }
+    throw error;
+  }
+}
+
 async function runAdmission(
   input: DispatchInput,
   adapter: HostedAdmissionAdapter
@@ -198,9 +295,9 @@ async function runAdmission(
   }
   if (!dispatched.ok) {
     return {
-      response: Response.json(
-        { ok: false, error: "channel_dispatch_failed" },
-        { status: dispatched.status >= 400 ? dispatched.status : 502 }
+      response: terminalHostedError(
+        dispatched.status >= 400 ? dispatched.status : 502,
+        "channel_dispatch_failed"
       ),
     };
   }
@@ -213,7 +310,7 @@ async function runAdmission(
       return rejected;
     }
     return {
-      response: errorResponse(
+      response: terminalHostedError(
         503,
         "background_dispatch_failed",
         boundedMessage(error instanceof Error ? error.message : String(error))
@@ -240,10 +337,7 @@ async function runAdmission(
   const outcome = dispatchOutcome(dispatched);
   if (outcome === undefined || outcome === "send") {
     return {
-      response: Response.json(
-        { ok: false, error: "channel_outcome_missing" },
-        { status: 502 }
-      ),
+      response: terminalHostedError(502, "channel_outcome_missing"),
     };
   }
   return {
@@ -329,6 +423,19 @@ export function registerHostedDeliveryRoute(input: {
     channelId: string,
     sessionPublicId?: string
   ): ChannelHandlerArgs;
+  /**
+   * Reserved reminder admission: dispatch a hydrated ReminderRunner fire
+   * without authored channel admission. Returns the runner's outcome so the
+   * route can map fired → task and noop → skip.
+   */
+  fireReminder?(
+    reminderId: string,
+    expectedFireCount: number
+  ): Promise<{
+    reminderId: string;
+    outcome: "fired" | "noop";
+    reason?: string;
+  }>;
   /**
    * Await the session's durable mirror (dispatch chain + storage queue)
    * before the execution reply: the control plane may park the pod the
@@ -358,6 +465,13 @@ export function registerHostedDeliveryRoute(input: {
   flushStartLog?(startLogId: string): Promise<void>;
   /** Snapshot of the process log ring at persist time. */
   snapshotLogs?(): LogRingEntry[];
+  /**
+   * Drop the cached SDK agent handle before the HTTP reply. Hosted v2
+   * hibernates this process as soon as the reply lands; leaving the handle
+   * in memory freezes a dead Connect/HTTP2 session that the next wake
+   * then reuses.
+   */
+  evictSdkSession?(sessionId: string): void;
   /**
    * Wait until guest egress works before authored admission/execution.
    * Defaults to {@link waitForGuestNetworkReady}. Tests inject a stub.
@@ -393,7 +507,11 @@ export function registerHostedDeliveryRoute(input: {
     const consumed = consumeBoundSecrets();
     return consumed.ok
       ? undefined
-      : errorResponse(503, consumed.code, boundedMessage(consumed.message));
+      : transientHostedError(
+          503,
+          consumed.code,
+          boundedMessage(consumed.message)
+        );
   };
   const finishNetworkWait = async (
     phase: "admission" | "execution"
@@ -416,7 +534,7 @@ export function registerHostedDeliveryRoute(input: {
             : "Guest network is not ready for outbound requests.";
       return {
         timing,
-        response: errorResponse(
+        response: transientHostedError(
           503,
           GUEST_NETWORK_UNAVAILABLE,
           boundedMessage(message)
@@ -463,23 +581,44 @@ export function registerHostedDeliveryRoute(input: {
         if (unconsumed !== undefined) {
           return finish(unconsumed);
         }
-        const delivery = parseHostedAdmission(await readJsonObject(request));
+        const rawAdmission = await readJsonObject(request);
+        const delivery = parseHostedAdmission(rawAdmission);
         if (delivery === undefined) {
+          const rawKeys =
+            typeof rawAdmission === "object" &&
+            rawAdmission !== null &&
+            !Array.isArray(rawAdmission)
+              ? Object.keys(rawAdmission as Record<string, unknown>)
+              : [];
+          console.info(
+            `[agent-sdk] hosted admission rejected: envelope failed to parse keys=${JSON.stringify(rawKeys)} hasManagedAutomation=${String(rawKeys.includes("managedAutomation"))}`
+          );
           return finish(
-            errorResponse(
+            terminalHostedError(
               400,
               "invalid_hosted_admission",
               "Expected a supported Agent SDK hosted-admission envelope."
             )
           );
         }
+        console.info(
+          `[agent-sdk] hosted admission received deliveryId=${delivery.deliveryId} channelId=${delivery.channelId} channelKind=${delivery.channelKind} eventType=${delivery.eventType} sessionMode=${delivery.sessionMode} managedAutomation=${delivery.managedAutomation === undefined ? "<absent>" : `automationUuid=${delivery.managedAutomation.automationUuid} mcpServerNames=${String(delivery.managedAutomation.mcpServerNames.length)} slackChannels=${delivery.managedAutomation.slackChannels === undefined ? "<absent>" : JSON.stringify(delivery.managedAutomation.slackChannels)}`}`
+        );
         recordHostedManagedAutomation(delivery);
+        if (isHostedReminderAdmission(delivery)) {
+          const network = await finishNetworkWait("admission");
+          guestNetwork = network.timing;
+          if (network.response !== undefined) {
+            return finish(network.response);
+          }
+          return finish(await dispatchHostedReminderAdmission(input, delivery));
+        }
         const channel = input.channels.find(
           (candidate) => candidate.id === delivery.channelId
         );
         if (channel === undefined) {
           return finish(
-            errorResponse(
+            terminalHostedError(
               404,
               "channel_not_found",
               `No channel named "${delivery.channelId}" is mounted.`
@@ -536,7 +675,7 @@ export function registerHostedDeliveryRoute(input: {
         const execution = parseHostedExecution(await readJsonObject(request));
         if (execution === undefined) {
           return finish(
-            errorResponse(
+            terminalHostedError(
               400,
               "invalid_hosted_execution",
               "Expected a supported Agent SDK hosted-execution envelope."
@@ -547,7 +686,7 @@ export function registerHostedDeliveryRoute(input: {
         const admitted = pending.get(execution.admissionToken);
         if (admitted === undefined) {
           return finish(
-            errorResponse(
+            transientHostedError(
               409,
               "hosted_admission_unavailable",
               "The hosted admission token is missing or expired."
@@ -559,7 +698,7 @@ export function registerHostedDeliveryRoute(input: {
           admitted.sessionPublicId !== execution.sessionPublicId
         ) {
           return finish(
-            errorResponse(
+            transientHostedError(
               409,
               "hosted_admission_session_mismatch",
               "The hosted admission token is already bound to another session."
@@ -624,6 +763,7 @@ export function registerHostedDeliveryRoute(input: {
             sessionId: "",
             turnStatus: HOSTED_EXECUTION_DIAG_RUNNING_STATUS,
           });
+          let sessionId = "";
           try {
             const args = input.buildHandlerArgs(
               admitted.send.channelId,
@@ -635,10 +775,19 @@ export function registerHostedDeliveryRoute(input: {
                 key: admitted.send.mailboxContinuationKey,
               },
             });
+            sessionId = session.id;
             const outcome = await session.waitForCompletion();
             // Failed turns drain too: their record/continuation updates must
             // survive the park just like a finished turn's.
             await input.drainSessionDurability?.(session.id);
+            // Evict before the reply: TAS parks and hibernates this process
+            // as soon as the POST returns. A leftover SDK handle freezes a
+            // dead Connect/HTTP2 session that the next wake then reuses.
+            evictHostedSdkSessions(
+              input.evictSdkSession,
+              session.id,
+              execution.sessionPublicId
+            );
             await writeDiag({
               sessionId: session.id,
               turnStatus: outcome.status,
@@ -652,11 +801,15 @@ export function registerHostedDeliveryRoute(input: {
               // waitForCompletion resolves (does not throw) on a quiet
               // Connect abort. Map that to guest_connect_stalled so TAS
               // retries the same pod. Real runner failures stay turn_failed.
+              const hostedFailure = hostedFailureForUnfinishedTurn(
+                outcome.errorMessage
+              );
               return {
                 status: 503,
                 body: {
                   ok: false,
-                  error: hostedErrorForUnfinishedTurn(outcome.errorMessage),
+                  error: hostedFailure.error,
+                  retry: hostedFailure.retry,
                   turnStatus: outcome.status,
                   message: outcome.errorMessage,
                 },
@@ -671,6 +824,11 @@ export function registerHostedDeliveryRoute(input: {
               },
             };
           } catch (error) {
+            evictHostedSdkSessions(
+              input.evictSdkSession,
+              sessionId,
+              execution.sessionPublicId
+            );
             await writeDiag({
               sessionId: "",
               turnStatus: "error",
@@ -687,16 +845,37 @@ export function registerHostedDeliveryRoute(input: {
   });
 }
 
-function hostedErrorForUnfinishedTurn(
-  errorMessage: string | undefined
-): typeof GUEST_CONNECT_STALLED | "turn_failed" {
+function evictHostedSdkSessions(
+  evict: ((sessionId: string) => void) | undefined,
+  ...ids: Array<string | undefined>
+): void {
+  if (evict === undefined) {
+    return;
+  }
+  const seen = new Set<string>();
+  for (const id of ids) {
+    if (id === undefined || id === "" || seen.has(id)) {
+      continue;
+    }
+    seen.add(id);
+    evict(id);
+  }
+}
+
+function hostedFailureForUnfinishedTurn(errorMessage: string | undefined): {
+  error: typeof GUEST_CONNECT_STALLED | "turn_failed";
+  retry: HostedGuestRetryDisposition;
+} {
   if (
     errorMessage !== undefined &&
     isQuietGuestConnectStallMessage(errorMessage)
   ) {
-    return GUEST_CONNECT_STALLED;
+    return {
+      error: GUEST_CONNECT_STALLED,
+      retry: HOSTED_GUEST_RETRY_TRANSIENT,
+    };
   }
-  return "turn_failed";
+  return { error: "turn_failed", retry: HOSTED_GUEST_RETRY_TERMINAL };
 }
 
 async function afterHostedWork<T>(

package/src/internal/hosted-managed-automation.ts

@@ -17,10 +17,36 @@
 
 import type { HostedAdmissionManagedAutomation } from "./hosted-delivery-protocol.js";
 
-const managedAutomationByDelivery = new Map<
-  string,
-  { managedAutomation: HostedAdmissionManagedAutomation; expiresAt: number }
->();
+type ManagedAutomationEntry = {
+  managedAutomation: HostedAdmissionManagedAutomation;
+  expiresAt: number;
+};
+
+/**
+ * Process-wide slot for the table. Hosted engines run the compiled CLI
+ * (`dist/`), which records at admission, while first-party factory agents
+ * relative-import this file from `src/` and read at finalize — two module
+ * instances in one process. A module-local Map would be recorded in one
+ * copy and read from the other (always undefined, so a fork never sees its
+ * Slack channels or MCP servers); the shared symbol keeps one table.
+ */
+const MANAGED_AUTOMATION_TABLE_KEY = Symbol.for(
+  "cursor.agentkit.hostedManagedAutomationByDelivery"
+);
+
+function managedAutomationTable(): Map<string, ManagedAutomationEntry> {
+  const slots = globalThis as unknown as Record<
+    symbol,
+    Map<string, ManagedAutomationEntry> | undefined
+  >;
+  let table = slots[MANAGED_AUTOMATION_TABLE_KEY];
+  if (table === undefined) {
+    table = new Map();
+    slots[MANAGED_AUTOMATION_TABLE_KEY] = table;
+  }
+  return table;
+}
+
 /** Long enough to outlive a slow review run kicked off by the delivery. */
 const MANAGED_AUTOMATION_TTL_MS = 60 * 60_000;
 const MANAGED_AUTOMATION_MAX_ENTRIES = 10_000;
@@ -30,8 +56,12 @@ export function recordHostedManagedAutomation(delivery: {
   managedAutomation?: HostedAdmissionManagedAutomation;
 }): void {
   if (delivery.managedAutomation === undefined) {
+    console.info(
+      `[agent-sdk] hosted managedAutomation not recorded deliveryId=${delivery.deliveryId}: admission envelope carried no managedAutomation slice (non-managed delivery, or the control plane resolved no MCP servers and no Slack channels)`
+    );
     return;
   }
+  const managedAutomationByDelivery = managedAutomationTable();
   const now = Date.now();
   for (const [key, entry] of managedAutomationByDelivery) {
     if (entry.expiresAt <= now) {
@@ -39,12 +69,19 @@ export function recordHostedManagedAutomation(delivery: {
     }
   }
   if (managedAutomationByDelivery.size >= MANAGED_AUTOMATION_MAX_ENTRIES) {
+    console.info(
+      `[agent-sdk] hosted managedAutomation table full (${String(managedAutomationByDelivery.size)} entries); clearing before recording deliveryId=${delivery.deliveryId}`
+    );
     managedAutomationByDelivery.clear();
   }
   managedAutomationByDelivery.set(delivery.deliveryId, {
     managedAutomation: delivery.managedAutomation,
     expiresAt: now + MANAGED_AUTOMATION_TTL_MS,
   });
+  const slackChannels = delivery.managedAutomation.slackChannels;
+  console.info(
+    `[agent-sdk] hosted managedAutomation recorded deliveryId=${delivery.deliveryId} automationUuid=${delivery.managedAutomation.automationUuid} mcpServerNames=${String(delivery.managedAutomation.mcpServerNames.length)} slackChannels=${slackChannels === undefined ? "<absent>" : JSON.stringify(slackChannels)} ttlMs=${String(MANAGED_AUTOMATION_TTL_MS)} tableSize=${String(managedAutomationByDelivery.size)}`
+  );
 }
 
 /**
@@ -55,11 +92,18 @@ export function recordHostedManagedAutomation(delivery: {
 export function getHostedManagedAutomation(
   deliveryId: string
 ): HostedAdmissionManagedAutomation | undefined {
+  const managedAutomationByDelivery = managedAutomationTable();
   const entry = managedAutomationByDelivery.get(deliveryId);
   if (entry === undefined) {
+    console.info(
+      `[agent-sdk] hosted managedAutomation lookup miss deliveryId=${deliveryId}: no entry (never recorded in this process, or evicted) tableSize=${String(managedAutomationByDelivery.size)} knownDeliveryIds=${JSON.stringify([...managedAutomationByDelivery.keys()].slice(0, 10))}`
+    );
     return undefined;
   }
   if (entry.expiresAt <= Date.now()) {
+    console.info(
+      `[agent-sdk] hosted managedAutomation lookup expired deliveryId=${deliveryId} automationUuid=${entry.managedAutomation.automationUuid} expiredMsAgo=${String(Date.now() - entry.expiresAt)}`
+    );
     managedAutomationByDelivery.delete(deliveryId);
     return undefined;
   }
@@ -68,5 +112,5 @@ export function getHostedManagedAutomation(
 
 /** Drop recorded managed-automation slices (tests only). */
 export function resetHostedManagedAutomationForTest(): void {
-  managedAutomationByDelivery.clear();
+  managedAutomationTable().clear();
 }

package/src/internal/init-project.ts

@@ -77,6 +77,7 @@ const TEMPLATES: Readonly<Record<TemplateName, TemplateEntry>> = {
   "agents-md": { dir: "agents-md" },
   "code-wiki": { dir: "code-wiki" },
   demo: { dir: "demo" },
+  "grokbot-agents": { dir: "grokbot-agents" },
   "pr-autofixer": { dir: "pr-autofixer" },
   "security-help": { dir: "security-help" },
   "security-reviewer": { dir: "security-reviewer" },
@@ -711,6 +712,7 @@ export function printInitGuide(): void {
 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 ./grokbot --template grokbot-agents    # talk to Grok Bot agents
   npx ${PACKAGE_NAME} init ./code-wiki --template code-wiki       # keep wiki pages current after merge
   npx ${PACKAGE_NAME} init ./agents-md --template agents-md       # keep AGENTS.md current from last week's PRs and Slack
   npx ${PACKAGE_NAME} init ./my-reviewer --template security-reviewer   # review PRs for security bugs
@@ -719,8 +721,9 @@ Scaffold a project, then open the playground:
   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
   npx ${PACKAGE_NAME} init ./pr-autofixer --template pr-autofixer # fix PRs on a cloud VM
-  # TTY asks for GitHub repos. Scripts pass --var:
+  # TTY asks the template's questions. Scripts pass --var:
   #   --var repos=acme/widgets,acme/api
+  #   --var agents="Plan Keeper, Chief of Staff"
   cd ./my-agent && agent-sdk dev        # or: npx ${PACKAGE_NAME} dev
 
 Recommended loop once the project exists (from the project directory):