@vellumai/assistant 0.11.3-dev.202608181709.1f85a67 → 0.11.3-dev.202608181811.60ef9e5

package/docs/architecture/memory.md

@@ -99,6 +99,17 @@ graph LR
     failure-backoff-respecting);
   - manual "Run now" via `POST /v1/consolidation/run-now`.
     Failed runs enter an exponential backoff (transient vs billing curves).
+  - The agent writes pages through the file tools, so nothing validates a
+    page at write time. Two corpus-level defects are instead reported by the
+    page index and fed back into the next pass's prompt as repair steps:
+    pages the index could not parse (`PageIndex.parseFailures`) and
+    structural references (`links:`, inline `[[wikilinks]]`, `edges:`) whose
+    target page does not exist (`PageIndex.danglingLinks`). The read-side
+    graph drops a dangling reference silently, so the job also counts them
+    after each run (`danglingLinks` on the outcome, a warn line) without
+    withholding the reindex follow-ups: the pages that were written still
+    become retrievable. The `memory validate` CLI subcommand reports the same
+    list.
 - **Ingestion** (`substrate/ingest.ts`, exposed as `POST /v1/memory/ingest`;
   generated HTTP operation id `memory_ingest_post`, IPC method
   `memory_ingest`) is the second sanctioned writer of
@@ -110,11 +121,12 @@ graph LR
   minute, and its same-minute burst guard falls back to processing the
   whole buffer in a single oversized run. Ingest writes validated pages
   directly instead. Purely mechanical: each page is validated and reported
-  individually, writes hold the consolidation lock so a batch cannot
-  interleave with a consolidation pass, and a batch that wrote at least one
-  page enqueues the same reindex follow-ups as consolidation
-  (`memory_v2_reembed`, `memory_v3_maintain`). Consolidation remains the only
-  LLM-driven writer.
+  individually (a `links:`/`[[wikilink]]`/`edges:` target that is neither on
+  disk nor in the batch is a per-page warning, not a rejection), writes hold
+  the consolidation lock so a batch cannot interleave with a consolidation
+  pass, and a batch that wrote at least one page enqueues the same reindex
+  follow-ups as consolidation (`memory_v2_reembed`, `memory_v3_maintain`).
+  Consolidation remains the only LLM-driven writer.
 
 ### Ingestion tracks and provenance
 

package/openapi.yaml

@@ -6608,6 +6608,20 @@ paths:
             predicate behind the unread count and the section index, so a client that keeps no complete conversation
             list can ask for exactly the rows its attention surfaces need. Composes with every other filter. Any value
             other than "true" is rejected. Omit to span every conversation.'
+        - name: foregroundOnly
+          in: query
+          required: false
+          schema:
+            type: string
+            enum:
+              - "true"
+          description:
+            Pass "true" to return only user-facing foreground conversations, dropping the automated background and
+            scheduled runs the standard listing admits when they are filed in a custom group (a surfaced run stays).
+            This is the same predicate the unread count and the section index apply, so a client can ask for the newest
+            conversation a user can open in one row instead of paging past runs it would skip. Composes with every other
+            filter; a foreground-only first page never has pinned rows appended to it. Any value other than "true" is
+            rejected. Omit to keep every visible row.
       responses:
         "200":
           description: Successful response

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.11.3-dev.202608181709.1f85a67",
+  "version": "0.11.3-dev.202608181811.60ef9e5",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/cli-memory-v2-reembed-skills.test.ts

@@ -45,6 +45,10 @@ mock.module("../plugins/defaults/memory/substrate/skill-store.js", () => ({
   seedV2SkillEntries: async () => {
     seedCallCount += 1;
   },
+  // The validate route builds the page index, which reads the seeded
+  // skill catalog; an empty catalog keeps that walk inert here.
+  listSkillEntries: () => [],
+  SKILL_SLUG_PREFIX: "skills/",
 }));
 
 // ---------------------------------------------------------------------------
