@cursor/july 0.1.108 → 0.1.111

package/src/internal/storage-coordinator.ts

@@ -11,19 +11,17 @@
  * must never stall or fail a turn.
  *
  * Scaling shape: sessions reduce to keyed puts on the KV sink; eval runs
- * and A/B metrics go to their dedicated tables (`evals` / `abs`).
- * Reminder documents live on the control plane. Everything shares one
- * bounded, serialized queue.
+ * go to their dedicated `evals` table. Reminder documents live on the
+ * control plane. Everything shares one bounded, serialized queue.
  *
  * It does three unrelated jobs, declared separately as
  * {@link FrameworkSessionStore}, {@link AuthorKvStore}, and
- * {@link EvalAbStore} — see `storage-roles.ts` for why they differ and where
+ * {@link EvalStore} — see `storage-roles.ts` for why they differ and where
  * each is headed. The queue stays shared: it is one bounded, serialized chain
  * per agent, and splitting it would change backpressure behavior, which this
  * seam deliberately does not touch.
  */
 
-import type { ABMetricSample } from "../ab.js";
 import type { EvalRunSnapshot } from "../evals.js";
 import {
   type ResolvedStoragePolicy,
@@ -36,12 +34,11 @@ import {
 } from "../storage.js";
 import { isCursorHostedStorage } from "../storage-backends/cursor-hosted.js";
 import type { JsonValue, SessionEvent, SessionRecord } from "../types.js";
-import type { ABSnapshot } from "./ab-snapshot.js";
 import { describeError } from "./describe-error.js";
 import type { EvalRunStorage } from "./eval-run-store.js";
 import type {
   AuthorKvStore,
-  EvalAbStore,
+  EvalStore,
   FrameworkSessionStore,
 } from "./storage-roles.js";
 
@@ -71,12 +68,8 @@ const CLOSE_DRAIN_TIMEOUT_MS = 10_000;
 /** Debounced event batching flushes early past this many buffered events. */
 const DEBOUNCE_MAX_BATCH = 200;
 
-/**
- * Aggregate A/B snapshots are refreshed at most this often — the
- * playground polls `GET /v1/abs` every few seconds, and the snapshot is a
- * convenience backfill, not a source of truth.
- */
-const AB_SNAPSHOT_MIN_INTERVAL_MS = 60_000;
+/** Cap on the per-session acked-record dedupe cache (oldest-out). */
+const MAX_ACKED_RECORDS = 5_000;
 
 /** One queued sink call (KV put/delete or a dedicated-table write). */
 interface StorageOp {
@@ -104,9 +97,9 @@ interface SessionBuffer {
 /** Session records out of raw sink entries; rows without a usable id are dropped. */
 function sessionRecordsOf(entries: readonly StorageEntry[]): SessionRecord[] {
   return entries
-    .map((entry) => entry.value as unknown as SessionRecord)
+    .map(entry => entry.value as unknown as SessionRecord)
     .filter(
-      (record) =>
+      record =>
         record != null &&
         typeof record.sessionId === "string" &&
         record.sessionId !== ""
@@ -114,7 +107,7 @@ function sessionRecordsOf(entries: readonly StorageEntry[]): SessionRecord[] {
 }
 
 export class StorageCoordinator
-  implements FrameworkSessionStore, AuthorKvStore, EvalAbStore
+  implements FrameworkSessionStore, AuthorKvStore, EvalStore
 {
   readonly policy: ResolvedStoragePolicy;
 
@@ -130,13 +123,21 @@ export class StorageCoordinator
    * change emits a delete for the stale index entry alongside the new put.
    */
   private readonly continuationIndex = new Map<string, string | null>();
+  /**
+   * Serialized form of the last session record each session **successfully**
+   * wrote, so a flush whose record is byte-identical skips the rewrite (the
+   * record rides every flush, changed or not). Keyed on acknowledged writes
+   * only: a failed write clears the entry, so at-most-once delivery never
+   * turns into never-delivered. Bounded; eviction only costs a redundant
+   * rewrite.
+   */
+  private readonly lastAckedRecordJson = new Map<string, string>();
   /** Single delivery chain: writes reach the sink serialized, in order. */
   private queue: Promise<void> = Promise.resolve();
   /** Ops on the queue not yet delivered (bounded by MAX_PENDING_OPS). */
   private pending = 0;
   /** Ops dropped because the queue was full. */
   private dropped = 0;
-  private lastAbSnapshotAt = 0;
   private closed = false;
 
   constructor(options: StorageCoordinatorOptions) {
@@ -216,22 +217,33 @@ export class StorageCoordinator
       clearTimeout(buffer.debounceTimer);
     }
     const ops: StorageOp[] = [];
+    const puts: Array<{ key: string; value: JsonValue }> = [];
     const first = buffer.events[0];
     if (first !== undefined) {
-      ops.push(
-        this.putOp(
-          this.keys.sessionEvents(this.agentName, sessionId, first.index),
-          buffer.events as unknown as JsonValue
-        )
-      );
+      puts.push({
+        key: this.keys.sessionEvents(this.agentName, sessionId, first.index),
+        value: buffer.events as unknown as JsonValue,
+      });
+    }
+    /** Set after the record write is acknowledged; undefined = no record write. */
+    let recordAck: { sessionId: string; json: string } | undefined;
+    if (buffer.record !== undefined) {
+      const recordJson = JSON.stringify(buffer.record);
+      if (this.lastAckedRecordJson.get(sessionId) === recordJson) {
+        // Byte-identical to the last acknowledged write: rewriting it buys
+        // nothing. Events and continuation index still flush normally.
+      } else {
+        puts.push({
+          key: this.keys.session(this.agentName, sessionId),
+          value: JSON.parse(recordJson) as JsonValue,
+        });
+        recordAck = { sessionId, json: recordJson };
+      }
+    }
+    if (puts.length > 0) {
+      ops.push(this.putsOp(puts, recordAck));
     }
     if (buffer.record !== undefined) {
-      ops.push(
-        this.putOp(
-          this.keys.session(this.agentName, sessionId),
-          buffer.record as unknown as JsonValue
-        )
-      );
       ops.push(...this.continuationOps(buffer.record));
     }
     if (ops.length > 0) {
@@ -239,6 +251,80 @@ export class StorageCoordinator
     }
   }
 
+  /**
+   * One queued op covering every put of a flush. When the sink offers
+   * `putMany`, the whole flush is one backend round trip (on the hosted
+   * file store: one presign call instead of one per key); otherwise the
+   * puts run sequentially, exactly as before. Failures stay per-key —
+   * logged and dropped (at-most-once), never failing batch siblings.
+   */
+  private putsOp(
+    puts: Array<{ key: string; value: JsonValue }>,
+    recordAck: { sessionId: string; json: string } | undefined
+  ): StorageOp {
+    const recordKey =
+      recordAck === undefined
+        ? undefined
+        : this.keys.session(this.agentName, recordAck.sessionId);
+    const settleRecord = (failed: boolean): void => {
+      if (recordAck === undefined) {
+        return;
+      }
+      if (failed) {
+        this.lastAckedRecordJson.delete(recordAck.sessionId);
+        return;
+      }
+      if (this.lastAckedRecordJson.size >= MAX_ACKED_RECORDS) {
+        const oldest = this.lastAckedRecordJson.keys().next();
+        if (!oldest.done) {
+          this.lastAckedRecordJson.delete(oldest.value);
+        }
+      }
+      this.lastAckedRecordJson.set(recordAck.sessionId, recordAck.json);
+    };
+    const putMany = this.definition.putMany?.bind(this.definition);
+    if (putMany !== undefined) {
+      return {
+        label: `putMany(${puts.map(entry => entry.key).join(", ")})`,
+        run: async ctx => {
+          const results = await putMany(puts, ctx);
+          let recordFailed = false;
+          for (const result of results) {
+            if (result.error === undefined) {
+              continue;
+            }
+            if (result.key === recordKey) {
+              recordFailed = true;
+            }
+            this.logger(
+              `[agent-sdk] storage put(${result.key}) failed: ${describeError(result.error)}`
+            );
+          }
+          settleRecord(recordFailed);
+        },
+      };
+    }
+    return {
+      label: `put(${puts.map(entry => entry.key).join(", ")})`,
+      run: async ctx => {
+        let recordFailed = false;
+        for (const entry of puts) {
+          try {
+            await this.definition.put(entry.key, entry.value, ctx);
+          } catch (error) {
+            if (entry.key === recordKey) {
+              recordFailed = true;
+            }
+            this.logger(
+              `[agent-sdk] storage put(${entry.key}) failed: ${describeError(error)}`
+            );
+          }
+        }
+        settleRecord(recordFailed);
+      },
+    };
+  }
+
   /**
    * Index maintenance for `continuation/{channelId}/{token}` → sessionId:
    * put the current token, delete the previous one when it changed.
@@ -273,7 +359,7 @@ export class StorageCoordinator
   private putOp(key: string, value: JsonValue): StorageOp {
     return {
       label: `put(${key})`,
-      run: (ctx) => this.definition.put(key, value, ctx),
+      run: ctx => this.definition.put(key, value, ctx),
     };
   }
 
@@ -281,7 +367,7 @@ export class StorageCoordinator
   private deleteOp(key: string): StorageOp {
     return {
       label: `delete(${key})`,
-      run: (ctx) => this.definition.delete?.(key, ctx),
+      run: ctx => this.definition.delete?.(key, ctx),
     };
   }
 
@@ -310,8 +396,8 @@ export class StorageCoordinator
   async listSessions(): Promise<SessionRecord[]> {
     const entries = await this.tryList(this.keys.sessionPrefix(this.agentName));
     return entries
-      .map((entry) => entry.value as unknown as SessionRecord)
-      .filter((record) => record != null);
+      .map(entry => entry.value as unknown as SessionRecord)
+      .filter(record => record != null);
   }
 
   /**
@@ -528,7 +614,7 @@ export class StorageCoordinator
           [
             {
               label: `evals.put(${run.runId})`,
-              run: (ctx) => table.put(snapshot, ctx),
+              run: ctx => table.put(snapshot, ctx),
             },
           ],
           "policy"
@@ -539,7 +625,7 @@ export class StorageCoordinator
           [
             {
               label: `evals.delete(${runId})`,
-              run: (ctx) => table.delete(runId, ctx),
+              run: ctx => table.delete(runId, ctx),
             },
           ],
           "policy"
@@ -559,66 +645,6 @@ export class StorageCoordinator
     };
   }
 
-  // ==========================================================================
-  // A/Bs (dedicated `abs` table)
-  // ==========================================================================
-
-  /** Append one metric sample to the `abs` table (no-op without it). */
-  abSample(sample: ABMetricSample): void {
-    const table = this.definition.abs;
-    if (this.closed || table === undefined) {
-      return;
-    }
-    this.enqueue(
-      [
-        {
-          label: `abs.putSample(${sample.sessionId})`,
-          run: (ctx) => table.putSample(sample, ctx),
-        },
-      ],
-      "policy"
-    );
-  }
-
-  /**
-   * Refresh the persisted aggregate A/B snapshot, throttled to once per
-   * {@link AB_SNAPSHOT_MIN_INTERVAL_MS} (the playground recomputes the
-   * fold on every `GET /v1/abs` poll). No-op without `abs.putSnapshot`.
-   */
-  abSnapshot(snapshot: ABSnapshot): void {
-    const putSnapshot = this.definition.abs?.putSnapshot;
-    const now = Date.now();
-    if (
-      this.closed ||
-      putSnapshot === undefined ||
-      now - this.lastAbSnapshotAt < AB_SNAPSHOT_MIN_INTERVAL_MS
-    ) {
-      return;
-    }
-    this.lastAbSnapshotAt = now;
-    this.enqueue(
-      [{ label: "abs.putSnapshot", run: (ctx) => putSnapshot(snapshot, ctx) }],
-      "policy"
-    );
-  }
-
-  /** Latest persisted aggregate A/B snapshot; errors read as absent. */
-  async getLatestAbSnapshot(): Promise<ABSnapshot | undefined> {
-    const getSnapshot = this.definition.abs?.getSnapshot;
-    if (getSnapshot === undefined) {
-      return undefined;
-    }
-    try {
-      const value = await getSnapshot(this.context("restore"));
-      return value ?? undefined;
-    } catch (error) {
-      this.logger(
-        `[agent-sdk] storage abs.getSnapshot() failed: ${describeError(error)}`
-      );
-      return undefined;
-    }
-  }
-
   // ==========================================================================
   // Delivery
   // ==========================================================================
@@ -638,7 +664,7 @@ export class StorageCoordinator
     let timer: ReturnType<typeof setTimeout> | undefined;
     const drained = await Promise.race([
       this.queue.then(() => true),
-      new Promise<boolean>((resolve) => {
+      new Promise<boolean>(resolve => {
         timer = setTimeout(() => resolve(false), CLOSE_DRAIN_TIMEOUT_MS);
         timer.unref?.();
       }),

package/src/internal/storage-roles.ts

@@ -14,18 +14,16 @@
  * - {@link AuthorKvStore} is author state: whatever `ctx.host.kv` was handed.
  *   It converges onto the author file plane, which is a different destination
  *   from the one above.
- * - {@link EvalAbStore} is playground/experiment bookkeeping with its own
- *   dedicated tables, and follows neither.
+ * - {@link EvalStore} is playground eval bookkeeping with its own dedicated
+ *   table, and follows neither.
  *
  * Consumers should depend on the narrowest role they use. That is what keeps a
  * later change to framework persistence from silently reaching author KV, and
  * it is why these are interfaces rather than a comment on one class.
  */
 
-import type { ABMetricSample } from "../ab.js";
 import type { StorageContext } from "../storage.js";
 import type { JsonValue, SessionEvent, SessionRecord } from "../types.js";
-import type { ABSnapshot } from "./ab-snapshot.js";
 import type { EvalRunStorage } from "./eval-run-store.js";
 
 /**
@@ -84,10 +82,7 @@ export interface AuthorKvStore {
   kvDelete(authorKey: string): Promise<void>;
 }
 
-/** Playground eval batches and live A/B metrics, on their own tables. */
-export interface EvalAbStore {
+/** Playground eval batches, on their own table. */
+export interface EvalStore {
   evalRuns(): EvalRunStorage | undefined;
-  abSample(sample: ABMetricSample): void;
-  abSnapshot(snapshot: ABSnapshot): void;
-  getLatestAbSnapshot(): Promise<ABSnapshot | undefined>;
 }

package/src/internal/storage.ts

@@ -0,0 +1 @@
+export * from "../storage.js";

package/src/internal/store-mirror.ts

@@ -26,15 +26,15 @@ export async function mirrorToStore(args: {
     )
   );
   const listed = await Promise.all(
-    [args.prefix, ...(args.legacyPrefixes ?? [])].map((prefix) =>
+    [args.prefix, ...(args.legacyPrefixes ?? [])].map(prefix =>
       args.sink.list(prefix)
     )
   );
   await Promise.all(
     listed
       .flat()
-      .filter((entry) => !args.desired.has(entry.key))
-      .map((entry) => args.sink.delete(entry.key))
+      .filter(entry => !args.desired.has(entry.key))
+      .map(entry => args.sink.delete(entry.key))
   );
 }
 
@@ -55,7 +55,7 @@ export function storeRelPath(
     relPath.includes("\\") ||
     posix.isAbsolute(relPath) ||
     relPath.endsWith("/") ||
-    relPath.split("/").some((seg) => seg === ".." || seg === ".") ||
+    relPath.split("/").some(seg => seg === ".." || seg === ".") ||
     posix.normalize(relPath) !== relPath
   ) {
     throw new Error(

package/src/internal/terminal-style.ts

@@ -111,7 +111,7 @@ export function formatTerminalBox(
   const padding = options?.padding ?? 1;
   const contentWidth = Math.max(
     options?.minWidth ?? 0,
-    ...lines.map((line) => visibleWidth(line)),
+    ...lines.map(line => visibleWidth(line)),
     1
   );
   const inner = contentWidth + padding * 2;
@@ -122,7 +122,7 @@ export function formatTerminalBox(
   const paint = (line: string): string => color(line);
   const box = [
     paint(`╭${"─".repeat(inner)}╮`),
-    ...lines.map((line) => paint(padLine(line))),
+    ...lines.map(line => paint(padLine(line))),
     paint(`╰${"─".repeat(inner)}╯`),
   ].join("\n");
   return box;

package/src/internal/tool-result.ts

@@ -47,8 +47,8 @@ export function toolCallErrorMessage(result: unknown): string | undefined {
   const texts = (
     result as { content: Array<{ type?: string; text?: string }> }
   ).content
-    .filter((part) => part.type === "text" && typeof part.text === "string")
-    .map((part) => part.text!.trim())
-    .filter((text) => text !== "");
+    .filter(part => part.type === "text" && typeof part.text === "string")
+    .map(part => part.text!.trim())
+    .filter(text => text !== "");
   return texts.length === 0 ? undefined : texts.join("\n");
 }

package/src/internal/trajectory.ts

@@ -147,7 +147,7 @@ export function buildTrajectory(events: SessionEvent[]): Trajectory {
           };
           pendingCalls.set(call.callId, entry);
           if (parentCallId !== undefined) {
-            let sub = turn.subagents.find((s) => s.callId === parentCallId);
+            let sub = turn.subagents.find(s => s.callId === parentCallId);
             if (sub === undefined) {
               sub = { callId: parentCallId, toolCalls: [] };
               turn.subagents.push(sub);
@@ -197,7 +197,7 @@ export function buildTrajectory(events: SessionEvent[]): Trajectory {
           };
           if (event.data.parentCallId !== undefined) {
             let sub = turn.subagents.find(
-              (s) => s.callId === event.data.parentCallId
+              s => s.callId === event.data.parentCallId
             );
             if (sub === undefined) {
               sub = {
@@ -217,7 +217,7 @@ export function buildTrajectory(events: SessionEvent[]): Trajectory {
         if (event.turnId !== undefined) {
           const turn = ensureTurn(event.turnId);
           const existing = turn.subagents.find(
-            (s) => s.callId === event.data.callId
+            s => s.callId === event.data.callId
           );
           if (existing !== undefined) {
             existing.name = event.data.name;
@@ -274,8 +274,8 @@ export function buildTrajectory(events: SessionEvent[]): Trajectory {
     }
   }
 
-  const turns = turnOrder.map((id) => turnsById.get(id)!);
-  const turnsFailed = turns.filter((t) => t.failed).length;
+  const turns = turnOrder.map(id => turnsById.get(id)!);
+  const turnsFailed = turns.filter(t => t.failed).length;
   const toolCallCount = turns.reduce(
     (n, t) =>
       n +
@@ -283,8 +283,8 @@ export function buildTrajectory(events: SessionEvent[]): Trajectory {
       t.subagents.reduce((m, s) => m + s.toolCalls.length, 0),
     0
   );
-  const lastGood = [...turns].reverse().find((t) => t.assistantText !== "");
-  const costedTurns = turns.filter((t) => t.cost !== undefined);
+  const lastGood = [...turns].reverse().find(t => t.assistantText !== "");
+  const costedTurns = turns.filter(t => t.cost !== undefined);
   const totalCostUsd =
     costedTurns.length === 0
       ? undefined

package/src/internal/turn-governor.ts

@@ -85,10 +85,10 @@ export class TurnGovernor {
     if (args.signal?.aborted === true) {
       return Promise.resolve(undefined);
     }
-    return new Promise<TurnPermit | undefined>((resolve) => {
+    return new Promise<TurnPermit | undefined>(resolve => {
       const waiter: TurnWaiter = {
         sessionId: args.sessionId,
-        grant: (permit) => resolve(permit),
+        grant: permit => resolve(permit),
         cancel: () => resolve(undefined),
         cleanup: () => {
           this.queuedSessions.delete(args.sessionId);

package/src/internal/turn-outbox.ts

@@ -66,7 +66,7 @@ export class TurnOutbox<T> {
       return [];
     }
     const items: OutboxItem<T>[] = [];
-    for (const name of names.filter((n) => n.endsWith(".json")).sort()) {
+    for (const name of names.filter(n => n.endsWith(".json")).sort()) {
       const path = join(dir, name);
       try {
         const raw = await readFile(path, "utf8");

package/src/internal/update-check.ts

@@ -385,7 +385,7 @@ async function findDependingProjectDir(
     }
     const inNodeModules = dir
       .split(sep)
-      .some((part) => part === "node_modules" || part === ".pnpm");
+      .some(part => part === "node_modules" || part === ".pnpm");
     if (!inNodeModules && (await declaresDependency(dir, packageName))) {
       return dir;
     }
@@ -545,7 +545,7 @@ function runUpdateCommand(command: UpdateCommand): Promise<number> {
       shell: process.platform === "win32",
     });
     child.on("error", reject);
-    child.on("close", (code) => {
+    child.on("close", code => {
       resolve(code ?? 1);
     });
   });

package/src/internal/v2-hosting.ts

@@ -5,12 +5,23 @@ import {
 } from "./cursor/hosted-store-secrets.js";
 import { AGENT_SERVE_GENERATION_ENV_VAR } from "./cursor-relay-core.js";
 
+/**
+ * Exported (as `1`) by the control plane's start script for a version
+ * container of a persistent deployment. Its presence, not the agent's
+ * `persistent` flag, is what tells the runtime it owns a durable state
+ * directory.
+ */
+export const AGENT_SERVE_PERSISTENT_ENV_VAR = "AGENT_SERVE_PERSISTENT";
+
 export type AgentV2Hosting =
   | { kind: "not-v2" }
   | { kind: "self-hosted" }
   | {
       kind: "cursor-managed";
       resolveStoreIds: () => CursorManagedV2StoreIds;
+    }
+  | {
+      kind: "cursor-managed-persistent";
     };
 
 /**
@@ -31,6 +42,9 @@ export function resolveAgentV2Hosting(input: {
   if (env[AGENT_SERVE_GENERATION_ENV_VAR] === undefined) {
     return { kind: "self-hosted" };
   }
+  if (env[AGENT_SERVE_PERSISTENT_ENV_VAR] === "1") {
+    return { kind: "cursor-managed-persistent" };
+  }
   return {
     kind: "cursor-managed",
     resolveStoreIds: () => requireCursorManagedV2StoreIdsSync(env),

package/src/internal/workspace.ts

@@ -1,10 +1,12 @@
 /**
  * Session workspace materialization. Each session gets its own working
- * directory that the Cursor harness treats as the project: instructions land
- * in `AGENTS.md`, skills land in `.cursor/skills/<name>/SKILL.md`,
- * agent-side tools land in `.agent-serve/tools/<name>.sh`, and
- * `agent/sandbox/workspace/**` seed files are mirrored in. The harness picks
- * all of this up natively through its project setting source.
+ * directory that the Cursor harness treats as the project: skills land in
+ * `.cursor/skills/<name>/SKILL.md`, agent-side tools land in
+ * `.agent-serve/tools/<name>.sh`, and `agent/sandbox/workspace/**` seed files
+ * are mirrored in. The harness picks all of this up natively through its
+ * project setting source. Instructions are not written here: local turns
+ * deliver them as the harness system prompt ({@link buildAgentsMdContent}),
+ * and cloud / grokbot harnesses never read the session workspace.
  */
 
 import { execFile } from "node:child_process";
@@ -92,7 +94,7 @@ export function buildCloudSessionWorkspaceSection(
   dir: string,
   relPaths: readonly string[]
 ): string {
-  const listed = relPaths.map((path) => `\`${path}\``).join(", ");
+  const listed = relPaths.map(path => `\`${path}\``).join(", ");
   return [
     "## Session workspace files",
     "",
@@ -158,7 +160,7 @@ export function buildAgentToolsCatalog(
   tools: DiscoveredTool[],
   options: { includeScripts: boolean } = { includeScripts: false }
 ): string {
-  const agentTools = tools.filter((tool) => tool.execution === "agent");
+  const agentTools = tools.filter(tool => tool.execution === "agent");
   if (agentTools.length === 0) {
     return "";
   }
@@ -219,7 +221,7 @@ export function buildServerToolsCatalog(
   tools: DiscoveredTool[],
   options: { mcpServerName: string }
 ): string {
-  const serverTools = tools.filter((tool) => tool.execution === "server");
+  const serverTools = tools.filter(tool => tool.execution === "server");
   if (serverTools.length === 0) {
     return "";
   }
@@ -250,11 +252,12 @@ export function buildServerToolsCatalog(
 }
 
 /**
- * The full AGENTS.md-equivalent context for an agent: instructions, identity
- * section, and the agent-side tool catalog. Written to the session workspace
- * as `AGENTS.md`, and inlined into the first turn's prompt when the harness
- * cannot discover that file (cloud runtime, or a local workspace the harness
- * will not treat as the project root — see {@link isNestedInGitRepo}).
+ * The full instructions context for an agent: instructions, identity
+ * section, and the agent-side tool catalog. Local turns send it as the
+ * harness system prompt (`AgentOptions.systemPrompt`, replacing Cursor's
+ * built-in prompt), grokbot turns carry it into the hosted session's system
+ * prompt, and cloud turns inline it into the first prompt because a cloud VM
+ * has no materialized workspace to read it from.
  *
  * `serverToolsMcpName` is cloud-only: when the turn's MCP config carries the
  * session-bound server-tool endpoint, the catalog names that server so the
@@ -279,7 +282,7 @@ export function buildAgentsMdContent(
       includeScripts: options.includeScripts,
     }),
   ]
-    .filter((part) => part !== "")
+    .filter(part => part !== "")
     .join("\n\n");
 }
 
@@ -344,9 +347,6 @@ export async function materializeWorkspace(
     await linkSharedMemoryDir(workspaceDir, stateRoot);
   }
 
-  const agentsMd = buildAgentsMdContent(agent, { includeScripts: false });
-  await writeFile(join(workspaceDir, "AGENTS.md"), agentsMd, "utf8");
-
   for (const tool of agent.tools) {
     if (tool.execution !== "agent" || tool.script === undefined) {
       continue;