@cursor/july 0.1.104 → 0.1.107

package/src/files.ts

@@ -163,8 +163,10 @@ export const AGENT_SERVE_USER_STORE_KEY_PREFIX = "agent-serve";
  * Skills sit at store-root `skills/<name>/…` so exec-daemon's
  * `--agent-store-skills-dir` walk finds them the same way it finds user-store
  * skills. Workspace seeds sit at store-root `workspace/…` so the mount path
- * the first cloud prompt names stays short. Memory and artifacts stay under
- * {@link STORAGE_KEY_ROOT}.
+ * the first cloud prompt names stays short. Per-turn `workspaceFiles` sit at
+ * `sessions/<sessionId>/workspace/…` on that same shared mount (replace on
+ * later sends; wipe when a task session ends). Memory and artifacts stay
+ * under {@link STORAGE_KEY_ROOT}.
  */
 function createAgentStoreKeys(root: string) {
   return {
@@ -191,6 +193,11 @@ function createAgentStoreKeys(root: string) {
     /** Personal-key cloud agents: namespaced like {@link userSkillsPrefix}. */
     userWorkspacePrefix: (agent: string): string =>
       `${AGENT_SERVE_USER_STORE_KEY_PREFIX}/${agent}/workspace/`,
+    sessionWorkspacePrefix: (sessionId: string): string =>
+      `sessions/${sessionId}/workspace/`,
+    /** Personal-key cloud agents: namespaced like {@link sessionWorkspacePrefix}. */
+    userSessionWorkspacePrefix: (agent: string, sessionId: string): string =>
+      `${AGENT_SERVE_USER_STORE_KEY_PREFIX}/${agent}/sessions/${sessionId}/workspace/`,
     memoryDir: (agent: string): string => `${root}/${agent}/memory`,
     memoryJournal: (agent: string): string =>
       `${root}/${agent}/memory/journal.jsonl`,

package/src/index.ts

@@ -139,7 +139,9 @@ export {
   TOOL_MCP_ENDPOINT_PATH,
 } from "./internal/mcp-endpoint.js";
 export {
+  REMINDER_ARGS_MAX_BYTES,
   ReminderValidationError,
+  rejectAnonymousReminderHandlers,
   UnknownReminderError,
 } from "./internal/reminder-runner.js";
 export type { AgentMount } from "./internal/server.js";
@@ -169,8 +171,10 @@ export { prompt } from "./prompt.js";
 export type {
   ReminderBusyPolicy,
   ReminderCreateInput,
+  ReminderDefinition,
   ReminderFireContext,
   ReminderFireResult,
+  ReminderHandlerConfig,
   ReminderHostApi,
   ReminderInfo,
   ReminderReschedule,
@@ -179,6 +183,7 @@ export type {
   ReminderTarget,
   ReminderUntilContext,
 } from "./reminders.js";
+export { defineReminder } from "./reminders.js";
 export { defineResult } from "./result.js";
 export { defineSchedule } from "./schedules.js";
 export { defineSkill } from "./skills.js";
@@ -226,9 +231,7 @@ export {
 
 /**
  * Runtime config for an agent — authored at `agent/agent.ts` (the root
- * agent) or `agent/subagents/<id>/agent.ts` (a subagent). Set
- * `architecture: "v2"` to deploy onto the v2 control plane; omitted
- * channel continuation then inherits kind `/v2` defaults.
+ * agent) or `agent/subagents/<id>/agent.ts` (a subagent).
  */
 export function defineAgent(config: AgentConfig): AgentConfigDefinition {
   return brandDefinition("agent", config);

package/src/internal/cli-deploy.ts

@@ -1570,14 +1570,26 @@ export async function cmdDelete(
   if (typeof ctx === "number") {
     return ctx;
   }
-  let accepted: DeleteAccepted;
+  // Same dispatch as `stop`: v1 409s architecture-v2 slugs, so the v2
+  // DELETE goes first. A v2 404 (missing slug, or an older backend)
+  // falls through to the v1 agent-serve delete.
+  let architecture: "v1" | "v2" = "v2";
+  let accepted: DeleteAccepted | AgentkitStopAccepted;
   try {
-    accepted = await ctx.client.deleteDeployment({
-      teamId: ctx.teamId,
-      slug,
-    });
+    accepted = await ctx.client.deleteAgentkit({ 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.deleteDeployment({
+        teamId: ctx.teamId,
+        slug,
+      });
+      architecture = "v1";
+    } catch (v1Error) {
+      return renderApiError(v1Error, ctx.err);
+    }
   }
   if (ctx.noWait) {
     if (ctx.json) {
@@ -1588,7 +1600,11 @@ export async function cmdDelete(
     return 0;
   }
   try {
-    await pollUntilGone(ctx, slug);
+    await pollUntilGone(ctx, slug, () =>
+      architecture === "v2"
+        ? ctx.client.getAgentkitDeploy({ teamId: ctx.teamId, slug })
+        : ctx.client.getDeployment({ teamId: ctx.teamId, slug })
+    );
   } catch (error) {
     return renderApiError(error, ctx.err);
   }
@@ -2103,7 +2119,12 @@ function transientDeployStatusWaitMs(
  */
 async function pollUntilGone(
   ctx: DeployCliContext,
-  slug: string
+  slug: string,
+  getDetail: () => Promise<{
+    status: string;
+    progress?: DeploymentProgress;
+    statusMessage?: string | null;
+  }>
 ): Promise<void> {
   const startedAt = Date.now();
   const tty = process.stderr.isTTY === true;
@@ -2126,10 +2147,7 @@ async function pollUntilGone(
 
   for (;;) {
     try {
-      const detail = await ctx.client.getDeployment({
-        teamId: ctx.teamId,
-        slug,
-      });
+      const detail = await getDetail();
       report(deployProgressLabel(detail));
     } catch (error: unknown) {
       if (error instanceof DeployApiError && error.status === 404) {

package/src/internal/cursor/backend-client.ts

@@ -82,6 +82,37 @@ const githubTokenResponseSchema: z.ZodType<CursorGithubToken> = z.object({
   expiresAt: z.string().datetime(),
 });
 
+/** SCMs whose git fetches ride the backend's `/v0/scm-events/<provider>-git-proxy` routes. */
+export type CursorScmCloneProvider = "gitlab" | "bitbucket";
+
+/**
+ * Proxied clone target for a GitLab / Bitbucket repository. The backend
+ * never hands out the provider credential: git fetches go to `remoteUrl`
+ * on the backend with the caller's own Cursor API key as a bearer token,
+ * and the backend adds the tenant credential per request.
+ */
+export interface CursorScmCloneTarget {
+  /** Absolute `<backend>/v0/scm-events/<provider>-git-proxy/<repo>.git`. */
+  remoteUrl: string;
+  /** Bearer credential git presents to the backend (the caller's API key). */
+  token: string;
+  /** ISO timestamp after which the caller re-resolves the target. */
+  expiresAt: string;
+  username: string;
+  authMode: "bearer";
+}
+
+const scmCloneTargetResponseSchema = z.object({
+  expiresAt: z.string().datetime(),
+  clone: z.object({
+    remotePath: z
+      .string()
+      .regex(/^\/v0\/scm-events\/[a-z]+-git-proxy\/.+\.git$/),
+    username: z.string().min(1),
+    authMode: z.literal("bearer"),
+  }),
+});
+
 const mcpToolSchema = z.object({
   name: z.string(),
   providerIdentifier: z.string().optional(),
@@ -490,6 +521,62 @@ export class CursorBackendClient {
     return githubTokenResponseSchema.parse(parsed);
   }
 
+  /**
+   * Resolve the proxied clone target for a GitLab / Bitbucket repository
+   * (`owner/name`; GitLab `path_with_namespace`). Same authorization as the
+   * provider proxy this host already calls; the returned remote lives on
+   * the backend and takes this client's API key, never a provider token.
+   */
+  async getScmCloneTarget(
+    provider: CursorScmCloneProvider,
+    repo: string
+  ): Promise<CursorScmCloneTarget> {
+    const label = provider === "gitlab" ? "GitLab" : "Bitbucket";
+    let response: Response;
+    try {
+      response = await this.fetchImpl(
+        `${this.backendUrl}/v0/scm-events/${provider}-clone-target`,
+        {
+          method: "POST",
+          headers: {
+            "content-type": "application/json",
+            authorization: `Bearer ${this.currentApiKey()}`,
+          },
+          body: JSON.stringify({ repo }),
+          signal: AbortSignal.timeout(30_000),
+        }
+      );
+    } catch (error) {
+      throw new CursorBackendError(
+        `Cursor ${label} clone target request failed: ${describeError(error)}`
+      );
+    }
+    const text = await response.text();
+    if (!response.ok) {
+      throw new CursorBackendError(
+        describeGithubTokenHttpFailure(response.status, text, label),
+        response.status,
+        retryAfterMsFromResponse(response)
+      );
+    }
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(text) as unknown;
+    } catch {
+      throw new CursorBackendError(
+        `Cursor backend returned a non-JSON ${label} clone target response.`
+      );
+    }
+    const body = scmCloneTargetResponseSchema.parse(parsed);
+    return {
+      remoteUrl: `${this.backendUrl}${body.clone.remotePath}`,
+      token: this.currentApiKey(),
+      expiresAt: body.expiresAt,
+      username: body.clone.username,
+      authMode: body.clone.authMode,
+    };
+  }
+
   /**
    * One unary Connect-JSON call on `aiserver.v1.<service>` with the same
    * token exchange and 401 retry as the dashboard RPCs. Callers parse the
@@ -864,7 +951,8 @@ const MAX_GITHUB_TOKEN_RETRY_AFTER_MS = 60 * 60_000;
  */
 function describeGithubTokenHttpFailure(
   status: number,
-  bodyText: string
+  bodyText: string,
+  label = "GitHub"
 ): string {
   const detail = githubTokenErrorFromBody(bodyText);
   if (status === 401) {
@@ -875,7 +963,7 @@ function describeGithubTokenHttpFailure(
   if (detail !== undefined) {
     return detail;
   }
-  return `Cursor GitHub credential request failed (${status}).`;
+  return `Cursor ${label} credential request failed (${status}).`;
 }
 
 function githubTokenErrorFromBody(bodyText: string): string | undefined {

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

@@ -7,6 +7,7 @@ const TEMPLATE_NAMES = [
   "agents-md",
   "code-wiki",
   "demo",
+  "grokbot-agents",
   "pr-autofixer",
   "security-help",
   "security-reviewer",

package/src/internal/deploy-client.ts

@@ -675,6 +675,22 @@ export class AgentServeDeployClient {
     return agentkitStopAcceptedSchema.parse(raw);
   }
 
+  /**
+   * Delete a v2 deployment (`DELETE /internal/agentsdk/deployments/:slug`).
+   * 202 means accepted; poll {@link getAgentkitDeploy} until 404.
+   */
+  async deleteAgentkit(args: {
+    teamId: number;
+    slug: string;
+  }): Promise<AgentkitStopAccepted> {
+    const raw = await this.request({
+      method: "DELETE",
+      path: `/internal/agentsdk/deployments/${encodeURIComponent(args.slug)}?teamId=${args.teamId}`,
+      context: { verb: "delete", slug: args.slug },
+    });
+    return agentkitStopAcceptedSchema.parse(raw);
+  }
+
   async listDeployments(args: { teamId: number }): Promise<Deployment[]> {
     const raw = await this.request({
       method: "GET",

package/src/internal/deploy-manifest.ts

@@ -47,7 +47,7 @@ import {
   projectInfo,
   runtimeArchitectureCompatibilityError,
 } from "./discovery.js";
-import { packageVersion } from "./distribution.js";
+import { packageGitSha, packageVersion } from "./distribution.js";
 
 export const DEPLOY_MANIFEST_VERSION: 1 = 1;
 
@@ -62,6 +62,10 @@ const agentDeployManifestV1Schema = z.object({
   manifestVersion: z.literal(DEPLOY_MANIFEST_VERSION),
   generatedAtMs: z.number().int().nonnegative(),
   cliVersion: z.string().min(1),
+  cliGitSha: z
+    .string()
+    .regex(/^[0-9a-f]{40,64}$/)
+    .optional(),
   declarations: z.object({
     egressDomains: z.array(z.string().min(1)).max(64),
     publicRoutePaths: z.array(z.string().min(1)).max(64),
@@ -115,6 +119,8 @@ export interface AgentDeployManifestV1 {
   generatedAtMs: number;
   /** `@cursor/july` version that produced the manifest. */
   cliVersion: string;
+  /** Git commit for a checkout-built `@cursor/july`; absent for npm builds. */
+  cliGitSha?: string;
   declarations: AgentDeployManifestDeclarations;
   /**
    * Full `projectInfo` payload (see `GET /v1/info`). Opaque to the wire
@@ -129,7 +135,7 @@ export interface AgentDeployManifestV1 {
  */
 export function buildAgentDeployManifest(
   project: AgentProject,
-  options?: { nowMs?: number; cliVersion?: string }
+  options?: { nowMs?: number; cliVersion?: string; cliGitSha?: string }
 ): AgentDeployManifestV1 {
   const runtimeArchitectureError = runtimeArchitectureCompatibilityError(
     project.agent
@@ -167,20 +173,19 @@ export function buildAgentDeployManifest(
     manifestVersion: DEPLOY_MANIFEST_VERSION,
     generatedAtMs: options?.nowMs ?? Date.now(),
     cliVersion: options?.cliVersion ?? packageVersion(),
+    cliGitSha: options?.cliGitSha ?? packageGitSha(),
     declarations: {
       egressDomains: [...(project.agent.hosting?.egressDomains ?? [])],
       publicRoutePaths,
-      // v2 ignores authored storage; deploy manifests describe
-      // Cursor-hosted deployments, where framework-storage-selection.ts
-      // injects the Cursor-hosted mirror.
+      // Deploy manifests describe Cursor-hosted deployments. When the agent
+      // authors no storage, framework-storage-selection.ts injects the
+      // platform Cursor-hosted mirror for both v1 and v2.
       frameworkStorage:
-        project.agent.architecture === "v2"
+        project.storage === undefined
           ? "cursor-hosted"
-          : project.storage === undefined
-            ? "none"
-            : isCursorHostedStorage(project.storage)
-              ? "cursor-hosted"
-              : "other",
+          : isCursorHostedStorage(project.storage)
+            ? "cursor-hosted"
+            : "other",
       ...(project.agent.architecture === undefined
         ? {}
         : { architecture: project.agent.architecture }),

package/src/internal/discovery/agent.ts

@@ -372,6 +372,7 @@ export async function warnUnknownSlots(
     "subagents",
     "channels",
     "schedules",
+    "reminders",
     "hooks",
     "ab",
     "sandbox",

package/src/internal/discovery/info.ts

@@ -151,6 +151,12 @@ export function projectInfo(project: AgentProject): AgentProjectInfo {
       cron: schedule.cron,
       kind: schedule.kind,
     })),
+    reminders:
+      (project.reminders ?? []).length === 0
+        ? undefined
+        : (project.reminders ?? []).map((reminder) => ({
+            name: reminder.name,
+          })),
     hooks: project.hooks.map((hook) => hook.name),
     abs: project.abs.map((experiment) => experiment.name),
     ...(project.abConfig === undefined && project.abs.length === 0

package/src/internal/discovery/modules.ts

@@ -9,10 +9,7 @@ import { type DiscoveryContext, displayPath, errorMessage } from "./context.js";
 import { isDirectory, isModuleFile, moduleStem, sortedEntries } from "./fs.js";
 import { validateName } from "./names.js";
 
-type ImportableKind = Exclude<
-  DefinitionKind,
-  "instructions" | "eval" | "reminder"
->;
+type ImportableKind = Exclude<DefinitionKind, "instructions" | "eval">;
 
 /** The module files of a slot directory whose filenames are valid names. */
 export async function moduleEntries(
@@ -104,6 +101,7 @@ const DEFINE_HELPER_NAME: Record<ImportableKind, string> = {
   channel: "defineChannel",
   "http-channel": "httpChannel",
   schedule: "defineSchedule",
+  reminder: "defineReminder",
   hook: "defineHook",
   ab: "defineAB",
   storage: "defineStorage",

package/src/internal/discovery/project.ts

@@ -31,6 +31,7 @@ import {
 } from "./fs.js";
 import { loadHooks } from "./hooks.js";
 import { NAME_PATTERN } from "./names.js";
+import { loadReminders } from "./reminders.js";
 import { loadSchedules } from "./schedules.js";
 import {
   appendArtifactTool,
@@ -236,6 +237,7 @@ export async function loadAgentProject(
   }
   const schedules = await loadSchedules(ctx, join(agentDir, "schedules"));
   schedules.push(...projectSlots.schedules);
+  const reminders = await loadReminders(ctx, join(agentDir, "reminders"));
   const hooks = await loadHooks(ctx, join(agentDir, "hooks"));
   hooks.push(...projectSlots.hooks);
   const abs = await loadABs(ctx, agentDir);
@@ -291,6 +293,7 @@ export async function loadAgentProject(
     httpChannel: resolvedHttpChannel,
     channels,
     schedules,
+    reminders,
     hooks,
     abs,
     abConfig,

package/src/internal/discovery/reminders.ts

@@ -0,0 +1,65 @@
+/**
+ * `agent/reminders/*.ts`: named durable reminder fire handlers.
+ */
+
+import { basename, extname, relative } from "node:path";
+import type { DiscoveredReminder, ReminderDefinition } from "../../types.js";
+import { getDefinitionKind } from "../brand.js";
+import { type DiscoveryContext, displayPath } from "./context.js";
+import { isDirectory, isModuleFile, toPosix, walkFiles } from "./fs.js";
+import { importDefault } from "./modules.js";
+import { NAME_PATTERN } from "./names.js";
+
+export async function loadReminders(
+  ctx: DiscoveryContext,
+  remindersDir: string,
+  onDisable?: (name: string, path: string) => void
+): Promise<DiscoveredReminder[]> {
+  if (!(await isDirectory(remindersDir))) {
+    return [];
+  }
+  const reminders: DiscoveredReminder[] = [];
+  for (const filePath of await walkFiles(remindersDir)) {
+    const rel = toPosix(relative(remindersDir, filePath));
+    if (!isModuleFile(basename(filePath))) {
+      continue;
+    }
+    const name = rel.slice(0, -extname(rel).length);
+    if (!NAME_PATTERN.test(name) || name.includes("__")) {
+      ctx.diagnostics.push({
+        severity: "error",
+        path: displayPath(ctx, filePath),
+        message: name.includes("__")
+          ? `Reminder name "${name}" may not contain "__"; it is reserved for extension contributions (\`<ns>__<name>\`).`
+          : `Reminder name "${name}" must match ${NAME_PATTERN}.`,
+      });
+      continue;
+    }
+    const definition = await importDefault(
+      ctx,
+      filePath,
+      onDisable === undefined ? "reminder" : ["reminder", "disabled"]
+    );
+    if (definition === undefined) {
+      continue;
+    }
+    if (getDefinitionKind(definition) === "disabled") {
+      onDisable?.(name, filePath);
+      continue;
+    }
+    const reminder = definition as ReminderDefinition;
+    if (typeof reminder.run !== "function") {
+      ctx.diagnostics.push({
+        severity: "error",
+        path: displayPath(ctx, filePath),
+        message: "Reminder handlers require a `run` function.",
+      });
+      continue;
+    }
+    reminders.push({
+      name,
+      definition: reminder,
+    });
+  }
+  return reminders;
+}

package/src/internal/discovery/subagent.ts

@@ -121,6 +121,7 @@ async function warnUnsupportedSubagentSlots(
     ["subagents", "nested subagents"],
     ["channels", "channels"],
     ["schedules", "schedules"],
+    ["reminders", "reminders"],
     ["hooks", "hooks"],
     ["sandbox", "sandbox files"],
   ] as const;

package/src/internal/distribution.ts

@@ -13,6 +13,8 @@ import { fileURLToPath, pathToFileURL } from "node:url";
 
 /** Published npm package name (pre-launch codename for Agent SDK). */
 export const PACKAGE_NAME = "@cursor/july";
+const HOSTED_WORKTREE_SHA_FILENAME = ".cursor-hosted-worktree-sha";
+const GIT_COMMIT_SHA_RE = /^[0-9a-f]{40,64}$/;
 
 /**
  * Bracketed product tag for stderr / ServeOptions.logger lines
@@ -59,6 +61,24 @@ export function packageVersion(): string {
   return packageManifest().version;
 }
 
+/**
+ * Git commit of a checkout-built framework distribution. Published npm
+ * packages do not carry this marker and return undefined.
+ */
+export function packageGitSha(): string | undefined {
+  try {
+    const sha = readFileSync(
+      join(packageRootDir(), "dist", HOSTED_WORKTREE_SHA_FILENAME),
+      "utf8"
+    )
+      .trim()
+      .toLowerCase();
+    return GIT_COMMIT_SHA_RE.test(sha) ? sha : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
 /** Facts `agent-sdk version` / `--version` print. */
 export interface CliVersionInfo {
   /** Published npm name (`@cursor/july`). */

package/src/internal/framework-file-storage.ts

@@ -9,7 +9,9 @@
  * - the **framework-level** store (`AGENT_SERVE_FRAMEWORK_STORE_SOURCE_ID`)
  *   holds engine-owned session state — session records, event transcripts,
  *   hosted-execution run logs, the continuation index, and the SDK
- *   conversation mirror — and is never exposed to authors or models.
+ *   conversation mirror — and is never mounted into author code or models.
+ *   The authenticated dashboard may read diagnostic families, but never the
+ *   continuation index.
  *
  * This module puts framework session state on the framework store. The
  * {@link storageKeys} scheme was designed for exactly this: keys are a

package/src/internal/framework-storage-selection.ts

@@ -13,7 +13,10 @@
  * That selection is a hosting-mode question, not an authoring question.
  * Architecture v2 moves it here: `agent/storage.ts` is rejected at
  * discovery (error diagnostic, so serve and deploy fail early), and the
- * platform picks the default —
+ * platform picks the default. Architecture v1 with no authored file now
+ * uses the same hosted-vs-self-hosted split, so deleting `agent/storage.ts`
+ * (required to deploy the same tree onto v2) does not drop the Cursor-hosted
+ * session mirror on a still-v1 pod.
  *
  * - **Cursor-managed hosting** (the deployment-generation environment
  *   variable is set, same signal that registers `GET /v1/manifest`):
@@ -33,8 +36,10 @@
  * - **Self-hosted**: no mirror. `--state-root` is the durable copy, which
  *   is correct when the operator owns the disk.
  *
- * v1 keeps the authored definition (or nothing) so existing deployments are
- * untouched while they run.
+ * v1 still honors an authored `agent/storage.ts` when present. Hosted v1
+ * pods with no authored file get the Cursor-hosted lazy mirror (gated on
+ * `AGENT_SERVE_DEPLOYMENT_ID`, the same signal the previous authored sinks
+ * used). Self-hosted v1 with no authored file stays disk-only.
  *
  * Local disk is not part of this decision. `<stateRoot>/sessions/<id>/`
  * already holds `session.json` and `events.ndjson` unconditionally, through
@@ -44,6 +49,10 @@
 
 import { cursorHostedFiles } from "../files-backends/cursor-hosted.js";
 import { defineStorage, type StorageDefinition } from "../storage.js";
+import {
+  AGENT_SERVE_DEPLOYMENT_ID_ENV_VAR,
+  cursorHostedStorage,
+} from "../storage-backends/cursor-hosted.js";
 import { cursorHostedStorageV2 } from "../storage-backends/cursor-hosted-v2.js";
 import type { AgentArchitecture } from "../types.js";
 import { resolveApiKeySync } from "./cursor/credentials.js";
@@ -54,6 +63,13 @@ import {
 } from "./framework-file-storage.js";
 import { resolveAgentV2Hosting } from "./v2-hosting.js";
 
+/**
+ * Hosted v2 event-chunk flush debounce. Matches the session view's live poll
+ * cadence; a streaming turn still caps each chunk at the coordinator's batch
+ * limit, so a long turn writes a few dozen chunks rather than one per event.
+ */
+export const HOSTED_V2_EVENT_FLUSH_DEBOUNCE_MS = 2_000;
+
 export interface FrameworkStorageSelectionInput {
   /** `agent/storage.ts`, when the author wrote one (v1 only: discovery rejects it on v2). */
   readonly authored: StorageDefinition | undefined;
@@ -73,8 +89,21 @@ export function selectFrameworkStorageDefinition(
   input: FrameworkStorageSelectionInput
 ): StorageDefinition | undefined {
   if (input.architecture !== "v2") {
-    // v1: the author decides, or there is no mirror.
-    return input.authored;
+    if (input.authored !== undefined) {
+      return input.authored;
+    }
+    const env = input.env ?? process.env;
+    if ((env[AGENT_SERVE_DEPLOYMENT_ID_ENV_VAR] ?? "").trim() !== "") {
+      // Hosted v1 pod with no authored sink: keep the Cursor-hosted
+      // mirror (lazy restore) so agents can delete `agent/storage.ts`
+      // without losing durability while they still run architecture v1.
+      return defineStorage({
+        name: "cursor-hosted (lazy restore)",
+        policy: { restore: "off" },
+        ...cursorHostedStorage(),
+      });
+    }
+    return undefined;
   }
   if (input.authored !== undefined) {
     // Discovery rejects agent/storage.ts on v2 before an engine is built;
@@ -97,7 +126,15 @@ export function selectFrameworkStorageDefinition(
   // backend it is per-key HTTP round trips before the listener even
   // comes up). Follow-ups restore lazily by continuation or session id;
   // GET /v1/sessions lists from the sink either way.
-  const policy = { restore: "off" } as const;
+  //
+  // Events flush on a quiet-period debounce rather than only at turn end so
+  // the read-only session view and dashboard trace (which have no resident
+  // engine to ask) see steps mid-turn. The turn-end record still lands
+  // before the execution reply: drainSessionDurability forces the flush.
+  const policy = {
+    restore: "off",
+    debounceMs: HOSTED_V2_EVENT_FLUSH_DEBOUNCE_MS,
+  } as const;
   // Full chain (env → bind file → stored login): frozen engines listen
   // unsigned and bind store ids + CURSOR_API_KEY at task time, after this
   // definition is constructed.

package/src/internal/guest-network.ts

@@ -19,6 +19,8 @@
  * with that message instead of throwing.
  */
 
+import { HOSTED_GUEST_RETRY_TRANSIENT } from "./hosted-delivery-protocol.js";
+
 export const GUEST_NETWORK_UNAVAILABLE = "guest_network_unavailable";
 export const GUEST_CONNECT_STALLED = "guest_connect_stalled";
 
@@ -369,6 +371,7 @@ export async function guestNetworkReadinessResponse(
       JSON.stringify({
         ok: false,
         error: GUEST_NETWORK_UNAVAILABLE,
+        retry: HOSTED_GUEST_RETRY_TRANSIENT,
         message: error.message,
         waitMs: error.waitMs,
         probeAttempts: error.probeAttempts,