@cursor/july 0.1.109 → 0.1.111

package/src/internal/env-file.ts

@@ -39,7 +39,7 @@ export async function upsertEnvFile(
   for (const { key, value } of entries) {
     const next = `${key}=${value}`;
     let replaced = false;
-    for (let i = 0; i < lines.length; ) {
+    for (let i = 0; i < lines.length;) {
       if (!matchesKey(lines[i] ?? "", key)) {
         i += 1;
         continue;
@@ -71,7 +71,7 @@ export async function ensureEnvLocalGitignored(dir: string): Promise<boolean> {
   const existing = await readOptionalFile(path);
   const covered = existing
     .split(/\r?\n/)
-    .some((line) => /^\.env(\.local\*?|\.\*|\*)$/.test(line.trim()));
+    .some(line => /^\.env(\.local\*?|\.\*|\*)$/.test(line.trim()));
   if (covered) {
     return false;
   }

package/src/internal/eval-run-store.ts

@@ -87,7 +87,7 @@ export class EvalRunStore {
     await this.hydrate();
     const { evals, config } = await discoverEvals(this.projectRoot);
     return {
-      evals: evals.map((e) => ({
+      evals: evals.map(e => ({
         id: e.id,
         fileId: e.fileId,
         ...(e.definition.description === undefined
@@ -156,9 +156,7 @@ export class EvalRunStore {
     }
 
     const runId = `evalrun_${randomUUID().replace(/-/g, "").slice(0, 16)}`;
-    const cases: EvalCaseSnapshot[] = selected.map((e) =>
-      discoveredToPending(e)
-    );
+    const cases: EvalCaseSnapshot[] = selected.map(e => discoveredToPending(e));
     const snapshot: EvalRunSnapshot = {
       runId,
       status: "running",
@@ -367,12 +365,12 @@ export class EvalRunStore {
           : { bearerToken: opts.bearerToken }),
         ...(opts.verbose === undefined ? {} : { verbose: opts.verbose }),
         ...(opts.timeoutMs === undefined ? {} : { timeoutMs: opts.timeoutMs }),
-        onCaseStart: (id) => {
+        onCaseStart: id => {
           const run = this.runs.get(runId);
           if (run === undefined || run.status === "cancelled") {
             return;
           }
-          const c = run.cases.find((x) => x.id === id);
+          const c = run.cases.find(x => x.id === id);
           if (c !== undefined) {
             c.status = "running";
             c.inputs = [];
@@ -389,7 +387,7 @@ export class EvalRunStore {
           if (run === undefined) {
             return;
           }
-          const c = run.cases.find((x) => x.id === id);
+          const c = run.cases.find(x => x.id === id);
           if (c === undefined) {
             return;
           }
@@ -414,7 +412,7 @@ export class EvalRunStore {
             c.finalText = event.data.text;
           }
         },
-        onCaseDone: (result) => {
+        onCaseDone: result => {
           this.applyCaseResult(runId, result);
           const run = this.runs.get(runId);
           if (run !== undefined) {
@@ -462,7 +460,7 @@ export class EvalRunStore {
     if (run === undefined) {
       return;
     }
-    const c = run.cases.find((x) => x.id === result.id);
+    const c = run.cases.find(x => x.id === result.id);
     if (c === undefined) {
       return;
     }

package/src/internal/eval-runner.ts

@@ -256,17 +256,17 @@ export function filterDiscoveredEvals(
 ): DiscoveredEval[] {
   let selected = evals as DiscoveredEval[];
   if (options.filterIds !== undefined && options.filterIds.length > 0) {
-    selected = selected.filter((e) =>
-      options.filterIds!.some((f) => matchesEvalIdFilter(e.id, f))
+    selected = selected.filter(e =>
+      options.filterIds!.some(f => matchesEvalIdFilter(e.id, f))
     );
   }
   if (options.tags !== undefined && options.tags.length > 0) {
-    selected = selected.filter((e) =>
-      (e.definition.tags ?? []).some((t) => options.tags!.includes(t))
+    selected = selected.filter(e =>
+      (e.definition.tags ?? []).some(t => options.tags!.includes(t))
     );
   }
   // Suite aggregators (`summary` tag) need sibling cases from the same file.
-  return expandSummarySuiteSelection(evals, selected, (e) =>
+  return expandSummarySuiteSelection(evals, selected, e =>
     isEvalSummaryCase(e.definition.tags)
   );
 }
@@ -314,7 +314,7 @@ export async function runDiscoveredEvals(
   const nested = await mapPool(
     groups,
     maxConcurrency,
-    async (group) => {
+    async group => {
       const results: EvalRunResult[] = [];
       for (const discovered of group) {
         if (options.signal?.aborted) {
@@ -335,7 +335,7 @@ export async function runDiscoveredEvals(
             configModel: config.judge?.model,
             caller: options.judgeCaller ?? callJudgeModel,
           },
-          onEvent: (event) => {
+          onEvent: event => {
             options.onCaseEvent?.(discovered.id, event);
             options.onEvent?.(event);
           },
@@ -392,7 +392,7 @@ function buildReporterHub(
   ];
   const perEval = skip
     ? []
-    : selected.flatMap((e) => e.definition.reporters ?? []);
+    : selected.flatMap(e => e.definition.reporters ?? []);
   const everyReporter = [...new Set([...runWide, ...perEval])];
   if (everyReporter.length === 0) {
     return undefined;
@@ -406,7 +406,7 @@ function buildReporterHub(
   return {
     async runStart(evals, target) {
       await all.onRunStart?.(
-        evals.map((e) => ({
+        evals.map(e => ({
           id: e.id,
           fileId: e.fileId,
           description: e.definition.description,
@@ -466,7 +466,7 @@ export function groupEvalsForIterationSchedule(
     }
     group.push(discovered);
   }
-  return order.map((key) => {
+  return order.map(key => {
     const group = groups.get(key)!;
     return group.sort(
       (a, b) => (a.definition.iteration ?? 1) - (b.definition.iteration ?? 1)
@@ -523,13 +523,13 @@ async function runOneEval(
   let reply: string | null = null;
 
   const toolsUsed = (): string[] =>
-    buildTrajectory(allEvents).turns.flatMap((t) =>
-      t.toolCalls.map((c) => c.toolName)
+    buildTrajectory(allEvents).turns.flatMap(t =>
+      t.toolCalls.map(c => c.toolName)
     );
 
   const toolCallIo = () =>
-    buildTrajectory(allEvents).turns.flatMap((turn) =>
-      turn.toolCalls.map((c) => ({
+    buildTrajectory(allEvents).turns.flatMap(turn =>
+      turn.toolCalls.map(c => ({
         toolName: c.toolName,
         ...(c.args === undefined ? {} : { args: c.args }),
         ...(c.output === undefined ? {} : { output: c.output }),
@@ -583,8 +583,8 @@ async function runOneEval(
 
   const judge = createJudgeSurface({
     recorder,
-    grader: (name) => EVAL_JUDGE_GRADERS[name],
-    resolveModel: (callModel) =>
+    grader: name => EVAL_JUDGE_GRADERS[name],
+    resolveModel: callModel =>
       resolveJudgeModel({
         call: callModel,
         evalLevel: def.judge?.model,
@@ -593,7 +593,7 @@ async function runOneEval(
       }),
     caller: opts.judge.caller,
     defaultValue: () => reply,
-    onUnavailable: (message) => {
+    onUnavailable: message => {
       judgeUnavailable = judgeUnavailable ?? message;
     },
   });
@@ -663,15 +663,15 @@ async function runOneEval(
         message: result.trajectory.finalText,
         sessionId: result.sessionId,
         events: turnEvents,
-        toolCalls: result.trajectory.turns.flatMap((turn) =>
-          turn.toolCalls.map((c) => c.toolName)
+        toolCalls: result.trajectory.turns.flatMap(turn =>
+          turn.toolCalls.map(c => c.toolName)
         ),
         ok: result.ok,
         index,
         expectOk() {
           if (!result.ok) {
             throw new Error(
-              `turn[${index}] failed: ${result.trajectory.turns.find((x) => x.failed)?.error ?? "unknown error"}`
+              `turn[${index}] failed: ${result.trajectory.turns.find(x => x.failed)?.error ?? "unknown error"}`
             );
           }
           return turn;

package/src/internal/evals-client.ts

@@ -165,17 +165,17 @@ export async function listRemoteEvals(args: {
 
   let selected = listed;
   if (args.filterIds !== undefined && args.filterIds.length > 0) {
-    selected = selected.filter((e) =>
-      args.filterIds!.some((f) => matchesEvalIdFilter(e.id, f))
+    selected = selected.filter(e =>
+      args.filterIds!.some(f => matchesEvalIdFilter(e.id, f))
     );
   }
   if (args.tags !== undefined && args.tags.length > 0) {
-    selected = selected.filter((e) =>
-      (e.tags ?? []).some((t) => args.tags!.includes(t))
+    selected = selected.filter(e =>
+      (e.tags ?? []).some(t => args.tags!.includes(t))
     );
   }
   // Match server-side filterDiscoveredEvals: summary → whole file.
-  return expandSummarySuiteSelection(listed, selected, (e) =>
+  return expandSummarySuiteSelection(listed, selected, e =>
     isEvalSummaryCase(e.tags)
   );
 }
@@ -483,7 +483,7 @@ export async function pollRemoteEvalRun(args: {
 export function snapshotToEvalRunResults(
   snapshot: EvalRunSnapshot
 ): EvalRunResult[] {
-  return snapshot.cases.map((c) => ({
+  return snapshot.cases.map(c => ({
     id: c.id,
     path: c.fileId,
     ...(c.description === undefined ? {} : { description: c.description }),

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

@@ -67,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;
@@ -85,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 === "..");
 }
 
 /**
@@ -109,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;
@@ -129,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[] = [];
@@ -213,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

@@ -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