@vellumai/assistant 0.4.17 → 0.4.18

package/src/__tests__/sandbox-host-parity.test.ts

@@ -27,14 +27,13 @@ import {
   realpathSync,
   rmSync,
   writeFileSync,
-} from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-
-import { afterEach, describe, expect, mock, test } from 'bun:test';
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, mock, test } from "bun:test";
 
 // Mock the logger before any transitive imports that depend on pino
-mock.module('../util/logger.js', () => ({
+mock.module("../util/logger.js", () => ({
   getLogger: () => ({
     error: () => {},
     warn: () => {},
@@ -43,15 +42,24 @@ mock.module('../util/logger.js', () => ({
   }),
 }));
 
-import { applyEdit } from '../tools/shared/filesystem/edit-engine.js';
-import { FileSystemOps, type PathPolicy } from '../tools/shared/filesystem/file-ops-service.js';
-import { hostPolicy,sandboxPolicy } from '../tools/shared/filesystem/path-policy.js';
-import { formatShellOutput, MAX_OUTPUT_LENGTH } from '../tools/shared/shell-output.js';
+import { applyEdit } from "../tools/shared/filesystem/edit-engine.js";
+import {
+  FileSystemOps,
+  type PathPolicy,
+} from "../tools/shared/filesystem/file-ops-service.js";
+import {
+  hostPolicy,
+  sandboxPolicy,
+} from "../tools/shared/filesystem/path-policy.js";
+import {
+  formatShellOutput,
+  MAX_OUTPUT_LENGTH,
+} from "../tools/shared/shell-output.js";
 
 // Dynamically import modules that depend on the mocked logger
-const { NativeBackend } = await import('../tools/terminal/backends/native.js');
-const { wrapCommand } = await import('../tools/terminal/sandbox.js');
-const { ToolError } = await import('../util/errors.js');
+const { NativeBackend } = await import("../tools/terminal/backends/native.js");
+const { wrapCommand } = await import("../tools/terminal/sandbox.js");
+const { ToolError } = await import("../util/errors.js");
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -60,7 +68,7 @@ const { ToolError } = await import('../util/errors.js');
 const testDirs: string[] = [];
 
 function makeTempDir(): string {
-  const dir = realpathSync(mkdtempSync(join(tmpdir(), 'parity-test-')));
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), "parity-test-")));
   testDirs.push(dir);
   return dir;
 }
@@ -85,7 +93,10 @@ function hostPolicyFn(): PathPolicy {
  * Run the same operation against both sandbox and host FileSystemOps
  * and return both results for comparison.
  */
-function dualOps(boundary: string): { sandbox: FileSystemOps; host: FileSystemOps } {
+function dualOps(boundary: string): {
+  sandbox: FileSystemOps;
+  host: FileSystemOps;
+} {
   return {
     sandbox: new FileSystemOps(sandboxPolicyFor(boundary)),
     host: new FileSystemOps(hostPolicyFn()),
@@ -96,16 +107,16 @@ function dualOps(boundary: string): { sandbox: FileSystemOps; host: FileSystemOp
 // 1. File read parity
 // ===========================================================================
 
-describe('Read parity: sandbox vs host produce identical content', () => {
-  test('simple file read returns same numbered content', () => {
+describe("Read parity: sandbox vs host produce identical content", () => {
+  test("simple file read returns same numbered content", () => {
     const dir = makeTempDir();
-    const content = 'line one\nline two\nline three\n';
-    writeFileSync(join(dir, 'data.txt'), content);
+    const content = "line one\nline two\nline three\n";
+    writeFileSync(join(dir, "data.txt"), content);
 
     const { sandbox, host } = dualOps(dir);
 
-    const sandboxResult = sandbox.readFileSafe({ path: 'data.txt' });
-    const hostResult = host.readFileSafe({ path: join(dir, 'data.txt') });
+    const sandboxResult = sandbox.readFileSafe({ path: "data.txt" });
+    const hostResult = host.readFileSafe({ path: join(dir, "data.txt") });
 
     expect(sandboxResult.ok).toBe(true);
     expect(hostResult.ok).toBe(true);
@@ -115,14 +126,22 @@ describe('Read parity: sandbox vs host produce identical content', () => {
     expect(sandboxResult.value.content).toBe(hostResult.value.content);
   });
 
-  test('read with offset and limit returns same slice', () => {
+  test("read with offset and limit returns same slice", () => {
     const dir = makeTempDir();
-    writeFileSync(join(dir, 'lines.txt'), 'a\nb\nc\nd\ne\nf\n');
+    writeFileSync(join(dir, "lines.txt"), "a\nb\nc\nd\ne\nf\n");
 
     const { sandbox, host } = dualOps(dir);
 
-    const sandboxResult = sandbox.readFileSafe({ path: 'lines.txt', offset: 2, limit: 3 });
-    const hostResult = host.readFileSafe({ path: join(dir, 'lines.txt'), offset: 2, limit: 3 });
+    const sandboxResult = sandbox.readFileSafe({
+      path: "lines.txt",
+      offset: 2,
+      limit: 3,
+    });
+    const hostResult = host.readFileSafe({
+      path: join(dir, "lines.txt"),
+      offset: 2,
+      limit: 3,
+    });
 
     expect(sandboxResult.ok).toBe(true);
     expect(hostResult.ok).toBe(true);
@@ -131,47 +150,49 @@ describe('Read parity: sandbox vs host produce identical content', () => {
     expect(sandboxResult.value.content).toBe(hostResult.value.content);
   });
 
-  test('reading a missing file returns NOT_FOUND from both', () => {
+  test("reading a missing file returns NOT_FOUND from both", () => {
     const dir = makeTempDir();
 
     const { sandbox, host } = dualOps(dir);
 
-    const sandboxResult = sandbox.readFileSafe({ path: 'nonexistent.txt' });
-    const hostResult = host.readFileSafe({ path: join(dir, 'nonexistent.txt') });
+    const sandboxResult = sandbox.readFileSafe({ path: "nonexistent.txt" });
+    const hostResult = host.readFileSafe({
+      path: join(dir, "nonexistent.txt"),
+    });
 
     expect(sandboxResult.ok).toBe(false);
     expect(hostResult.ok).toBe(false);
     if (sandboxResult.ok || hostResult.ok) return;
 
-    expect(sandboxResult.error.code).toBe('NOT_FOUND');
-    expect(hostResult.error.code).toBe('NOT_FOUND');
+    expect(sandboxResult.error.code).toBe("NOT_FOUND");
+    expect(hostResult.error.code).toBe("NOT_FOUND");
   });
 
-  test('reading a directory returns NOT_A_FILE from both', () => {
+  test("reading a directory returns NOT_A_FILE from both", () => {
     const dir = makeTempDir();
-    mkdirSync(join(dir, 'subdir'));
+    mkdirSync(join(dir, "subdir"));
 
     const { sandbox, host } = dualOps(dir);
 
-    const sandboxResult = sandbox.readFileSafe({ path: 'subdir' });
-    const hostResult = host.readFileSafe({ path: join(dir, 'subdir') });
+    const sandboxResult = sandbox.readFileSafe({ path: "subdir" });
+    const hostResult = host.readFileSafe({ path: join(dir, "subdir") });
 
     expect(sandboxResult.ok).toBe(false);
     expect(hostResult.ok).toBe(false);
     if (sandboxResult.ok || hostResult.ok) return;
 
-    expect(sandboxResult.error.code).toBe('NOT_A_FILE');
-    expect(hostResult.error.code).toBe('NOT_A_FILE');
+    expect(sandboxResult.error.code).toBe("NOT_A_FILE");
+    expect(hostResult.error.code).toBe("NOT_A_FILE");
   });
 
-  test('empty file read returns same content from both', () => {
+  test("empty file read returns same content from both", () => {
     const dir = makeTempDir();
-    writeFileSync(join(dir, 'empty.txt'), '');
+    writeFileSync(join(dir, "empty.txt"), "");
 
     const { sandbox, host } = dualOps(dir);
 
-    const sandboxResult = sandbox.readFileSafe({ path: 'empty.txt' });
-    const hostResult = host.readFileSafe({ path: join(dir, 'empty.txt') });
+    const sandboxResult = sandbox.readFileSafe({ path: "empty.txt" });
+    const hostResult = host.readFileSafe({ path: join(dir, "empty.txt") });
 
     expect(sandboxResult.ok).toBe(true);
     expect(hostResult.ok).toBe(true);
@@ -180,15 +201,16 @@ describe('Read parity: sandbox vs host produce identical content', () => {
     expect(sandboxResult.value.content).toBe(hostResult.value.content);
   });
 
-  test('file with unicode content returns same from both', () => {
+  test("file with unicode content returns same from both", () => {
     const dir = makeTempDir();
-    const unicode = 'Hello\nEmoji: \u{1F600}\nCJK: \u4F60\u597D\nAccent: caf\u00E9\n';
-    writeFileSync(join(dir, 'unicode.txt'), unicode);
+    const unicode =
+      "Hello\nEmoji: \u{1F600}\nCJK: \u4F60\u597D\nAccent: caf\u00E9\n";
+    writeFileSync(join(dir, "unicode.txt"), unicode);
 
     const { sandbox, host } = dualOps(dir);
 
-    const sandboxResult = sandbox.readFileSafe({ path: 'unicode.txt' });
-    const hostResult = host.readFileSafe({ path: join(dir, 'unicode.txt') });
+    const sandboxResult = sandbox.readFileSafe({ path: "unicode.txt" });
+    const hostResult = host.readFileSafe({ path: join(dir, "unicode.txt") });
 
     expect(sandboxResult.ok).toBe(true);
     expect(hostResult.ok).toBe(true);
@@ -202,14 +224,20 @@ describe('Read parity: sandbox vs host produce identical content', () => {
 // 2. File write parity
 // ===========================================================================
 
-describe('Write parity: sandbox vs host produce identical results', () => {
-  test('writing a new file returns same shape from both', () => {
+describe("Write parity: sandbox vs host produce identical results", () => {
+  test("writing a new file returns same shape from both", () => {
     const dir = makeTempDir();
 
     const { sandbox, host } = dualOps(dir);
 
-    const sandboxResult = sandbox.writeFileSafe({ path: 'new-s.txt', content: 'hello' });
-    const hostResult = host.writeFileSafe({ path: join(dir, 'new-h.txt'), content: 'hello' });
+    const sandboxResult = sandbox.writeFileSafe({
+      path: "new-s.txt",
+      content: "hello",
+    });
+    const hostResult = host.writeFileSafe({
+      path: join(dir, "new-h.txt"),
+      content: "hello",
+    });
 
     expect(sandboxResult.ok).toBe(true);
     expect(hostResult.ok).toBe(true);
@@ -221,15 +249,21 @@ describe('Write parity: sandbox vs host produce identical results', () => {
     expect(sandboxResult.value.oldContent).toBe(hostResult.value.oldContent);
   });
 
-  test('overwriting an existing file returns old content from both', () => {
+  test("overwriting an existing file returns old content from both", () => {
     const dir = makeTempDir();
-    writeFileSync(join(dir, 'existing-s.txt'), 'old');
-    writeFileSync(join(dir, 'existing-h.txt'), 'old');
+    writeFileSync(join(dir, "existing-s.txt"), "old");
+    writeFileSync(join(dir, "existing-h.txt"), "old");
 
     const { sandbox, host } = dualOps(dir);
 
-    const sandboxResult = sandbox.writeFileSafe({ path: 'existing-s.txt', content: 'new' });
-    const hostResult = host.writeFileSafe({ path: join(dir, 'existing-h.txt'), content: 'new' });
+    const sandboxResult = sandbox.writeFileSafe({
+      path: "existing-s.txt",
+      content: "new",
+    });
+    const hostResult = host.writeFileSafe({
+      path: join(dir, "existing-h.txt"),
+      content: "new",
+    });
 
     expect(sandboxResult.ok).toBe(true);
     expect(hostResult.ok).toBe(true);
@@ -237,30 +271,36 @@ describe('Write parity: sandbox vs host produce identical results', () => {
 
     expect(sandboxResult.value.isNewFile).toBe(false);
     expect(hostResult.value.isNewFile).toBe(false);
-    expect(sandboxResult.value.oldContent).toBe('old');
-    expect(hostResult.value.oldContent).toBe('old');
-    expect(sandboxResult.value.newContent).toBe('new');
-    expect(hostResult.value.newContent).toBe('new');
+    expect(sandboxResult.value.oldContent).toBe("old");
+    expect(hostResult.value.oldContent).toBe("old");
+    expect(sandboxResult.value.newContent).toBe("new");
+    expect(hostResult.value.newContent).toBe("new");
 
     // Verify actual files on disk
-    expect(readFileSync(join(dir, 'existing-s.txt'), 'utf-8')).toBe('new');
-    expect(readFileSync(join(dir, 'existing-h.txt'), 'utf-8')).toBe('new');
+    expect(readFileSync(join(dir, "existing-s.txt"), "utf-8")).toBe("new");
+    expect(readFileSync(join(dir, "existing-h.txt"), "utf-8")).toBe("new");
   });
 
-  test('creating nested directories works from both', () => {
+  test("creating nested directories works from both", () => {
     const dir = makeTempDir();
 
     const { sandbox, host } = dualOps(dir);
 
-    const sandboxResult = sandbox.writeFileSafe({ path: 'a/b/deep-s.txt', content: 'deep' });
-    const hostResult = host.writeFileSafe({ path: join(dir, 'c/d/deep-h.txt'), content: 'deep' });
+    const sandboxResult = sandbox.writeFileSafe({
+      path: "a/b/deep-s.txt",
+      content: "deep",
+    });
+    const hostResult = host.writeFileSafe({
+      path: join(dir, "c/d/deep-h.txt"),
+      content: "deep",
+    });
 
     expect(sandboxResult.ok).toBe(true);
     expect(hostResult.ok).toBe(true);
     if (!sandboxResult.ok || !hostResult.ok) return;
 
-    expect(existsSync(join(dir, 'a/b/deep-s.txt'))).toBe(true);
-    expect(existsSync(join(dir, 'c/d/deep-h.txt'))).toBe(true);
+    expect(existsSync(join(dir, "a/b/deep-s.txt"))).toBe(true);
+    expect(existsSync(join(dir, "c/d/deep-h.txt"))).toBe(true);
     expect(sandboxResult.value.isNewFile).toBe(true);
     expect(hostResult.value.isNewFile).toBe(true);
   });
@@ -270,24 +310,24 @@ describe('Write parity: sandbox vs host produce identical results', () => {
 // 3. File edit parity
 // ===========================================================================
 
-describe('Edit parity: sandbox vs host produce identical edits', () => {
-  test('unique match edit produces same result from both', () => {
+describe("Edit parity: sandbox vs host produce identical edits", () => {
+  test("unique match edit produces same result from both", () => {
     const dir = makeTempDir();
-    writeFileSync(join(dir, 'edit-s.txt'), 'one two three');
-    writeFileSync(join(dir, 'edit-h.txt'), 'one two three');
+    writeFileSync(join(dir, "edit-s.txt"), "one two three");
+    writeFileSync(join(dir, "edit-h.txt"), "one two three");
 
     const { sandbox, host } = dualOps(dir);
 
     const sandboxResult = sandbox.editFileSafe({
-      path: 'edit-s.txt',
-      oldString: 'two',
-      newString: 'TWO',
+      path: "edit-s.txt",
+      oldString: "two",
+      newString: "TWO",
       replaceAll: false,
     });
     const hostResult = host.editFileSafe({
-      path: join(dir, 'edit-h.txt'),
-      oldString: 'two',
-      newString: 'TWO',
+      path: join(dir, "edit-h.txt"),
+      oldString: "two",
+      newString: "TWO",
       replaceAll: false,
     });
 
@@ -297,29 +337,29 @@ describe('Edit parity: sandbox vs host produce identical edits', () => {
 
     expect(sandboxResult.value.matchCount).toBe(1);
     expect(hostResult.value.matchCount).toBe(1);
-    expect(sandboxResult.value.newContent).toBe('one TWO three');
-    expect(hostResult.value.newContent).toBe('one TWO three');
+    expect(sandboxResult.value.newContent).toBe("one TWO three");
+    expect(hostResult.value.newContent).toBe("one TWO three");
     expect(sandboxResult.value.matchMethod).toBe(hostResult.value.matchMethod);
   });
 
-  test('replaceAll edit produces same result from both', () => {
+  test("replaceAll edit produces same result from both", () => {
     const dir = makeTempDir();
-    const original = 'foo bar foo baz foo';
-    writeFileSync(join(dir, 'ra-s.txt'), original);
-    writeFileSync(join(dir, 'ra-h.txt'), original);
+    const original = "foo bar foo baz foo";
+    writeFileSync(join(dir, "ra-s.txt"), original);
+    writeFileSync(join(dir, "ra-h.txt"), original);
 
     const { sandbox, host } = dualOps(dir);
 
     const sandboxResult = sandbox.editFileSafe({
-      path: 'ra-s.txt',
-      oldString: 'foo',
-      newString: 'qux',
+      path: "ra-s.txt",
+      oldString: "foo",
+      newString: "qux",
       replaceAll: true,
     });
     const hostResult = host.editFileSafe({
-      path: join(dir, 'ra-h.txt'),
-      oldString: 'foo',
-      newString: 'qux',
+      path: join(dir, "ra-h.txt"),
+      oldString: "foo",
+      newString: "qux",
       replaceAll: true,
     });
 
@@ -330,26 +370,26 @@ describe('Edit parity: sandbox vs host produce identical edits', () => {
     expect(sandboxResult.value.matchCount).toBe(3);
     expect(hostResult.value.matchCount).toBe(3);
     expect(sandboxResult.value.newContent).toBe(hostResult.value.newContent);
-    expect(sandboxResult.value.newContent).toBe('qux bar qux baz qux');
+    expect(sandboxResult.value.newContent).toBe("qux bar qux baz qux");
   });
 
-  test('missing old_string returns MATCH_NOT_FOUND from both', () => {
+  test("missing old_string returns MATCH_NOT_FOUND from both", () => {
     const dir = makeTempDir();
-    writeFileSync(join(dir, 'mnf-s.txt'), 'hello world');
-    writeFileSync(join(dir, 'mnf-h.txt'), 'hello world');
+    writeFileSync(join(dir, "mnf-s.txt"), "hello world");
+    writeFileSync(join(dir, "mnf-h.txt"), "hello world");
 
     const { sandbox, host } = dualOps(dir);
 
     const sandboxResult = sandbox.editFileSafe({
-      path: 'mnf-s.txt',
-      oldString: 'xyz',
-      newString: 'abc',
+      path: "mnf-s.txt",
+      oldString: "xyz",
+      newString: "abc",
       replaceAll: false,
     });
     const hostResult = host.editFileSafe({
-      path: join(dir, 'mnf-h.txt'),
-      oldString: 'xyz',
-      newString: 'abc',
+      path: join(dir, "mnf-h.txt"),
+      oldString: "xyz",
+      newString: "abc",
       replaceAll: false,
     });
 
@@ -357,28 +397,28 @@ describe('Edit parity: sandbox vs host produce identical edits', () => {
     expect(hostResult.ok).toBe(false);
     if (sandboxResult.ok || hostResult.ok) return;
 
-    expect(sandboxResult.error.code).toBe('MATCH_NOT_FOUND');
-    expect(hostResult.error.code).toBe('MATCH_NOT_FOUND');
+    expect(sandboxResult.error.code).toBe("MATCH_NOT_FOUND");
+    expect(hostResult.error.code).toBe("MATCH_NOT_FOUND");
   });
 
-  test('ambiguous match returns MATCH_AMBIGUOUS from both', () => {
+  test("ambiguous match returns MATCH_AMBIGUOUS from both", () => {
     const dir = makeTempDir();
-    const content = 'repeat\nrepeat\n';
-    writeFileSync(join(dir, 'amb-s.txt'), content);
-    writeFileSync(join(dir, 'amb-h.txt'), content);
+    const content = "repeat\nrepeat\n";
+    writeFileSync(join(dir, "amb-s.txt"), content);
+    writeFileSync(join(dir, "amb-h.txt"), content);
 
     const { sandbox, host } = dualOps(dir);
 
     const sandboxResult = sandbox.editFileSafe({
-      path: 'amb-s.txt',
-      oldString: 'repeat',
-      newString: 'unique',
+      path: "amb-s.txt",
+      oldString: "repeat",
+      newString: "unique",
       replaceAll: false,
     });
     const hostResult = host.editFileSafe({
-      path: join(dir, 'amb-h.txt'),
-      oldString: 'repeat',
-      newString: 'unique',
+      path: join(dir, "amb-h.txt"),
+      oldString: "repeat",
+      newString: "unique",
       replaceAll: false,
     });
 
@@ -386,25 +426,25 @@ describe('Edit parity: sandbox vs host produce identical edits', () => {
     expect(hostResult.ok).toBe(false);
     if (sandboxResult.ok || hostResult.ok) return;
 
-    expect(sandboxResult.error.code).toBe('MATCH_AMBIGUOUS');
-    expect(hostResult.error.code).toBe('MATCH_AMBIGUOUS');
+    expect(sandboxResult.error.code).toBe("MATCH_AMBIGUOUS");
+    expect(hostResult.error.code).toBe("MATCH_AMBIGUOUS");
   });
 
-  test('editing a nonexistent file returns NOT_FOUND from both', () => {
+  test("editing a nonexistent file returns NOT_FOUND from both", () => {
     const dir = makeTempDir();
 
     const { sandbox, host } = dualOps(dir);
 
     const sandboxResult = sandbox.editFileSafe({
-      path: 'nope.txt',
-      oldString: 'a',
-      newString: 'b',
+      path: "nope.txt",
+      oldString: "a",
+      newString: "b",
       replaceAll: false,
     });
     const hostResult = host.editFileSafe({
-      path: join(dir, 'nope.txt'),
-      oldString: 'a',
-      newString: 'b',
+      path: join(dir, "nope.txt"),
+      oldString: "a",
+      newString: "b",
       replaceAll: false,
     });
 
@@ -412,8 +452,8 @@ describe('Edit parity: sandbox vs host produce identical edits', () => {
     expect(hostResult.ok).toBe(false);
     if (sandboxResult.ok || hostResult.ok) return;
 
-    expect(sandboxResult.error.code).toBe('NOT_FOUND');
-    expect(hostResult.error.code).toBe('NOT_FOUND');
+    expect(sandboxResult.error.code).toBe("NOT_FOUND");
+    expect(hostResult.error.code).toBe("NOT_FOUND");
   });
 });
 
@@ -421,22 +461,22 @@ describe('Edit parity: sandbox vs host produce identical edits', () => {
 // 4. Edit engine consistency (pure function)
 // ===========================================================================
 
-describe('applyEdit engine: deterministic across invocations', () => {
-  test('exact single match is idempotent', () => {
-    const content = 'alpha beta gamma';
-    const r1 = applyEdit(content, 'beta', 'BETA', false);
-    const r2 = applyEdit(content, 'beta', 'BETA', false);
+describe("applyEdit engine: deterministic across invocations", () => {
+  test("exact single match is idempotent", () => {
+    const content = "alpha beta gamma";
+    const r1 = applyEdit(content, "beta", "BETA", false);
+    const r2 = applyEdit(content, "beta", "BETA", false);
 
     expect(r1).toEqual(r2);
     expect(r1.ok).toBe(true);
     if (!r1.ok) return;
-    expect(r1.updatedContent).toBe('alpha BETA gamma');
+    expect(r1.updatedContent).toBe("alpha BETA gamma");
   });
 
-  test('replaceAll is idempotent', () => {
-    const content = 'x y x z x';
-    const r1 = applyEdit(content, 'x', 'X', true);
-    const r2 = applyEdit(content, 'x', 'X', true);
+  test("replaceAll is idempotent", () => {
+    const content = "x y x z x";
+    const r1 = applyEdit(content, "x", "X", true);
+    const r2 = applyEdit(content, "x", "X", true);
 
     expect(r1).toEqual(r2);
     expect(r1.ok).toBe(true);
@@ -444,56 +484,56 @@ describe('applyEdit engine: deterministic across invocations', () => {
     expect(r1.matchCount).toBe(3);
   });
 
-  test('not-found is consistent', () => {
-    const content = 'hello';
-    const r1 = applyEdit(content, 'missing', 'found', false);
-    const r2 = applyEdit(content, 'missing', 'found', false);
+  test("not-found is consistent", () => {
+    const content = "hello";
+    const r1 = applyEdit(content, "missing", "found", false);
+    const r2 = applyEdit(content, "missing", "found", false);
 
     expect(r1).toEqual(r2);
     expect(r1.ok).toBe(false);
     if (r1.ok) return;
-    expect(r1.reason).toBe('not_found');
+    expect(r1.reason).toBe("not_found");
   });
 
-  test('ambiguous is consistent', () => {
-    const content = 'dup dup dup';
-    const r1 = applyEdit(content, 'dup', 'uniq', false);
-    const r2 = applyEdit(content, 'dup', 'uniq', false);
+  test("ambiguous is consistent", () => {
+    const content = "dup dup dup";
+    const r1 = applyEdit(content, "dup", "uniq", false);
+    const r2 = applyEdit(content, "dup", "uniq", false);
 
     expect(r1).toEqual(r2);
     expect(r1.ok).toBe(false);
     if (r1.ok) return;
-    expect(r1.reason).toBe('ambiguous');
-    if (r1.reason !== 'ambiguous') return;
+    expect(r1.reason).toBe("ambiguous");
+    if (r1.reason !== "ambiguous") return;
     expect(r1.matchCount).toBe(3);
   });
 
-  test('multiline content is handled correctly', () => {
-    const content = 'line1\nline2\nline3\nline4\n';
-    const result = applyEdit(content, 'line2\nline3', 'replaced', false);
+  test("multiline content is handled correctly", () => {
+    const content = "line1\nline2\nline3\nline4\n";
+    const result = applyEdit(content, "line2\nline3", "replaced", false);
 
     expect(result.ok).toBe(true);
     if (!result.ok) return;
-    expect(result.updatedContent).toBe('line1\nreplaced\nline4\n');
+    expect(result.updatedContent).toBe("line1\nreplaced\nline4\n");
     expect(result.matchCount).toBe(1);
   });
 
-  test('replacing with empty string works', () => {
-    const content = 'keep remove keep';
-    const result = applyEdit(content, ' remove', '', false);
+  test("replacing with empty string works", () => {
+    const content = "keep remove keep";
+    const result = applyEdit(content, " remove", "", false);
 
     expect(result.ok).toBe(true);
     if (!result.ok) return;
-    expect(result.updatedContent).toBe('keep keep');
+    expect(result.updatedContent).toBe("keep keep");
   });
 
-  test('special regex characters in old_string are treated as literals', () => {
-    const content = 'price is $100.00 (USD)';
-    const result = applyEdit(content, '$100.00', '$200.00', false);
+  test("special regex characters in old_string are treated as literals", () => {
+    const content = "price is $100.00 (USD)";
+    const result = applyEdit(content, "$100.00", "$200.00", false);
 
     expect(result.ok).toBe(true);
     if (!result.ok) return;
-    expect(result.updatedContent).toBe('price is $200.00 (USD)');
+    expect(result.updatedContent).toBe("price is $200.00 (USD)");
   });
 });
 
@@ -501,57 +541,62 @@ describe('applyEdit engine: deterministic across invocations', () => {
 // 5. Path policy divergence — expected differences
 // ===========================================================================
 
-describe('Path policy divergence: sandbox blocks escapes, host requires absolute', () => {
-  test('sandbox blocks path traversal (../), host allows any absolute path', () => {
+describe("Path policy divergence: sandbox blocks escapes, host requires absolute", () => {
+  test("sandbox blocks path traversal (../), host allows any absolute path", () => {
     const dir = makeTempDir();
-    writeFileSync(join(dir, 'inside.txt'), 'safe content');
+    writeFileSync(join(dir, "inside.txt"), "safe content");
 
     const sandboxOps = new FileSystemOps(sandboxPolicyFor(dir));
     const hostOps = new FileSystemOps(hostPolicyFn());
 
     // Sandbox: path traversal should be rejected
-    const sandboxResult = sandboxOps.readFileSafe({ path: '../../../etc/hostname' });
+    const sandboxResult = sandboxOps.readFileSafe({
+      path: "../../../etc/hostname",
+    });
     expect(sandboxResult.ok).toBe(false);
     if (!sandboxResult.ok) {
-      expect(sandboxResult.error.code).toBe('PATH_OUT_OF_BOUNDS');
+      expect(sandboxResult.error.code).toBe("PATH_OUT_OF_BOUNDS");
     }
 
     // Host: relative paths are rejected (requires absolute)
-    const hostResult = hostOps.readFileSafe({ path: 'relative.txt' });
+    const hostResult = hostOps.readFileSafe({ path: "relative.txt" });
     expect(hostResult.ok).toBe(false);
     if (!hostResult.ok) {
-      expect(hostResult.error.code).toBe('PATH_NOT_ABSOLUTE');
+      expect(hostResult.error.code).toBe("PATH_NOT_ABSOLUTE");
     }
   });
 
-  test('sandbox allows relative paths within boundary', () => {
+  test("sandbox allows relative paths within boundary", () => {
     const dir = makeTempDir();
-    writeFileSync(join(dir, 'valid.txt'), 'data');
+    writeFileSync(join(dir, "valid.txt"), "data");
 
     const sandboxOps = new FileSystemOps(sandboxPolicyFor(dir));
 
-    const result = sandboxOps.readFileSafe({ path: 'valid.txt' });
+    const result = sandboxOps.readFileSafe({ path: "valid.txt" });
     expect(result.ok).toBe(true);
   });
 
-  test('host requires absolute path even for simple filenames', () => {
+  test("host requires absolute path even for simple filenames", () => {
     const hostOps = new FileSystemOps(hostPolicyFn());
 
-    const result = hostOps.readFileSafe({ path: 'just-a-name.txt' });
+    const result = hostOps.readFileSafe({ path: "just-a-name.txt" });
     expect(result.ok).toBe(false);
     if (!result.ok) {
-      expect(result.error.code).toBe('PATH_NOT_ABSOLUTE');
+      expect(result.error.code).toBe("PATH_NOT_ABSOLUTE");
     }
   });
 
-  test('sandbox rejects absolute paths outside boundary', () => {
+  test("sandbox rejects absolute paths outside boundary", () => {
     const dir = makeTempDir();
     const sandboxOps = new FileSystemOps(sandboxPolicyFor(dir));
 
-    const result = sandboxOps.writeFileSafe({ path: '/tmp/somewhere-else.txt', content: 'bad' });
+    const result = sandboxOps.writeFileSafe({
+      path: "/tmp/somewhere-else.txt",
+      content: "bad",
+    });
     expect(result.ok).toBe(false);
     if (!result.ok) {
-      expect(result.error.code).toBe('PATH_OUT_OF_BOUNDS');
+      expect(result.error.code).toBe("PATH_OUT_OF_BOUNDS");
     }
   });
 });
@@ -560,21 +605,21 @@ describe('Path policy divergence: sandbox blocks escapes, host requires absolute
 // 6. Sandbox backend parity — NativeBackend & DockerBackend SandboxResult shape
 // ===========================================================================
 
-describe('SandboxResult shape consistency across backends', () => {
-  test('NativeBackend.wrap returns required fields', () => {
+describe("SandboxResult shape consistency across backends", () => {
+  test("NativeBackend.wrap returns required fields", () => {
     const native = new NativeBackend();
 
     // On macOS this will succeed; on other platforms it will throw ToolError
     try {
-      const result = native.wrap('echo test', '/tmp');
-      expect(typeof result.command).toBe('string');
+      const result = native.wrap("echo test", "/tmp");
+      expect(typeof result.command).toBe("string");
       expect(Array.isArray(result.args)).toBe(true);
-      expect(typeof result.sandboxed).toBe('boolean');
+      expect(typeof result.sandboxed).toBe("boolean");
       expect(result.sandboxed).toBe(true);
 
       // All args must be strings
       for (const arg of result.args) {
-        expect(typeof arg).toBe('string');
+        expect(typeof arg).toBe("string");
       }
     } catch (err) {
       // NativeBackend explicitly throws ToolError on unsupported platforms or
@@ -582,29 +627,32 @@ describe('SandboxResult shape consistency across backends', () => {
       // throw system errors (ErrnoException). Both are legitimate — but
       // programming errors like TypeError/ReferenceError should still fail.
       const isToolError = err instanceof ToolError;
-      const isSystemError = err instanceof Error && 'syscall' in err && typeof (err as NodeJS.ErrnoException).code === 'string';
+      const isSystemError =
+        err instanceof Error &&
+        "syscall" in err &&
+        typeof (err as NodeJS.ErrnoException).code === "string";
       expect(isToolError || isSystemError).toBe(true);
     }
   });
 
-  test('wrapCommand disabled returns bash with sandboxed=false', () => {
-    const result = wrapCommand('echo hi', '/tmp', { enabled: false });
+  test("wrapCommand disabled returns bash with sandboxed=false", () => {
+    const result = wrapCommand("echo hi", "/tmp", { enabled: false });
 
-    expect(result.command).toBe('bash');
-    expect(result.args).toEqual(['-c', '--', 'echo hi']);
+    expect(result.command).toBe("bash");
+    expect(result.args).toEqual(["-c", "--", "echo hi"]);
     expect(result.sandboxed).toBe(false);
   });
 
-  test('wrapCommand disabled result has same shape as enabled result', () => {
-    const disabled = wrapCommand('echo hi', '/tmp', { enabled: false });
+  test("wrapCommand disabled result has same shape as enabled result", () => {
+    const disabled = wrapCommand("echo hi", "/tmp", { enabled: false });
 
     // Both must have: command (string), args (string[]), sandboxed (boolean)
-    expect(typeof disabled.command).toBe('string');
+    expect(typeof disabled.command).toBe("string");
     expect(Array.isArray(disabled.args)).toBe(true);
-    expect(typeof disabled.sandboxed).toBe('boolean');
+    expect(typeof disabled.sandboxed).toBe("boolean");
 
     for (const arg of disabled.args) {
-      expect(typeof arg).toBe('string');
+      expect(typeof arg).toBe("string");
     }
   });
 });
@@ -613,58 +661,60 @@ describe('SandboxResult shape consistency across backends', () => {
 // 7. Terminal output format consistency
 // ===========================================================================
 
-describe('Terminal output format: formatShellOutput shared by sandbox and host', () => {
-  test('successful command output has no XML status tags', () => {
-    const result = formatShellOutput('hello world', '', 0, false, 120);
+describe("Terminal output format: formatShellOutput shared by sandbox and host", () => {
+  test("successful command output has no XML status tags", () => {
+    const result = formatShellOutput("hello world", "", 0, false, 120);
 
-    expect(result.content).toBe('hello world');
-    expect(result.content).not.toContain('<command_exit');
-    expect(result.content).not.toContain('<command_completed');
+    expect(result.content).toBe("hello world");
+    expect(result.content).not.toContain("<command_exit");
+    expect(result.content).not.toContain("<command_completed");
     expect(result.isError).toBe(false);
     expect(result.status).toBeUndefined();
   });
 
-  test('empty output on success produces <command_completed /> tag', () => {
-    const result = formatShellOutput('', '', 0, false, 120);
+  test("empty output on success produces <command_completed /> tag", () => {
+    const result = formatShellOutput("", "", 0, false, 120);
 
-    expect(result.content).toBe('<command_completed />');
+    expect(result.content).toBe("<command_completed />");
     expect(result.isError).toBe(false);
   });
 
-  test('non-zero exit code with empty output produces <command_exit /> tag', () => {
-    const result = formatShellOutput('', '', 42, false, 120);
+  test("non-zero exit code with empty output produces <command_exit /> tag", () => {
+    const result = formatShellOutput("", "", 42, false, 120);
 
     expect(result.content).toBe('<command_exit code="42" />');
     expect(result.isError).toBe(true);
   });
 
-  test('stderr is appended to stdout with a newline separator', () => {
-    const result = formatShellOutput('out', 'err', 0, false, 120);
+  test("stderr is appended to stdout with a newline separator", () => {
+    const result = formatShellOutput("out", "err", 0, false, 120);
 
-    expect(result.content).toBe('out\nerr');
+    expect(result.content).toBe("out\nerr");
   });
 
-  test('stderr-only output uses stderr as the output', () => {
-    const result = formatShellOutput('', 'error message', 0, false, 120);
+  test("stderr-only output uses stderr as the output", () => {
+    const result = formatShellOutput("", "error message", 0, false, 120);
 
-    expect(result.content).toBe('error message');
+    expect(result.content).toBe("error message");
   });
 
-  test('output truncation uses the shared MAX_OUTPUT_LENGTH constant', () => {
-    const longOutput = 'x'.repeat(MAX_OUTPUT_LENGTH + 100);
-    const result = formatShellOutput(longOutput, '', 0, false, 120);
+  test("output truncation uses the shared MAX_OUTPUT_LENGTH constant", () => {
+    const longOutput = "x".repeat(MAX_OUTPUT_LENGTH + 100);
+    const result = formatShellOutput(longOutput, "", 0, false, 120);
 
-    expect(result.content.length).toBe(MAX_OUTPUT_LENGTH + 1 + '<output_truncated limit="50K" />'.length);
-    expect(result.content).toContain('<output_truncated');
+    expect(result.content.length).toBe(
+      MAX_OUTPUT_LENGTH + 1 + '<output_truncated limit="50K" />'.length,
+    );
+    expect(result.content).toContain("<output_truncated");
   });
 
-  test('timed-out command appends timeout tag and sets isError', () => {
-    const result = formatShellOutput('partial', '', 137, true, 30);
+  test("timed-out command appends timeout tag and sets isError", () => {
+    const result = formatShellOutput("partial", "", 137, true, 30);
 
-    expect(result.content).toContain('partial');
+    expect(result.content).toContain("partial");
     expect(result.content).toContain('<command_timeout seconds="30" />');
     expect(result.isError).toBe(true);
-    expect(result.status).toContain('<command_timeout');
+    expect(result.status).toContain("<command_timeout");
   });
 });
 
@@ -672,39 +722,45 @@ describe('Terminal output format: formatShellOutput shared by sandbox and host',
 // 8. Regression tests for edge cases found during migration
 // ===========================================================================
 
-describe('Regression: edge cases in shared FileSystemOps', () => {
-  test('writing empty content creates a file with empty content', () => {
+describe("Regression: edge cases in shared FileSystemOps", () => {
+  test("writing empty content creates a file with empty content", () => {
     const dir = makeTempDir();
 
     const { sandbox, host } = dualOps(dir);
 
-    const sandboxResult = sandbox.writeFileSafe({ path: 'empty-s.txt', content: '' });
-    const hostResult = host.writeFileSafe({ path: join(dir, 'empty-h.txt'), content: '' });
+    const sandboxResult = sandbox.writeFileSafe({
+      path: "empty-s.txt",
+      content: "",
+    });
+    const hostResult = host.writeFileSafe({
+      path: join(dir, "empty-h.txt"),
+      content: "",
+    });
 
     expect(sandboxResult.ok).toBe(true);
     expect(hostResult.ok).toBe(true);
 
-    expect(readFileSync(join(dir, 'empty-s.txt'), 'utf-8')).toBe('');
-    expect(readFileSync(join(dir, 'empty-h.txt'), 'utf-8')).toBe('');
+    expect(readFileSync(join(dir, "empty-s.txt"), "utf-8")).toBe("");
+    expect(readFileSync(join(dir, "empty-h.txt"), "utf-8")).toBe("");
   });
 
-  test('editing a file with only whitespace works correctly', () => {
+  test("editing a file with only whitespace works correctly", () => {
     const dir = makeTempDir();
-    writeFileSync(join(dir, 'ws-s.txt'), '  \n  \n  ');
-    writeFileSync(join(dir, 'ws-h.txt'), '  \n  \n  ');
+    writeFileSync(join(dir, "ws-s.txt"), "  \n  \n  ");
+    writeFileSync(join(dir, "ws-h.txt"), "  \n  \n  ");
 
     const { sandbox, host } = dualOps(dir);
 
     const sandboxResult = sandbox.editFileSafe({
-      path: 'ws-s.txt',
-      oldString: '  \n  \n  ',
-      newString: 'replaced',
+      path: "ws-s.txt",
+      oldString: "  \n  \n  ",
+      newString: "replaced",
       replaceAll: false,
     });
     const hostResult = host.editFileSafe({
-      path: join(dir, 'ws-h.txt'),
-      oldString: '  \n  \n  ',
-      newString: 'replaced',
+      path: join(dir, "ws-h.txt"),
+      oldString: "  \n  \n  ",
+      newString: "replaced",
       replaceAll: false,
     });
 
@@ -712,21 +768,21 @@ describe('Regression: edge cases in shared FileSystemOps', () => {
     expect(hostResult.ok).toBe(true);
     if (!sandboxResult.ok || !hostResult.ok) return;
 
-    expect(sandboxResult.value.newContent).toBe('replaced');
-    expect(hostResult.value.newContent).toBe('replaced');
+    expect(sandboxResult.value.newContent).toBe("replaced");
+    expect(hostResult.value.newContent).toBe("replaced");
   });
 
-  test('write then read roundtrip produces consistent content', () => {
+  test("write then read roundtrip produces consistent content", () => {
     const dir = makeTempDir();
-    const content = 'line 1\nline 2\nline 3';
+    const content = "line 1\nline 2\nline 3";
 
     const { sandbox, host } = dualOps(dir);
 
     // Write via sandbox, read via both
-    sandbox.writeFileSafe({ path: 'roundtrip.txt', content });
+    sandbox.writeFileSafe({ path: "roundtrip.txt", content });
 
-    const sandboxRead = sandbox.readFileSafe({ path: 'roundtrip.txt' });
-    const hostRead = host.readFileSafe({ path: join(dir, 'roundtrip.txt') });
+    const sandboxRead = sandbox.readFileSafe({ path: "roundtrip.txt" });
+    const hostRead = host.readFileSafe({ path: join(dir, "roundtrip.txt") });
 
     expect(sandboxRead.ok).toBe(true);
     expect(hostRead.ok).toBe(true);
@@ -735,43 +791,43 @@ describe('Regression: edge cases in shared FileSystemOps', () => {
     expect(sandboxRead.value.content).toBe(hostRead.value.content);
   });
 
-  test('write then edit then read roundtrip is consistent', () => {
+  test("write then edit then read roundtrip is consistent", () => {
     const dir = makeTempDir();
-    const initial = 'const x = 1;\nconst y = 2;\nconst z = 3;';
+    const initial = "const x = 1;\nconst y = 2;\nconst z = 3;";
 
     const { sandbox, host } = dualOps(dir);
 
-    sandbox.writeFileSafe({ path: 'code.ts', content: initial });
+    sandbox.writeFileSafe({ path: "code.ts", content: initial });
 
     sandbox.editFileSafe({
-      path: 'code.ts',
-      oldString: 'const y = 2;',
-      newString: 'const y = 42;',
+      path: "code.ts",
+      oldString: "const y = 2;",
+      newString: "const y = 42;",
       replaceAll: false,
     });
 
-    const sandboxRead = sandbox.readFileSafe({ path: 'code.ts' });
-    const hostRead = host.readFileSafe({ path: join(dir, 'code.ts') });
+    const sandboxRead = sandbox.readFileSafe({ path: "code.ts" });
+    const hostRead = host.readFileSafe({ path: join(dir, "code.ts") });
 
     expect(sandboxRead.ok).toBe(true);
     expect(hostRead.ok).toBe(true);
     if (!sandboxRead.ok || !hostRead.ok) return;
 
     expect(sandboxRead.value.content).toBe(hostRead.value.content);
-    expect(sandboxRead.value.content).toContain('const y = 42;');
-    expect(sandboxRead.value.content).not.toContain('const y = 2;');
+    expect(sandboxRead.value.content).toContain("const y = 42;");
+    expect(sandboxRead.value.content).not.toContain("const y = 2;");
   });
 
-  test('file with very long lines is handled identically', () => {
+  test("file with very long lines is handled identically", () => {
     const dir = makeTempDir();
-    const longLine = 'a'.repeat(10_000);
-    writeFileSync(join(dir, 'long-s.txt'), longLine);
-    writeFileSync(join(dir, 'long-h.txt'), longLine);
+    const longLine = "a".repeat(10_000);
+    writeFileSync(join(dir, "long-s.txt"), longLine);
+    writeFileSync(join(dir, "long-h.txt"), longLine);
 
     const { sandbox, host } = dualOps(dir);
 
-    const sandboxResult = sandbox.readFileSafe({ path: 'long-s.txt' });
-    const hostResult = host.readFileSafe({ path: join(dir, 'long-h.txt') });
+    const sandboxResult = sandbox.readFileSafe({ path: "long-s.txt" });
+    const hostResult = host.readFileSafe({ path: join(dir, "long-h.txt") });
 
     expect(sandboxResult.ok).toBe(true);
     expect(hostResult.ok).toBe(true);
@@ -780,80 +836,82 @@ describe('Regression: edge cases in shared FileSystemOps', () => {
     expect(sandboxResult.value.content).toBe(hostResult.value.content);
   });
 
-  test('concurrent writes to different files in same dir are isolated', () => {
+  test("concurrent writes to different files in same dir are isolated", () => {
     const dir = makeTempDir();
 
     const { sandbox } = dualOps(dir);
 
     // Simulate two "concurrent" writes (sequential here, but tests isolation)
-    const r1 = sandbox.writeFileSafe({ path: 'a.txt', content: 'content-a' });
-    const r2 = sandbox.writeFileSafe({ path: 'b.txt', content: 'content-b' });
+    const r1 = sandbox.writeFileSafe({ path: "a.txt", content: "content-a" });
+    const r2 = sandbox.writeFileSafe({ path: "b.txt", content: "content-b" });
 
     expect(r1.ok).toBe(true);
     expect(r2.ok).toBe(true);
 
-    expect(readFileSync(join(dir, 'a.txt'), 'utf-8')).toBe('content-a');
-    expect(readFileSync(join(dir, 'b.txt'), 'utf-8')).toBe('content-b');
+    expect(readFileSync(join(dir, "a.txt"), "utf-8")).toBe("content-a");
+    expect(readFileSync(join(dir, "b.txt"), "utf-8")).toBe("content-b");
   });
 
-  test('edit preserves file content exactly except for the replacement', () => {
+  test("edit preserves file content exactly except for the replacement", () => {
     const dir = makeTempDir();
     // Content with trailing newline, tabs, and special chars
-    const content = '\tfirst line\n\tsecond line\n\tthird line\n';
-    writeFileSync(join(dir, 'precise.txt'), content);
+    const content = "\tfirst line\n\tsecond line\n\tthird line\n";
+    writeFileSync(join(dir, "precise.txt"), content);
 
     const ops = new FileSystemOps(sandboxPolicyFor(dir));
     const result = ops.editFileSafe({
-      path: 'precise.txt',
-      oldString: '\tsecond line',
-      newString: '\treplaced line',
+      path: "precise.txt",
+      oldString: "\tsecond line",
+      newString: "\treplaced line",
       replaceAll: false,
     });
 
     expect(result.ok).toBe(true);
     if (!result.ok) return;
 
-    expect(result.value.newContent).toBe('\tfirst line\n\treplaced line\n\tthird line\n');
-    expect(readFileSync(join(dir, 'precise.txt'), 'utf-8')).toBe(
-      '\tfirst line\n\treplaced line\n\tthird line\n',
+    expect(result.value.newContent).toBe(
+      "\tfirst line\n\treplaced line\n\tthird line\n",
+    );
+    expect(readFileSync(join(dir, "precise.txt"), "utf-8")).toBe(
+      "\tfirst line\n\treplaced line\n\tthird line\n",
     );
   });
 
-  test('read with offset=1 and no limit returns all lines', () => {
+  test("read with offset=1 and no limit returns all lines", () => {
     const dir = makeTempDir();
-    writeFileSync(join(dir, 'full.txt'), 'one\ntwo\nthree\n');
+    writeFileSync(join(dir, "full.txt"), "one\ntwo\nthree\n");
 
     const ops = new FileSystemOps(sandboxPolicyFor(dir));
-    const result = ops.readFileSafe({ path: 'full.txt', offset: 1 });
+    const result = ops.readFileSafe({ path: "full.txt", offset: 1 });
 
     expect(result.ok).toBe(true);
     if (!result.ok) return;
 
-    expect(result.value.content).toContain('one');
-    expect(result.value.content).toContain('two');
-    expect(result.value.content).toContain('three');
+    expect(result.value.content).toContain("one");
+    expect(result.value.content).toContain("two");
+    expect(result.value.content).toContain("three");
   });
 
-  test('symlink within sandbox boundary is readable', () => {
+  test("symlink within sandbox boundary is readable", () => {
     const dir = makeTempDir();
-    const targetFile = join(dir, 'target.txt');
-    writeFileSync(targetFile, 'linked content');
+    const targetFile = join(dir, "target.txt");
+    writeFileSync(targetFile, "linked content");
 
-    const linkPath = join(dir, 'link.txt');
+    const linkPath = join(dir, "link.txt");
     try {
       // eslint-disable-next-line @typescript-eslint/no-require-imports
-      require('node:fs').symlinkSync(targetFile, linkPath);
+      require("node:fs").symlinkSync(targetFile, linkPath);
     } catch {
       // Symlink creation may fail on some systems — skip gracefully
       return;
     }
 
     const ops = new FileSystemOps(sandboxPolicyFor(dir));
-    const result = ops.readFileSafe({ path: 'link.txt' });
+    const result = ops.readFileSafe({ path: "link.txt" });
 
     expect(result.ok).toBe(true);
     if (!result.ok) return;
-    expect(result.value.content).toContain('linked content');
+    expect(result.value.content).toContain("linked content");
   });
 });
 
@@ -861,20 +919,25 @@ describe('Regression: edge cases in shared FileSystemOps', () => {
 // 9. NativeBackend shape verification
 // ===========================================================================
 
-describe('NativeBackend: SandboxResult shape', () => {
-  test('NativeBackend has a wrap method', () => {
+describe("NativeBackend: SandboxResult shape", () => {
+  test("NativeBackend has a wrap method", () => {
     const native = new NativeBackend();
-    expect(typeof native.wrap).toBe('function');
+    expect(typeof native.wrap).toBe("function");
   });
 
-  test('disabled sandbox returns consistent bash -c -- invocation', () => {
+  test("disabled sandbox returns consistent bash -c -- invocation", () => {
     // Various commands should all be wrapped consistently when disabled
-    const commands = ['echo hello', 'ls -la', 'cat /etc/hosts', 'true && false'];
+    const commands = [
+      "echo hello",
+      "ls -la",
+      "cat /etc/hosts",
+      "true && false",
+    ];
     for (const cmd of commands) {
-      const result = wrapCommand(cmd, '/tmp', { enabled: false });
-      expect(result.command).toBe('bash');
-      expect(result.args[0]).toBe('-c');
-      expect(result.args[1]).toBe('--');
+      const result = wrapCommand(cmd, "/tmp", { enabled: false });
+      expect(result.command).toBe("bash");
+      expect(result.args[0]).toBe("-c");
+      expect(result.args[1]).toBe("--");
       expect(result.args[2]).toBe(cmd);
       expect(result.sandboxed).toBe(false);
     }
@@ -885,15 +948,15 @@ describe('NativeBackend: SandboxResult shape', () => {
 // 10. Error handling consistency
 // ===========================================================================
 
-describe('Error handling consistency across code paths', () => {
-  test('FsError codes are consistent between sandbox and host for same conditions', () => {
+describe("Error handling consistency across code paths", () => {
+  test("FsError codes are consistent between sandbox and host for same conditions", () => {
     const dir = makeTempDir();
 
     const { sandbox, host } = dualOps(dir);
 
     // NOT_FOUND
-    const sfNotFound = sandbox.readFileSafe({ path: 'missing.txt' });
-    const hfNotFound = host.readFileSafe({ path: join(dir, 'missing.txt') });
+    const sfNotFound = sandbox.readFileSafe({ path: "missing.txt" });
+    const hfNotFound = host.readFileSafe({ path: join(dir, "missing.txt") });
     expect(sfNotFound.ok).toBe(false);
     expect(hfNotFound.ok).toBe(false);
     if (!sfNotFound.ok && !hfNotFound.ok) {
@@ -901,9 +964,9 @@ describe('Error handling consistency across code paths', () => {
     }
 
     // NOT_A_FILE
-    mkdirSync(join(dir, 'dirA'));
-    const sfNotFile = sandbox.readFileSafe({ path: 'dirA' });
-    const hfNotFile = host.readFileSafe({ path: join(dir, 'dirA') });
+    mkdirSync(join(dir, "dirA"));
+    const sfNotFile = sandbox.readFileSafe({ path: "dirA" });
+    const hfNotFile = host.readFileSafe({ path: join(dir, "dirA") });
     expect(sfNotFile.ok).toBe(false);
     expect(hfNotFile.ok).toBe(false);
     if (!sfNotFile.ok && !hfNotFile.ok) {
@@ -911,34 +974,47 @@ describe('Error handling consistency across code paths', () => {
     }
   });
 
-  test('write error codes match between sandbox and host for same conditions', () => {
+  test("write error codes match between sandbox and host for same conditions", () => {
     const dir = makeTempDir();
 
     const { sandbox, host } = dualOps(dir);
 
     // Both should succeed for valid operations
-    const sfWrite = sandbox.writeFileSafe({ path: 'ok-s.txt', content: 'ok' });
-    const hfWrite = host.writeFileSafe({ path: join(dir, 'ok-h.txt'), content: 'ok' });
+    const sfWrite = sandbox.writeFileSafe({ path: "ok-s.txt", content: "ok" });
+    const hfWrite = host.writeFileSafe({
+      path: join(dir, "ok-h.txt"),
+      content: "ok",
+    });
 
     expect(sfWrite.ok).toBe(true);
     expect(hfWrite.ok).toBe(true);
   });
 
-  test('edit MATCH_NOT_FOUND vs MATCH_AMBIGUOUS error codes match between paths', () => {
+  test("edit MATCH_NOT_FOUND vs MATCH_AMBIGUOUS error codes match between paths", () => {
     const dir = makeTempDir();
-    writeFileSync(join(dir, 'err-s.txt'), 'unique text');
-    writeFileSync(join(dir, 'err-h.txt'), 'unique text');
+    writeFileSync(join(dir, "err-s.txt"), "unique text");
+    writeFileSync(join(dir, "err-h.txt"), "unique text");
 
     const { sandbox, host } = dualOps(dir);
 
     // MATCH_NOT_FOUND
-    const sfMnf = sandbox.editFileSafe({ path: 'err-s.txt', oldString: 'nope', newString: 'x', replaceAll: false });
-    const hfMnf = host.editFileSafe({ path: join(dir, 'err-h.txt'), oldString: 'nope', newString: 'x', replaceAll: false });
+    const sfMnf = sandbox.editFileSafe({
+      path: "err-s.txt",
+      oldString: "nope",
+      newString: "x",
+      replaceAll: false,
+    });
+    const hfMnf = host.editFileSafe({
+      path: join(dir, "err-h.txt"),
+      oldString: "nope",
+      newString: "x",
+      replaceAll: false,
+    });
     expect(sfMnf.ok).toBe(false);
     expect(hfMnf.ok).toBe(false);
     if (!sfMnf.ok && !hfMnf.ok) {
       expect(sfMnf.error.code).toBe(hfMnf.error.code);
-      expect(sfMnf.error.code).toBe('MATCH_NOT_FOUND');
+      expect(sfMnf.error.code).toBe("MATCH_NOT_FOUND");
     }
   });
 });