@gotgenes/pi-permission-system 18.1.1 → 18.1.2

package/CHANGELOG.md

@@ -5,6 +5,22 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [18.1.2](https://github.com/gotgenes/pi-packages/compare/pi-permission-system-v18.1.1...pi-permission-system-v18.1.2) (2026-07-05)
+
+
+### Bug Fixes
+
+* **pi-permission-system:** allow-list Git Bash POSIX paths via external_directory on win32 ([#533](https://github.com/gotgenes/pi-packages/issues/533)) ([5532a43](https://github.com/gotgenes/pi-packages/commit/5532a436d825625316c67f29b90f0ceb427d4b29))
+* **pi-permission-system:** fold Git Bash cd targets with MSYS semantics on win32 ([#533](https://github.com/gotgenes/pi-packages/issues/533)) ([5cb20b4](https://github.com/gotgenes/pi-packages/commit/5cb20b41db7c22c3344ab7f8a4fa39e89adb1e1a))
+* **pi-permission-system:** match Git Bash POSIX-absolute bash tokens as typed on win32 ([#533](https://github.com/gotgenes/pi-packages/issues/533)) ([095fa5e](https://github.com/gotgenes/pi-packages/commit/095fa5eaf774567cfae8f82d11b0224ace7bc5eb))
+* **pi-permission-system:** recognize POSIX device paths in bash commands on win32 ([#533](https://github.com/gotgenes/pi-packages/issues/533)) ([11ca70f](https://github.com/gotgenes/pi-packages/commit/11ca70fe845469d478fb47b12e8ff572930a1be4))
+* **pi-permission-system:** translate MSYS drive-mount bash tokens on win32 ([#533](https://github.com/gotgenes/pi-packages/issues/533)) ([2bf4e53](https://github.com/gotgenes/pi-packages/commit/2bf4e53674c48ac9591ffb21831eb82bc3cb77b8))
+
+
+### Documentation
+
+* **pi-permission-system:** document Git Bash path semantics on Windows ([#533](https://github.com/gotgenes/pi-packages/issues/533)) ([09afcb2](https://github.com/gotgenes/pi-packages/commit/09afcb241ea05938d88ffce8c3d6d34cbb821619))
+
 ## [18.1.1](https://github.com/gotgenes/pi-packages/compare/pi-permission-system-v18.1.0...pi-permission-system-v18.1.1) (2026-07-03)
 
 

package/docs/configuration.md

@@ -505,6 +505,17 @@ On Windows, path matching for `external_directory`, `path`, and the path-bearing
 A mixed-case allow override such as `~/AppData/Roaming/npm/node_modules/@earendil-works/pi-coding-agent/*` therefore matches a lowercased, backslash-normalized path value.
 POSIX matching remains case-sensitive.
 
+#### Git Bash / MSYS paths on Windows
+
+On Windows, Pi executes bash commands through Git Bash, so a bash token that looks like a POSIX absolute path carries MSYS mount semantics rather than native `node:path.win32` semantics.
+The `external_directory` and `path` gates interpret bash tokens accordingly (tool-input paths for `read`/`write`/`edit` keep native Windows semantics, since those tools resolve them through Node's filesystem):
+
+- The safe device paths (`/dev/null`, `/dev/stdin`, `/dev/stdout`, `/dev/stderr`) are recognized as MSYS devices and never trigger the gate — the same exclusion that holds on POSIX, so `echo hi > /dev/null` does not prompt.
+- MSYS drive mounts (`/c/…`, `/d/…`) are translated to their Windows equivalent (`C:\…`), so a project file referenced through a mount is matched against its real Windows path and an in-CWD mount is not flagged.
+- Every other POSIX-absolute token (`/tmp/foo`, `/usr/bin`) has an install-dependent target this extension cannot resolve deterministically (Git Bash mounts `/tmp` to `%TEMP%`, MSYS2 to its own root), so it is treated as an external path matched and displayed exactly as typed, never rewritten to `C:\tmp\foo`.
+
+To allow-list such a path, write the rule using the path as typed — for example `external_directory: { "/tmp/*": "allow" }` — and the Windows separator folding above makes the forward-slash rule match the Git Bash token.
+
 ### Home Directory Expansion in Patterns
 
 Pattern keys in any permission surface can start with `~/` or `$HOME/` (or be exactly `~` / `$HOME`).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gotgenes/pi-permission-system",
-  "version": "18.1.1",
+  "version": "18.1.2",
   "description": "Permission enforcement extension for the Pi coding agent.",
   "type": "module",
   "exports": {
@@ -12,7 +12,6 @@
   },
   "files": [
     "src",
-    "test",
     "config/config.example.json",
     "schemas/permissions.schema.json",
     "docs/*.md",

package/src/access-intent/access-path.ts

@@ -118,10 +118,35 @@ export class AccessPath {
    * unknown (a relative bash token after a non-literal `cd`).
    *
    * Carries no canonical alias and no absolute resolution — `matchValues()` is
-   * `[literal]` (or `[]` when empty) and `boundaryValue()` is `""` — so no
-   * spurious absolute or symlink-resolved rule can match (#393).
+   * `[literal, ...matchAliases]` (or `[]` when empty) and `boundaryValue()` is
+   * `""` — so no spurious absolute or symlink-resolved rule can match (#393).
+   *
+   * `matchAliases` supplies extra match-only forms that do not change the
+   * display value: a win32 Git Bash POSIX absolute carries a backslash-separated
+   * alias so the separator-folding path matcher can match a `/tmp/*` rule (#533).
+   */
+  static forLiteral(
+    literal: string,
+    matchAliases: readonly string[] = [],
+  ): AccessPath {
+    if (!literal) return new AccessPath("", [], "");
+    const aliases = [...new Set([literal, ...matchAliases.filter(Boolean)])];
+    return new AccessPath(literal, aliases, "");
+  }
+
+  /**
+   * Build an `AccessPath` for a Git Bash/MSYS device path (`/dev/null`,
+   * `/dev/std{in,out,err}`) seen in a bash command on a win32 host.
+   *
+   * The token names an MSYS runtime device, not a filesystem path, so it is
+   * preserved verbatim across all three representations — `value()`,
+   * `boundaryValue()`, and `matchValues()` are the device path itself, never
+   * `win32.resolve`-mangled into `c:\dev\null`. The identical lexical and
+   * canonical forms let the boundary check reach `isSafeSystemPath` (so the
+   * device never triggers `external_directory`) while a config rule still
+   * matches the path as typed.
    */
-  static forLiteral(literal: string): AccessPath {
-    return new AccessPath(literal, literal ? [literal] : [], "");
+  static forDevice(devicePath: string): AccessPath {
+    return new AccessPath(devicePath, [devicePath], devicePath);
   }
 }

package/src/access-intent/bash/bash-path-resolver.ts

@@ -315,23 +315,34 @@ export class BashPathResolver {
    * Returns `base` unchanged unless the command is `cd`:
    *
    * - `cd /abs` (absolute literal) → a fresh known base, recovering from an
-   *   earlier unknown base.
+   *   earlier unknown base. On win32 a drive-mount target (`cd /c/x`) folds to
+   *   its translated Windows base, while a non-mount POSIX absolute
+   *   (`cd /tmp`) is not deterministically resolvable and yields unknown (#533).
    * - `cd rel` (relative literal) → fold into a known base, or stay unknown if
    *   the base was already unknown.
    * - `cd "$DIR"` / `cd $(…)` / `cd -` / bare `cd` / `cd ~…` (non-literal) →
    *   unknown.
+   *
+   * The target's platform/MSYS interpretation is delegated to the
+   * {@link PathNormalizer}; this method owns only the base-folding state.
    */
   private foldCd(commandNode: TSNode, base: EffectiveBase): EffectiveBase {
     if (extractCommandName(commandNode) !== "cd") return base;
     const target = cdLiteralTarget(commandNode);
     if (target === null) return UNKNOWN_BASE;
-    if (this.normalizer.isAbsolute(target))
-      return { kind: "known", offset: target };
-    if (base.kind === "unknown") return UNKNOWN_BASE;
-    return {
-      kind: "known",
-      offset: this.normalizer.joinBase(base.offset, target),
-    };
+    const interpreted = this.normalizer.interpretBashCdTarget(target);
+    switch (interpreted.kind) {
+      case "absolute":
+        return { kind: "known", offset: interpreted.value };
+      case "unknown":
+        return UNKNOWN_BASE;
+      case "relative":
+        if (base.kind === "unknown") return UNKNOWN_BASE;
+        return {
+          kind: "known",
+          offset: this.normalizer.joinBase(base.offset, target),
+        };
+    }
   }
 
   // ── Projection ─────────────────────────────────────────────────────────
@@ -376,19 +387,29 @@ export class BashPathResolver {
         base.kind === "known"
           ? this.normalizer.resolveBase(base.offset)
           : undefined;
-      const accessPath = this.normalizer.forPath(candidate, { resolveBase });
+      const accessPath = this.normalizer.forBashToken(candidate, {
+        resolveBase,
+      });
       const lexical = accessPath.value();
       if (!lexical) continue;
       // The boundary decision and dedup identity use the canonical
-      // (symlink-resolved) form, but the returned value is the lexical form so
-      // config patterns match the path as the user typed it (#418).
+      // (symlink-resolved) form the AccessPath already derived, but the returned
+      // value is the lexical form so config patterns match the path as the user
+      // typed it (#418). A win32 device path preserves `/dev/null` as its
+      // boundary value, so `isBoundaryOutsideWorkingDirectory` reaches the
+      // safe-path exclusion (#533).
       const canonical = accessPath.boundaryValue();
-
-      if (
-        this.normalizer.isOutsideWorkingDirectory(lexical) &&
-        !seen.has(canonical)
-      ) {
-        seen.add(canonical);
+      // A literal-only bash token (a win32 non-mount POSIX absolute like `/tmp`)
+      // has no canonical form; it is foreign to the win32 cwd, so it is always
+      // external. Its lexical value is the dedup identity so two distinct
+      // literal-only paths do not collapse (#533).
+      const isExternal = canonical
+        ? this.normalizer.isBoundaryOutsideWorkingDirectory(canonical)
+        : true;
+      const dedupKey = canonical || lexical;
+
+      if (isExternal && !seen.has(dedupKey)) {
+        seen.add(dedupKey);
         externalPaths.push(accessPath);
       }
     }
@@ -450,7 +471,7 @@ export class BashPathResolver {
       base.kind === "known"
         ? this.normalizer.resolveBase(base.offset)
         : undefined;
-    return this.normalizer.forPath(candidate, { resolveBase });
+    return this.normalizer.forBashToken(candidate, { resolveBase });
   }
 
   /**

package/src/access-intent/bash/msys-bash-tokens.ts

@@ -0,0 +1,64 @@
+/**
+ * Pure shape classifier for a bash-command token on a win32 host, where Pi core
+ * executes commands through Git Bash and POSIX-shaped absolute tokens carry
+ * MSYS mount semantics rather than `node:path.win32` semantics.
+ *
+ * Consumed only by {@link PathNormalizer.forBashToken}; kept as a standalone
+ * module so the shape knowledge is unit-testable in isolation (no filesystem,
+ * no platform read).
+ */
+import { isSafeSystemPath } from "#src/safe-system-paths";
+
+/**
+ * The MSYS interpretation of a win32 bash token:
+ *
+ * - `device` — a safe MSYS runtime device (`/dev/null`, `/dev/std{in,out,err}`);
+ *   never a filesystem path.
+ * - `drive-mount` — an MSYS drive mount (`/c/…`, `/d/…`); `windowsPath` is its
+ *   deterministic Windows equivalent (`C:\…`).
+ * - `posix-absolute` — any other absolute POSIX path (`/tmp/foo`, `/usr/bin`);
+ *   its Windows target is install-dependent and not deterministically knowable,
+ *   so it is treated literally.
+ * - `plain` — everything else (relative tokens, `~/…`, native Windows drive
+ *   paths); handled by ordinary win32 resolution.
+ */
+export type Win32BashTokenKind =
+  | { kind: "device" }
+  | { kind: "drive-mount"; windowsPath: string }
+  | { kind: "posix-absolute" }
+  | { kind: "plain" };
+
+/**
+ * A single-letter first path segment identifies an MSYS drive mount: `/c`,
+ * `/c/`, or `/c/rest`. A multi-letter first segment (`/dev`, `/tmp`) is not a
+ * mount. The device set is checked before this pattern, so `/dev/*` never
+ * reaches it.
+ */
+const MSYS_DRIVE_MOUNT_PATTERN = /^\/([a-zA-Z])(\/.*)?$/;
+
+export function classifyWin32BashToken(token: string): Win32BashTokenKind {
+  if (isSafeSystemPath(token)) return { kind: "device" };
+
+  const driveMatch = MSYS_DRIVE_MOUNT_PATTERN.exec(token);
+  if (driveMatch) {
+    return {
+      kind: "drive-mount",
+      windowsPath: toWindowsDrivePath(driveMatch[1], driveMatch[2]),
+    };
+  }
+
+  if (token.startsWith("/")) return { kind: "posix-absolute" };
+
+  return { kind: "plain" };
+}
+
+/**
+ * Build the Windows equivalent of an MSYS drive mount: uppercase drive letter,
+ * `:\`, and the remainder with `/` separators rewritten to `\`. A bare or
+ * trailing-slash mount (`/c`, `/c/`) maps to the drive root (`C:\`).
+ */
+function toWindowsDrivePath(letter: string, rest: string | undefined): string {
+  const drive = `${letter.toUpperCase()}:`;
+  const tail = (rest ?? "").replace(/^\//, "").replaceAll("/", "\\");
+  return tail ? `${drive}\\${tail}` : `${drive}\\`;
+}

package/src/path-normalizer.ts

@@ -1,9 +1,11 @@
 import { posix as posixPath, win32 as winPath } from "node:path";
 
 import { AccessPath } from "./access-intent/access-path";
+import { classifyWin32BashToken } from "./access-intent/bash/msys-bash-tokens";
 import {
   canonicalNormalizePathForComparison,
   normalizePathForComparison,
+  normalizePathPolicyLiteral,
 } from "./access-intent/path-normalization";
 import {
   isPathOutsideWorkingDirectory,
@@ -11,6 +13,22 @@ import {
 } from "./path-containment";
 import { isPiInfrastructureRead } from "./pi-infrastructure-read";
 
+/**
+ * The interpreted effect of a literal `cd` target on the effective base, under
+ * the host platform's (and, on win32, Git Bash's) semantics.
+ *
+ * - `absolute` — the target names a resolvable absolute base (`value`); an
+ *   earlier unknown base is recovered.
+ * - `relative` — the target folds into the current base.
+ * - `unknown` — the target is not deterministically resolvable (a win32
+ *   non-mount POSIX absolute like `cd /tmp`, or a device), so the base becomes
+ *   conservatively unknown.
+ */
+export type BashCdTarget =
+  | { readonly kind: "absolute"; readonly value: string }
+  | { readonly kind: "relative" }
+  | { readonly kind: "unknown" };
+
 /**
  * Path-interpretation collaborator, constructed once at the session edge with
  * the two ambient inputs — the host `platform` and the session `cwd` — baked
@@ -47,8 +65,46 @@ export class PathNormalizer {
   }
 
   /** Build a literal-only AccessPath (unknown base after a non-literal `cd`). */
-  forLiteral(literal: string): AccessPath {
-    return AccessPath.forLiteral(literal);
+  forLiteral(literal: string, matchAliases?: readonly string[]): AccessPath {
+    return AccessPath.forLiteral(literal, matchAliases);
+  }
+
+  /**
+   * Build an AccessPath for a bash-command token, applying Git Bash/MSYS
+   * semantics on a win32 host.
+   *
+   * Pi core always executes bash through Git Bash on Windows, so a POSIX-shaped
+   * absolute token carries MSYS semantics, not `node:path.win32` semantics. On
+   * win32 the recognized safe device paths (`/dev/null`, `/dev/std{in,out,err}`)
+   * are preserved verbatim as devices instead of being resolved into
+   * `c:\dev\null`, and MSYS drive mounts (`/c/…`) are translated to their
+   * Windows equivalent (`C:\…`) before resolution; every other token delegates
+   * to {@link forPath}. On POSIX this is a straight delegation to
+   * {@link forPath}.
+   */
+  forBashToken(token: string, options?: { resolveBase?: string }): AccessPath {
+    if (this.platform !== "win32") return this.forPath(token, options);
+
+    const shape = classifyWin32BashToken(token);
+    switch (shape.kind) {
+      case "device":
+        return AccessPath.forDevice(token);
+      case "drive-mount":
+        return this.forPath(shape.windowsPath, options);
+      case "posix-absolute": {
+        // A non-mount POSIX absolute (`/tmp`, `/usr`) has an install-dependent
+        // Windows target this package cannot know, so it is kept literal: always
+        // external, matched and displayed as typed, never fabricated into
+        // `c:\tmp` (#533). The win32 path matcher folds a rule's separators
+        // (`/` -> `\`), so a forward-slash value is unmatchable; carry a
+        // backslash match alias so a natural `/tmp/*` external_directory rule
+        // still resolves, while `value()` stays as typed for display.
+        const literal = normalizePathPolicyLiteral(token);
+        return this.forLiteral(literal, [literal.replaceAll("/", "\\")]);
+      }
+      case "plain":
+        return this.forPath(token, options);
+    }
   }
 
   /** Platform-aware absoluteness (`win32` vs `posix` rules). */
@@ -56,6 +112,36 @@ export class PathNormalizer {
     return this.impl.isAbsolute(pathValue);
   }
 
+  /**
+   * Interpret a literal `cd` target's effect on the effective base.
+   *
+   * On win32 the target carries Git Bash/MSYS semantics: a drive mount
+   * (`cd /c/x`) resolves to a translated Windows base (`C:\x`), a non-mount
+   * POSIX absolute (`cd /tmp`) is not deterministically resolvable and yields an
+   * `unknown` base, and a native/relative target is handled as usual. On POSIX
+   * an absolute target is absolute and everything else is relative.
+   */
+  interpretBashCdTarget(target: string): BashCdTarget {
+    if (this.platform !== "win32") {
+      return this.impl.isAbsolute(target)
+        ? { kind: "absolute", value: target }
+        : { kind: "relative" };
+    }
+
+    const shape = classifyWin32BashToken(target);
+    switch (shape.kind) {
+      case "drive-mount":
+        return { kind: "absolute", value: shape.windowsPath };
+      case "device":
+      case "posix-absolute":
+        return { kind: "unknown" };
+      case "plain":
+        return this.impl.isAbsolute(target)
+          ? { kind: "absolute", value: target }
+          : { kind: "relative" };
+    }
+  }
+
   /** Resolve a `cd`-folded offset against the baked cwd (platform-aware). */
   resolveBase(offset: string): string {
     return this.impl.resolve(this.cwd, offset);
@@ -85,6 +171,23 @@ export class PathNormalizer {
     );
   }
 
+  /**
+   * Outside-cwd test for an already-canonical boundary value (from
+   * {@link AccessPath.boundaryValue}), against the baked cwd.
+   *
+   * Unlike {@link isOutsideWorkingDirectory}, it does not re-derive the
+   * canonical form — the caller passes a value the {@link AccessPath} already
+   * canonicalized, so a device's preserved `/dev/null` reaches the pure check's
+   * `isSafeSystemPath` exclusion intact.
+   */
+  isBoundaryOutsideWorkingDirectory(canonicalPath: string): boolean {
+    return isPathOutsideWorkingDirectory(
+      canonicalPath,
+      this.canonicalCwd,
+      this.platform,
+    );
+  }
+
   /**
    * Lexical (not symlink-resolved) comparison value, resolved against the baked
    * cwd. Mirrors the as-typed absolute form used for skill-prompt matching;

package/test/access-intent/access-path.test.ts

@@ -1,277 +0,0 @@
-import { beforeEach, describe, expect, test, vi } from "vitest";
-
-// Mock node:os so tilde-expansion is deterministic across platforms.
-vi.mock("node:os", () => {
-  const homedir = vi.fn(() => "/mock/home");
-  return {
-    homedir,
-    default: { homedir },
-  };
-});
-
-// Mock node:fs so realpathSync (used by canonicalizePath) is controllable.
-// Default implementation is identity — lexical tests are unaffected.
-const realpathSync = vi.hoisted(() =>
-  vi.fn<(path: string) => string>((p) => p),
-);
-vi.mock("node:fs", () => ({
-  realpathSync,
-  default: { realpathSync },
-}));
-
-import { AccessPath } from "#src/access-intent/access-path";
-
-describe("AccessPath.forPath", () => {
-  const cwd = "/projects/my-app";
-
-  beforeEach(() => {
-    realpathSync.mockReset();
-    realpathSync.mockImplementation((p: string) => p);
-  });
-
-  describe("matchValues()", () => {
-    test("adds the symlink-resolved alias alongside the typed path", () => {
-      // /tmp -> /private/tmp (the macOS symlink from the bug report, #418).
-      realpathSync.mockImplementation((p: string) =>
-        p.startsWith("/tmp") ? `/private${p}` : p,
-      );
-      expect(
-        AccessPath.forPath("/tmp/x", { cwd, platform: "linux" }).matchValues(),
-      ).toEqual(["/tmp/x", "/private/tmp/x"]);
-    });
-
-    test("deduplicates when the canonical form equals the lexical form", () => {
-      expect(
-        AccessPath.forPath("/etc/hosts", {
-          cwd,
-          platform: "linux",
-        }).matchValues(),
-      ).toEqual(["/etc/hosts"]);
-    });
-
-    test("keeps the relative aliases for an in-cwd token without duplicating", () => {
-      expect(
-        AccessPath.forPath("src/foo.ts", {
-          cwd,
-          platform: "linux",
-        }).matchValues(),
-      ).toEqual(["/projects/my-app/src/foo.ts", "src/foo.ts"]);
-    });
-
-    test("includes only the lexical aliases when canonical is empty", () => {
-      // Force canonicalizePath to return the original (no-op symlink resolution
-      // effectively means canonical === lexical, handled by dedup).
-      expect(
-        AccessPath.forPath("/etc/hosts", {
-          cwd,
-          platform: "linux",
-        }).matchValues(),
-      ).not.toHaveLength(0);
-    });
-
-    test("resolves a relative token against an explicit resolveBase", () => {
-      // The cd-folded effective base differs from cwd (the bash-path case).
-      expect(
-        AccessPath.forPath("foo.ts", {
-          cwd,
-          resolveBase: "/projects/my-app/sub",
-          platform: "linux",
-        }).matchValues(),
-      ).toEqual(["/projects/my-app/sub/foo.ts", "sub/foo.ts", "foo.ts"]);
-    });
-
-    test("adds the canonical alias resolved against resolveBase", () => {
-      realpathSync.mockImplementation((p: string) =>
-        p === "/projects/my-app/sub/foo.ts" ? "/real/foo.ts" : p,
-      );
-      expect(
-        AccessPath.forPath("foo.ts", {
-          cwd,
-          resolveBase: "/projects/my-app/sub",
-          platform: "linux",
-        }).matchValues(),
-      ).toEqual([
-        "/projects/my-app/sub/foo.ts",
-        "sub/foo.ts",
-        "foo.ts",
-        "/real/foo.ts",
-      ]);
-    });
-  });
-
-  describe("platform option", () => {
-    test("win32: builds lexical/match/boundary values with win32 rules", () => {
-      const ap = AccessPath.forPath("src\\foo.ts", {
-        cwd: "C:\\Projects\\App",
-        platform: "win32",
-      });
-      expect(ap.value()).toBe("c:\\projects\\app\\src\\foo.ts");
-      expect(ap.boundaryValue()).toBe("c:\\projects\\app\\src\\foo.ts");
-      expect(ap.matchValues()).toEqual([
-        "c:\\projects\\app\\src\\foo.ts",
-        "src\\foo.ts",
-      ]);
-    });
-
-    test("win32: lowercases the symlink-resolved boundary value", () => {
-      realpathSync.mockImplementation((p: string) =>
-        p === "c:\\projects\\app\\link" ? "C:\\Real\\App" : p,
-      );
-      expect(
-        AccessPath.forPath("link", {
-          cwd: "C:\\Projects\\App",
-          platform: "win32",
-        }).boundaryValue(),
-      ).toBe("c:\\real\\app");
-    });
-  });
-
-  describe("boundaryValue()", () => {
-    test("returns the canonical (symlink-resolved) form", () => {
-      realpathSync.mockImplementation((p: string) =>
-        p.startsWith("/tmp") ? `/private${p}` : p,
-      );
-      expect(
-        AccessPath.forPath("/tmp/x", {
-          cwd,
-          platform: "linux",
-        }).boundaryValue(),
-      ).toBe("/private/tmp/x");
-    });
-
-    test("returns the lexical form when path has no symlinks", () => {
-      expect(
-        AccessPath.forPath("/etc/hosts", {
-          cwd,
-          platform: "linux",
-        }).boundaryValue(),
-      ).toBe("/etc/hosts");
-    });
-
-    test("returns empty string for empty input", () => {
-      expect(
-        AccessPath.forPath("", { cwd, platform: "linux" }).boundaryValue(),
-      ).toBe("");
-    });
-  });
-
-  describe("value()", () => {
-    test("returns the lexical (as-typed, normalized) form", () => {
-      realpathSync.mockImplementation((p: string) =>
-        p.startsWith("/tmp") ? `/private${p}` : p,
-      );
-      // Even when the path resolves to a different canonical, value() stays lexical.
-      expect(
-        AccessPath.forPath("/tmp/x", { cwd, platform: "linux" }).value(),
-      ).toBe("/tmp/x");
-    });
-
-    test("normalizes the path against cwd", () => {
-      // A relative path becomes an absolute lexical value.
-      expect(
-        AccessPath.forPath("src/foo.ts", { cwd, platform: "linux" }).value(),
-      ).toBe("/projects/my-app/src/foo.ts");
-    });
-
-    test("normalizes a relative path against an explicit resolveBase", () => {
-      expect(
-        AccessPath.forPath("foo.ts", {
-          cwd,
-          resolveBase: "/projects/my-app/sub",
-          platform: "linux",
-        }).value(),
-      ).toBe("/projects/my-app/sub/foo.ts");
-    });
-
-    test("returns empty string for empty input", () => {
-      expect(AccessPath.forPath("", { cwd, platform: "linux" }).value()).toBe(
-        "",
-      );
-    });
-  });
-});
-
-describe("resolvedAlias()", () => {
-  const cwd = "/projects/my-app";
-
-  beforeEach(() => {
-    realpathSync.mockReset();
-    realpathSync.mockImplementation((p: string) => p);
-  });
-
-  test("returns the canonical form when a symlink resolves elsewhere", () => {
-    realpathSync.mockImplementation((p: string) =>
-      p === "/projects/my-app/demo-symlink-passwd" ? "/etc/passwd" : p,
-    );
-    expect(
-      AccessPath.forPath("demo-symlink-passwd", {
-        cwd,
-        platform: "linux",
-      }).resolvedAlias(),
-    ).toBe("/etc/passwd");
-  });
-
-  test("returns undefined when the path has no symlinks (canonical equals lexical)", () => {
-    expect(
-      AccessPath.forPath("/etc/hosts", {
-        cwd,
-        platform: "linux",
-      }).resolvedAlias(),
-    ).toBeUndefined();
-  });
-
-  test("returns undefined for a literal-only path (no canonical)", () => {
-    expect(AccessPath.forLiteral("foo.ts").resolvedAlias()).toBeUndefined();
-  });
-
-  test("returns undefined for empty input", () => {
-    expect(
-      AccessPath.forPath("", { cwd, platform: "linux" }).resolvedAlias(),
-    ).toBeUndefined();
-  });
-
-  test("win32: returns the lowercased canonical form for a real symlink target", () => {
-    realpathSync.mockImplementation((p: string) =>
-      p === "c:\\projects\\app\\link" ? "C:\\Real\\App" : p,
-    );
-    expect(
-      AccessPath.forPath("link", {
-        cwd: "C:\\Projects\\App",
-        platform: "win32",
-      }).resolvedAlias(),
-    ).toBe("c:\\real\\app");
-  });
-
-  test("win32: returns undefined for a case-only difference (both forms lowercased)", () => {
-    expect(
-      AccessPath.forPath("src\\foo.ts", {
-        cwd: "C:\\Projects\\App",
-        platform: "win32",
-      }).resolvedAlias(),
-    ).toBeUndefined();
-  });
-});
-
-describe("AccessPath.forLiteral", () => {
-  beforeEach(() => {
-    realpathSync.mockReset();
-    realpathSync.mockImplementation((p: string) => p);
-  });
-
-  test("matchValues() carries only the literal — no canonical, no absolute", () => {
-    expect(AccessPath.forLiteral("foo.ts").matchValues()).toEqual(["foo.ts"]);
-  });
-
-  test("boundaryValue() is empty (no outside-cwd notion for an unknown base)", () => {
-    expect(AccessPath.forLiteral("foo.ts").boundaryValue()).toBe("");
-  });
-
-  test("value() returns the literal", () => {
-    expect(AccessPath.forLiteral("foo.ts").value()).toBe("foo.ts");
-  });
-
-  test("an empty literal yields no match values", () => {
-    expect(AccessPath.forLiteral("").matchValues()).toEqual([]);
-    expect(AccessPath.forLiteral("").value()).toBe("");
-  });
-});