fix(cli): fallback to local filesystem when ACP writeTextFile fails with invalid path

packages/cli/src/acp-integration/service/filesystem.test.ts

@@ -179,4 +179,69 @@ describe('AcpFileSystemService', () => {
       expect(client.readTextFile).not.toHaveBeenCalled();
     });
   });
+
+  describe('writeTextFile invalid path fallback', () => {
+    it('falls back to local filesystem when ACP write fails with invalid path', async () => {
+      const invalidPathError = {
+        code: INTERNAL_ERROR_CODE,
+        message: 'Internal error',
+        data: 'invalid path',
+      };
+      const client = {
+        writeTextFile: vi.fn().mockRejectedValue(invalidPathError),
+      } as unknown as AgentSideConnection;
+
+      const fallback = createFallback();
+      (fallback.writeTextFile as ReturnType<typeof vi.fn>).mockResolvedValue(
+        undefined,
+      );
+
+      const svc = new AcpFileSystemService(
+        client,
+        'session-4',
+        { readTextFile: true, writeTextFile: true },
+        fallback,
+      );
+
+      await expect(
+        svc.writeTextFile('/some/file.txt', 'hello world'),
+      ).resolves.toBeUndefined();
+
+      expect(client.writeTextFile).toHaveBeenCalledWith({
+        path: '/some/file.txt',
+        content: 'hello world',
+        sessionId: 'session-4',
+      });
+      expect(fallback.writeTextFile).toHaveBeenCalledWith(
+        '/some/file.txt',
+        'hello world',
+        undefined,
+      );
+    });
+
+    it('rethrows ACP write errors that are not invalid path', async () => {
+      const writeError = {
+        code: INTERNAL_ERROR_CODE,
+        message: 'Internal error',
+        data: 'permission denied',
+      };
+      const client = {
+        writeTextFile: vi.fn().mockRejectedValue(writeError),
+      } as unknown as AgentSideConnection;
+
+      const fallback = createFallback();
+
+      const svc = new AcpFileSystemService(
+        client,
+        'session-5',
+        { readTextFile: true, writeTextFile: true },
+        fallback,
+      );
+
+      await expect(
+        svc.writeTextFile('/some/file.txt', 'hello world'),
+      ).rejects.toMatchObject(writeError);
+      expect(fallback.writeTextFile).not.toHaveBeenCalled();
+    });
+  });
 });

packages/cli/src/acp-integration/service/filesystem.ts

@@ -16,6 +16,29 @@ import type {
 
 const RESOURCE_NOT_FOUND_CODE = -32002;
 
+function isInvalidPathWriteError(error: unknown): boolean {
+  const data =
+    typeof error === 'object' && error !== null && 'data' in error
+      ? (error as { data?: unknown }).data
+      : undefined;
+
+  if (typeof data === 'string') {
+    return data.toLowerCase() === 'invalid path';
+  }
+
+  const message =
+    error instanceof Error
+      ? error.message
+      : typeof error === 'object' && error !== null && 'message' in error
+        ? (error as { message?: unknown }).message
+        : undefined;
+
+  return (
+    typeof message === 'string' &&
+    message.toLowerCase().includes('invalid path')
+  );
+}
+
 export class AcpFileSystemService implements FileSystemService {
   constructor(
     private readonly connection: AgentSideConnection,
@@ -75,12 +98,19 @@ export class AcpFileSystemService implements FileSystemService {
     }
 
     const finalContent = options?.bom ? '\uFEFF' + content : content;
-
-    await this.connection.writeTextFile({
-      path: filePath,
-      content: finalContent,
-      sessionId: this.sessionId,
-    });
+    try {
+      await this.connection.writeTextFile({
+        path: filePath,
+        content: finalContent,
+        sessionId: this.sessionId,
+      });
+    } catch (error) {
+      if (isInvalidPathWriteError(error)) {
+        await this.fallback.writeTextFile(filePath, content, options);
+        return;
+      }
+      throw error;
+    }
   }
 
   async detectFileBOM(filePath: string): Promise<boolean> {