@@ -254,7 +258,7 @@ describe("all memory v2 routes — MEMORY_V2_DISABLED gate", () => {
     const result = (await route!.handler({ body: {} })) as {
       pageCount: number;
       edgeCount: number;
-      missingEdgeEndpoints: unknown[];
+      danglingLinks: unknown[];
       oversizedPages: unknown[];
       parseFailures: unknown[];
     };
@@ -263,7 +267,7 @@ describe("all memory v2 routes — MEMORY_V2_DISABLED gate", () => {
     // returned at all (no MEMORY_V2_DISABLED throw).
     expect(result.pageCount).toBe(0);
     expect(result.edgeCount).toBe(0);
-    expect(result.missingEdgeEndpoints).toEqual([]);
+    expect(result.danglingLinks).toEqual([]);
     expect(result.oversizedPages).toEqual([]);
     expect(result.parseFailures).toEqual([]);
   });

package/src/__tests__/context-search-memory-v2-source.test.ts

@@ -71,7 +71,6 @@ mock.module("../plugins/defaults/memory/substrate/edge-index.js", () => ({
   getEdgeIndex: async (): Promise<EdgeIndex> => edgeIndex,
   invalidateEdgeIndex: () => {},
   getReachable: () => new Set<string>(),
-  validateEdgeTargets: () => ({ ok: true, missing: [] }),
   totalEdgeCount: () => 0,
 }));
 

package/src/__tests__/file-ops-service.test.ts

@@ -10,10 +10,11 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, describe, expect, test } from "bun:test";
 
+import { THRESHOLD_CHARS } from "../context/post-turn-tool-result-truncation.js";
 import {
-  DEFAULT_READ_LINE_LIMIT,
   FileSystemOps,
   type PathPolicy,
+  READ_CHAR_BUDGET,
 } from "../tools/shared/filesystem/file-ops-service.js";
 import { sandboxPolicy } from "../tools/shared/filesystem/path-policy.js";
 
@@ -111,34 +112,28 @@ describe("FileSystemOps.readFileSafe", () => {
     expect(result.error.code).toBe("PATH_OUT_OF_BOUNDS");
   });
 
-  test("respects offset and limit", async () => {
+  test("respects startIndex and maxChars", async () => {
     const dir = makeTempDir();
     writeFileSync(join(dir, "lines.txt"), "a\nb\nc\nd\ne\n");
     const ops = new FileSystemOps(sandboxPolicyFor(dir));
 
     const result = await ops.readFileSafe({
       path: "lines.txt",
-      offset: 2,
-      limit: 2,
+      startIndex: 2,
+      maxChars: 3,
     });
     expect(result.ok).toBe(true);
     if (!result.ok) {
       return;
     }
-    // Assert on the numbered lines rather than bare letters: the truncation
-    // notice is prose, so a bare `toContain("d")` matches its wording.
     const [body] = result.value.content.split("\n\n[Truncated:");
-    expect(body).toContain("     2  b");
-    expect(body).toContain("     3  c");
-    expect(body).not.toContain("     1  a");
-    expect(body).not.toContain("     4  d");
+    expect(body).toBe("b\nc");
   });
 
-  test("caps an unbounded read at the default line limit and says so", async () => {
+  test("caps an unbounded read at the character budget and says so", async () => {
     const dir = makeTempDir();
-    const total = DEFAULT_READ_LINE_LIMIT + 500;
-    const lines = Array.from({ length: total }, (_, i) => `line${i + 1}`);
-    writeFileSync(join(dir, "big.txt"), lines.join("\n"));
+    const total = READ_CHAR_BUDGET + 500;
+    writeFileSync(join(dir, "big.txt"), "x".repeat(total));
     const ops = new FileSystemOps(sandboxPolicyFor(dir));
 
     const result = await ops.readFileSafe({ path: "big.txt" });
@@ -146,36 +141,74 @@ describe("FileSystemOps.readFileSafe", () => {
     if (!result.ok) {
       return;
     }
-    const content = result.value.content;
-    expect(content).toContain(`  ${DEFAULT_READ_LINE_LIMIT}  line2000`);
-    expect(content).not.toContain("line2001");
-    expect(content).toContain(
-      `[Truncated: showing through line ${DEFAULT_READ_LINE_LIMIT} of ${total}. Read on with offset=${DEFAULT_READ_LINE_LIMIT + 1}`,
+    const [body] = result.value.content.split("\n\n[Truncated:");
+    expect(body).toHaveLength(READ_CHAR_BUDGET);
+    expect(result.value.content).toContain(
+      `[Truncated: characters 0-${READ_CHAR_BUDGET} of ${total}. Read on with start_index=${READ_CHAR_BUDGET}.]`,
     );
   });
 
-  test("an explicit limit is honored rather than replaced by the default", async () => {
+  test("a maxChars above the budget is clamped to it", async () => {
     const dir = makeTempDir();
-    const lines = Array.from(
-      { length: DEFAULT_READ_LINE_LIMIT + 500 },
-      (_, i) => `line${i + 1}`,
-    );
-    writeFileSync(join(dir, "big.txt"), lines.join("\n"));
+    const total = READ_CHAR_BUDGET + 500;
+    writeFileSync(join(dir, "big.txt"), "x".repeat(total));
     const ops = new FileSystemOps(sandboxPolicyFor(dir));
 
     const result = await ops.readFileSafe({
       path: "big.txt",
-      limit: DEFAULT_READ_LINE_LIMIT + 500,
+      maxChars: total,
     });
     expect(result.ok).toBe(true);
     if (!result.ok) {
       return;
     }
-    expect(result.value.content).toContain("line2500");
-    expect(result.value.content).not.toContain("[Truncated:");
+    const [body] = result.value.content.split("\n\n[Truncated:");
+    expect(body).toHaveLength(READ_CHAR_BUDGET);
+  });
+
+  test("a maxChars below the budget is honored as given", async () => {
+    const dir = makeTempDir();
+    writeFileSync(join(dir, "big.txt"), "x".repeat(500));
+    const ops = new FileSystemOps(sandboxPolicyFor(dir));
+
+    const result = await ops.readFileSafe({ path: "big.txt", maxChars: 10 });
+    expect(result.ok).toBe(true);
+    if (!result.ok) {
+      return;
+    }
+    const [body] = result.value.content.split("\n\n[Truncated:");
+    expect(body).toHaveLength(10);
+    expect(result.value.content).toContain(
+      "[Truncated: characters 0-10 of 500. Read on with start_index=10.]",
+    );
+  });
+
+  test("paging with the offset from a notice returns the next window", async () => {
+    const dir = makeTempDir();
+    writeFileSync(join(dir, "big.txt"), "abcdefghij");
+    const ops = new FileSystemOps(sandboxPolicyFor(dir));
+
+    const first = await ops.readFileSafe({ path: "big.txt", maxChars: 4 });
+    expect(first.ok).toBe(true);
+    if (!first.ok) {
+      return;
+    }
+    expect(first.value.content).toContain("start_index=4");
+
+    const second = await ops.readFileSafe({
+      path: "big.txt",
+      startIndex: 4,
+      maxChars: 4,
+    });
+    expect(second.ok).toBe(true);
+    if (!second.ok) {
+      return;
+    }
+    const [body] = second.value.content.split("\n\n[Truncated:");
+    expect(body).toBe("efgh");
   });
 
-  test("a read that reaches the last line carries no truncation notice", async () => {
+  test("a read that reaches the end carries no truncation notice", async () => {
     const dir = makeTempDir();
     writeFileSync(join(dir, "small.txt"), "a\nb\nc");
     const ops = new FileSystemOps(sandboxPolicyFor(dir));
@@ -193,13 +226,113 @@ describe("FileSystemOps.readFileSafe", () => {
     writeFileSync(join(dir, "small.txt"), "a\nb\nc");
     const ops = new FileSystemOps(sandboxPolicyFor(dir));
 
-    const result = await ops.readFileSafe({ path: "small.txt", offset: 100 });
+    const result = await ops.readFileSafe({
+      path: "small.txt",
+      startIndex: 100,
+    });
     expect(result.ok).toBe(true);
     if (!result.ok) {
       return;
     }
     expect(result.value.content).not.toContain("[Truncated:");
   });
+
+  test("a window boundary inside a surrogate pair does not corrupt it", async () => {
+    const dir = makeTempDir();
+    // "ab" + a 2-unit emoji + "cd": a maxChars of 3 would split the pair.
+    writeFileSync(join(dir, "emoji.txt"), `ab\u{1F600}cd`);
+    const ops = new FileSystemOps(sandboxPolicyFor(dir));
+
+    const result = await ops.readFileSafe({ path: "emoji.txt", maxChars: 3 });
+    expect(result.ok).toBe(true);
+    if (!result.ok) {
+      return;
+    }
+    const [body] = result.value.content.split("\n\n[Truncated:");
+    expect(body).toBe("ab");
+    expect(body).not.toContain("\uFFFD");
+  });
+
+  test("paging across a surrogate pair reassembles the whole file", async () => {
+    const dir = makeTempDir();
+    const original = `ab\u{1F600}cd`;
+    writeFileSync(join(dir, "emoji.txt"), original);
+    const ops = new FileSystemOps(sandboxPolicyFor(dir));
+
+    let assembled = "";
+    let startIndex = 0;
+    for (let i = 0; i < 10; i++) {
+      const result = await ops.readFileSafe({
+        path: "emoji.txt",
+        startIndex,
+        maxChars: 3,
+      });
+      expect(result.ok).toBe(true);
+      if (!result.ok) {
+        return;
+      }
+      const [body] = result.value.content.split("\n\n[Truncated:");
+      assembled += body;
+      const match = /start_index=(\d+)/.exec(result.value.content);
+      if (match?.[1] === undefined) {
+        break;
+      }
+      startIndex = Number(match[1]);
+    }
+    expect(assembled).toBe(original);
+  });
+
+  test("a lone-low-surrogate startIndex backs up onto the whole pair", async () => {
+    const dir = makeTempDir();
+    writeFileSync(join(dir, "emoji.txt"), `ab\u{1F600}cd`);
+    const ops = new FileSystemOps(sandboxPolicyFor(dir));
+
+    // Index 3 (0-indexed) is the low half of the emoji.
+    const result = await ops.readFileSafe({
+      path: "emoji.txt",
+      startIndex: 3,
+      maxChars: 2,
+    });
+    expect(result.ok).toBe(true);
+    if (!result.ok) {
+      return;
+    }
+    const [body] = result.value.content.split("\n\n[Truncated:");
+    expect(body).toBe(`\u{1F600}`);
+    expect(body).not.toContain("\uFFFD");
+  });
+
+  test("legacy offset/limit are rejected rather than silently ignored", async () => {
+    const { fileReadTool } = await import("../tools/filesystem/read.js");
+    const dir = makeTempDir();
+    writeFileSync(join(dir, "big.txt"), "x".repeat(500));
+
+    const result = await fileReadTool.execute(
+      { path: join(dir, "big.txt"), offset: 2001, limit: 2000 },
+      { workingDir: dir } as never,
+    );
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("no longer takes");
+    expect(result.content).toContain("start_index");
+  });
+
+  test("legacy fields alongside current ones do not trigger the guard", async () => {
+    const { fileReadTool } = await import("../tools/filesystem/read.js");
+    const dir = makeTempDir();
+    writeFileSync(join(dir, "big.txt"), "abcdefghij");
+
+    const result = await fileReadTool.execute(
+      { path: join(dir, "big.txt"), offset: 1, max_chars: 4 },
+      { workingDir: dir } as never,
+    );
+    expect(result.isError).toBe(false);
+    const [body] = result.content.split("\n\n[Truncated:");
+    expect(body).toBe("abcd");
+  });
+
+  test("the read budget stays under the tool-result spool threshold", () => {
+    expect(READ_CHAR_BUDGET).toBeLessThan(THRESHOLD_CHARS);
+  });
 });
 
 // ---------------------------------------------------------------------------

package/src/__tests__/filesystem-tools.test.ts

@@ -125,16 +125,19 @@ describe("FileSystemOps symlink handling", () => {
 });
 
 // ===========================================================================
-// FileSystemOps: read offset/limit edge cases
+// FileSystemOps: read character-window edge cases
 // ===========================================================================
 
-describe("FileSystemOps read offset/limit edge cases", () => {
-  test("offset beyond file length returns empty content", async () => {
+describe("FileSystemOps read character-window edge cases", () => {
+  test("startIndex beyond file length returns empty content", async () => {
     const dir = makeTempDir();
     writeFileSync(join(dir, "short.txt"), "a\nb\nc");
     const ops = new FileSystemOps(sandboxPolicyFor(dir));
 
-    const result = await ops.readFileSafe({ path: "short.txt", offset: 100 });
+    const result = await ops.readFileSafe({
+      path: "short.txt",
+      startIndex: 100,
+    });
     expect(result.ok).toBe(true);
     if (!result.ok) {
       return;
@@ -142,12 +145,12 @@ describe("FileSystemOps read offset/limit edge cases", () => {
     expect(result.value.content).toBe("");
   });
 
-  test("limit of zero returns empty content", async () => {
+  test("maxChars of zero returns empty content", async () => {
     const dir = makeTempDir();
     writeFileSync(join(dir, "file.txt"), "a\nb\nc");
     const ops = new FileSystemOps(sandboxPolicyFor(dir));
 
-    const result = await ops.readFileSafe({ path: "file.txt", limit: 0 });
+    const result = await ops.readFileSafe({ path: "file.txt", maxChars: 0 });
     expect(result.ok).toBe(true);
     if (!result.ok) {
       return;
@@ -155,61 +158,57 @@ describe("FileSystemOps read offset/limit edge cases", () => {
     expect(result.value.content).toBe("");
   });
 
-  test("offset=1 reads from first line (1-indexed)", async () => {
+  test("startIndex=0 reads from the first character (0-indexed)", async () => {
     const dir = makeTempDir();
     writeFileSync(join(dir, "file.txt"), "first\nsecond\nthird");
     const ops = new FileSystemOps(sandboxPolicyFor(dir));
 
     const result = await ops.readFileSafe({
       path: "file.txt",
-      offset: 1,
-      limit: 1,
+      startIndex: 0,
+      maxChars: 5,
     });
     expect(result.ok).toBe(true);
     if (!result.ok) {
       return;
     }
-    expect(result.value.content).toContain("first");
-    expect(result.value.content).not.toContain("second");
+    const [body] = result.value.content.split("\n\n[Truncated:");
+    expect(body).toBe("first");
   });
 
-  test("limit exceeding file length returns all remaining lines", async () => {
+  test("maxChars exceeding file length returns the rest of the file", async () => {
     const dir = makeTempDir();
     writeFileSync(join(dir, "file.txt"), "a\nb");
     const ops = new FileSystemOps(sandboxPolicyFor(dir));
 
     const result = await ops.readFileSafe({
       path: "file.txt",
-      offset: 1,
-      limit: 1000,
+      startIndex: 0,
+      maxChars: 1000,
     });
     expect(result.ok).toBe(true);
     if (!result.ok) {
       return;
     }
-    expect(result.value.content).toContain("a");
-    expect(result.value.content).toContain("b");
+    expect(result.value.content).toBe("a\nb");
   });
 
-  test("read adds line numbers starting from offset", async () => {
+  test("the window starts at startIndex and carries no line numbers", async () => {
     const dir = makeTempDir();
     writeFileSync(join(dir, "file.txt"), "a\nb\nc\nd\ne");
     const ops = new FileSystemOps(sandboxPolicyFor(dir));
 
     const result = await ops.readFileSafe({
       path: "file.txt",
-      offset: 3,
-      limit: 2,
+      startIndex: 4,
+      maxChars: 3,
     });
     expect(result.ok).toBe(true);
     if (!result.ok) {
       return;
     }
-    // Lines should be numbered 3 and 4
-    expect(result.value.content).toContain("3");
-    expect(result.value.content).toContain("4");
-    expect(result.value.content).toContain("c");
-    expect(result.value.content).toContain("d");
+    const [body] = result.value.content.split("\n\n[Truncated:");
+    expect(body).toBe("c\nd");
   });
 });
 

package/src/__tests__/host-file-read-tool.test.ts

@@ -27,7 +27,7 @@ mock.module("../daemon/host-file-proxy.js", () => ({
 }));
 
 import { hostFileReadTool } from "../tools/host-filesystem/read.js";
-import { DEFAULT_READ_LINE_LIMIT } from "../tools/shared/filesystem/file-ops-service.js";
+import { READ_CHAR_BUDGET } from "../tools/shared/filesystem/file-ops-service.js";
 import type { ToolContext } from "../tools/types.js";
 
 const testDirs: string[] = [];
@@ -77,19 +77,19 @@ describe("host_file_read tool", () => {
     expect(result.content).toContain("must be absolute");
   });
 
-  test("reads file with line numbers", async () => {
+  test("reads a character window", async () => {
     const dir = mkdtempSync(join(tmpdir(), "host-file-read-test-"));
     testDirs.push(dir);
     const filePath = join(dir, "sample.txt");
     writeFileSync(filePath, "first\nsecond\nthird\n");
 
     const result = await hostFileReadTool.execute(
-      { path: filePath, offset: 2, limit: 2 },
+      { path: filePath, start_index: 6, max_chars: 6 },
       makeContext(),
     );
     expect(result.isError).toBe(false);
-    expect(result.content).toContain("2  second");
-    expect(result.content).toContain("3  third");
+    expect(result.content).toContain("second");
+    expect(result.content).not.toContain("first");
   });
 
   test("returns error when file does not exist", async () => {
@@ -128,7 +128,7 @@ describe("host_file_read tool", () => {
     expect(result.content).toContain('Invalid input for tool "host_file_read"');
   });
 
-  test("reads entire file when no offset or limit specified", async () => {
+  test("reads the whole file when no window is specified", async () => {
     const dir = mkdtempSync(join(tmpdir(), "host-file-read-test-"));
     testDirs.push(dir);
     const filePath = join(dir, "full.txt");
@@ -139,9 +139,7 @@ describe("host_file_read tool", () => {
       makeContext(),
     );
     expect(result.isError).toBe(false);
-    expect(result.content).toContain("1  line1");
-    expect(result.content).toContain("2  line2");
-    expect(result.content).toContain("3  line3");
+    expect(result.content).toBe("line1\nline2\nline3\n");
   });
 
   test("handles empty file", async () => {
@@ -157,20 +155,19 @@ describe("host_file_read tool", () => {
     expect(result.isError).toBe(false);
   });
 
-  test("offset starts from the correct line (1-indexed)", async () => {
+  test("start_index is 0-indexed", async () => {
     const dir = mkdtempSync(join(tmpdir(), "host-file-read-test-"));
     testDirs.push(dir);
     const filePath = join(dir, "lines.txt");
     writeFileSync(filePath, "a\nb\nc\nd\ne\n");
 
     const result = await hostFileReadTool.execute(
-      { path: filePath, offset: 3, limit: 1 },
+      { path: filePath, start_index: 4, max_chars: 1 },
       makeContext(),
     );
     expect(result.isError).toBe(false);
-    expect(result.content).toContain("3  c");
-    expect(result.content).not.toContain("2  b");
-    expect(result.content).not.toContain("4  d");
+    const [body] = result.content.split("\n\n[Truncated:");
+    expect(body).toBe("c");
   });
 
   test("reads a file with symlinks resolved", async () => {
@@ -228,15 +225,15 @@ describe("host_file_read image support", () => {
     expect(result.isError).toBe(false);
     expect(result.contentBlocks).toHaveLength(1);
     // The proxied request carries the resolved default window, so a host read
-    // is bounded by the same limit as a local one rather than streaming a
+    // is bounded by the same budget as a local one rather than streaming a
     // whole file across the bridge.
     expect(requests).toEqual([
       {
         input: {
           operation: "read",
           path: "/host/screenshot.png",
-          offset: undefined,
-          limit: DEFAULT_READ_LINE_LIMIT,
+          startIndex: undefined,
+          maxChars: READ_CHAR_BUDGET,
         },
         conversationId: "test-conversation",
         signal: undefined,
@@ -306,8 +303,8 @@ describe("host_file_read image support", () => {
     );
 
     expect(result.isError).toBe(false);
-    expect(result.content).toContain("1  hello world");
-    expect(result.content).toContain("2  second line");
+    expect(result.content).toContain("hello world");
+    expect(result.content).toContain("second line");
     expect((result as any).contentBlocks).toBeUndefined();
   });
 

package/src/__tests__/tool-executor.test.ts

@@ -1457,7 +1457,11 @@ describe("ToolExecutor input-schema validation gate", () => {
     const executor = new ToolExecutor(makePrompter());
     const result = await executor.execute(
       "file_read",
-      { path: "a.txt", offset: "not-a-number", activity: "Reading a file" },
+      {
+        path: "a.txt",
+        start_index: "not-a-number",
+        activity: "Reading a file",
+      },
       makeContext(),
     );
 

package/src/api/events/host-file.ts

@@ -21,8 +21,8 @@ const HostFileReadRequestSchema = z.object({
   targetClientId: z.string().optional(),
   operation: z.literal("read"),
   path: z.string(),
-  offset: z.number().optional(),
-  limit: z.number().optional(),
+  startIndex: z.number().optional(),
+  maxChars: z.number().optional(),
 });
 
 const HostFileWriteRequestSchema = z.object({