fix(acp): reject fractional readTextFile limits

packages/acp-bridge/src/bridgeClient.test.ts

@@ -268,6 +268,28 @@ describe('BridgeClient — BridgeFileSystem injection seam (F1 step 5)', () => {
       expect((err.data as { hint?: unknown }).hint).toBeUndefined();
     });
 
+    it('readTextFile maps parse_error FsError to invalid params', async () => {
+      const readText = vi.fn(async (): Promise<ReadTextFileResponse> => {
+        throw makeFsError(
+          'parse_error',
+          'limit must be a positive integer, got 1.5',
+          { status: 400 },
+        );
+      });
+      const client = makeClient({ writeText: vi.fn(), readText });
+
+      const err = (await client
+        .readTextFile({ path: '/x', sessionId: 'sess:test', limit: 1.5 })
+        .catch((e) => e)) as Error & { code?: number; data?: unknown };
+
+      expect(err.name).toBe('RequestError');
+      expect(err.code).toBe(-32602);
+      expect(err.data).toMatchObject({
+        errorKind: 'parse_error',
+        status: 400,
+      });
+    });
+
     it('passes non-FsError errors through unchanged (no RequestError wrap)', async () => {
       // Plain Error → bridgeClient must NOT wrap it. Only structured
       // FsError gets the reshape. ACP's default serialization is
@@ -401,6 +423,46 @@ describe('BridgeClient — BridgeFileSystem injection seam (F1 step 5)', () => {
 
       expect(response.content).toBe('on-disk-content');
     });
+
+    it('readTextFile rejects fractional positive limits before slicing inline content', async () => {
+      const client = makeClient(/* no fileSystem */);
+      const target = path.join(tmpDir, 'lines.txt');
+      await fsp.writeFile(target, 'a\nb\nc\n', 'utf8');
+
+      const err = await client
+        .readTextFile({
+          path: target,
+          sessionId: 'sess:test',
+          line: 1,
+          limit: 1.5,
+        })
+        .catch((e: unknown) => e);
+
+      expect(err).toBeInstanceOf(RequestError);
+      expect((err as Error).message).toContain(
+        '`limit` must be a positive integer, got 1.5',
+      );
+    });
+
+    it('readTextFile rejects fractional positive lines before slicing inline content', async () => {
+      const client = makeClient(/* no fileSystem */);
+      const target = path.join(tmpDir, 'lines.txt');
+      await fsp.writeFile(target, 'a\nb\nc\n', 'utf8');
+
+      const err = await client
+        .readTextFile({
+          path: target,
+          sessionId: 'sess:test',
+          line: 1.5,
+          limit: 1,
+        })
+        .catch((e: unknown) => e);
+
+      expect(err).toBeInstanceOf(RequestError);
+      expect((err as Error).message).toContain(
+        '`line` must be a positive integer, got 1.5',
+      );
+    });
   });
 });
 

packages/acp-bridge/src/bridgeClient.ts

@@ -320,7 +320,8 @@ function isTrustedArtifactToolUpdate(
  */
 function preserveFsErrorOverAcp(err: unknown): never {
   if (isFsErrorShape(err)) {
-    throw new RequestError(-32603, err.message, {
+    const code = err.kind === 'parse_error' ? -32602 : -32603;
+    throw new RequestError(code, err.message, {
       errorKind: err.kind,
       ...(err.hint !== undefined ? { hint: err.hint } : {}),
       ...(err.status !== undefined ? { status: err.status } : {}),
@@ -1879,6 +1880,26 @@ export class BridgeClient implements Client {
     if (typeof params.limit === 'number' && params.limit <= 0) {
       return { content: '' };
     }
+    if (
+      typeof params.limit === 'number' &&
+      params.limit > 0 &&
+      !Number.isSafeInteger(params.limit)
+    ) {
+      throw RequestError.invalidParams(
+        undefined,
+        `\`limit\` must be a positive integer, got ${params.limit}`,
+      );
+    }
+    if (
+      typeof params.line === 'number' &&
+      params.line > 0 &&
+      !Number.isSafeInteger(params.line)
+    ) {
+      throw RequestError.invalidParams(
+        undefined,
+        `\`line\` must be a positive integer, got ${params.line}`,
+      );
+    }
     // BSA0E: cap the file size we'll buffer into RSS at 100 MiB so a
     // request like `{ line: 1, limit: 10 }` against a 500 MB log
     // doesn't cost the daemon 500 MB of memory just to return 10

packages/cli/src/serve/bridge-file-system-adapter.test.ts

@@ -365,6 +365,28 @@ describe('createBridgeFileSystemAdapter', () => {
       });
       expect(response.content).toBe('x\ny\n');
     });
+
+    it('readText surfaces workspace-file-system parse_error for fractional positive limits', async () => {
+      const target = path.join(tmpDir, 'fractional-limit.txt');
+      await fsp.writeFile(target, 'x\ny\nz\n', 'utf8');
+      const adapter = createBridgeFileSystemAdapter(
+        buildFactory({ trusted: true }),
+      );
+
+      const err = await adapter
+        .readText({
+          path: target,
+          sessionId: 'sess:test',
+          line: 1,
+          limit: 1.5,
+        })
+        .catch((e: unknown) => e);
+
+      expect((err as { kind?: string }).kind).toBe('parse_error');
+      expect((err as Error).message).toContain(
+        'limit must be a positive integer',
+      );
+    });
   });
 
   describe('boundary enforcement', () => {