@cursor/july 0.1.108 → 0.1.111

package/src/internal/event-log.ts

@@ -101,7 +101,7 @@ export class SessionEventLog {
 
   private async readNextIndex(): Promise<void> {
     let next = 0;
-    await readNdjsonEvents(this.filePath, (event) => {
+    await readNdjsonEvents(this.filePath, event => {
       if (typeof event.index === "number" && event.index >= next) {
         next = event.index + 1;
       }
@@ -155,7 +155,7 @@ export class SessionEventLog {
       .then(() => {
         this.dropInflight(index);
       })
-      .catch((error) => this.onPersistError(error));
+      .catch(error => this.onPersistError(error));
     return event;
   }
 
@@ -164,7 +164,7 @@ export class SessionEventLog {
       this.inflight.shift();
       return;
     }
-    const i = this.inflight.findIndex((event) => event.index === index);
+    const i = this.inflight.findIndex(event => event.index === index);
     if (i >= 0) {
       this.inflight.splice(i, 1);
     }
@@ -181,7 +181,7 @@ export class SessionEventLog {
    */
   async snapshot(startIndex = 0): Promise<SessionEvent[]> {
     const byIndex = new Map<number, SessionEvent>();
-    await readNdjsonEvents(this.filePath, (event) => {
+    await readNdjsonEvents(this.filePath, event => {
       if (event.index >= startIndex) {
         byIndex.set(event.index, event);
       }
@@ -232,7 +232,7 @@ export class SessionEventLog {
     const encoder = new TextEncoder();
     let unsubscribe: (() => void) | undefined;
     return new ReadableStream<Uint8Array>({
-      start: async (controller) => {
+      start: async controller => {
         const push = (event: SessionEvent): void => {
           try {
             controller.enqueue(encoder.encode(`${JSON.stringify(event)}\n`));
@@ -242,7 +242,7 @@ export class SessionEventLog {
         };
         let following = false;
         const buffered: SessionEvent[] = [];
-        unsubscribe = this.subscribe((event) => {
+        unsubscribe = this.subscribe(event => {
           if (event.index < startIndex) {
             return;
           }
@@ -308,10 +308,10 @@ export class EventLogStore {
           SessionEventLog.open({
             sessionId,
             filePath,
-            onPersistError: (error) => this.onPersistError(sessionId, error),
+            onPersistError: error => this.onPersistError(sessionId, error),
           })
         )
-        .then((opened) => {
+        .then(opened => {
           this.opened.set(sessionId, opened);
           return opened;
         });
@@ -337,8 +337,8 @@ export class EventLogStore {
 
   async flushAll(): Promise<void> {
     await Promise.all(
-      [...this.logs.values()].map((logPromise) =>
-        logPromise.then((log) => log.flush()).catch(() => {})
+      [...this.logs.values()].map(logPromise =>
+        logPromise.then(log => log.flush()).catch(() => {})
       )
     );
   }

package/src/internal/event-mapper.ts

@@ -108,6 +108,41 @@ export class TurnEventMapper {
     return this.lastAssistantText;
   }
 
+  /**
+   * Unflushed `text-delta` buffer, else the last completed parent block.
+   * Used by `defineResult` before `finish()` so commit can read a
+   * text-only run without emitting `message.completed`.
+   */
+  get pendingText(): string | undefined {
+    if (this.textAccumulator !== "") {
+      return this.textAccumulator;
+    }
+    return this.lastAssistantText;
+  }
+
+  /**
+   * Drop streamed parent text so a same-turn repair does not concatenate
+   * or recommit the rejected attempt. Does not emit.
+   */
+  clearPendingText(): void {
+    this.textAccumulator = "";
+    this.lastAssistantText = undefined;
+  }
+
+  /**
+   * Drop rejected parent text and emit an empty `stop` `message.completed`.
+   * Slack `finalizeEmpty`s the open stream so a repair starts a new one
+   * instead of appending onto the rejected block. Origin/GitHub skip
+   * empty text and do not post.
+   */
+  abandonPendingText(): void {
+    this.clearPendingText();
+    this.emit({
+      type: "message.completed",
+      data: { text: "", finishReason: "stop" },
+    });
+  }
+
   /** Conversation summary produced by the harness (used as session title). */
   get title(): string | undefined {
     return this.summaryTitle;
@@ -434,8 +469,8 @@ export function describeToolResult(toolCall: ToolCall): ToolResultDescription {
       isError?: boolean;
     };
     const text = (value.content ?? [])
-      .map((item) => item.text?.text ?? "")
-      .filter((part) => part !== "")
+      .map(item => item.text?.text ?? "")
+      .filter(part => part !== "")
       .join("\n");
     return {
       output: text === "" ? value : text,

package/src/internal/filesystem/format.ts

@@ -140,16 +140,15 @@ function renderDirectoryTree(
       | { type: "file"; name: string }
       | { type: "dir"; name: string; dir: LsDirectoryTreeNode };
     const allChildren: LsChild[] = [
-      ...dir.childrenFiles.map(
-        (file): LsChild => ({ type: "file", name: file.name })
-      ),
-      ...dir.childrenDirs.map(
-        (childDir): LsChild => ({
-          type: "dir",
-          name: posix.basename(childDir.absPath),
-          dir: childDir,
-        })
-      ),
+      ...dir.childrenFiles.map((file): LsChild => ({
+        type: "file",
+        name: file.name,
+      })),
+      ...dir.childrenDirs.map((childDir): LsChild => ({
+        type: "dir",
+        name: posix.basename(childDir.absPath),
+        dir: childDir,
+      })),
     ];
     allChildren.sort((left, right) => left.name.localeCompare(right.name));
 
@@ -195,7 +194,7 @@ export function formatGlobOutput(
 ): string {
   const normalizedRoot = dir.replace(/\/+$/, "") || "/";
   const prefix = normalizedRoot === "/" ? "/" : `${normalizedRoot}/`;
-  const relative = files.map((filePath) =>
+  const relative = files.map(filePath =>
     filePath.startsWith(prefix) ? filePath.slice(prefix.length) : filePath
   );
   if (relative.length === 0) {
@@ -228,7 +227,7 @@ export function formatGrepOutput(union: GrepUnionResult | undefined): string {
       return "No matches found";
     }
     return union.output.counts
-      .map((row) => `${row.file}:${row.count}`)
+      .map(row => `${row.file}:${row.count}`)
       .join("\n");
   }
   if (union.output.matches.length === 0) {

package/src/internal/filesystem/scratch.ts

@@ -107,7 +107,7 @@ export function rewriteWebScratchValue(args: {
     return rewriteWebScratchText({ cwd, text: value });
   }
   if (Array.isArray(value)) {
-    return value.map((item) => rewriteWebScratchValue({ cwd, value: item }));
+    return value.map(item => rewriteWebScratchValue({ cwd, value: item }));
   }
   if (value !== null && typeof value === "object") {
     const next: Record<string, unknown> = {};
@@ -207,8 +207,8 @@ async function listHostAgentToolsFiles(cwd: string): Promise<string[]> {
   try {
     const entries = await readdir(dir, { withFileTypes: true });
     return entries
-      .filter((entry) => entry.isFile() && UUID_TXT.test(entry.name))
-      .map((entry) => path.join(dir, entry.name));
+      .filter(entry => entry.isFile() && UUID_TXT.test(entry.name))
+      .map(entry => path.join(dir, entry.name));
   } catch (error) {
     if (isEnoent(error)) {
       return [];

package/src/internal/filesystem/tools.ts

@@ -130,9 +130,7 @@ export function hostFileToolsFromAuthored(
 }
 
 const HOST_DEFAULT_SYNTHESIZED_NAMES: readonly SynthesizedFileSystemToolName[] =
-  SYNTHESIZED_FILE_SYSTEM_TOOL_NAMES.filter(
-    (name) => name !== "SemanticSearch"
-  );
+  SYNTHESIZED_FILE_SYSTEM_TOOL_NAMES.filter(name => name !== "SemanticSearch");
 
 /**
  * Names July will actually synthesize for this agent. Discovery reserves
@@ -151,7 +149,7 @@ export function synthesizedFileSystemToolNames(options: {
   if (filter === undefined) {
     return catalog;
   }
-  return catalog.filter((name) => filter.includes(name));
+  return catalog.filter(name => filter.includes(name));
 }
 
 function wantsTool(
@@ -248,7 +246,7 @@ async function collectMultilineGrepFiles(
     pattern: recursiveGrepGlob(input.glob),
     ...(input.path === undefined ? {} : { dir: input.path }),
   });
-  return entries.map((entry) => entry.path);
+  return entries.map(entry => entry.path);
 }
 
 function recursiveGrepGlob(glob: string | undefined): string {
@@ -537,7 +535,7 @@ Tool to search for files matching a glob pattern
             pattern: globPattern,
             ...(targetDirectory === undefined ? {} : { dir: targetDirectory }),
           })
-        ).map((entry) => entry.path);
+        ).map(entry => entry.path);
         return formatGlobOutput(dir, files);
       },
     }),
@@ -546,7 +544,7 @@ Tool to search for files matching a glob pattern
 }
 
 const grepInputSchema = z.preprocess(
-  (raw) => {
+  raw => {
     const aliased = aliasKeys({
       output_mode: "outputMode",
       head_limit: "headLimit",
@@ -743,7 +741,7 @@ function semanticSearchTool(root: FileSystem): DiscoveredTool {
             break;
           }
         }
-        return hits.map((hit) => `${hit.path}: ${hit.snippet}`).join("\n");
+        return hits.map(hit => `${hit.path}: ${hit.snippet}`).join("\n");
       },
     }),
     { input: sdkSemSearchArgs, output: sdkSemSearchResult }

package/src/internal/filesystem/walk.ts

@@ -288,7 +288,7 @@ export function applyIgnores(
     return [...entries];
   }
   return entries.filter(
-    (entry) => !ignoreGlobs.some((glob) => matchesIgnoreGlob(entry.path, glob))
+    entry => !ignoreGlobs.some(glob => matchesIgnoreGlob(entry.path, glob))
   );
 }
 

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

@@ -21,9 +21,8 @@
  * `continuation` go to the framework file store (file-shaped; the store
  * accepts values up to 64 MiB per
  * object without chunking, versus the KV proxy's 1 MiB row cap), while
- * author `kv`, eval runs, A/B samples, and conditional writes stay on the
- * control-plane KV proxy (the dashboard reads them there, and CAS needs a
- * database).
+ * author `kv`, eval runs, and conditional writes stay on the control-plane
+ * KV proxy (the dashboard reads them there, and CAS needs a database).
  *
  * v2 only, by construction: the composite is selected in
  * framework-storage-selection.ts, which v1 never reaches with a
@@ -68,10 +67,15 @@ export function isFrameworkFileKey(key: string): boolean {
   return FRAMEWORK_FILE_KINDS.has(kind);
 }
 
-/** The KV core over a {@link FileSink}: one JSON document per key. */
+/**
+ * The KV core over a {@link FileSink}: one JSON document per key.
+ * `putMany` stays optional — the KV-proxy core has no batch write, and the
+ * composite falls back to sequential puts on a side without one.
+ */
 export type FileSinkStorageCore = Required<
   Pick<StorageConfig, "put" | "get" | "delete" | "list">
->;
+> &
+  Pick<StorageConfig, "putMany">;
 
 /** Parallel per-key reads backing `list` (each is presign + object GET). */
 const LIST_READ_CONCURRENCY = 8;
@@ -86,7 +90,7 @@ const LIST_READ_CONCURRENCY = 8;
 function isUnrepresentableFileKey(key: string): boolean {
   return key
     .split("/")
-    .some((segment) => segment === "" || segment === "." || segment === "..");
+    .some(segment => segment === "" || segment === "." || segment === "..");
 }
 
 /**
@@ -110,6 +114,63 @@ export function fileSinkStorageCore(sink: FileSink): FileSinkStorageCore {
       }
       await sink.put(key, encodeDocument(key, value));
     },
+    async putMany(entries): Promise<Array<{ key: string; error?: unknown }>> {
+      const results: Array<{ key: string; error?: unknown }> = entries.map(
+        entry => ({ key: entry.key })
+      );
+      const writable: Array<{ index: number; key: string; body: Uint8Array }> =
+        [];
+      for (let index = 0; index < entries.length; index += 1) {
+        const entry = entries[index];
+        if (entry === undefined) {
+          continue;
+        }
+        if (isUnrepresentableFileKey(entry.key)) {
+          results[index] = {
+            key: entry.key,
+            error: new Error(
+              `framework file storage: key "${entry.key}" has a path segment the store cannot represent`
+            ),
+          };
+          continue;
+        }
+        writable.push({
+          index,
+          key: entry.key,
+          body: encodeDocument(entry.key, entry.value),
+        });
+      }
+      if (writable.length === 0) {
+        return results;
+      }
+      if (sink.putMany !== undefined) {
+        // The point of the batch: one backend round trip for the flush.
+        const settled = await sink.putMany(
+          writable.map(({ key, body }) => ({ key, body }))
+        );
+        for (let i = 0; i < writable.length; i += 1) {
+          const target = writable[i];
+          const outcome = settled[i];
+          if (target === undefined) {
+            continue;
+          }
+          if (outcome?.status === "rejected") {
+            results[target.index] = { key: target.key, error: outcome.reason };
+          }
+        }
+        return results;
+      }
+      // No batch support: sequential puts, preserving the sink's strict
+      // one-at-a-time ordering contract.
+      for (const target of writable) {
+        try {
+          await sink.put(target.key, target.body);
+        } catch (error) {
+          results[target.index] = { key: target.key, error };
+        }
+      }
+      return results;
+    },
     async get(key): Promise<JsonValue | undefined> {
       if (isUnrepresentableFileKey(key)) {
         return undefined;
@@ -130,7 +191,7 @@ export function fileSinkStorageCore(sink: FileSink): FileSinkStorageCore {
       const entries = await sink.list(prefix);
       // FileSink.list returns metadata only, so each value is its own
       // read; bound the fan-out — a bulk read here sits on restore paths.
-      const bodies = await mapBounded(entries, LIST_READ_CONCURRENCY, (entry) =>
+      const bodies = await mapBounded(entries, LIST_READ_CONCURRENCY, entry =>
         sink.get(entry.key)
       );
       const out: StorageEntry[] = [];
@@ -202,8 +263,8 @@ function decodeDocument(key: string, bytes: Uint8Array): JsonValue {
 /**
  * Split one storage core by key kind: framework session state to `files`,
  * everything else to `kv`. Spread over the KV backend when building the
- * full definition so its `evals` / `abs` groups (and the cursor-hosted
- * marker) ride along untouched; wrap the KV `cas` group with
+ * full definition so its `evals` group (and the cursor-hosted marker)
+ * rides along untouched; wrap the KV `cas` group with
  * {@link frameworkGuardedCas} rather than spreading it as-is.
  */
 export function composeFrameworkStorage(input: {
@@ -214,6 +275,44 @@ export function composeFrameworkStorage(input: {
     isFrameworkFileKey(key) ? input.files : input.kv;
   return {
     put: (key, value, ctx) => route(key).put(key, value, ctx),
+    async putMany(entries, ctx) {
+      // Partition by destination store, batch each side, and reassemble
+      // per-entry outcomes in input order.
+      const indexed = entries.map((entry, index) => ({ entry, index }));
+      const results: Array<{ key: string; error?: unknown }> = entries.map(
+        entry => ({ key: entry.key })
+      );
+      for (const core of [input.files, input.kv]) {
+        const side = indexed.filter(({ entry }) => route(entry.key) === core);
+        if (side.length === 0) {
+          continue;
+        }
+        if (core.putMany === undefined) {
+          // No batch write on this side (the KV proxy): sequential puts,
+          // preserving the strict one-at-a-time ordering it promises.
+          for (const { entry, index } of side) {
+            try {
+              await core.put(entry.key, entry.value, ctx);
+            } catch (error) {
+              results[index] = { key: entry.key, error };
+            }
+          }
+          continue;
+        }
+        const settled = await core.putMany(
+          side.map(({ entry }) => entry),
+          ctx
+        );
+        for (let i = 0; i < side.length; i += 1) {
+          const target = side[i];
+          const outcome = settled[i];
+          if (target !== undefined && outcome !== undefined) {
+            results[target.index] = outcome;
+          }
+        }
+      }
+      return results;
+    },
     get: (key, ctx) => route(key).get(key, ctx),
     delete: (key, ctx) => route(key).delete(key, ctx),
     list: (prefix, ctx) => route(prefix).list(prefix, ctx),

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

@@ -24,8 +24,8 @@
  *   (`AGENT_SERVE_FRAMEWORK_STORE_SOURCE_ID`, bound at task time) holds
  *   session records, event transcripts, and the continuation index —
  *   file-shaped state on file storage, apart from the author-facing user
- *   store. Author `host.kv`, eval runs, A/B samples, and conditional writes
- *   ride the AgentSDK v2 KV proxy (cursor-hosted-v2.ts), which resolves the
+ *   store. Author `host.kv`, eval runs, and conditional writes ride the
+ *   AgentSDK v2 KV proxy (cursor-hosted-v2.ts), which resolves the
  *   pod service account to the factorydb deployment row (the v1 Bugbot
  *   proxy cannot resolve v2 pods at all). Framework session state never
  *   routes to the KV proxy — the composite splits by key kind — so
@@ -63,13 +63,6 @@ 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;
@@ -127,13 +120,10 @@ export function selectFrameworkStorageDefinition(
   // comes up). Follow-ups restore lazily by continuation or session id;
   // GET /v1/sessions lists from the sink either way.
   //
-  // 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.
+  // Events flush at turn end. drainSessionDurability still forces the
+  // record onto the sink before the execution reply.
   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

package/src/internal/github-fanout.ts

@@ -78,7 +78,7 @@ function handleFanoutRequest(
   });
   req.on("end", () => {
     void fanoutDelivery(Buffer.concat(chunks), req.headers, targets, options)
-      .then((delivered) => {
+      .then(delivered => {
         res.writeHead(200, { "content-type": "application/json" });
         res.end(JSON.stringify({ ok: true, delivered }));
       })
@@ -105,7 +105,7 @@ export async function fanoutDelivery(
   targets: readonly GitHubForwardTarget[],
   options: FanoutOptions = {}
 ): Promise<string[]> {
-  const log = options.logger ?? ((line) => process.stderr.write(line));
+  const log = options.logger ?? (line => process.stderr.write(line));
   const event =
     typeof headers["x-github-event"] === "string"
       ? headers["x-github-event"]
@@ -118,7 +118,7 @@ export async function fanoutDelivery(
     }
   }
   const recipients = targets.filter(
-    (target) => event === undefined || target.events.includes(event)
+    target => event === undefined || target.events.includes(event)
   );
   // Reuse one Uint8Array view across recipients (Buffer isn't a BodyInit).
   const payload = new Uint8Array(body);
@@ -126,7 +126,7 @@ export async function fanoutDelivery(
   // Bounded by the number of GitHub channels in the project (a handful), so
   // unbounded-concurrency concerns do not apply here.
   await Promise.all(
-    recipients.map(async (target) => {
+    recipients.map(async target => {
       const label = targetLabel(target);
       try {
         const response = await fetch(target.url, {

package/src/internal/guest-network.ts

@@ -141,7 +141,7 @@ function hasCodeAtDepth(
   }
   if (
     error instanceof AggregateError &&
-    error.errors.some((inner) => hasCodeAtDepth(inner, depth + 1, codes))
+    error.errors.some(inner => hasCodeAtDepth(inner, depth + 1, codes))
   ) {
     return true;
   }
@@ -165,7 +165,7 @@ function isQuietSignatureAtDepth(error: unknown, depth: number): boolean {
   }
   if (
     error instanceof AggregateError &&
-    error.errors.some((inner) => isQuietSignatureAtDepth(inner, depth + 1))
+    error.errors.some(inner => isQuietSignatureAtDepth(inner, depth + 1))
   ) {
     return true;
   }
@@ -199,7 +199,7 @@ function isTransientAtDepth(error: unknown, depth: number): boolean {
   }
   if (
     error instanceof AggregateError &&
-    error.errors.some((inner) => isTransientAtDepth(inner, depth + 1))
+    error.errors.some(inner => isTransientAtDepth(inner, depth + 1))
   ) {
     return true;
   }
@@ -228,7 +228,7 @@ export type GuestNetworkWaitOptions = {
 };
 
 function defaultSleep(ms: number): Promise<void> {
-  return new Promise((resolve) => {
+  return new Promise(resolve => {
     setTimeout(resolve, ms);
   });
 }

package/src/internal/host-files.ts

@@ -217,7 +217,7 @@ async function statKey(
     return await sink.stat(key);
   }
   const entries = await sink.list(key);
-  return entries.find((entry) => entry.key === key);
+  return entries.find(entry => entry.key === key);
 }
 
 // ============================================================================

package/src/internal/host-kv.ts

@@ -28,9 +28,9 @@ export function createHostKvApi(options: CreateHostKvApiOptions): HostKvApi {
   const storage = options.storage;
   if (storage?.supportsAuthorKv === true) {
     return {
-      get: (key) => storage.kvGet(normalizeAuthorKey(key)),
+      get: key => storage.kvGet(normalizeAuthorKey(key)),
       put: (key, value) => storage.kvPut(normalizeAuthorKey(key), value),
-      delete: (key) => storage.kvDelete(normalizeAuthorKey(key)),
+      delete: key => storage.kvDelete(normalizeAuthorKey(key)),
     };
   }
   return createFilesystemKvApi({

package/src/internal/hosted-admission-adapter.ts

@@ -25,6 +25,8 @@ export type HostedAdmissionAdapter = {
     payload: unknown;
     deliveryId: string;
     args: ChannelHandlerArgs;
+    /** Mailbox key the control plane already allocated for this admission. */
+    mailboxContinuationKey?: string;
   }): Promise<Response>;
 };
 

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

@@ -13,6 +13,8 @@
  * plane never runs channel code.
  */
 
+import { isRecord } from "./is-record.js";
+
 export const AGENT_SDK_CATCH_ENVELOPE_VERSION = 1;
 export const AGENT_SDK_CATCH_EVENT_TYPE = "http.request";
 export const AGENT_SDK_CUSTOM_CHANNEL_KIND = "custom";
@@ -69,10 +71,6 @@ const MAX_QUERY_CHARS = 4096;
 const MAX_HEADER_COUNT = 64;
 const MAX_HEADER_BYTES = 16 * 1024;
 
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
 /** Strict parse of a claim-checked catch envelope; anything else is undefined. */
 export function parseCatchRequestEnvelope(
   value: unknown
@@ -81,7 +79,7 @@ export function parseCatchRequestEnvelope(
     return undefined;
   }
   if (
-    Object.keys(value).some((key) => !ENVELOPE_KEYS.has(key)) ||
+    Object.keys(value).some(key => !ENVELOPE_KEYS.has(key)) ||
     value.v !== AGENT_SDK_CATCH_ENVELOPE_VERSION ||
     typeof value.method !== "string" ||
     !METHODS.has(value.method) ||

package/src/internal/hosted-catch.ts

@@ -101,7 +101,7 @@ export async function replayCatchRequest(input: {
   }
   const matched = router.match(envelope.method, envelope.path);
   const route = input.routes.find(
-    (candidate) =>
+    candidate =>
       candidate.method === matched?.route.method &&
       candidate.path === matched.route.pattern
   );