superbee 0.1.3-pre.1 → 0.1.3

package/dist/superbee.mjs

@@ -44,7 +44,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var define_SUPERBEE_BUILD_IDENTITY_default;
 var init_define_SUPERBEE_BUILD_IDENTITY = __esm({
   "<define:__SUPERBEE_BUILD_IDENTITY__>"() {
-    define_SUPERBEE_BUILD_IDENTITY_default = { schema: "superbee.build-identity.v1", package: { name: "superbee", version: "0.1.3-pre.1" }, source: { commit: "0bed485ab3c3f0f385fb77f5a96cfb757529b1e1", dirty: false }, artifact: { channel: "npm-package" }, compatibility_contracts: { skill: 1, hook: 1, mcp: 1 } };
+    define_SUPERBEE_BUILD_IDENTITY_default = { schema: "superbee.build-identity.v1", package: { name: "superbee", version: "0.1.3" }, source: { commit: "f4e1c37349627030f8201ff52028f71a9c92570a", dirty: false }, artifact: { channel: "npm-package" }, compatibility_contracts: { skill: 1, hook: 1, mcp: 1 } };
   }
 });
 
@@ -52,7 +52,7 @@ var init_define_SUPERBEE_BUILD_IDENTITY = __esm({
 var define_SUPERBEE_UPDATE_POLICY_default;
 var init_define_SUPERBEE_UPDATE_POLICY = __esm({
   "<define:__SUPERBEE_UPDATE_POLICY__>"() {
-    define_SUPERBEE_UPDATE_POLICY_default = { enabled: true };
+    define_SUPERBEE_UPDATE_POLICY_default = { enabled: false };
   }
 });
 
@@ -1143,7 +1143,7 @@ var require_kind_of = __commonJS({
     init_define_SUPERBEE_BUILD_IDENTITY();
     init_define_SUPERBEE_UPDATE_POLICY();
     var toString2 = Object.prototype.toString;
-    module2.exports = function kindOf(val) {
+    module2.exports = function kindOf2(val) {
       if (val === void 0) return "undefined";
       if (val === null) return "null";
       var type = typeof val;
@@ -4872,7 +4872,7 @@ var init_content_type = __esm({
 });
 
 // ../core/src/errors.ts
-var InvalidInputError;
+var InvalidInputError, FilesystemIdentityAliasError, ConcurrentReplacementError;
 var init_errors = __esm({
   "../core/src/errors.ts"() {
     "use strict";
@@ -4884,6 +4884,26 @@ var init_errors = __esm({
         this.name = "InvalidInputError";
       }
     };
+    FilesystemIdentityAliasError = class extends InvalidInputError {
+      rel;
+      segment;
+      constructor(rel, segment) {
+        super(
+          `Path '${rel}' does not match the exact spelling of an existing filesystem entry at segment '${segment}'; ids that differ only by case or Unicode normalization cannot share one file.`
+        );
+        this.name = "FilesystemIdentityAliasError";
+        this.rel = rel;
+        this.segment = segment;
+      }
+    };
+    ConcurrentReplacementError = class extends Error {
+      rel;
+      constructor(rel, attempts) {
+        super(`Path '${rel}' was replaced concurrently on each of ${attempts} observation attempts; retry.`);
+        this.name = "ConcurrentReplacementError";
+        this.rel = rel;
+      }
+    };
   }
 });
 
@@ -5121,7 +5141,7 @@ async function canonicalTargetInDirectory(directory, requestedBasename) {
   }
   return requested;
 }
-function timeoutError(lockPath, owner) {
+function timeoutError(lockPath, owner, guarded) {
   const malformed2 = owner === null;
   const sameHost = owner?.hostname === hostname();
   const stale = owner !== null && sameHost && !processExists(owner.pid);
@@ -5133,28 +5153,20 @@ function timeoutError(lockPath, owner) {
   } else {
     message = `timed out waiting for filesystem mutation lock '${lockPath}' held by PID ${owner.pid} on ${owner.hostname}; retry the mutation.`;
   }
-  return new FilesystemMutationLockError(message, { lockPath, owner, stale, malformed: malformed2 });
+  return new FilesystemMutationLockError(`${message} The lock guards '${guarded}'.`, { lockPath, owner, stale, malformed: malformed2 });
 }
-async function acquireFilesystemMutationLock(target, options2 = {}) {
-  const waitMs = positiveOption(options2.waitMs, DEFAULT_WAIT_MS, "waitMs");
-  const pollMs = positiveOption(options2.pollMs, DEFAULT_POLL_MS, "pollMs");
-  const targetResolved = path.resolve(target);
-  const targetDir = path.dirname(targetResolved);
-  const started = Date.now();
-  await fs.mkdir(targetDir, { recursive: true });
-  const canonicalDir = await fs.realpath(targetDir);
-  const targetCanonical = await canonicalTargetInDirectory(canonicalDir, path.basename(targetResolved));
-  const portableRoot = options2.portableRoot ? await fs.realpath(options2.portableRoot).catch(() => path.resolve(options2.portableRoot)) : void 0;
+async function resolvedPortableRoot(portableRoot) {
+  if (portableRoot === void 0) return void 0;
+  return fs.realpath(portableRoot).catch(() => path.resolve(portableRoot));
+}
+async function selectLockRoot(options2) {
+  const portableRoot = await resolvedPortableRoot(options2.portableRoot);
   const lockRoot = options2.lockRoot !== void 0 ? explicitFilesystemMutationLockRoot(options2.lockRoot, portableRoot) : filesystemMutationLockRoot(portableRoot);
   await ensurePrivateLockRoot(lockRoot);
-  const lockPath = filesystemMutationLockPathInRoot(targetCanonical, lockRoot);
-  const owner = {
-    pid: process.pid,
-    hostname: hostname(),
-    created_at_ms: started,
-    token: randomUUID(),
-    target: targetCanonical
-  };
+  return lockRoot;
+}
+async function claimLockPath(lockPath, owner, waitMs, pollMs) {
+  const started = owner.created_at_ms;
   while (true) {
     try {
       await fs.mkdir(lockPath, { mode: 448 });
@@ -5191,10 +5203,43 @@ async function acquireFilesystemMutationLock(target, options2 = {}) {
     } catch (err) {
       if (err.code !== "EEXIST") throw err;
     }
-    if (Date.now() - started >= waitMs) throw timeoutError(lockPath, await readOwner(lockPath));
+    if (Date.now() - started >= waitMs) throw timeoutError(lockPath, await readOwner(lockPath), owner.target);
     await delay(pollMs);
   }
 }
+function newOwner(target) {
+  return {
+    pid: process.pid,
+    hostname: hostname(),
+    created_at_ms: Date.now(),
+    token: randomUUID(),
+    target
+  };
+}
+async function acquireFilesystemMutationLock(target, options2 = {}) {
+  const waitMs = positiveOption(options2.waitMs, DEFAULT_WAIT_MS, "waitMs");
+  const pollMs = positiveOption(options2.pollMs, DEFAULT_POLL_MS, "pollMs");
+  const targetResolved = path.resolve(target);
+  const targetDir = path.dirname(targetResolved);
+  const owner = newOwner(targetResolved);
+  await fs.mkdir(targetDir, { recursive: true });
+  const canonicalDir = await fs.realpath(targetDir);
+  const targetCanonical = await canonicalTargetInDirectory(canonicalDir, path.basename(targetResolved));
+  const lockRoot = await selectLockRoot(options2);
+  const lockPath = filesystemMutationLockPathInRoot(targetCanonical, lockRoot);
+  return claimLockPath(lockPath, { ...owner, target: targetCanonical }, waitMs, pollMs);
+}
+function assertIdentityKey(key) {
+  if (!IDENTITY_KEY_SHAPE.test(key)) throw new TypeError("identity key must be a lowercase hex sha256 digest");
+}
+async function acquireFilesystemIdentityLock(key, identity, options2 = {}) {
+  assertIdentityKey(key);
+  const waitMs = positiveOption(options2.waitMs, DEFAULT_WAIT_MS, "waitMs");
+  const pollMs = positiveOption(options2.pollMs, DEFAULT_POLL_MS, "pollMs");
+  const owner = newOwner(identity);
+  const lockRoot = await selectLockRoot(options2);
+  return claimLockPath(path.join(lockRoot, `${key}.lock`), owner, waitMs, pollMs);
+}
 async function withFilesystemMutationLock(target, fn, options2 = {}) {
   const release = await acquireFilesystemMutationLock(target, options2);
   try {
@@ -5203,7 +5248,7 @@ async function withFilesystemMutationLock(target, fn, options2 = {}) {
     await release();
   }
 }
-var OWNER_FILE, DEFAULT_WAIT_MS, DEFAULT_POLL_MS, FilesystemMutationLockError;
+var OWNER_FILE, DEFAULT_WAIT_MS, DEFAULT_POLL_MS, FilesystemMutationLockError, IDENTITY_KEY_SHAPE;
 var init_filesystem_lock = __esm({
   "../core/src/filesystem-lock.ts"() {
     "use strict";
@@ -5226,6 +5271,427 @@ var init_filesystem_lock = __esm({
         this.malformed = details.malformed;
       }
     };
+    IDENTITY_KEY_SHAPE = /^[0-9a-f]{64}$/;
+  }
+});
+
+// ../core/src/filesystem-identity.ts
+import { promises as fs2 } from "node:fs";
+import path2 from "node:path";
+import { createHash as createHash3, randomUUID as randomUUID2 } from "node:crypto";
+function isAbsentPathError(err) {
+  return ABSENT_PATH_CODES.has(err?.code ?? "");
+}
+function relSegments(rel) {
+  if (typeof rel !== "string" || rel.startsWith("/")) {
+    throw new InvalidInputError(`Path '${String(rel)}' resolves outside the bundle root.`);
+  }
+  const segments = rel.split("/").filter((segment) => segment !== "" && segment !== ".");
+  if (segments.length === 0 || segments.some((segment) => segment === "..")) {
+    throw new InvalidInputError(`Path '${rel}' resolves outside the bundle root.`);
+  }
+  return segments;
+}
+function foldSegment(segment) {
+  return segment.normalize("NFKD").toLowerCase().toUpperCase().toLowerCase();
+}
+async function existingAnchor(resolved) {
+  const tail = [];
+  let candidate = resolved;
+  for (; ; ) {
+    try {
+      return { anchor: await fs2.realpath(candidate), tail };
+    } catch (err) {
+      if (!isAbsentPathError(err)) throw err;
+    }
+    const parent = path2.dirname(candidate);
+    if (parent === candidate) return { anchor: candidate, tail };
+    tail.unshift(path2.basename(candidate));
+    candidate = parent;
+  }
+}
+async function identityKey(root, rel) {
+  const foldedRel = relSegments(rel).map(foldSegment).join("/");
+  const { anchor, tail } = await existingAnchor(path2.resolve(root));
+  const anchorSegments = anchor.split(path2.sep).filter((segment, index2) => index2 === 0 || segment !== "");
+  const foldedRoot = [...anchorSegments, ...tail].map(foldSegment).join("/");
+  return createHash3("sha256").update(`superbee-identity/v1\0${foldedRoot}\0${foldedRel}`).digest("hex");
+}
+function sameWitness(a, b) {
+  return a.dev === b.dev && a.ino === b.ino;
+}
+function confirmAlias(listingHasExact, probe, recorded) {
+  if (probe === null) return "absent";
+  if (!sameWitness(probe, recorded)) return "restart";
+  return listingHasExact ? "continue" : "aliased";
+}
+function classifyLeaf(snapshot2) {
+  if (snapshot2.probe === null) return "absent";
+  if (!sameWitness(snapshot2.probe, snapshot2.handle)) return "replaced";
+  return snapshot2.listed ? "exact" : "aliased";
+}
+function classifyMkdir(outcome, listing, segment, isTail) {
+  if (outcome === "created") return "created";
+  const exact = listing.find((entry) => entry.name === segment);
+  if (exact === void 0) return isTail ? "exact" : "aliased";
+  return exact.kind === "directory" ? "exact" : "shape-mismatch";
+}
+async function probeSegment(port, candidate, rel, segment) {
+  const probed = await port.probe(candidate);
+  if (probed !== null && probed.kind === "symlink") throw new FilesystemSymlinkEntryError(rel, segment);
+  return probed;
+}
+function hasExact(listing, segment) {
+  return listing.some((entry) => entry.name === segment);
+}
+async function walkExact(port, rootResolved, segments, rel) {
+  let parent = rootResolved;
+  for (let index2 = 0; index2 < segments.length; index2++) {
+    const segment = segments[index2];
+    const candidate = path2.join(parent, segment);
+    const probed = await probeSegment(port, candidate, rel, segment);
+    if (probed === null) return { state: "absent", depth: index2 };
+    const listing = await port.entries(parent);
+    if (listing === null) return { state: "absent", depth: index2 };
+    if (!hasExact(listing, segment)) throw new FilesystemIdentityAliasError(rel, segment);
+    if (index2 === segments.length - 1) return { state: "exact", leaf: probed };
+    if (probed.kind !== "directory") return { state: "shape-mismatch", segment };
+    parent = candidate;
+  }
+  throw new InvalidInputError(`Path '${rel}' resolves outside the bundle root.`);
+}
+async function recordWalk(port, rootResolved, segments, rel) {
+  const recorded = [];
+  let parent = rootResolved;
+  for (let index2 = 0; index2 < segments.length; index2++) {
+    const segment = segments[index2];
+    const candidate = path2.join(parent, segment);
+    const probed = await probeSegment(port, candidate, rel, segment);
+    if (probed === null) return null;
+    if (index2 < segments.length - 1 && probed.kind !== "directory") return null;
+    recorded.push(probed);
+    parent = candidate;
+  }
+  return recorded;
+}
+async function confirmedWalk(port, rootResolved, segments, rel, recorded, handle) {
+  let parent = rootResolved;
+  for (let index2 = 0; index2 < segments.length; index2++) {
+    const segment = segments[index2];
+    const candidate = path2.join(parent, segment);
+    const listing = await port.entries(parent);
+    if (listing === null) return "absent";
+    const listed = hasExact(listing, segment);
+    if (handle !== null && index2 === segments.length - 1) {
+      const verdict = classifyLeaf({ listed, probe: await probeSegment(port, candidate, rel, segment), handle });
+      if (verdict === "aliased") throw new FilesystemIdentityAliasError(rel, segment);
+      return verdict === "replaced" ? "restart" : verdict;
+    }
+    if (index2 < segments.length - 1 || !listed) {
+      const verdict = confirmAlias(listed, await probeSegment(port, candidate, rel, segment), recorded[index2]);
+      if (verdict === "aliased") throw new FilesystemIdentityAliasError(rel, segment);
+      if (verdict !== "continue") return verdict;
+    }
+    parent = candidate;
+  }
+  return "continue";
+}
+function countRestart(restarts, rel) {
+  if (restarts >= MAX_RESTARTS) throw new ConcurrentReplacementError(rel, restarts + 1);
+  return restarts + 1;
+}
+async function observeExact(port, root, rel, read) {
+  const segments = relSegments(rel);
+  const rootResolved = path2.resolve(root);
+  const target = path2.join(rootResolved, ...segments);
+  for (let restarts = 0; ; ) {
+    const recorded = await recordWalk(port, rootResolved, segments, rel);
+    if (recorded === null) return { state: "absent" };
+    const verified = await confirmedWalk(port, rootResolved, segments, rel, recorded, null);
+    if (verified === "absent") return { state: "absent" };
+    if (verified === "restart") {
+      restarts = countRestart(restarts, rel);
+      continue;
+    }
+    let opened;
+    try {
+      opened = await port.open(target);
+    } catch (err) {
+      if (isAbsentPathError(err)) return { state: "absent" };
+      throw err;
+    }
+    let value;
+    let verdict;
+    try {
+      value = await read(opened.handle, target);
+      if (value === null) return { state: "absent" };
+      verdict = await confirmedWalk(port, rootResolved, segments, rel, recorded, opened);
+    } finally {
+      await port.close(opened.handle);
+    }
+    if (verdict === "exact") return { state: "exact", value };
+    if (verdict === "absent") return { state: "absent" };
+    restarts = countRestart(restarts, rel);
+  }
+}
+async function probeExact(port, root, rel) {
+  const segments = relSegments(rel);
+  const rootResolved = path2.resolve(root);
+  for (let restarts = 0; ; ) {
+    const recorded = await recordWalk(port, rootResolved, segments, rel);
+    if (recorded === null) return { state: "absent" };
+    const leaf = recorded[recorded.length - 1];
+    const verified = await confirmedWalk(port, rootResolved, segments, rel, recorded, null);
+    const verdict = verified === "continue" ? await confirmedWalk(port, rootResolved, segments, rel, recorded, leaf) : verified;
+    if (verdict === "exact") return { state: "exact", value: leaf };
+    if (verdict === "absent") return { state: "absent" };
+    restarts = countRestart(restarts, rel);
+  }
+}
+function enqueue(key, fn) {
+  const tail = queues.get(key) ?? Promise.resolve();
+  const run = tail.then(fn, fn);
+  const settled = run.then(
+    () => void 0,
+    () => void 0
+  );
+  queues.set(key, settled);
+  void settled.then(() => {
+    if (queues.get(key) === settled) queues.delete(key);
+  });
+  return run;
+}
+function absentDirectoryError(dir) {
+  const err = new Error(`ENOENT: no such file or directory, scandir '${dir}'`);
+  err.code = "ENOENT";
+  err.syscall = "scandir";
+  err.path = dir;
+  return err;
+}
+async function readWhole(port, target) {
+  let opened;
+  try {
+    opened = await port.open(target);
+  } catch (err) {
+    if (ABSENT_FILE_CODES.has(err?.code ?? "")) return null;
+    throw err;
+  }
+  try {
+    return await port.readAll(opened.handle);
+  } catch (err) {
+    if (ABSENT_FILE_CODES.has(err?.code ?? "")) return null;
+    throw err;
+  } finally {
+    await port.close(opened.handle);
+  }
+}
+async function mkdirExact(port, parent, segment, isTail, rel) {
+  const outcome = await port.mkdir(path2.join(parent, segment));
+  if (outcome === "created") return;
+  const listing = await port.entries(parent);
+  if (listing === null) throw absentDirectoryError(parent);
+  if (listing.some((entry) => entry.name === segment && entry.kind === "symlink")) {
+    throw new FilesystemSymlinkEntryError(rel, segment);
+  }
+  const verdict = classifyMkdir(outcome, listing, segment, isTail);
+  if (verdict === "aliased") throw new FilesystemIdentityAliasError(rel, segment);
+  if (verdict === "shape-mismatch") throw new FilesystemShapeMismatchError(rel, segment);
+}
+async function ensureExactDirectories(port, rootResolved, segments, existingDepth, rel) {
+  if (existingDepth === 0 && await port.probe(rootResolved) === null) {
+    const tail = [];
+    let candidate = rootResolved;
+    for (; ; ) {
+      const parent2 = path2.dirname(candidate);
+      if (parent2 === candidate) break;
+      tail.unshift(path2.basename(candidate));
+      candidate = parent2;
+      if (await port.probe(candidate) !== null) break;
+    }
+    for (const segment of tail) {
+      await mkdirExact(port, candidate, segment, true, rel);
+      candidate = path2.join(candidate, segment);
+    }
+  }
+  let parent = path2.join(rootResolved, ...segments.slice(0, existingDepth));
+  for (const segment of segments.slice(existingDepth, -1)) {
+    await mkdirExact(port, parent, segment, false, rel);
+    parent = path2.join(parent, segment);
+  }
+}
+async function createExactLeaf(port, tmp, target, rel, leaf, rootResolved) {
+  const outcome = await port.link(tmp, target);
+  if (outcome === "linked") {
+    await port.unlink(tmp).catch(() => {
+    });
+    return;
+  }
+  if (outcome === "unsupported") {
+    linkUnsupportedRoots.add(rootResolved);
+    await port.rename(tmp, target);
+    return;
+  }
+  const listing = await port.entries(path2.dirname(target)) ?? [];
+  if (hasExact(listing, leaf)) throw new ConcurrentReplacementError(rel, 1);
+  throw new FilesystemIdentityAliasError(rel, leaf);
+}
+async function mutateExact(port, root, rel, body) {
+  const segments = relSegments(rel);
+  const rootResolved = path2.resolve(root);
+  const target = path2.join(rootResolved, ...segments);
+  const leaf = segments[segments.length - 1];
+  const key = await identityKey(root, rel);
+  return enqueue(key, async () => {
+    const release = await port.claim(key, { root: rootResolved, rel });
+    try {
+      const realized = await walkExact(port, rootResolved, segments, rel);
+      if (realized.state === "shape-mismatch") throw new FilesystemShapeMismatchError(rel, realized.segment);
+      const existingDepth = realized.state === "absent" ? realized.depth : segments.length - 1;
+      const context = {
+        state: realized.state,
+        async current() {
+          return realized.state === "exact" ? readWhole(port, target) : null;
+        },
+        async replace(bytes) {
+          await ensureExactDirectories(port, rootResolved, segments, existingDepth, rel);
+          const dir = path2.dirname(target);
+          const tmpName = `.${leaf}.${process.pid}.${Date.now()}.${randomUUID2()}.tmp`;
+          const tmp = path2.join(dir, tmpName);
+          await port.writeTemp(dir, tmpName, bytes);
+          try {
+            if (realized.state === "exact" || linkUnsupportedRoots.has(rootResolved)) {
+              await port.rename(tmp, target);
+              return;
+            }
+            await createExactLeaf(port, tmp, target, rel, leaf, rootResolved);
+          } catch (err) {
+            await port.unlink(tmp).catch(() => {
+            });
+            throw err;
+          }
+        },
+        async remove() {
+          await port.unlink(target);
+        }
+      };
+      return await body(context);
+    } finally {
+      await release();
+    }
+  });
+}
+function kindOf(stats) {
+  if (stats.isSymbolicLink()) return "symlink";
+  if (stats.isDirectory()) return "directory";
+  if (stats.isFile()) return "file";
+  return "other";
+}
+var FilesystemSymlinkEntryError, FilesystemShapeMismatchError, ABSENT_PATH_CODES, MAX_RESTARTS, linkUnsupportedRoots, queues, ABSENT_FILE_CODES, nodeFilesystemIdentityPort;
+var init_filesystem_identity = __esm({
+  "../core/src/filesystem-identity.ts"() {
+    "use strict";
+    init_define_SUPERBEE_BUILD_IDENTITY();
+    init_define_SUPERBEE_UPDATE_POLICY();
+    init_errors();
+    init_filesystem_lock();
+    FilesystemSymlinkEntryError = class extends InvalidInputError {
+      rel;
+      segment;
+      constructor(rel, segment) {
+        super(`Path '${rel}' reaches a symbolic link at segment '${segment}'; symlinked entries inside a bundle are unsupported.`);
+        this.name = "FilesystemSymlinkEntryError";
+        this.rel = rel;
+        this.segment = segment;
+      }
+    };
+    FilesystemShapeMismatchError = class extends Error {
+      rel;
+      segment;
+      constructor(rel, segment) {
+        super(`Path '${rel}' needs a directory at segment '${segment}' but a regular file exists there.`);
+        this.name = "FilesystemShapeMismatchError";
+        this.rel = rel;
+        this.segment = segment;
+      }
+    };
+    ABSENT_PATH_CODES = /* @__PURE__ */ new Set(["ENOENT", "ENOTDIR"]);
+    MAX_RESTARTS = 3;
+    linkUnsupportedRoots = /* @__PURE__ */ new Set();
+    queues = /* @__PURE__ */ new Map();
+    ABSENT_FILE_CODES = /* @__PURE__ */ new Set(["ENOENT", "ENOTDIR", "EISDIR"]);
+    nodeFilesystemIdentityPort = Object.freeze({
+      async probe(target) {
+        let lstats;
+        try {
+          lstats = await fs2.lstat(target);
+        } catch (err) {
+          if (isAbsentPathError(err)) return null;
+          throw err;
+        }
+        return { kind: kindOf(lstats), dev: lstats.dev, ino: lstats.ino };
+      },
+      async entries(dir) {
+        try {
+          const dirents = await fs2.readdir(dir, { withFileTypes: true });
+          return dirents.map((dirent) => ({ name: dirent.name, kind: kindOf(dirent) }));
+        } catch (err) {
+          if (isAbsentPathError(err)) return null;
+          throw err;
+        }
+      },
+      async open(target) {
+        const handle = await fs2.open(target, "r");
+        try {
+          const stats = await handle.stat();
+          return { handle, dev: stats.dev, ino: stats.ino };
+        } catch (err) {
+          await handle.close().catch(() => {
+          });
+          throw err;
+        }
+      },
+      readAll(handle) {
+        return handle.readFile();
+      },
+      close(handle) {
+        return handle.close();
+      },
+      async stat(target) {
+        return { mtime: (await fs2.stat(target)).mtime };
+      },
+      async mkdir(dir) {
+        try {
+          await fs2.mkdir(dir);
+          return "created";
+        } catch (err) {
+          if (err.code === "EEXIST") return "exists";
+          throw err;
+        }
+      },
+      async writeTemp(dir, name, bytes) {
+        await fs2.writeFile(path2.join(dir, name), bytes);
+      },
+      async link(from, to) {
+        try {
+          await fs2.link(from, to);
+          return "linked";
+        } catch (err) {
+          const code3 = err.code;
+          if (code3 === "EEXIST") return "exists";
+          if (code3 === "EPERM" || code3 === "ENOTSUP" || code3 === "EOPNOTSUPP" || code3 === "EXDEV") return "unsupported";
+          throw err;
+        }
+      },
+      async rename(from, to) {
+        await fs2.rename(from, to);
+      },
+      async unlink(target) {
+        await fs2.unlink(target);
+      },
+      claim(key, identity) {
+        return acquireFilesystemIdentityLock(key, `${identity.root}:${identity.rel}`, { portableRoot: identity.root });
+      }
+    });
   }
 });
 
@@ -5262,9 +5728,9 @@ var init_mutation_attribution = __esm({
 });
 
 // ../core/src/versioning.ts
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash4 } from "node:crypto";
 function sha256Hex(input) {
-  return createHash3("sha256").update(input, "utf8").digest("hex");
+  return createHash4("sha256").update(input, "utf8").digest("hex");
 }
 function contentVersion(doc2) {
   return `sha256:${sha256Hex(stringifyDoc(doc2.frontmatter, doc2.body ?? ""))}`;
@@ -5273,7 +5739,7 @@ function versionOfBytes(raw) {
   return `sha256:${sha256Hex(raw)}`;
 }
 function blobVersion(bytes) {
-  return `sha256:${createHash3("sha256").update(bytes).digest("hex")}`;
+  return `sha256:${createHash4("sha256").update(bytes).digest("hex")}`;
 }
 function stripETagWrapper(raw) {
   let v2 = raw.trim();
@@ -5312,82 +5778,47 @@ var init_versioning = __esm({
 });
 
 // ../core/src/backend.ts
-import { promises as fs2 } from "node:fs";
-import path2 from "node:path";
-import { randomUUID as randomUUID2 } from "node:crypto";
+import path3 from "node:path";
 function firstString(...vals) {
   for (const v2 of vals) {
     if (typeof v2 === "string" && v2.trim() !== "") return v2;
   }
   return void 0;
 }
-async function pathExists(p2) {
-  try {
-    await fs2.stat(p2);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function pathIsFile(p2) {
-  try {
-    return (await fs2.stat(p2)).isFile();
-  } catch {
-    return false;
-  }
-}
 function isAbsentFileError(err) {
   const code3 = err?.code;
-  return code3 === "ENOENT" || code3 === "EISDIR";
-}
-async function atomicWrite(filePath, content3) {
-  const dir = path2.dirname(filePath);
-  await fs2.mkdir(dir, { recursive: true });
-  const tmp = path2.join(dir, `.${path2.basename(filePath)}.${process.pid}.${Date.now()}.${randomUUID2()}.tmp`);
-  if (typeof content3 === "string") {
-    await fs2.writeFile(tmp, content3, "utf8");
-  } else {
-    await fs2.writeFile(tmp, content3);
-  }
-  await fs2.rename(tmp, filePath);
+  return code3 === "ENOENT" || code3 === "ENOTDIR" || code3 === "EISDIR";
+}
+function notFound(root, rel) {
+  const target = path3.join(root, rel);
+  const err = new Error(`ENOENT: no such file or directory, open '${target}'`);
+  err.code = "ENOENT";
+  err.syscall = "open";
+  err.path = target;
+  return err;
 }
-async function safeReaddir(abs) {
+async function readBytes(handle) {
   try {
-    return await fs2.readdir(abs, { withFileTypes: true });
-  } catch {
-    return [];
+    return await nodeFilesystemIdentityPort.readAll(handle);
+  } catch (err) {
+    if (isAbsentFileError(err)) return null;
+    throw err;
   }
 }
-async function walkMarkdown(root, sub = "") {
-  const abs = path2.join(root, sub);
-  const entries = await safeReaddir(abs);
+async function walkFiles(root, keep, sub = "") {
+  const entries = await nodeFilesystemIdentityPort.entries(path3.join(root, sub)) ?? [];
   const out = [];
   for (const entry of entries) {
     if (entry.name.startsWith(".")) continue;
     const rel = sub === "" ? entry.name : `${sub}/${entry.name}`;
-    if (entry.isDirectory()) {
-      out.push(...await walkMarkdown(root, rel));
-    } else if (entry.isFile() && entry.name.endsWith(".md")) {
+    if (entry.kind === "directory") {
+      out.push(...await walkFiles(root, keep, rel));
+    } else if (entry.kind === "file" && keep(entry.name)) {
       out.push(rel);
     }
   }
   return out;
 }
-async function walkBlobs(root, sub = "") {
-  const abs = path2.join(root, sub);
-  const entries = await safeReaddir(abs);
-  const out = [];
-  for (const entry of entries) {
-    if (entry.name.startsWith(".")) continue;
-    const rel = sub === "" ? entry.name : `${sub}/${entry.name}`;
-    if (entry.isDirectory()) {
-      out.push(...await walkBlobs(root, rel));
-    } else if (entry.isFile() && !entry.name.toLowerCase().endsWith(".md")) {
-      out.push(toPosix(rel));
-    }
-  }
-  return out;
-}
 function reservedPath(dir, name) {
   const d2 = toPosix(dir).replace(/^\.?\//, "").replace(/\/$/, "");
   return d2 === "" ? name : `${d2}/${name}`;
@@ -5402,93 +5833,25 @@ var init_backend = __esm({
     init_content_type();
     init_paths();
     init_errors();
-    init_filesystem_lock();
+    init_filesystem_identity();
     init_mutation_attribution();
     init_versioning();
-    FilesystemBackend = class _FilesystemBackend {
-      root;
+    FilesystemBackend = class {
+      #root;
       /**
-       * Per-resolved-path promise chain serializing writes within this process before the
-       * same-user cross-process filesystem lock is acquired.
-       *
-       * `write()`/`writeReserved()`'s compare-and-swap is check-then-write across two
-       * `await`s (read the current version, then `atomicWrite`): without serialization, N
-       * concurrent writers targeting the SAME file can all observe the SAME pre-write
-       * version, all pass the CAS check, and all proceed to write — every writer reports
-       * success, only the last write survives, and no `VersionConflict` is ever thrown to
-       * trigger a caller's retry loop. Queuing each write's full check-then-write critical
-       * section behind this per-key chain avoids needless polling between local callers.
-       * `withFilesystemMutationLock` then makes the same critical section exclusive across
-       * independent processes, so at most one writer can satisfy a given version premise.
-       * Reads stay lock-free because target replacement is atomic.
-       *
-       * STATIC, not per-instance: `core/src/bundle.ts`'s `backendFor()` constructs a FRESH
-       * `FilesystemBackend` on every bundle operation when the caller passes a bare
-       * `{ root }` (no explicit `backend`) — which is the shape `serve`/`openBundle` use
-       * for every request. An instance-level map would give every concurrent write its own
-       * empty lock table and serialize nothing; a process-wide map keyed by the RESOLVED
-       * absolute path is what actually makes concurrent writers to the same physical file
-       * queue behind each other, regardless of how many `FilesystemBackend` objects front
-       * them. Different bundle roots never collide because their resolved paths differ, so
-       * sharing the map across instances cannot cross-serialize unrelated bundles.
-       *
-       * Keyed by the RESOLVED absolute path so both `write()` (concept documents) and
-       * `writeReserved()` (`index.md`/`log.md`) share one queue per physical file — the
-       * only thing that actually needs serializing is contention on the same bytes.
-       *
-       * The external runtime lock is used for conditional and unconditional mutations alike: an
-       * unconditional writer must not move the target between another process's version
-       * check and write. A crash leftover fails closed with inspectable owner metadata.
+       * The root is resolved once here: a relative root would otherwise re-resolve against the
+       * process's current directory on every operation, so a later `chdir` would silently move the
+       * bundle and derive a different identity key.
        */
-      static locks = /* @__PURE__ */ new Map();
       constructor(root) {
-        this.root = root;
-      }
-      /**
-       * Run `fn` after any prior write queued under `key` has settled (success or
-       * failure), guaranteeing at most one in-flight critical section per key at a time —
-       * across ALL `FilesystemBackend` instances in this process (see `locks`'s doc
-       * comment on why the map is static). Must be called with NO prior `await` in the
-       * caller since acquiring the tail from the map and re-registering it happen
-       * synchronously here — that is what makes concurrent callers queue in call order
-       * rather than racing each other for the map entry. The chain entry is deleted once
-       * it drains and no newer waiter has replaced it, so a long-lived `serve` process
-       * does not accumulate one `Map` entry per ever-written file.
-       */
-      withLock(key, fn) {
-        const locks = _FilesystemBackend.locks;
-        const tail = locks.get(key) ?? Promise.resolve();
-        const locked = () => withFilesystemMutationLock(key, fn, { portableRoot: this.root });
-        const run = tail.then(locked, locked);
-        const settled = run.then(
-          () => void 0,
-          () => void 0
-        );
-        locks.set(key, settled);
-        void settled.then(() => {
-          if (locks.get(key) === settled) locks.delete(key);
-        });
-        return run;
-      }
-      /**
-       * Join `rel` onto the bundle root and resolve it. Belt-and-suspenders containment: even
-       * though every caller here first validates the id/dir it derived `rel` from
-       * ({@link assertSafeConceptId} / {@link assertSafeReservedDir}), this asserts the
-       * REALIZED path still lands inside the bundle root before any `fs` call touches it, so
-       * a future caller that skips the upstream guard cannot escape the bundle either.
-       */
-      abs(rel) {
-        const rootResolved = path2.resolve(this.root);
-        const resolved = path2.resolve(rootResolved, rel);
-        if (resolved !== rootResolved && !resolved.startsWith(rootResolved + path2.sep)) {
-          throw new InvalidInputError(`Path '${rel}' resolves outside the bundle root.`);
-        }
-        return resolved;
+        this.#root = path3.resolve(root);
       }
       async read(id) {
         assertSafeConceptId(id);
         const rel = pathFromConceptId(id);
-        const raw = await fs2.readFile(this.abs(rel), "utf8");
+        const observed = await observeExact(nodeFilesystemIdentityPort, this.#root, rel, readBytes);
+        if (observed.state === "absent") throw notFound(this.#root, rel);
+        const raw = observed.value.toString("utf8");
         const { frontmatter, body } = parseMarkdown(raw, rel);
         return { doc: { id, frontmatter, body }, version: versionOfBytes(raw) };
       }
@@ -5498,65 +5861,60 @@ var init_backend = __esm({
         for (const id of ids) out.push(await this.read(id));
         return out;
       }
-      /** Current version of the file at the already-resolved `absPath`, or `null` if absent. */
-      async currentVersionAt(absPath) {
-        try {
-          return versionOfBytes(await fs2.readFile(absPath, "utf8"));
-        } catch (err) {
-          if (isAbsentFileError(err)) return null;
-          throw err;
-        }
-      }
       async write(id, doc2, options2 = {}) {
         assertSafeConceptId(id);
         const raw = stringifyDoc(doc2.frontmatter, doc2.body ?? "");
-        const target = this.abs(pathFromConceptId(id));
-        return this.withLock(target, async () => {
+        const rel = pathFromConceptId(id);
+        return mutateExact(nodeFilesystemIdentityPort, this.#root, rel, async (target) => {
           if (options2.expectedVersion !== void 0) {
-            const current = await this.currentVersionAt(target);
+            const bytes = await target.current();
+            const current = bytes === null ? null : versionOfBytes(bytes.toString("utf8"));
             if (current !== options2.expectedVersion) {
               throw new VersionConflict(id, options2.expectedVersion, current);
             }
           }
-          await atomicWrite(target, raw);
+          await target.replace(Buffer.from(raw, "utf8"));
           return versionOfBytes(raw);
         });
       }
       async delete(id, options2 = {}) {
         assertSafeConceptId(id);
-        const target = this.abs(pathFromConceptId(id));
-        return this.withLock(target, async () => {
-          const current = await this.currentVersionAt(target);
-          if (current === null) return false;
+        return mutateExact(nodeFilesystemIdentityPort, this.#root, pathFromConceptId(id), async (target) => {
+          const bytes = await target.current();
+          if (bytes === null) return false;
+          const current = versionOfBytes(bytes.toString("utf8"));
           if (options2.expectedVersion !== void 0 && current !== options2.expectedVersion) {
             throw new VersionConflict(id, options2.expectedVersion, current);
           }
-          await fs2.unlink(target);
+          await target.remove();
           return true;
         });
       }
       async versions(id) {
         assertSafeConceptId(id);
-        const p2 = this.abs(pathFromConceptId(id));
-        let raw;
-        let mtime;
-        try {
-          raw = await fs2.readFile(p2, "utf8");
-          mtime = (await fs2.stat(p2)).mtime;
-        } catch {
-          return [];
-        }
-        const { frontmatter } = parseMarkdown(raw, pathFromConceptId(id));
+        const rel = pathFromConceptId(id);
+        const observed = await observeExact(nodeFilesystemIdentityPort, this.#root, rel, async (handle, target) => {
+          try {
+            const bytes = await nodeFilesystemIdentityPort.readAll(handle);
+            const { mtime: mtime2 } = await nodeFilesystemIdentityPort.stat(target);
+            return { raw: bytes.toString("utf8"), mtime: mtime2 };
+          } catch {
+            return null;
+          }
+        });
+        if (observed.state === "absent") return [];
+        const { raw, mtime } = observed.value;
+        const { frontmatter } = parseMarkdown(raw, rel);
         const actor = mutationActorFromFrontmatter(frontmatter) ?? defaultActor();
         const timestamp = firstString(frontmatter.timestamp) ?? mtime.toISOString();
         return [{ version: versionOfBytes(raw), actor, timestamp }];
       }
       async exists(id) {
         assertSafeConceptId(id);
-        return pathExists(this.abs(pathFromConceptId(id)));
+        return (await probeExact(nodeFilesystemIdentityPort, this.#root, pathFromConceptId(id))).state === "exact";
       }
       async list(prefix) {
-        const files = await walkMarkdown(this.root);
+        const files = await walkFiles(this.#root, (name) => name.endsWith(".md"));
         const ids = [];
         for (const rel of files) {
           if (isReservedFile(rel)) continue;
@@ -5575,80 +5933,69 @@ var init_backend = __esm({
       }
       async readReserved(dir, name) {
         assertSafeReservedDir(dir);
-        const p2 = this.abs(reservedPath(dir, name));
-        if (!await pathExists(p2)) return null;
-        const content3 = await fs2.readFile(p2, "utf8");
+        const observed = await observeExact(nodeFilesystemIdentityPort, this.#root, reservedPath(dir, name), readBytes);
+        if (observed.state === "absent") return null;
+        const content3 = observed.value.toString("utf8");
         return { content: content3, version: versionOfBytes(content3) };
       }
       async writeReserved(dir, name, content3, options2 = {}) {
         assertSafeReservedDir(dir);
         const rel = reservedPath(dir, name);
-        const target = this.abs(rel);
-        return this.withLock(target, async () => {
+        return mutateExact(nodeFilesystemIdentityPort, this.#root, rel, async (target) => {
           if (options2.expectedVersion !== void 0) {
-            const current = await this.currentVersionAt(target);
+            const bytes = await target.current();
+            const current = bytes === null ? null : versionOfBytes(bytes.toString("utf8"));
             if (current !== options2.expectedVersion) {
               throw new VersionConflict(rel, options2.expectedVersion, current);
             }
           }
-          await atomicWrite(target, content3);
+          await target.replace(Buffer.from(content3, "utf8"));
           return versionOfBytes(content3);
         });
       }
       // ── blobs: opaque bytes + a content-type ──────────────────────────────────
-      /** Current RAW-BYTES version of the blob at the already-resolved `absPath`, or `null` if absent. Reads with NO encoding — reusing the doc-shaped `currentVersionAt` would corrupt binary content via UTF-8 decoding (B1). */
-      async currentBlobVersionAt(absPath) {
-        try {
-          return blobVersion(await fs2.readFile(absPath));
-        } catch (err) {
-          if (isAbsentFileError(err)) return null;
-          throw err;
-        }
-      }
       async readBlob(key) {
         assertSafeBlobKey(key);
-        let bytes;
-        try {
-          bytes = await fs2.readFile(this.abs(key));
-        } catch (err) {
-          if (isAbsentFileError(err)) return null;
-          throw err;
-        }
+        const observed = await observeExact(nodeFilesystemIdentityPort, this.#root, key, readBytes);
+        if (observed.state === "absent") return null;
+        const bytes = observed.value;
         return { bytes, contentType: resolveContentType(key), version: blobVersion(bytes) };
       }
       async writeBlob(key, bytes, _contentType, options2 = {}) {
         assertSafeBlobKey(key);
-        const target = this.abs(key);
-        return this.withLock(target, async () => {
+        return mutateExact(nodeFilesystemIdentityPort, this.#root, key, async (target) => {
           if (options2.expectedVersion !== void 0) {
-            const current = await this.currentBlobVersionAt(target);
+            const existing = await target.current();
+            const current = existing === null ? null : blobVersion(existing);
             if (current !== options2.expectedVersion) {
               throw new VersionConflict(key, options2.expectedVersion, current);
             }
           }
-          await atomicWrite(target, bytes);
+          await target.replace(bytes);
           return blobVersion(bytes);
         });
       }
       async deleteBlob(key, options2 = {}) {
         assertSafeBlobKey(key);
-        const target = this.abs(key);
-        return this.withLock(target, async () => {
-          const current = await this.currentBlobVersionAt(target);
-          if (current === null) return false;
+        return mutateExact(nodeFilesystemIdentityPort, this.#root, key, async (target) => {
+          const existing = await target.current();
+          if (existing === null) return false;
+          const current = blobVersion(existing);
           if (options2.expectedVersion !== void 0 && current !== options2.expectedVersion) {
             throw new VersionConflict(key, options2.expectedVersion, current);
           }
-          await fs2.unlink(target);
+          await target.remove();
           return true;
         });
       }
       async existsBlob(key) {
         assertSafeBlobKey(key);
-        return pathIsFile(this.abs(key));
+        const observed = await probeExact(nodeFilesystemIdentityPort, this.#root, key);
+        return observed.state === "exact" && observed.value.kind === "file";
       }
       async listBlobs(prefix) {
-        const keys = await walkBlobs(this.root);
+        const files = await walkFiles(this.#root, (name) => !name.toLowerCase().endsWith(".md"));
+        const keys = files.map(toPosix);
         const filtered = prefix ? keys.filter((k2) => k2.startsWith(prefix)) : keys;
         filtered.sort((a, b) => a.localeCompare(b));
         return filtered;
@@ -5911,7 +6258,7 @@ var init_query_filter = __esm({
 });
 
 // ../core/src/bundle.ts
-import path3 from "node:path";
+import path4 from "node:path";
 function backendFor(bundle) {
   return bundle.backend ?? new FilesystemBackend(bundle.root);
 }
@@ -5932,10 +6279,10 @@ function resolveOkfAuthoringVersion(requested) {
 }
 async function initBundle(root, options2 = {}) {
   const okfVersion = resolveOkfAuthoringVersion(options2.okfVersion);
-  const resolved = path3.resolve(root);
+  const resolved = path4.resolve(root);
   const backend = new FilesystemBackend(resolved);
   if (options2.expectNew || await backend.readReserved("", "index.md") === null) {
-    const name = path3.basename(resolved);
+    const name = path4.basename(resolved);
     const body = `${GENERATED_INDEX_MARKER}
 # ${name}
 
@@ -6240,7 +6587,7 @@ var init_freshness = __esm({
 function snapshot(value) {
   return structuredClone(value);
 }
-function notFound(id) {
+function notFound2(id) {
   const err = new Error(`no concept document '${id}'`);
   err.code = "ENOENT";
   return err;
@@ -6268,7 +6615,7 @@ var init_memory_backend = __esm({
       async read(id) {
         assertSafeConceptId(id);
         const head = this.chains.get(id)?.[0];
-        if (!head) throw notFound(id);
+        if (!head) throw notFound2(id);
         return { doc: snapshot(head.doc), version: head.version };
       }
       async readMany(ids) {
@@ -6387,7 +6734,7 @@ var init_memory_backend = __esm({
 });
 
 // ../core/src/remote-backend.ts
-function notFound2(id) {
+function notFound3(id) {
   const err = new Error(`no concept document '${id}'`);
   err.code = "ENOENT";
   return err;
@@ -6510,7 +6857,7 @@ var init_remote_backend = __esm({
       async read(id) {
         assertSafeConceptId(id);
         const res = await this.send(`/docs/${encodeId(id)}`, { method: "GET" });
-        if (res.status === 404) throw notFound2(id);
+        if (res.status === 404) throw notFound3(id);
         if (!res.ok) throw await this.toError(res, id);
         const version2 = extractVersion(res, `GET /docs/${id}`);
         const payload = await res.json();
@@ -6531,7 +6878,7 @@ var init_remote_backend = __esm({
             missing2 = envelope.error.details?.missing ?? [];
           } catch {
           }
-          throw notFound2(missing2[0] ?? ids[0]);
+          throw notFound3(missing2[0] ?? ids[0]);
         }
         if (!res.ok) throw await this.toError(res, ids[0] ?? "");
         const payload = await res.json();
@@ -6684,6 +7031,7 @@ var init_remote_backend = __esm({
       // Content-type rides `Content-Type`; the version rides `X-Version`/`ETag` (extractVersion),
       // exactly like docs.
       async readBlob(key) {
+        assertSafeBlobKey(key);
         const res = await this.send(`/blobs/${encodeBlobKey(key)}`, { method: "GET" });
         if (res.status === 404) return null;
         if (!res.ok) throw await this.toError(res, key);
@@ -6693,6 +7041,7 @@ var init_remote_backend = __esm({
         return { bytes, contentType, version: version2 };
       }
       async writeBlob(key, bytes, contentType, options2 = {}) {
+        assertSafeBlobKey(key);
         assertValidExpectedVersion(options2.expectedVersion);
         const headers = {};
         if (contentType) headers["content-type"] = contentType;
@@ -6710,6 +7059,7 @@ var init_remote_backend = __esm({
       }
       /** `DELETE /blobs/{key}`, mirroring `delete`'s `If-Match`/no-404/no-actor posture exactly. */
       async deleteBlob(key, options2 = {}) {
+        assertSafeBlobKey(key);
         assertValidExpectedVersion(options2.expectedVersion);
         const headers = {};
         if (options2.expectedVersion !== void 0) headers["If-Match"] = options2.expectedVersion;
@@ -6719,6 +7069,7 @@ var init_remote_backend = __esm({
         return payload.deleted;
       }
       async existsBlob(key) {
+        assertSafeBlobKey(key);
         const res = await this.send(`/blobs/${encodeBlobKey(key)}`, { method: "HEAD" });
         if (res.status === 404) return false;
         if (!res.ok) throw await this.toError(res, key);
@@ -6749,7 +7100,14 @@ var init_remote_backend = __esm({
 async function versionedMutation(opts) {
   const maxAttempts = opts.maxAttempts ?? CAS_MAX_ATTEMPTS;
   for (let attempt = 0; ; attempt++) {
-    const { state, version: version2 } = await opts.read();
+    let fresh;
+    try {
+      fresh = await opts.read();
+    } catch (err) {
+      if (err instanceof ConcurrentReplacementError && attempt < maxAttempts - 1) continue;
+      throw err;
+    }
+    const { state, version: version2 } = fresh;
     const decision = await opts.decide(state, attempt);
     if (decision.action === "done") {
       return { result: decision.result, version: version2, wrote: false };
@@ -6769,6 +7127,7 @@ var init_mutation = __esm({
     "use strict";
     init_define_SUPERBEE_BUILD_IDENTITY();
     init_define_SUPERBEE_UPDATE_POLICY();
+    init_errors();
     init_versioning();
     CAS_MAX_ATTEMPTS = 5;
   }
@@ -6879,13 +7238,13 @@ function describeShape(value) {
   if (typeof value === "object") return "an object";
   return typeof value;
 }
-function toStringArrayLenient(value, path28, docId, warnings) {
+function toStringArrayLenient(value, path29, docId, warnings) {
   if (!Array.isArray(value)) {
     if (value !== void 0) {
       warnings.push({
         code: "KIND_CONVENTION_BAD_SHAPE",
-        message: `kind convention '${docId}' has a non-list '${path28}' (${describeShape(value)}; expected a list of strings); ignoring it.`,
-        field: path28,
+        message: `kind convention '${docId}' has a non-list '${path29}' (${describeShape(value)}; expected a list of strings); ignoring it.`,
+        field: path29,
         severity: "warning"
       });
     }
@@ -6898,8 +7257,8 @@ function toStringArrayLenient(value, path28, docId, warnings) {
     } else {
       warnings.push({
         code: "KIND_CONVENTION_BAD_MEMBER",
-        message: `kind convention '${docId}' has a non-scalar member (${describeShape(v2)}) in '${path28}'; skipping it.`,
-        field: path28,
+        message: `kind convention '${docId}' has a non-scalar member (${describeShape(v2)}) in '${path29}'; skipping it.`,
+        field: path29,
         severity: "warning"
       });
     }
@@ -7241,7 +7600,7 @@ function parseConventionDoc(doc2) {
       });
     }
   }
-  const path28 = typeof fm.path === "string" && fm.path.trim() !== "" ? fm.path.trim() : void 0;
+  const path29 = typeof fm.path === "string" && fm.path.trim() !== "" ? fm.path.trim() : void 0;
   const freshnessHorizon = typeof fm.freshness_horizon === "string" && fm.freshness_horizon.trim() !== "" ? fm.freshness_horizon.trim() : void 0;
   const browseCollapsed = fm.browse_collapsed === true ? true : void 0;
   const kind2 = {
@@ -7251,7 +7610,7 @@ function parseConventionDoc(doc2) {
     fields: { required: required2, optional: optional2, values, valueDescriptions, terminal, descriptions }
   };
   if (description !== void 0) kind2.description = description;
-  if (path28 !== void 0) kind2.path = path28;
+  if (path29 !== void 0) kind2.path = path29;
   if (links !== void 0) kind2.links = links;
   if (linkDescriptions !== void 0) kind2.linkDescriptions = linkDescriptions;
   if (expectsInbound !== void 0) kind2.expectsInbound = expectsInbound;
@@ -8203,11 +8562,11 @@ import {
   writeFileSync as writeFileSync2
 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
-import path4 from "node:path";
+import path5 from "node:path";
 function recognizedBundlePath(name, sourcePath) {
   try {
     const link3 = lstatSync2(sourcePath);
-    if (!statSync2(sourcePath).isDirectory() || !statSync2(path4.join(sourcePath, "index.md")).isFile()) return null;
+    if (!statSync2(sourcePath).isDirectory() || !statSync2(path5.join(sourcePath, "index.md")).isFile()) return null;
     return { name, sourcePath, realPath: realpathSync4(sourcePath), symlink: link3.isSymbolicLink() };
   } catch {
     return null;
@@ -8215,7 +8574,7 @@ function recognizedBundlePath(name, sourcePath) {
 }
 function bundleDirNameForProject(top) {
   const matches = BUNDLE_DIRS.flatMap((name) => {
-    const direct = path4.join(top, name);
+    const direct = path5.join(top, name);
     return [recognizedBundlePath(name, direct), recognizedBundlePath(name, `${direct}.establish-backup`)].filter((match) => match !== null);
   });
   const byName = /* @__PURE__ */ new Map();
@@ -8231,7 +8590,7 @@ function bundleDirNameForProject(top) {
       return [...aliases].sort((a, b) => Number(a.symlink) - Number(b.symlink))[0].name;
     }
     const sources = [...byName.values()].map((group) => group[0].sourcePath);
-    const shown = sources.map((source) => `'${path4.relative(top, source)}/'`).join(" and ");
+    const shown = sources.map((source) => `'${path5.relative(top, source)}/'`).join(" and ");
     throw new BoardGitError(
       "CONFLICT",
       `${shown} contain project bundles at ${top} \u2014 refusing to choose between two project bundles`,
@@ -8240,7 +8599,7 @@ function bundleDirNameForProject(top) {
           path: top,
           phase: "filesystem-bundle-selection",
           state: "bundle-directory-conflict",
-          directories: sources.map((source) => path4.relative(top, source))
+          directories: sources.map((source) => path5.relative(top, source))
         },
         help: "choose the project bundle to keep, then move the other directory outside the repository before retrying"
       }
@@ -8318,10 +8677,10 @@ function identityFlags(dir, actor) {
   return ["-c", `user.name=${name}`, "-c", `user.email=${slugifyActor(name)}@superbee.invalid`];
 }
 function hasEnclosingGitMarker(dir) {
-  let current = path4.resolve(dir);
+  let current = path5.resolve(dir);
   for (; ; ) {
-    if (existsSync(path4.join(current, ".git"))) return true;
-    const parent = path4.dirname(current);
+    if (existsSync(path5.join(current, ".git"))) return true;
+    const parent = path5.dirname(current);
     if (parent === current) return false;
     current = parent;
   }
@@ -8348,7 +8707,7 @@ function repoTopLevel(dir) {
 }
 function worktreeGitPath(boardPath, relative2) {
   const raw = mustGit(boardPath, ["rev-parse", "--git-path", relative2]).trim();
-  return path4.resolve(boardPath, raw);
+  return path5.resolve(boardPath, raw);
 }
 function realOrSame(p2) {
   try {
@@ -8362,7 +8721,7 @@ function gitCommonDir(dir) {
   if (r2.status !== 0) return null;
   const raw = r2.stdout.trim();
   if (raw.length === 0) return null;
-  return realOrSame(path4.isAbsolute(raw) ? raw : path4.resolve(dir, raw));
+  return realOrSame(path5.isAbsolute(raw) ? raw : path5.resolve(dir, raw));
 }
 function sameGitCommonDir(a, b) {
   const aCommon = gitCommonDir(a);
@@ -8378,7 +8737,7 @@ function worktreeRootResolvesForOwner(boardPath, ownerTop) {
 }
 function rebaseWasFromBoardBranch(boardPath) {
   for (const state of ["rebase-merge", "rebase-apply"]) {
-    const headNamePath = path4.join(worktreeGitPath(boardPath, state), "head-name");
+    const headNamePath = path5.join(worktreeGitPath(boardPath, state), "head-name");
     if (!existsSync(headNamePath)) continue;
     try {
       if (readFileSync3(headNamePath, "utf8").trim() === `refs/heads/${BOARD_BRANCH}`) return true;
@@ -8396,13 +8755,13 @@ function repairedWorktreeIsBoard(boardPath, ownerTop) {
 function isProvisioned(dir) {
   const top = repoTopLevel(dir);
   if (!top) return false;
-  const boardPath = path4.join(top, bundleDirNameForProject(top));
+  const boardPath = path5.join(top, bundleDirNameForProject(top));
   if (!existsSync(boardPath) || !worktreeRootResolvesForOwner(boardPath, top)) return false;
   const branch = runGit(boardPath, ["rev-parse", "--abbrev-ref", "HEAD"]);
   return branch.status === 0 && branch.stdout.trim() === BOARD_BRANCH;
 }
 function hasWorktreeSignature(dir) {
-  const gitPath = path4.join(dir, ".git");
+  const gitPath = path5.join(dir, ".git");
   if (!existsSync(gitPath)) return false;
   try {
     return statSync2(gitPath).isFile();
@@ -8482,7 +8841,7 @@ function boardWindowGuidance(top, originConfigured = true, bundleDir = bundleDir
   };
 }
 function preShareWindowError(top, boardPath, originConfigured = true) {
-  const base = path4.basename(boardPath);
+  const base = path5.basename(boardPath);
   const bundleDir = BUNDLE_DIRS.includes(base) ? base : bundleDirNameForProject(top);
   const guidance = boardWindowGuidance(top, originConfigured, bundleDir);
   const details = { path: boardPath, state: guidance.state };
@@ -8494,7 +8853,7 @@ function preShareWindowError(top, boardPath, originConfigured = true) {
   return new BoardGitError("RUNTIME", guidance.message, { details, help: guidance.help });
 }
 function existingDirRefusal(reason, boardPath, top) {
-  const bundleDir = path4.basename(boardPath);
+  const bundleDir = path5.basename(boardPath);
   const messages = {
     foreign: {
       message: `a non-empty '${bundleDir}' directory already exists at ${boardPath} but is not the shared board checkout \u2014 move it aside, then re-run sync`,
@@ -8522,7 +8881,7 @@ function provisionBoardWorktree(dir, budget = {}) {
   const top = repoTopLevel(dir);
   if (!top) return { kind: "no_repo" };
   const bundleDir = bundleDirNameForProject(top);
-  const boardPath = path4.join(top, bundleDir);
+  const boardPath = path5.join(top, bundleDir);
   const withIgnoreCoverage = (outcome) => {
     if (!budget.ensureIgnore) return outcome;
     const gitignore = ensureBoardGitignoreWorkingTree(top);
@@ -8765,7 +9124,7 @@ function snapshotFilesystemFiles(root) {
           { details: { nested_git_paths: [relPath] } }
         );
       }
-      if (entry.isDirectory()) visit2(path4.join(dir, entry.name), relPath);
+      if (entry.isDirectory()) visit2(path5.join(dir, entry.name), relPath);
       else if (entry.isFile() || entry.isSymbolicLink()) files.push(relPath);
       else {
         throw new BoardGitError(
@@ -8787,8 +9146,8 @@ function assertBundleBytesMatchCommit(top, bundlePath, commit) {
     if (tab < 0) continue;
     const [mode, type, oid] = row2.slice(0, tab).split(" ");
     const relPath = row2.slice(tab + 1);
-    const absolute = path4.resolve(bundlePath, relPath);
-    if (!absolute.startsWith(`${path4.resolve(bundlePath)}${path4.sep}`)) {
+    const absolute = path5.resolve(bundlePath, relPath);
+    if (!absolute.startsWith(`${path5.resolve(bundlePath)}${path5.sep}`)) {
       mismatches.push(relPath);
       continue;
     }
@@ -8828,8 +9187,8 @@ function assertBundleBytesMatchCommit(top, bundlePath, commit) {
 function snapshotBundleCommit(top, bundlePath) {
   const gitDir = mustGit(top, ["rev-parse", "--absolute-git-dir"]).trim();
   const filesystemFiles = snapshotFilesystemFiles(bundlePath);
-  const scratch = mkdtempSync(path4.join(tmpdir2(), "aslite-establish-index-"));
-  const indexFile = path4.join(scratch, "index");
+  const scratch = mkdtempSync(path5.join(tmpdir2(), "aslite-establish-index-"));
+  const indexFile = path5.join(scratch, "index");
   const snapshotOptions = { gitDir, workTree: bundlePath, indexFile };
   try {
     mustGit(bundlePath, ["read-tree", "--empty"], snapshotOptions);
@@ -8920,8 +9279,8 @@ function fetchRebaseResolving(boardPath, exportDir) {
         let bodyExportPath = null;
         const isDoc = isConceptDocPath(relPath);
         if (local.status === 0) {
-          exportPath = path4.join(exportDir, relPath);
-          mkdirSync2(path4.dirname(exportPath), { recursive: true, mode: 448 });
+          exportPath = path5.join(exportDir, relPath);
+          mkdirSync2(path5.dirname(exportPath), { recursive: true, mode: 448 });
           writeFileSync2(exportPath, local.stdout, { mode: 384 });
           if (isDoc) {
             try {
@@ -9015,7 +9374,7 @@ function withIgnoreEntries(content3) {
   return out;
 }
 function ensureBoardGitignoreWorkingTree(top) {
-  const gitignorePath = path4.join(top, ".gitignore");
+  const gitignorePath = path5.join(top, ".gitignore");
   let content3 = "";
   try {
     content3 = readFileSync3(gitignorePath, "utf8");
@@ -9142,7 +9501,7 @@ var init_porcelain = __esm({
 
 // ../board-git/src/flow.ts
 import { existsSync as existsSync2, readFileSync as readFileSync4, renameSync as renameSync2, unlinkSync as unlinkSync2, writeFileSync as writeFileSync3 } from "node:fs";
-import path5 from "node:path";
+import path6 from "node:path";
 function refCommit(top, ref) {
   const r2 = runGit(top, ["rev-parse", "--verify", "--quiet", ref]);
   const value = r2.stdout.trim();
@@ -9164,7 +9523,7 @@ function resolveOriginRef(boardPath) {
 function hasLocalOnlyBundle(dir) {
   const top = repoTopLevel(dir);
   if (!top) return false;
-  return existsSync2(path5.join(top, bundleDirNameForProject(top), "index.md"));
+  return existsSync2(path6.join(top, bundleDirNameForProject(top), "index.md"));
 }
 function committedBundleAtHead(top) {
   const found = [];
@@ -9223,7 +9582,7 @@ function annotateLanded(boardPath, conflicts) {
   }));
 }
 function markerPath(top, key) {
-  return path5.join(mustGit(top, ["rev-parse", "--absolute-git-dir"]).trim(), key);
+  return path6.join(mustGit(top, ["rev-parse", "--absolute-git-dir"]).trim(), key);
 }
 function readGitDirMarker(top, key) {
   try {
@@ -9317,7 +9676,7 @@ var init_flow = __esm({
 });
 
 // ../board-git/src/channel.ts
-import path6 from "node:path";
+import path7 from "node:path";
 function indeterminateTrackedReason(bundleDir) {
   return `'${bundleDir}/' is committed on the current branch, but ${BOARD_REMOTE} could not be checked for a shared '${BOARD_BRANCH}' branch \u2014 refusing to classify: an existing shared board must never be shadowed by guessing in-tree`;
 }
@@ -9348,7 +9707,7 @@ function probeRemoteBoardState(top, budget = {}) {
 function ownerRegistersBoardWorktree(top, bundleDir) {
   const r2 = runGit(top, ["worktree", "list", "--porcelain"]);
   if (r2.status !== 0) return false;
-  return r2.stdout.split("\n").some((l) => l.startsWith("worktree ") && path6.basename(l.slice("worktree ".length).trim()) === bundleDir);
+  return r2.stdout.split("\n").some((l) => l.startsWith("worktree ") && path7.basename(l.slice("worktree ".length).trim()) === bundleDir);
 }
 function verifiedForeignBoardRoot(top) {
   const folderTree = folderTreeAtHead(top);
@@ -9361,7 +9720,7 @@ function verifiedForeignBoardRoot(top) {
   return shas.every((sha) => treeOf(top, sha) !== folderTree);
 }
 function dualBoardError(boardPath) {
-  const bundleDir = path6.basename(boardPath);
+  const bundleDir = path7.basename(boardPath);
   return new BoardGitError(
     "CONFLICT",
     `a shared '${BOARD_BRANCH}' branch exists on ${BOARD_REMOTE} AND '${bundleDir}' is committed on the current branch with content that never seeded that branch \u2014 two competing board locations; nothing is safe to adopt automatically`,
@@ -9376,7 +9735,7 @@ function detectBoardChannel(dir, options2 = {}) {
   if (!top) return localOnlyChannel();
   const committed = committedBundleAtHead(top);
   const bundleDir = committed?.bundleDir ?? bundleDirNameForProject(top);
-  const boardPath = path6.join(top, bundleDir);
+  const boardPath = path7.join(top, bundleDir);
   if (hasWorktreeSignature(boardPath)) {
     if (worktreeRootResolvesForOwner(boardPath, top)) return branchChannel();
     if (!worktreeRootResolves(boardPath) && ownerRegistersBoardWorktree(top, bundleDir)) return branchChannel();
@@ -9472,7 +9831,7 @@ var init_diff = __esm({
 
 // ../board-git/src/cursor.ts
 import { readFile as readFile2 } from "node:fs/promises";
-import { createHash as createHash4 } from "node:crypto";
+import { createHash as createHash5 } from "node:crypto";
 import { basename, join as join5, resolve } from "node:path";
 function normalizeRemoteUrl(url2) {
   let u2 = url2.trim().replace(/\/+$/, "");
@@ -9493,7 +9852,7 @@ ${resolve(src.checkoutRoot)}`;
 ${resolve(src.root)}`;
 }
 function keyDigest(key) {
-  return createHash4("sha256").update(key, "utf8").digest("hex").slice(0, 32);
+  return createHash5("sha256").update(key, "utf8").digest("hex").slice(0, 32);
 }
 function isRecord3(v2) {
   return typeof v2 === "object" && v2 !== null && !Array.isArray(v2);
@@ -9729,7 +10088,7 @@ var init_cursor = __esm({
 
 // ../board-git/src/engine.ts
 import { existsSync as existsSync3, realpathSync as realpathSync5, statSync as statSync3 } from "node:fs";
-import path7 from "node:path";
+import path8 from "node:path";
 function realOrSame2(p2) {
   try {
     return realpathSync5(p2);
@@ -9742,23 +10101,23 @@ function isLinkedWorktree(p2) {
   if (r2.status !== 0) return false;
   const [gitDirRaw, commonDirRaw] = r2.stdout.trim().split("\n");
   if (!gitDirRaw || !commonDirRaw) return false;
-  const commonDir = path7.isAbsolute(commonDirRaw) ? commonDirRaw : path7.resolve(p2, commonDirRaw);
+  const commonDir = path8.isAbsolute(commonDirRaw) ? commonDirRaw : path8.resolve(p2, commonDirRaw);
   return realOrSame2(gitDirRaw) !== realOrSame2(commonDir);
 }
 function hasGitFileSignature(p2) {
   try {
-    return statSync3(path7.join(p2, ".git")).isFile();
+    return statSync3(path8.join(p2, ".git")).isFile();
   } catch {
     return false;
   }
 }
 function retargetStaleBoardInteriorByPath(dir) {
-  let cur = path7.resolve(dir);
+  let cur = path8.resolve(dir);
   for (; ; ) {
-    if (BUNDLE_DIRS.includes(path7.basename(cur)) && hasGitFileSignature(cur)) {
-      return path7.dirname(cur);
+    if (BUNDLE_DIRS.includes(path8.basename(cur)) && hasGitFileSignature(cur)) {
+      return path8.dirname(cur);
     }
-    const parent = path7.dirname(cur);
+    const parent = path8.dirname(cur);
     if (parent === cur) return null;
     cur = parent;
   }
@@ -9766,8 +10125,8 @@ function retargetStaleBoardInteriorByPath(dir) {
 function retargetBoardInterior(dir) {
   try {
     const top = repoTopLevel(dir);
-    if (top && BUNDLE_DIRS.includes(path7.basename(top)) && isLinkedWorktree(top)) {
-      return path7.dirname(top);
+    if (top && BUNDLE_DIRS.includes(path8.basename(top)) && isLinkedWorktree(top)) {
+      return path8.dirname(top);
     }
   } catch {
   }
@@ -9777,7 +10136,7 @@ function healStaleRebaseBeforeProvisioning(dir) {
   try {
     const top = repoTopLevel(dir);
     if (!top) return;
-    const candidateBoardPath = path7.join(top, bundleDirNameForProject(top));
+    const candidateBoardPath = path8.join(top, bundleDirNameForProject(top));
     if (!existsSync3(candidateBoardPath)) return;
     const boardTop = repoTopLevel(candidateBoardPath);
     if (!boardTop || realOrSame2(boardTop) !== realOrSame2(candidateBoardPath)) return;
@@ -9829,7 +10188,7 @@ var init_engine = __esm({
 });
 
 // ../board-git/src/autopull.ts
-import path8 from "node:path";
+import path9 from "node:path";
 import { realpathSync as realpathSync6, statSync as statSync4 } from "node:fs";
 function realOrSame3(p2) {
   try {
@@ -9840,21 +10199,21 @@ function realOrSame3(p2) {
 }
 function hasGitFileSignature2(p2) {
   try {
-    return statSync4(path8.join(p2, ".git")).isFile();
+    return statSync4(path9.join(p2, ".git")).isFile();
   } catch {
     return false;
   }
 }
 function findBoardCandidate(start) {
-  let cur = path8.resolve(start);
+  let cur = path9.resolve(start);
   for (; ; ) {
-    if (BUNDLE_DIRS.includes(path8.basename(cur)) && hasGitFileSignature2(cur)) {
-      return { top: path8.dirname(cur), boardPath: cur };
+    if (BUNDLE_DIRS.includes(path9.basename(cur)) && hasGitFileSignature2(cur)) {
+      return { top: path9.dirname(cur), boardPath: cur };
     }
-    const candidates = BUNDLE_DIRS.map((name) => path8.join(cur, name)).filter(hasGitFileSignature2);
+    const candidates = BUNDLE_DIRS.map((name) => path9.join(cur, name)).filter(hasGitFileSignature2);
     if (candidates.length > 1) return null;
     if (candidates[0]) return { top: cur, boardPath: candidates[0] };
-    const parent = path8.dirname(cur);
+    const parent = path9.dirname(cur);
     if (parent === cur) return null;
     cur = parent;
   }
@@ -9898,7 +10257,7 @@ async function maybeAutoPull(deps, dir, opts = {}) {
     if (!candidate) return "no-board";
     const boardPath = candidate.boardPath;
     if (opts.requireBoardBundle !== false) {
-      const root = dir !== void 0 ? path8.resolve(dir) : await deps.resolveBundleRoot(start);
+      const root = dir !== void 0 ? path9.resolve(dir) : await deps.resolveBundleRoot(start);
       if (!root || realOrSame3(root) !== realOrSame3(boardPath)) return "different-bundle";
     }
     const key = resolveBundleKey(boardPath);
@@ -9908,7 +10267,7 @@ async function maybeAutoPull(deps, dir, opts = {}) {
     if (ageOk(state.cache?.updatedAt)) return "fresh";
     if (ageOk(state.autoPullAttemptAt)) return "throttled";
     const gitTop = repoTopLevel(candidate.top);
-    if (!gitTop || realOrSame3(path8.join(gitTop, path8.basename(boardPath))) !== realOrSame3(boardPath) || !isProvisioned(gitTop)) {
+    if (!gitTop || realOrSame3(path9.join(gitTop, path9.basename(boardPath))) !== realOrSame3(boardPath) || !isProvisioned(gitTop)) {
       return "no-board";
     }
     await deps.store.recordAutoPullAttempt(key, now);
@@ -11300,26 +11659,26 @@ function applyReplacer(root, replacer) {
   if (replacedRoot === void 0) return transformChildren(root, replacer, []);
   return transformChildren(normalizeValue(replacedRoot), replacer, []);
 }
-function transformChildren(value, replacer, path28) {
-  if (isJsonObject(value)) return transformObject(value, replacer, path28);
-  if (isJsonArray(value)) return transformArray(value, replacer, path28);
+function transformChildren(value, replacer, path29) {
+  if (isJsonObject(value)) return transformObject(value, replacer, path29);
+  if (isJsonArray(value)) return transformArray(value, replacer, path29);
   return value;
 }
-function transformObject(obj, replacer, path28) {
+function transformObject(obj, replacer, path29) {
   const result3 = {};
   for (const [key, value] of Object.entries(obj)) {
-    const childPath = [...path28, key];
+    const childPath = [...path29, key];
     const replacedValue = replacer(key, value, childPath);
     if (replacedValue === void 0) continue;
     result3[key] = transformChildren(normalizeValue(replacedValue), replacer, childPath);
   }
   return result3;
 }
-function transformArray(arr, replacer, path28) {
+function transformArray(arr, replacer, path29) {
   const result3 = [];
   for (let i = 0; i < arr.length; i++) {
     const value = arr[i];
-    const childPath = [...path28, i];
+    const childPath = [...path29, i];
     const replacedValue = replacer(String(i), value, childPath);
     if (replacedValue === void 0) continue;
     const normalizedValue = normalizeValue(replacedValue);
@@ -11364,11 +11723,11 @@ var init_dist = __esm({
 
 // ../../node_modules/axi-sdk-js/dist/output.js
 import { homedir as homedir6 } from "node:os";
-function collapseHomeDirectory2(path28, homeDir = homedir6()) {
-  if (!path28.startsWith(homeDir)) {
-    return path28;
+function collapseHomeDirectory2(path29, homeDir = homedir6()) {
+  if (!path29.startsWith(homeDir)) {
+    return path29;
   }
-  return `~${path28.slice(homeDir.length)}`;
+  return `~${path29.slice(homeDir.length)}`;
 }
 function homeHeaderOutput(options2) {
   return {
@@ -11499,36 +11858,36 @@ function readNearestPackageJson(startPath, fs9 = nodeFs) {
 }
 function detectInstallMethod(options2) {
   const env = options2.env ?? process.env;
-  const path28 = options2.entry.replaceAll("\\", "/");
-  if (path28.includes("/_npx/") || /\/dlx-[^/]+\//.test(path28) || path28.includes("/pnpm/dlx/") || path28.includes("/bun/install/cache/")) {
+  const path29 = options2.entry.replaceAll("\\", "/");
+  if (path29.includes("/_npx/") || /\/dlx-[^/]+\//.test(path29) || path29.includes("/pnpm/dlx/") || path29.includes("/bun/install/cache/")) {
     return { kind: "npx" };
   }
-  const homebrewFormula = homebrewFormulaFromPath(path28, env);
+  const homebrewFormula = homebrewFormulaFromPath(path29, env);
   if (homebrewFormula) {
     return { kind: "homebrew", formula: homebrewFormula };
   }
   const pnpmHome = normalizePathRoot(env.PNPM_HOME);
-  if (isPathInsideRoot(path28, pnpmHome) || isKnownPnpmGlobalStore(path28, env)) {
+  if (isPathInsideRoot(path29, pnpmHome) || isKnownPnpmGlobalStore(path29, env)) {
     return { kind: "pnpm-global" };
   }
-  if (isKnownNpmGlobalInstall(path28, env)) {
+  if (isKnownNpmGlobalInstall(path29, env)) {
     return { kind: "npm-global" };
   }
   return { kind: "unknown" };
 }
-function normalizePathRoot(path28) {
-  const normalized = path28?.replaceAll("\\", "/").replace(/\/+$/, "");
+function normalizePathRoot(path29) {
+  const normalized = path29?.replaceAll("\\", "/").replace(/\/+$/, "");
   return normalized && normalized.length > 0 ? normalized : void 0;
 }
-function isPathInsideRoot(path28, root) {
-  return root !== void 0 && (path28 === root || path28.startsWith(`${root}/`));
+function isPathInsideRoot(path29, root) {
+  return root !== void 0 && (path29 === root || path29.startsWith(`${root}/`));
 }
-function homebrewFormulaFromPath(path28, env) {
+function homebrewFormulaFromPath(path29, env) {
   for (const root of homebrewCellarRoots(env)) {
-    if (!isPathInsideRoot(path28, root)) {
+    if (!isPathInsideRoot(path29, root)) {
       continue;
     }
-    const relative2 = path28.slice(root.length).replace(/^\/+/, "");
+    const relative2 = path29.slice(root.length).replace(/^\/+/, "");
     const formula = relative2.split("/")[0];
     if (formula) {
       return formula;
@@ -11556,12 +11915,12 @@ function homebrewCellarRoots(env) {
   }
   return [...new Set(roots)];
 }
-function isKnownPnpmGlobalStore(path28, env) {
+function isKnownPnpmGlobalStore(path29, env) {
   return pnpmGlobalStoreRoots(env).some((root) => {
-    if (!isPathInsideRoot(path28, root)) {
+    if (!isPathInsideRoot(path29, root)) {
       return false;
     }
-    const relative2 = path28.slice(root.length).replace(/^\/+/, "");
+    const relative2 = path29.slice(root.length).replace(/^\/+/, "");
     return /^\d+\/\.pnpm\//.test(relative2);
   });
 }
@@ -11579,8 +11938,8 @@ function pnpmGlobalStoreRoots(env) {
   }
   return [...new Set(roots)];
 }
-function isKnownNpmGlobalInstall(path28, env) {
-  return npmGlobalNodeModulesRoots(env).some((root) => isPathInsideRoot(path28, root)) || isKnownVersionManagerNpmGlobal(path28, env);
+function isKnownNpmGlobalInstall(path29, env) {
+  return npmGlobalNodeModulesRoots(env).some((root) => isPathInsideRoot(path29, root)) || isKnownVersionManagerNpmGlobal(path29, env);
 }
 function npmGlobalNodeModulesRoots(env) {
   const roots = [
@@ -11606,8 +11965,8 @@ function npmGlobalNodeModulesRoots(env) {
   }
   return [...new Set(roots)];
 }
-function isKnownVersionManagerNpmGlobal(path28, env) {
-  return versionManagerNodeRoots(env).some((root) => isPathInsideRoot(path28, root) && path28.includes("/lib/node_modules/"));
+function isKnownVersionManagerNpmGlobal(path29, env) {
+  return versionManagerNodeRoots(env).some((root) => isPathInsideRoot(path29, root) && path29.includes("/lib/node_modules/"));
 }
 function versionManagerNodeRoots(env) {
   const roots = [];
@@ -11841,7 +12200,7 @@ async function runUpdate(options2) {
   const binName = binNameFromArgv(invokedAs);
   const mode = parseUpdateArgs(options2.args, binName);
   const platform = options2.platform ?? process.platform;
-  const realpath2 = options2.realpath ?? ((path28) => realpathSync7(path28));
+  const realpath2 = options2.realpath ?? ((path29) => realpathSync7(path29));
   const entry = resolveEntry(invokedAs, realpath2);
   const fs9 = options2.fs ?? nodeFs;
   const fromPackageJson = entry ? readNearestPackageJson(entry, fs9) : {};
@@ -11926,7 +12285,7 @@ var init_update = __esm({
     REGISTRY_FETCH_TIMEOUT_MS = 2e4;
     nodeFs = {
       existsSync: existsSync4,
-      readFileSync: (path28, encoding) => readFileSync5(path28, encoding)
+      readFileSync: (path29, encoding) => readFileSync5(path29, encoding)
     };
     RegistryNotFoundError = class extends Error {
     };
@@ -12194,8 +12553,8 @@ function normalizeServer(raw) {
   if (url2.protocol !== "http:" && url2.protocol !== "https:") {
     throw new Error(`server URL must use http or https: ${raw}`);
   }
-  const path28 = url2.pathname.replace(/\/+$/, "");
-  return { base: url2.origin + path28, resource: url2.origin };
+  const path29 = url2.pathname.replace(/\/+$/, "");
+  return { base: url2.origin + path29, resource: url2.origin };
 }
 var init_config = __esm({
   "src/config.ts"() {
@@ -12208,7 +12567,7 @@ var init_config = __esm({
 // src/private-state-bundle-boundary.ts
 import { lstatSync as lstatSync3, readlinkSync as readlinkSync2, realpathSync as realpathSync8, statSync as statSync5 } from "node:fs";
 import { homedir as homedir7 } from "node:os";
-import path9 from "node:path";
+import path10 from "node:path";
 function code(error51) {
   return error51?.code;
 }
@@ -12235,7 +12594,7 @@ function danglingLinkTarget(cursor, seenLinks) {
     throw new CliError("RUNTIME", "cannot resolve the private-state filesystem boundary");
   }
   seenLinks.add(cursor);
-  return path9.resolve(path9.dirname(cursor), readlinkSync2(cursor));
+  return path10.resolve(path10.dirname(cursor), readlinkSync2(cursor));
 }
 function realAnchor(anchorPath) {
   try {
@@ -12253,7 +12612,7 @@ function anchorAt(lexicalAnchorPath, anchorStatus, missing2) {
     const key = inodeKey(status2);
     if (key === null) return { anchorKey: null, anchorChain: chain, missing: missing2, anchorPath };
     chain.push(key);
-    const parent = path9.dirname(current);
+    const parent = path10.dirname(current);
     if (parent === current) break;
     try {
       status2 = statSync5(parent, { bigint: true });
@@ -12265,10 +12624,10 @@ function anchorAt(lexicalAnchorPath, anchorStatus, missing2) {
   return { anchorKey: chain[0] ?? null, anchorChain: chain, missing: missing2, anchorPath };
 }
 function physicalCoordinate(candidate, seenLinks = /* @__PURE__ */ new Set()) {
-  if (!path9.isAbsolute(candidate)) {
+  if (!path10.isAbsolute(candidate)) {
     throw new CliError("RUNTIME", "private state and bundle identities require absolute filesystem paths");
   }
-  let cursor = path9.normalize(candidate);
+  let cursor = path10.normalize(candidate);
   const missing2 = [];
   for (; ; ) {
     try {
@@ -12278,12 +12637,12 @@ function physicalCoordinate(candidate, seenLinks = /* @__PURE__ */ new Set()) {
       if (!absentComponent(error51)) throw runtimeFailure();
     }
     const hop = danglingLinkTarget(cursor, seenLinks);
-    if (hop !== null) return physicalCoordinate(path9.resolve(hop, ...[...missing2].reverse()), seenLinks);
-    const parent = path9.dirname(cursor);
+    if (hop !== null) return physicalCoordinate(path10.resolve(hop, ...[...missing2].reverse()), seenLinks);
+    const parent = path10.dirname(cursor);
     if (parent === cursor) {
       throw new CliError("RUNTIME", "cannot resolve the private-state filesystem boundary");
     }
-    missing2.push(path9.basename(cursor));
+    missing2.push(path10.basename(cursor));
     cursor = parent;
   }
 }
@@ -12291,7 +12650,7 @@ function fold(segment) {
   return segment.normalize("NFC").toLowerCase();
 }
 function foldedSegments(coordinate) {
-  return path9.resolve(coordinate.anchorPath, ...coordinate.missing).split(path9.sep).filter(Boolean).map(fold);
+  return path10.resolve(coordinate.anchorPath, ...coordinate.missing).split(path10.sep).filter(Boolean).map(fold);
 }
 function relateSegments(bundle, state) {
   const shared = Math.min(bundle.length, state.length);
@@ -12302,8 +12661,8 @@ function relateSegments(bundle, state) {
   return bundle.length < state.length ? "bundle-contains-state" : "bundle-inside-state";
 }
 function relateToPrivateState(candidate, stateRoot) {
-  const bundle = physicalCoordinate(path9.resolve(candidate));
-  const state = physicalCoordinate(path9.resolve(stateRoot));
+  const bundle = physicalCoordinate(path10.resolve(candidate));
+  const state = physicalCoordinate(path10.resolve(stateRoot));
   if (bundle.anchorKey === null || state.anchorKey === null) {
     return relateSegments(foldedSegments(bundle), foldedSegments(state));
   }
@@ -12355,17 +12714,17 @@ function bundleBoundaryError(finding) {
   );
 }
 function assertBundleOutsidePrivateState(bundleRoot, home2 = homedir7()) {
-  const finding = classifyAgainstPrivateState(path9.resolve(bundleRoot), home2);
+  const finding = classifyAgainstPrivateState(path10.resolve(bundleRoot), home2);
   if (finding.relation === "unrelated") return;
   throw bundleBoundaryError(finding);
 }
 function assertSearchDirOutsidePrivateState(dir, home2 = homedir7()) {
-  const finding = classifyAgainstPrivateState(path9.resolve(dir), home2);
+  const finding = classifyAgainstPrivateState(path10.resolve(dir), home2);
   if (finding.relation !== "identical" && finding.relation !== "bundle-inside-state") return;
   throw bundleBoundaryError(finding);
 }
 function assertPathOutsidePrivateState(target, home2 = homedir7()) {
-  const finding = classifyAgainstPrivateState(path9.resolve(target), home2);
+  const finding = classifyAgainstPrivateState(path10.resolve(target), home2);
   if (finding.relation !== "identical" && finding.relation !== "bundle-inside-state") return;
   throw new CliError(
     "CONFLICT",
@@ -12387,7 +12746,7 @@ var init_private_state_bundle_boundary = __esm({
 // src/bound-board-owner.ts
 import { realpath } from "node:fs/promises";
 import { realpathSync as realpathSync9 } from "node:fs";
-import path10 from "node:path";
+import path11 from "node:path";
 function failure(target, stage, message) {
   return new CliError("CONFLICT", `project binding cannot be used as a board owner: ${message}`, {
     details: {
@@ -12399,7 +12758,7 @@ function failure(target, stage, message) {
 }
 function canonicalGitPath(from, raw) {
   if (!raw) return null;
-  const candidate = path10.isAbsolute(raw) ? raw : path10.resolve(from, raw);
+  const candidate = path11.isAbsolute(raw) ? raw : path11.resolve(from, raw);
   try {
     return realpathSync9(candidate);
   } catch {
@@ -12411,9 +12770,9 @@ async function validateBoundBoardOwner(target) {
   const bindingFile = target.bindingFile;
   if (!bindingFile) throw failure(target, "binding", "the selected binding has no source path");
   const bundleRoot = await realpath(target.canonicalRoot);
-  const bundleDir = path10.basename(bundleRoot);
+  const bundleDir = path11.basename(bundleRoot);
   if (!BUNDLE_DIRS.includes(bundleDir)) return void 0;
-  const ownerRoot = path10.dirname(bundleRoot);
+  const ownerRoot = path11.dirname(bundleRoot);
   if (repoTopLevel(bundleRoot) !== bundleRoot || repoTopLevel(ownerRoot) !== ownerRoot) return void 0;
   const candidateGit = runGit(bundleRoot, ["rev-parse", "--git-common-dir"]);
   const ownerGit = runGit(ownerRoot, ["rev-parse", "--git-common-dir"]);
@@ -12462,7 +12821,7 @@ var init_bound_board_owner = __esm({
 
 // src/bundle.ts
 import { constants as constants3, promises as fs3 } from "node:fs";
-import path11 from "node:path";
+import path12 from "node:path";
 async function exists(p2) {
   try {
     await fs3.stat(p2);
@@ -12472,16 +12831,16 @@ async function exists(p2) {
   }
 }
 function resolveTargetDir(dirFlag) {
-  return path11.resolve(dirFlag ?? process.cwd());
+  return path12.resolve(dirFlag ?? process.cwd());
 }
 async function assertPlainInitTarget(dirFlag) {
   const target = resolveTargetDir(dirFlag);
   assertBundleOutsidePrivateState(target);
-  const ownIndex = await exists(path11.join(target, "index.md"));
-  const base = path11.basename(target);
+  const ownIndex = await exists(path12.join(target, "index.md"));
+  const base = path12.basename(target);
   if (BUNDLE_DIRS.includes(base)) {
-    const selected = await conventionalBundleAt(path11.dirname(target));
-    if (selected && path11.resolve(selected) !== target) {
+    const selected = await conventionalBundleAt(path12.dirname(target));
+    if (selected && path12.resolve(selected) !== target) {
       throw new CliError(
         "CONFLICT",
         `an existing project workspace ${selected} already serves this location \u2014 refusing to create a second conventional bundle`,
@@ -12512,20 +12871,20 @@ function conventionalBundleConflict(dir) {
 async function conventionalBundleAt(dir) {
   const found = [];
   for (const name of BUNDLE_DIRS) {
-    const candidate = path11.join(dir, name);
-    if (await exists(path11.join(candidate, "index.md"))) found.push(candidate);
+    const candidate = path12.join(dir, name);
+    if (await exists(path12.join(candidate, "index.md"))) found.push(candidate);
   }
   if (found.length > 1) throw conventionalBundleConflict(dir);
   return found[0] ?? null;
 }
 async function findBundleRoot(start) {
   assertSearchDirOutsidePrivateState(start);
-  let dir = path11.resolve(start);
+  let dir = path12.resolve(start);
   while (true) {
-    if (await exists(path11.join(dir, "index.md"))) return dir;
+    if (await exists(path12.join(dir, "index.md"))) return dir;
     const conventional = await conventionalBundleAt(dir);
     if (conventional) return conventional;
-    const parent = path11.dirname(dir);
+    const parent = path12.dirname(dir);
     if (parent === dir) return null;
     dir = parent;
   }
@@ -12577,7 +12936,7 @@ function parseProjectBinding(file2, raw) {
       { help: `${cliInvocation()} <command> --remote ${remote}` }
     );
   }
-  return { file: file2, target: path11.resolve(path11.dirname(file2), value) };
+  return { file: file2, target: path12.resolve(path12.dirname(file2), value) };
 }
 async function readProjectBindingFile(file2) {
   let handle;
@@ -12613,8 +12972,8 @@ async function readProjectBindingFile(file2) {
   }
 }
 function projectBindingConflict(dir) {
-  const preferred = path11.join(dir, SUPERBEE_PROJECT_BINDING_FILE_NAME);
-  const legacy = path11.join(dir, PROJECT_BINDING_FILE_NAME);
+  const preferred = path12.join(dir, SUPERBEE_PROJECT_BINDING_FILE_NAME);
+  const legacy = path12.join(dir, PROJECT_BINDING_FILE_NAME);
   return new CliError(
     "USAGE",
     `conflicting project bindings at ${dir}: found both ${preferred} and ${legacy}; remove one instead of relying on an ambiguous target`,
@@ -12637,7 +12996,7 @@ async function ordinaryBindingEntryExists(file2) {
 async function ordinaryProjectBindingAtLevel(dir) {
   const observed = await Promise.all(
     PROJECT_BINDING_FILE_NAMES.map(async (name) => {
-      const file2 = path11.join(dir, name);
+      const file2 = path12.join(dir, name);
       return { file: file2, present: await ordinaryBindingEntryExists(file2) };
     })
   );
@@ -12646,11 +13005,11 @@ async function ordinaryProjectBindingAtLevel(dir) {
   return present[0]?.file ?? null;
 }
 async function resolveProjectBinding(startDir = process.cwd()) {
-  let dir = path11.resolve(startDir);
+  let dir = path12.resolve(startDir);
   for (; ; ) {
     const file2 = await ordinaryProjectBindingAtLevel(dir);
     if (file2) return parseProjectBinding(file2, await readProjectBindingFile(file2));
-    const parent = path11.dirname(dir);
+    const parent = path12.dirname(dir);
     if (parent === dir) return null;
     dir = parent;
   }
@@ -12749,12 +13108,12 @@ function createOnlyUncertainty(phase, operation, p2, err, createdDirectories = [
   );
 }
 function samePhysicalPath(a, b) {
-  const left = path11.resolve(a);
-  const right = path11.resolve(b);
+  const left = path12.resolve(a);
+  const right = path12.resolve(b);
   return process.platform === "win32" ? left.toLowerCase() === right.toLowerCase() : left === right;
 }
 function createOnlyArbitrationLockKey(physicalTarget) {
-  return path11.parse(path11.resolve(physicalTarget)).root;
+  return path12.parse(path12.resolve(physicalTarget)).root;
 }
 async function optionalLstat(io, p2, phase, operation, createdDirectories = []) {
   try {
@@ -12785,9 +13144,9 @@ async function resolveCreateOnlyPhysicalTarget(logical, io, phase, createdDirect
         });
       }
       if (code3 !== "ENOENT") createOnlyUncertainty(phase, "lstat", existingPrefix, err, createdDirectories);
-      const parent = path11.dirname(existingPrefix);
+      const parent = path12.dirname(existingPrefix);
       if (parent === existingPrefix) createOnlyUncertainty(phase, "lstat", existingPrefix, err, createdDirectories);
-      missingTail.unshift(path11.basename(existingPrefix));
+      missingTail.unshift(path12.basename(existingPrefix));
       existingPrefix = parent;
     }
   }
@@ -12817,7 +13176,7 @@ async function resolveCreateOnlyPhysicalTarget(logical, io, phase, createdDirect
   }
   return {
     logical,
-    target: path11.join(physicalPrefix, ...missingTail),
+    target: path12.join(physicalPrefix, ...missingTail),
     physicalPrefix,
     missingTail,
     ...targetStat ? { targetStat } : {}
@@ -12900,7 +13259,7 @@ async function existingBundleAt(io, candidate, phase, createdDirectories) {
   if (!physicalInfo.isDirectory()) return null;
   const own5 = await optionalLstat(
     io,
-    path11.join(physicalCandidate, "index.md"),
+    path12.join(physicalCandidate, "index.md"),
     phase,
     "lstat-own-index",
     createdDirectories
@@ -12911,7 +13270,7 @@ async function existingBundleAt(io, candidate, phase, createdDirectories) {
 async function strictConventionalBundleAt(io, dir, phase, createdDirectories, operation) {
   const found = [];
   for (const name of BUNDLE_DIRS) {
-    const candidate = path11.join(dir, name);
+    const candidate = path12.join(dir, name);
     const info = await optionalLstat(io, candidate, phase, `lstat-${operation}-directory`, createdDirectories);
     if (!info) continue;
     if (info.isSymbolicLink() || !info.isDirectory()) {
@@ -12923,7 +13282,7 @@ async function strictConventionalBundleAt(io, dir, phase, createdDirectories, op
         createdDirectories
       );
     }
-    if (await optionalLstat(io, path11.join(candidate, "index.md"), phase, `lstat-${operation}-index`, createdDirectories)) {
+    if (await optionalLstat(io, path12.join(candidate, "index.md"), phase, `lstat-${operation}-index`, createdDirectories)) {
       found.push(candidate);
     }
   }
@@ -12936,7 +13295,7 @@ async function strictProjectBinding(io, start, phase, createdDirectories) {
     await assertObservedDirectory(io, dir, phase, createdDirectories);
     const observed = await Promise.all(
       PROJECT_BINDING_FILE_NAMES.map(async (name) => {
-        const file2 = path11.join(dir, name);
+        const file2 = path12.join(dir, name);
         const info = await optionalLstat(
           io,
           file2,
@@ -12968,7 +13327,7 @@ async function strictProjectBinding(io, start, phase, createdDirectories) {
       }
       return parseProjectBinding(file2, raw);
     }
-    const parent = path11.dirname(dir);
+    const parent = path12.dirname(dir);
     if (parent === dir) return null;
     dir = parent;
   }
@@ -12977,7 +13336,7 @@ async function inspectCreateOnlyTarget(logical, io, phase, createdDirectories =
   const resolved = await resolveCreateOnlyPhysicalTarget(logical, io, phase, createdDirectories);
   const target = resolved.target;
   if (resolved.missingTail.length === 0) {
-    if (await optionalLstat(io, path11.join(target, "index.md"), phase, "lstat-own-index", createdDirectories)) {
+    if (await optionalLstat(io, path12.join(target, "index.md"), phase, "lstat-own-index", createdDirectories)) {
       createOnlyConflict(`create-only target ${target} is already an OKF bundle`, {
         phase,
         residual_created_directories: [...createdDirectories]
@@ -13003,11 +13362,11 @@ async function inspectCreateOnlyTarget(logical, io, phase, createdDirectories =
       );
     }
   }
-  const existingParent = resolved.missingTail.length > 0 ? resolved.physicalPrefix : path11.dirname(target);
+  const existingParent = resolved.missingTail.length > 0 ? resolved.physicalPrefix : path12.dirname(target);
   let ancestor = existingParent;
   for (; ; ) {
     await assertObservedDirectory(io, ancestor, phase, createdDirectories);
-    if (await optionalLstat(io, path11.join(ancestor, "index.md"), phase, "lstat-upward-own-index", createdDirectories)) {
+    if (await optionalLstat(io, path12.join(ancestor, "index.md"), phase, "lstat-upward-own-index", createdDirectories)) {
       createOnlyConflict(`create-only target ${target} would nest inside the existing bundle at ${ancestor}`, {
         phase,
         residual_created_directories: [...createdDirectories]
@@ -13020,7 +13379,7 @@ async function inspectCreateOnlyTarget(logical, io, phase, createdDirectories =
         residual_created_directories: [...createdDirectories]
       });
     }
-    const parent = path11.dirname(ancestor);
+    const parent = path12.dirname(ancestor);
     if (parent === ancestor) break;
     ancestor = parent;
   }
@@ -13042,7 +13401,7 @@ function createOnlyIo(deps) {
 async function createMissingDirectories(resolution, io, createdDirectories) {
   let current = resolution.physicalPrefix;
   for (const segment of resolution.missingTail) {
-    const next = path11.join(current, segment);
+    const next = path12.join(current, segment);
     try {
       await io.mkdir(next);
       createdDirectories.push(next);
@@ -13149,7 +13508,7 @@ function decorateCreateOnlyFailure(err, target, createdDirectories, publicationS
     createOnlyConflict(`create-only target ${target} gained a bundle concurrently \u2014 another process created it first`, {
       phase: "pre-publish",
       operation: "write-index-expect-absent",
-      path: path11.join(target, "index.md"),
+      path: path12.join(target, "index.md"),
       residual_created_directories: [...createdDirectories],
       publication_outcome: publicationState
     });
@@ -13167,7 +13526,7 @@ function decorateCreateOnlyFailure(err, target, createdDirectories, publicationS
   createOnlyUncertainty(
     publicationState === "not-started" ? "directory-creation" : "pre-publish",
     publicationState === "not-started" ? "create-only-critical-section" : "publish-index",
-    publicationState === "not-started" ? err?.path ?? target : err?.path ?? path11.join(target, "index.md"),
+    publicationState === "not-started" ? err?.path ?? target : err?.path ?? path12.join(target, "index.md"),
     err,
     createdDirectories,
     { publication_outcome: publicationState }
@@ -13175,7 +13534,7 @@ function decorateCreateOnlyFailure(err, target, createdDirectories, publicationS
 }
 async function withCreateOnlyTarget(dirFlag, publish, startDir = process.cwd(), deps = {}) {
   const io = createOnlyIo(deps);
-  const logical = path11.resolve(startDir, dirFlag ?? startDir);
+  const logical = path12.resolve(startDir, dirFlag ?? startDir);
   try {
     assertBundleOutsidePrivateState(logical);
   } catch (error51) {
@@ -13260,9 +13619,9 @@ async function withCreateOnlyTarget(dirFlag, publish, startDir = process.cwd(),
 }
 async function resolveLocalBundleTarget(dirFlag, startDir = process.cwd()) {
   if (dirFlag !== void 0) {
-    const requested = path11.resolve(startDir, dirFlag);
+    const requested = path12.resolve(startDir, dirFlag);
     assertBundleOutsidePrivateState(requested);
-    const ownIndex = await exists(path11.join(requested, "index.md"));
+    const ownIndex = await exists(path12.join(requested, "index.md"));
     const conventional = ownIndex ? null : await conventionalBundleAt(requested);
     const root = ownIndex ? requested : conventional ?? requested;
     let canonicalRoot2;
@@ -13288,7 +13647,7 @@ async function resolveLocalBundleTarget(dirFlag, startDir = process.cwd()) {
   }
   const binding = await resolveProjectBinding(startDir);
   if (binding) {
-    assertBundleOutsidePrivateState(path11.resolve(binding.target));
+    assertBundleOutsidePrivateState(path12.resolve(binding.target));
     const canonicalRoot2 = await canonicalDirectoryRoot(
       binding.target,
       `no local bundle directory at ${binding.target} \u2014 from project binding ${binding.file}`,
@@ -13324,17 +13683,17 @@ function bindingPathConflict(target, message) {
   });
 }
 function strictlyLexicalAncestor(ancestor, descendant) {
-  const relative2 = path11.relative(ancestor, descendant);
-  return relative2 !== "" && relative2 !== ".." && !relative2.startsWith(`..${path11.sep}`) && !path11.isAbsolute(relative2);
+  const relative2 = path12.relative(ancestor, descendant);
+  return relative2 !== "" && relative2 !== ".." && !relative2.startsWith(`..${path12.sep}`) && !path12.isAbsolute(relative2);
 }
 function lexicalBindingAnchors(anchor) {
   const anchors = [anchor];
   if (process.platform !== "darwin") return anchors;
   for (const [physical, lexical] of [
-    [path11.join(path11.sep, "private", "var"), path11.join(path11.sep, "var")],
-    [path11.join(path11.sep, "private", "tmp"), path11.join(path11.sep, "tmp")]
+    [path12.join(path12.sep, "private", "var"), path12.join(path12.sep, "var")],
+    [path12.join(path12.sep, "private", "tmp"), path12.join(path12.sep, "tmp")]
   ]) {
-    if (anchor === physical || anchor.startsWith(`${physical}${path11.sep}`)) {
+    if (anchor === physical || anchor.startsWith(`${physical}${path12.sep}`)) {
       anchors.push(`${lexical}${anchor.slice(physical.length)}`);
     }
   }
@@ -13343,14 +13702,14 @@ function lexicalBindingAnchors(anchor) {
 async function bindingRouteTraversesSymlink(target) {
   if (target.selectedBy !== "project-binding") return false;
   if (!target.bindingFile) throw bindingPathConflict(target, "the selected binding has no source path");
-  const lexicalAnchor = path11.resolve(path11.dirname(target.bindingFile));
+  const lexicalAnchor = path12.resolve(path12.dirname(target.bindingFile));
   const lexicalAnchors = lexicalBindingAnchors(lexicalAnchor);
-  const targetRoot = path11.resolve(target.root);
-  const targetParts = targetRoot.split(path11.sep).filter(Boolean);
+  const targetRoot = path12.resolve(target.root);
+  const targetParts = targetRoot.split(path12.sep).filter(Boolean);
   let traversesBindingSymlink = false;
-  let current = path11.parse(targetRoot).root;
+  let current = path12.parse(targetRoot).root;
   for (const segment of targetParts) {
-    current = path11.join(current, segment);
+    current = path12.join(current, segment);
     let info;
     try {
       info = await fs3.lstat(current);
@@ -13371,7 +13730,7 @@ async function captureDirectoryIdentity(target) {
   } catch {
     throw bindingPathConflict(target, "the selected target is unavailable");
   }
-  assertBundleOutsidePrivateState(path11.resolve(target.root));
+  assertBundleOutsidePrivateState(path12.resolve(target.root));
   assertBundleOutsidePrivateState(canonicalRoot);
   if (canonicalRoot !== target.canonicalRoot) {
     throw bindingPathConflict(target, "the selected target changed while its lexical path was validated");
@@ -13387,14 +13746,14 @@ async function captureDirectoryIdentity(target) {
 }
 async function hasOwnGitWorktreeSignature(root) {
   try {
-    await fs3.lstat(path11.join(root, ".git"));
+    await fs3.lstat(path12.join(root, ".git"));
     return true;
   } catch {
     return false;
   }
 }
 async function assertSymlinkedTargetIsNotBoardShaped(target, identity) {
-  if (!BUNDLE_DIRS.includes(path11.basename(identity.canonicalRoot))) return;
+  if (!BUNDLE_DIRS.includes(path12.basename(identity.canonicalRoot))) return;
   if (await hasOwnGitWorktreeSignature(identity.canonicalRoot)) {
     throw bindingPathConflict(target, "the symlinked target has a conventional board-worktree signature");
   }
@@ -13407,7 +13766,7 @@ async function assertResolvedLocalRouteIdentity(route) {
   } catch {
     throw bindingPathConflict(route.target, "the selected target is unavailable");
   }
-  assertBundleOutsidePrivateState(path11.resolve(route.target.root));
+  assertBundleOutsidePrivateState(path12.resolve(route.target.root));
   assertBundleOutsidePrivateState(canonicalRoot);
   if (canonicalRoot !== route.identity.canonicalRoot) {
     throw bindingPathConflict(route.target, "the selected target changed after classification");
@@ -13450,7 +13809,7 @@ function boardAttributionForRoute(route) {
     return route.readiness === "ready" ? { kind: "board", stateKey: route.owner.stateKey } : { kind: "none" };
   }
   if (route.kind === "bound-local") return { kind: "none" };
-  if (!BUNDLE_DIRS.includes(path11.basename(route.bundle.root))) return { kind: "none" };
+  if (!BUNDLE_DIRS.includes(path12.basename(route.bundle.root))) return { kind: "none" };
   try {
     return { kind: "board", stateKey: resolveBundleKey(route.bundle.root) };
   } catch {
@@ -13519,8 +13878,8 @@ function exactPositionalArity(count) {
 function pathFlags(...flags) {
   return Object.freeze(flags.map((entry) => Object.freeze({ ...entry })));
 }
-function firstWord(path28) {
-  return path28.split(" ", 1)[0];
+function firstWord(path29) {
+  return path29.split(" ", 1)[0];
 }
 function surfaceOf(surface, arity) {
   const positionals = surface?.positionals ?? NO_PATH_POSITIONALS;
@@ -13531,14 +13890,14 @@ function surfaceOf(surface, arity) {
   }
   return { pathFlags: surface?.flags ?? NO_PATHS, pathPositionals: positionals };
 }
-function publicLeaf(id, path28, arity, commandOrder, surface) {
+function publicLeaf(id, path29, arity, commandOrder, surface) {
   if (commandOrder !== void 0 && (!Number.isSafeInteger(commandOrder) || commandOrder < 0)) {
     throw new TypeError(`command order must be a non-negative safe integer; received ${commandOrder}`);
   }
   const mutable = {
     id,
-    path: path28,
-    command: firstWord(path28),
+    path: path29,
+    command: firstWord(path29),
     arity,
     canonical: void 0,
     exposure: "public",
@@ -13551,12 +13910,12 @@ function publicLeaf(id, path28, arity, commandOrder, surface) {
   OWNED_CLI_LEAVES.add(mutable);
   return Object.freeze(mutable);
 }
-function publicAlias(id, path28, canonical, commandOrder) {
+function publicAlias(id, path29, canonical, commandOrder) {
   if (canonical.exposure !== "public") throw new TypeError("a public alias must target a public leaf");
   const mutable = {
     id,
-    path: path28,
-    command: firstWord(path28),
+    path: path29,
+    command: firstWord(path29),
     arity: canonical.arity,
     canonical: canonical.canonical,
     exposure: "public",
@@ -13571,11 +13930,11 @@ function publicAlias(id, path28, canonical, commandOrder) {
   OWNED_CLI_LEAVES.add(mutable);
   return Object.freeze(mutable);
 }
-function hiddenLeaf(id, path28, arity, surface) {
+function hiddenLeaf(id, path29, arity, surface) {
   const mutable = {
     id,
-    path: path28,
-    command: firstWord(path28),
+    path: path29,
+    command: firstWord(path29),
     arity,
     canonical: void 0,
     exposure: "hidden",
@@ -13956,22 +14315,22 @@ function boundedToken(token) {
 }
 function assertLeafArity(leaf, positionals) {
   assertCliLeaf(leaf);
-  const path28 = leaf.canonical.path;
+  const path29 = leaf.canonical.path;
   const count = leaf.arity.count;
   const expected = count === 0 ? "no positional arguments" : `exactly ${count} positional${count === 1 ? "" : "s"}`;
   const actual = positionals.length;
   if (actual === count) return;
   const firstUnexpected = boundedToken(positionals[count]);
   const surplus = Math.max(0, actual - count);
-  throw new CliError("USAGE", `${path28} expected ${expected}; received ${actual}`, {
+  throw new CliError("USAGE", `${path29} expected ${expected}; received ${actual}`, {
     details: {
-      command: path28,
+      command: path29,
       expected,
       actual,
       ...surplus === 0 ? {} : { surplus },
       ...firstUnexpected === void 0 ? {} : { first_unexpected: firstUnexpected }
     },
-    help: `${cliInvocation()} ${path28} --help`
+    help: `${cliInvocation()} ${path29} --help`
   });
 }
 var init_positional_arity = __esm({
@@ -15187,13 +15546,13 @@ var init_recipe_parser = __esm({
 
 // src/recipe-ref.ts
 import os from "node:os";
-import path12 from "node:path";
+import path13 from "node:path";
 function looksLikeRecipePath(ref) {
   return ref.includes("/") || ref.startsWith("~");
 }
 function expandRecipePath(ref) {
   if (ref === "~") return os.homedir();
-  if (ref.startsWith("~/")) return path12.join(os.homedir(), ref.slice(2));
+  if (ref.startsWith("~/")) return path13.join(os.homedir(), ref.slice(2));
   return ref;
 }
 var init_recipe_ref = __esm({
@@ -15315,15 +15674,15 @@ var init_recipe_source_builtin = __esm({
 
 // src/recipe-source-filesystem.ts
 import { promises as fs4 } from "node:fs";
-import path13 from "node:path";
+import path14 from "node:path";
 async function readRecipeDir(root) {
   const files = [];
   const rootReal = await fs4.realpath(root);
-  const manifestPath = path13.join(root, "recipe.md");
+  const manifestPath = path14.join(root, "recipe.md");
   const manifestStat = await fs4.stat(manifestPath).catch(() => null);
   if (manifestStat?.isFile()) {
     const manifestReal = await fs4.realpath(manifestPath).catch(() => null);
-    if (!manifestReal || manifestReal !== rootReal && !manifestReal.startsWith(rootReal + path13.sep)) {
+    if (!manifestReal || manifestReal !== rootReal && !manifestReal.startsWith(rootReal + path14.sep)) {
       throw new RecipeUnsafePathSignal("recipe.md");
     }
     const bytes = await fs4.readFile(manifestPath, "utf8");
@@ -15334,7 +15693,7 @@ async function readRecipeDir(root) {
       return files;
     }
   }
-  const conventionsRoot = path13.join(root, "conventions");
+  const conventionsRoot = path14.join(root, "conventions");
   const conventionsStat = await fs4.stat(conventionsRoot).catch(() => null);
   if (conventionsStat?.isDirectory()) {
     await walkConventions(conventionsRoot, "conventions", rootReal, files);
@@ -15344,7 +15703,7 @@ async function readRecipeDir(root) {
 async function walkRecipeFiles(dir, relPrefix, rootReal, out, skip) {
   const entries = await fs4.readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const abs = path13.join(dir, entry.name);
+    const abs = path14.join(dir, entry.name);
     const rel = relPrefix ? `${relPrefix}/${entry.name}` : entry.name;
     if (skip.has(rel)) continue;
     if (entry.name.startsWith(".")) {
@@ -15356,7 +15715,7 @@ async function walkRecipeFiles(dir, relPrefix, rootReal, out, skip) {
     }
     if (!entry.isFile() && !entry.isSymbolicLink()) continue;
     const real = await fs4.realpath(abs).catch(() => null);
-    if (!real || real !== rootReal && !real.startsWith(rootReal + path13.sep)) {
+    if (!real || real !== rootReal && !real.startsWith(rootReal + path14.sep)) {
       throw new RecipeUnsafePathSignal(rel);
     }
     const stat4 = await fs4.stat(real).catch(() => null);
@@ -15367,7 +15726,7 @@ async function walkRecipeFiles(dir, relPrefix, rootReal, out, skip) {
 async function walkConventions(dir, relPrefix, rootReal, out) {
   const entries = await fs4.readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const abs = path13.join(dir, entry.name);
+    const abs = path14.join(dir, entry.name);
     const rel = `${relPrefix}/${entry.name}`;
     if (entry.isDirectory()) {
       await walkConventions(abs, rel, rootReal, out);
@@ -15376,7 +15735,7 @@ async function walkConventions(dir, relPrefix, rootReal, out) {
     if (!entry.isFile() && !entry.isSymbolicLink()) continue;
     if (!rel.endsWith(".md")) continue;
     const real = await fs4.realpath(abs).catch(() => null);
-    if (!real || real !== rootReal && !real.startsWith(rootReal + path13.sep)) {
+    if (!real || real !== rootReal && !real.startsWith(rootReal + path14.sep)) {
       throw new RecipeUnsafePathSignal(rel);
     }
     out.push({ path: rel, bytes: await fs4.readFile(abs, "utf8") });
@@ -15388,7 +15747,7 @@ function filesRecipeSource() {
     async resolve(ref) {
       if (!looksLikeRecipePath(ref)) return null;
       const expanded = expandRecipePath(ref);
-      const real = await fs4.realpath(path13.resolve(expanded)).catch(() => null);
+      const real = await fs4.realpath(path14.resolve(expanded)).catch(() => null);
       if (!real) {
         return { ok: false, error: { code: "RECIPE_NOT_FOUND", message: `no recipe folder at '${ref}'` } };
       }
@@ -15474,12 +15833,12 @@ var init_recipe_source = __esm({
 // src/commands/init.ts
 import { parseArgs } from "node:util";
 import { existsSync as existsSync5 } from "node:fs";
-import path14 from "node:path";
+import path15 from "node:path";
 function insideGitRepo(dir) {
-  let cur = path14.resolve(dir);
+  let cur = path15.resolve(dir);
   for (; ; ) {
-    if (existsSync5(path14.join(cur, ".git"))) return true;
-    const parent = path14.dirname(cur);
+    if (existsSync5(path15.join(cur, ".git"))) return true;
+    const parent = path15.dirname(cur);
     if (parent === cur) return false;
     cur = parent;
   }
@@ -16237,12 +16596,12 @@ var init_concept_id = __esm({
 // src/external-file.ts
 import { promises as fs5 } from "node:fs";
 import { homedir as homedir9 } from "node:os";
-import path15 from "node:path";
+import path16 from "node:path";
 function isExportedBundleContent(resolved, home2) {
   return relateToPrivateState(resolved, syncExportsRoot(home2)) === "bundle-inside-state";
 }
 function guardExternalRead(file2, home2 = homedir9()) {
-  const resolved = path15.resolve(file2);
+  const resolved = path16.resolve(file2);
   if (isExportedBundleContent(resolved, home2)) return;
   assertPathOutsidePrivateState(resolved, home2);
 }
@@ -24295,7 +24654,7 @@ function tokenizeWwwAutolink(effects, ok4, nok) {
     }
     effects.enter("literalAutolink");
     effects.enter("literalAutolinkWww");
-    return effects.check(wwwPrefix, effects.attempt(domain, effects.attempt(path16, wwwAfter), nok), nok)(code3);
+    return effects.check(wwwPrefix, effects.attempt(domain, effects.attempt(path17, wwwAfter), nok), nok)(code3);
   }
   function wwwAfter(code3) {
     effects.exit("literalAutolinkWww");
@@ -24345,7 +24704,7 @@ function tokenizeProtocolAutolink(effects, ok4, nok) {
     return nok(code3);
   }
   function afterProtocol(code3) {
-    return code3 === null || asciiControl(code3) || markdownLineEndingOrSpace(code3) || unicodeWhitespace(code3) || unicodePunctuation(code3) ? nok(code3) : effects.attempt(domain, effects.attempt(path16, protocolAfter), nok)(code3);
+    return code3 === null || asciiControl(code3) || markdownLineEndingOrSpace(code3) || unicodeWhitespace(code3) || unicodePunctuation(code3) ? nok(code3) : effects.attempt(domain, effects.attempt(path17, protocolAfter), nok)(code3);
   }
   function protocolAfter(code3) {
     effects.exit("literalAutolinkHttp");
@@ -24521,7 +24880,7 @@ function previousUnbalanced(events) {
   }
   return result3;
 }
-var wwwPrefix, domain, path16, trail, emailDomainDotTrail, wwwAutolink, protocolAutolink, emailAutolink, text3, code2;
+var wwwPrefix, domain, path17, trail, emailDomainDotTrail, wwwAutolink, protocolAutolink, emailAutolink, text3, code2;
 var init_syntax = __esm({
   "../../node_modules/micromark-extension-gfm-autolink-literal/lib/syntax.js"() {
     init_define_SUPERBEE_BUILD_IDENTITY();
@@ -24535,7 +24894,7 @@ var init_syntax = __esm({
       tokenize: tokenizeDomain,
       partial: true
     };
-    path16 = {
+    path17 = {
       tokenize: tokenizePath,
       partial: true
     };
@@ -26072,7 +26431,7 @@ function transformGfmAutolinkLiterals(tree) {
     { ignore: ["link", "linkReference"] }
   );
 }
-function findUrl(_2, protocol, domain3, path28, match) {
+function findUrl(_2, protocol, domain3, path29, match) {
   let prefix = "";
   if (!previous2(match)) {
     return false;
@@ -26085,7 +26444,7 @@ function findUrl(_2, protocol, domain3, path28, match) {
   if (!isCorrectDomain(domain3)) {
     return false;
   }
-  const parts = splitUrl(domain3 + path28);
+  const parts = splitUrl(domain3 + path29);
   if (!parts[0]) return false;
   const result3 = {
     type: "link",
@@ -54729,7 +55088,7 @@ var init_static = __esm({
 // src/commands/doc/read.ts
 import { parseArgs as parseArgs4 } from "node:util";
 import { promises as fs6 } from "node:fs";
-import path17 from "node:path";
+import path18 from "node:path";
 async function docRead(argv2, deps) {
   const stderr = deps.stderr ?? ((s) => void process.stderr.write(s));
   const rawStdoutReserved = requestsStdoutByteChannel(argv2);
@@ -54822,7 +55181,7 @@ async function docReadInner(argv2, deps) {
     const bodyOut = bodyOutValue.trim();
     const streamMode2 = bodyOut === "-";
     if (!streamMode2) {
-      assertPathOutsidePrivateState(path17.resolve(bodyOut));
+      assertPathOutsidePrivateState(path18.resolve(bodyOut));
       await assertSafeNonDocumentOutTarget(bundle, "--body-out", bodyOut, id, "body-only markdown");
     }
     const runToTarget2 = async () => {
@@ -54857,7 +55216,7 @@ async function docReadInner(argv2, deps) {
     const renderedOut = renderedOutValue.trim();
     const streamMode2 = renderedOut === "-";
     if (!streamMode2) {
-      assertPathOutsidePrivateState(path17.resolve(renderedOut));
+      assertPathOutsidePrivateState(path18.resolve(renderedOut));
       await assertSafeNonDocumentOutTarget(bundle, "--rendered-out", renderedOut, id, "rendered HTML");
     }
     let parsed;
@@ -54943,7 +55302,7 @@ async function docReadInner(argv2, deps) {
     return;
   }
   const streamMode = out === "-";
-  if (!streamMode) assertPathOutsidePrivateState(path17.resolve(out));
+  if (!streamMode) assertPathOutsidePrivateState(path18.resolve(out));
   const runToTarget = async () => {
     let bytes;
     let rel;
@@ -54960,7 +55319,7 @@ async function docReadInner(argv2, deps) {
       try {
         assertSafeConceptId(id);
         rel = pathFromConceptId(id);
-        bytes = await fs6.readFile(path17.join(bundle.root, rel));
+        bytes = await fs6.readFile(path18.join(bundle.root, rel));
       } catch (err) {
         throw readErrorToCliError(err, id, values.remote);
       }
@@ -54997,10 +55356,10 @@ function requestsStdoutByteChannel(argv2) {
 }
 async function assertSafeNonDocumentOutTarget(bundle, flag, outValue, id, payload) {
   if (bundle.backend) return;
-  const lexicalTarget = path17.resolve(outValue);
-  const rootReal = await fs6.realpath(path17.resolve(bundle.root)).catch(() => path17.resolve(bundle.root));
+  const lexicalTarget = path18.resolve(outValue);
+  const rootReal = await fs6.realpath(path18.resolve(bundle.root)).catch(() => path18.resolve(bundle.root));
   const effectiveTarget = await effectiveOutputPath(lexicalTarget);
-  const inside = (candidate, base) => candidate === base || candidate.startsWith(base + path17.sep);
+  const inside = (candidate, base) => candidate === base || candidate.startsWith(base + path18.sep);
   const unsafeLexical = inside(lexicalTarget, rootReal) && lexicalTarget.endsWith(".md");
   const unsafeEffective = inside(effectiveTarget, rootReal) && effectiveTarget.endsWith(".md");
   if (!unsafeLexical && !unsafeEffective) return;
@@ -55015,11 +55374,11 @@ async function effectiveOutputPath(absoluteTarget) {
   const missingSuffix = [];
   while (true) {
     try {
-      return path17.join(await fs6.realpath(probe), ...missingSuffix);
+      return path18.join(await fs6.realpath(probe), ...missingSuffix);
     } catch {
-      const parent = path17.dirname(probe);
+      const parent = path18.dirname(probe);
       if (parent === probe) return absoluteTarget;
-      missingSuffix.unshift(path17.basename(probe));
+      missingSuffix.unshift(path18.basename(probe));
       probe = parent;
     }
   }
@@ -55047,9 +55406,9 @@ function formatFieldValue(value) {
 }
 function inBundlePollutionWarning(bundle, out) {
   if (bundle.backend) return void 0;
-  const resolvedOut = path17.resolve(out);
+  const resolvedOut = path18.resolve(out);
   const root = bundle.root;
-  const isInside = resolvedOut === root || resolvedOut.startsWith(root + path17.sep);
+  const isInside = resolvedOut === root || resolvedOut.startsWith(root + path18.sep);
   if (!isInside) return void 0;
   if (isReservedFile(resolvedOut)) {
     return `--out ${out} resolves to ${resolvedOut}, which is INSIDE this bundle (${root}) at a reserved OKF filename \u2014 the write will CLOBBER that reserved file (index.md/log.md is never re-parsed as a concept doc). Pass a path outside the bundle if that is not intended.`;
@@ -55339,6 +55698,81 @@ function deleteOptionsFromHeaders(req) {
 function versionHeaders(version2) {
   return { "X-Version": version2, ETag: `"${version2}"` };
 }
+function matchWireResources(pathname) {
+  if (pathname === "/v0/capabilities") return [{ resource: "capabilities" }];
+  const match = BUNDLE_PATH_RE.exec(pathname);
+  if (!match) return [];
+  const rest = match[2] ?? "";
+  if (rest === "docs") return [{ resource: "docs" }];
+  if (rest === "docs:read-many") return [{ resource: "docs-read-many" }];
+  if (rest.startsWith("docs/")) {
+    const tail = rest.slice("docs/".length);
+    return tail.endsWith("/versions") ? [
+      { resource: "doc-versions", value: tail.slice(0, -"/versions".length) },
+      { resource: "doc", value: tail }
+    ] : [{ resource: "doc", value: tail }];
+  }
+  if (rest.startsWith("reserved/")) {
+    return [{ resource: "reserved", value: rest.slice("reserved/".length) }];
+  }
+  if (rest === "blobs") return [{ resource: "blobs" }];
+  if (rest.startsWith("blobs/")) return [{ resource: "blob", value: rest.slice("blobs/".length) }];
+  return [];
+}
+function resolveWireEndpoint(resources, method) {
+  for (const match of resources) {
+    const endpoint = WIRE_ENDPOINTS.find((row2) => row2.resource === match.resource && row2.method === method);
+    if (endpoint) return { endpoint, match };
+  }
+  return void 0;
+}
+function unsupportedMethodResponse(method, match) {
+  let label;
+  switch (match.resource) {
+    case "docs":
+      label = "/docs";
+      break;
+    case "docs-read-many":
+      label = "/docs:read-many";
+      break;
+    case "doc":
+    case "doc-versions":
+      label = "a doc route";
+      break;
+    case "reserved":
+      label = "a reserved-file route";
+      break;
+    case "blobs":
+      label = "/blobs";
+      break;
+    case "blob":
+      label = "a blob route";
+      break;
+    case "capabilities":
+      label = "/v0/capabilities";
+      break;
+  }
+  return errorResponse(400, "USAGE", `unsupported method ${method} for ${label}`);
+}
+function registeredWireRouter(dispatch) {
+  return async function handle(req) {
+    let url2;
+    try {
+      url2 = new URL(req.url);
+    } catch {
+      return errorResponse(400, "USAGE", "invalid request URL");
+    }
+    const resources = matchWireResources(url2.pathname);
+    if (resources.length === 0) return errorResponse(404, "NOT_FOUND", `no route for ${url2.pathname}`);
+    const resolved = resolveWireEndpoint(resources, req.method);
+    if (!resolved) return unsupportedMethodResponse(req.method, resources[0]);
+    try {
+      return await dispatch(req, { ...resolved, searchParams: url2.searchParams });
+    } catch (err) {
+      return errorFromCaught(err);
+    }
+  };
+}
 function createRouter(bundle) {
   return buildRouter(bundle.backend ?? new FilesystemBackend(bundle.root));
 }
@@ -55430,15 +55864,15 @@ function buildRouter(backend) {
       results: results.map((r2) => ({ id: r2.doc.id, frontmatter: r2.doc.frontmatter, body: r2.doc.body, version: r2.version }))
     });
   }
-  async function handleList(url2) {
-    const prefix = url2.searchParams.get("prefix") ?? void 0;
-    const type = url2.searchParams.get("type") ?? void 0;
-    const tags = url2.searchParams.getAll("tag");
-    const fields = url2.searchParams.get("fields");
-    const limitParam = url2.searchParams.get("limit");
+  async function handleList(searchParams) {
+    const prefix = searchParams.get("prefix") ?? void 0;
+    const type = searchParams.get("type") ?? void 0;
+    const tags = searchParams.getAll("tag");
+    const fields = searchParams.get("fields");
+    const limitParam = searchParams.get("limit");
     const parsedLimit = limitParam ? parseInt(limitParam, 10) : NaN;
     const limit = Number.isFinite(parsedLimit) && parsedLimit > 0 ? parsedLimit : DEFAULT_LIST_LIMIT;
-    const cursor = url2.searchParams.get("cursor") ?? void 0;
+    const cursor = searchParams.get("cursor") ?? void 0;
     const heads = await queryHeads(bundle, { prefix, type, tags });
     const count = heads.length;
     let page = heads;
@@ -55519,12 +55953,12 @@ function buildRouter(backend) {
     const deleted = await backend.deleteBlob(key, options2);
     return jsonResponse(200, { deleted });
   }
-  async function handleListBlobs(url2) {
-    const prefix = url2.searchParams.get("prefix") ?? void 0;
-    const limitParam = url2.searchParams.get("limit");
+  async function handleListBlobs(searchParams) {
+    const prefix = searchParams.get("prefix") ?? void 0;
+    const limitParam = searchParams.get("limit");
     const parsedLimit = limitParam ? parseInt(limitParam, 10) : NaN;
     const limit = Number.isFinite(parsedLimit) && parsedLimit > 0 ? parsedLimit : DEFAULT_LIST_LIMIT;
-    const cursor = url2.searchParams.get("cursor") ?? void 0;
+    const cursor = searchParams.get("cursor") ?? void 0;
     const keys = await backend.listBlobs(prefix);
     const count = keys.length;
     let page = keys;
@@ -55554,69 +55988,47 @@ function buildRouter(backend) {
       blobs: caps.blobs
     });
   }
-  return async function handle(req) {
-    let url2;
-    try {
-      url2 = new URL(req.url);
-    } catch {
-      return errorResponse(400, "USAGE", "invalid request URL");
-    }
-    if (url2.pathname === "/v0/capabilities") {
-      return handleCapabilities();
-    }
-    const match = BUNDLE_PATH_RE.exec(url2.pathname);
-    if (!match) return errorResponse(404, "NOT_FOUND", `no route for ${url2.pathname}`);
-    const rest = match[2] ?? "";
-    try {
-      if (rest === "docs") {
-        if (req.method === "GET") return await handleList(url2);
-        return errorResponse(400, "USAGE", `unsupported method ${req.method} for /docs`);
-      }
-      if (rest === "docs:read-many") {
-        if (req.method === "POST") return await handleReadMany(req);
-        return errorResponse(400, "USAGE", `unsupported method ${req.method} for /docs:read-many`);
-      }
-      if (rest.startsWith("docs/")) {
-        const tail = rest.slice("docs/".length);
-        if (tail.endsWith("/versions") && req.method === "GET") {
-          return await handleVersions(decodeId(tail.slice(0, -"/versions".length)));
-        }
-        const id = decodeId(tail);
-        if (req.method === "GET") return await handleReadDoc(id);
-        if (req.method === "PUT") return await handleWriteDoc(id, req);
-        if (req.method === "HEAD") return await handleHeadDoc(id);
-        if (req.method === "DELETE") return await handleDeleteDoc(id, req);
-        return errorResponse(400, "USAGE", `unsupported method ${req.method} for a doc route`);
-      }
-      if (rest.startsWith("reserved/")) {
-        const name = rest.slice("reserved/".length);
+  return registeredWireRouter(async (req, { endpoint, match, searchParams }) => {
+    switch (endpoint.id) {
+      case "capabilities":
+        return handleCapabilities();
+      case "docs-list":
+        return await handleList(searchParams);
+      case "docs-read-many":
+        return await handleReadMany(req);
+      case "doc-versions":
+        return await handleVersions(decodeId(match.value));
+      case "doc-read":
+        return await handleReadDoc(decodeId(match.value));
+      case "doc-write":
+        return await handleWriteDoc(decodeId(match.value), req);
+      case "doc-head":
+        return await handleHeadDoc(decodeId(match.value));
+      case "doc-delete":
+        return await handleDeleteDoc(decodeId(match.value), req);
+      case "reserved-read":
+      case "reserved-write": {
+        const name = match.value;
         if (name !== "index.md" && name !== "log.md") {
           return errorResponse(400, "USAGE", `reserved file name must be index.md or log.md, got '${name}'`);
         }
-        const dir = url2.searchParams.get("dir") ?? "";
-        if (req.method === "GET") return await handleReadReserved(dir, name);
-        if (req.method === "PUT") return await handleWriteReserved(dir, name, req);
-        return errorResponse(400, "USAGE", `unsupported method ${req.method} for a reserved-file route`);
-      }
-      if (rest === "blobs") {
-        if (req.method === "GET") return await handleListBlobs(url2);
-        return errorResponse(400, "USAGE", `unsupported method ${req.method} for /blobs`);
-      }
-      if (rest.startsWith("blobs/")) {
-        const key = decodeBlobKey(rest.slice("blobs/".length));
-        if (req.method === "GET") return await handleReadBlob(key);
-        if (req.method === "PUT") return await handleWriteBlob(key, req);
-        if (req.method === "HEAD") return await handleHeadBlob(key);
-        if (req.method === "DELETE") return await handleDeleteBlob(key, req);
-        return errorResponse(400, "USAGE", `unsupported method ${req.method} for a blob route`);
+        const dir = searchParams.get("dir") ?? "";
+        return endpoint.id === "reserved-read" ? await handleReadReserved(dir, name) : await handleWriteReserved(dir, name, req);
       }
-      return errorResponse(404, "NOT_FOUND", `no route for ${url2.pathname}`);
-    } catch (err) {
-      return errorFromCaught(err);
+      case "blobs-list":
+        return await handleListBlobs(searchParams);
+      case "blob-read":
+        return await handleReadBlob(decodeBlobKey(match.value));
+      case "blob-write":
+        return await handleWriteBlob(decodeBlobKey(match.value), req);
+      case "blob-head":
+        return await handleHeadBlob(decodeBlobKey(match.value));
+      case "blob-delete":
+        return await handleDeleteBlob(decodeBlobKey(match.value), req);
     }
-  };
+  });
 }
-var DEFAULT_LIST_LIMIT, BUNDLE_PATH_RE;
+var DEFAULT_LIST_LIMIT, BUNDLE_PATH_RE, WIRE_ENDPOINTS;
 var init_router = __esm({
   "../server/src/router.ts"() {
     "use strict";
@@ -55625,6 +56037,48 @@ var init_router = __esm({
     init_src();
     DEFAULT_LIST_LIMIT = 50;
     BUNDLE_PATH_RE = /^\/v0\/bundles\/([^/]+)\/(.*)$/;
+    WIRE_ENDPOINTS = [
+      { id: "capabilities", resource: "capabilities", method: "GET", path: "/v0/capabilities" },
+      { id: "docs-list", resource: "docs", method: "GET", path: "/v0/bundles/{bundle}/docs" },
+      {
+        id: "docs-read-many",
+        resource: "docs-read-many",
+        method: "POST",
+        path: "/v0/bundles/{bundle}/docs:read-many"
+      },
+      { id: "doc-read", resource: "doc", method: "GET", path: "/v0/bundles/{bundle}/docs/{id...}" },
+      { id: "doc-write", resource: "doc", method: "PUT", path: "/v0/bundles/{bundle}/docs/{id...}" },
+      { id: "doc-head", resource: "doc", method: "HEAD", path: "/v0/bundles/{bundle}/docs/{id...}" },
+      { id: "doc-delete", resource: "doc", method: "DELETE", path: "/v0/bundles/{bundle}/docs/{id...}" },
+      {
+        id: "doc-versions",
+        resource: "doc-versions",
+        method: "GET",
+        path: "/v0/bundles/{bundle}/docs/{id...}/versions"
+      },
+      {
+        id: "reserved-read",
+        resource: "reserved",
+        method: "GET",
+        path: "/v0/bundles/{bundle}/reserved/{name}"
+      },
+      {
+        id: "reserved-write",
+        resource: "reserved",
+        method: "PUT",
+        path: "/v0/bundles/{bundle}/reserved/{name}"
+      },
+      { id: "blobs-list", resource: "blobs", method: "GET", path: "/v0/bundles/{bundle}/blobs" },
+      { id: "blob-read", resource: "blob", method: "GET", path: "/v0/bundles/{bundle}/blobs/{key...}" },
+      { id: "blob-write", resource: "blob", method: "PUT", path: "/v0/bundles/{bundle}/blobs/{key...}" },
+      { id: "blob-head", resource: "blob", method: "HEAD", path: "/v0/bundles/{bundle}/blobs/{key...}" },
+      {
+        id: "blob-delete",
+        resource: "blob",
+        method: "DELETE",
+        path: "/v0/bundles/{bundle}/blobs/{key...}"
+      }
+    ];
   }
 });
 
@@ -58373,7 +58827,7 @@ var init_src6 = __esm({
 });
 
 // src/bundle-name.ts
-import path18 from "node:path";
+import path19 from "node:path";
 function nonEmptyString3(value) {
   if (typeof value !== "string") return void 0;
   const trimmed = value.trim();
@@ -58388,9 +58842,9 @@ async function deriveBundleDisplayName(bundle) {
     }
   } catch {
   }
-  const base = path18.basename(bundle.root);
+  const base = path19.basename(bundle.root);
   if (base === CONVENTIONAL_BUNDLE_DIR_NAME || base === LEGACY_CONVENTIONAL_BUNDLE_DIR_NAME) {
-    const parent = path18.basename(path18.dirname(bundle.root));
+    const parent = path19.basename(path19.dirname(bundle.root));
     if (parent) return { name: parent, source: "conventional-parent" };
   }
   return { name: base || FALLBACK_NAME, source: "root-basename" };
@@ -58443,15 +58897,15 @@ var init_assets2 = __esm({
 import { randomUUID as randomUUID3 } from "node:crypto";
 import { open as open2, readFile as readFile3, stat as stat2, unlink as unlink2 } from "node:fs/promises";
 import { homedir as homedir10 } from "node:os";
-import path19 from "node:path";
+import path20 from "node:path";
 function catalogDir(home2) {
   return credentialsDir(home2);
 }
 function catalogPath(home2 = homedir10()) {
-  return path19.join(catalogDir(home2), CATALOG_FILE_NAME);
+  return path20.join(catalogDir(home2), CATALOG_FILE_NAME);
 }
 function catalogLockPath(home2 = homedir10()) {
-  return path19.join(catalogDir(home2), CATALOG_LOCK_FILE_NAME);
+  return path20.join(catalogDir(home2), CATALOG_LOCK_FILE_NAME);
 }
 function isObject2(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
@@ -58491,7 +58945,7 @@ function validateEntry(value, file2, index2) {
   if (value.locator.kind !== "local-path") {
     throw invalidCatalog(file2, `entries[${index2}].locator.kind must be "local-path"`);
   }
-  if (typeof value.locator.path !== "string" || !path19.isAbsolute(value.locator.path) || path19.normalize(value.locator.path) !== value.locator.path) {
+  if (typeof value.locator.path !== "string" || !path20.isAbsolute(value.locator.path) || path20.normalize(value.locator.path) !== value.locator.path) {
     throw invalidCatalog(file2, `entries[${index2}].locator.path must be a normalized absolute path`);
   }
   return {
@@ -58668,7 +59122,7 @@ function generatedId(options2, existing) {
 }
 async function addCatalogEntry(label, canonicalPath, options2 = {}) {
   assertCatalogLabel(label);
-  if (!path19.isAbsolute(canonicalPath)) throw new CliError("USAGE", "workspace catalog paths must be absolute");
+  if (!path20.isAbsolute(canonicalPath)) throw new CliError("USAGE", "workspace catalog paths must be absolute");
   const result3 = await mutateCatalog(async (current) => {
     const target = await resolveLocalBundleTarget(canonicalPath);
     if (target.canonicalRoot !== canonicalPath) {
@@ -58771,7 +59225,7 @@ var init_catalog2 = __esm({
 });
 
 // src/ui/sharing.ts
-import path20 from "node:path";
+import path21 from "node:path";
 import { realpathSync as realpathSync10 } from "node:fs";
 function realOr(p2) {
   try {
@@ -58810,13 +59264,13 @@ function classifySharing(bundleRoot, now = () => /* @__PURE__ */ new Date()) {
   const asOf = now().toISOString();
   try {
     const root = realOr(bundleRoot);
-    const repo = probeRepoTopLevel(path20.dirname(root));
+    const repo = probeRepoTopLevel(path21.dirname(root));
     if (repo.kind === "not_repo") return { kind: "private", as_of: asOf };
     if (repo.kind === "unavailable") return { kind: "unavailable", reason: repo.reason, as_of: asOf };
     const top = repo.top;
     const committed = committedBundleAtHead(top);
     const bundleDir = committed?.bundleDir ?? bundleDirNameForProject(top);
-    if (realOr(path20.join(top, bundleDir)) !== root) return { kind: "unscoped", as_of: asOf };
+    if (realOr(path21.join(top, bundleDir)) !== root) return { kind: "unscoped", as_of: asOf };
     const evidence = localEvidence(top, committed !== null);
     const branchMode = hasWorktreeSignature(root) && worktreeRootResolvesForOwner(root, top) || !evidence.tracked && localBranchExists(top, BOARD_BRANCH);
     if (branchMode) {
@@ -58898,7 +59352,7 @@ var init_sharing = __esm({
 });
 
 // src/ui/view-authorizations.ts
-import { createHash as createHash5 } from "node:crypto";
+import { createHash as createHash6 } from "node:crypto";
 import { homedir as homedir11 } from "node:os";
 import { join as join9 } from "node:path";
 function stableRecord(bundle, subject) {
@@ -58948,12 +59402,12 @@ function assertMigratableViewAuthorization(name, raw) {
   }
   const canonical = JSON.stringify(value);
   if (raw !== `${canonical}
-` || name !== `${createHash5("sha256").update(canonical).digest("hex")}.json`) {
+` || name !== `${createHash6("sha256").update(canonical).digest("hex")}.json`) {
     throw new Error("legacy View authorization does not match its immutable identity");
   }
 }
 function fileName(bundle, subject) {
-  return `${createHash5("sha256").update(serialized(bundle, subject)).digest("hex")}.json`;
+  return `${createHash6("sha256").update(serialized(bundle, subject)).digest("hex")}.json`;
 }
 var STORE_DIR, LocalViewAuthorizationStore;
 var init_view_authorizations = __esm({
@@ -59592,7 +60046,7 @@ Options:
 // src/commands/pull.ts
 import { parseArgs as parseArgs9 } from "node:util";
 import { promises as fs7 } from "node:fs";
-import path21 from "node:path";
+import path22 from "node:path";
 function isDocRouteKey2(key) {
   return key.toLowerCase().endsWith(".md");
 }
@@ -59683,7 +60137,7 @@ async function pull(argv2, deps = {}) {
       help: `${cliInvocation()} pull --doc-key ${key} --out <path>`
     });
   }
-  if (out !== "-") assertPathOutsidePrivateState(path21.resolve(out));
+  if (out !== "-") assertPathOutsidePrivateState(path22.resolve(out));
   const bundle = await openBundle(values.dir, await resolveRemoteFlag(values.remote, values.dir));
   const mode = resolveMode(values);
   const streamMode = out === "-";
@@ -63055,8 +63509,8 @@ var init_parseUtil = __esm({
     init_errors5();
     init_en();
     makeIssue = (params) => {
-      const { data, path: path28, errorMaps, issueData } = params;
-      const fullPath = [...path28, ...issueData.path || []];
+      const { data, path: path29, errorMaps, issueData } = params;
+      const fullPath = [...path29, ...issueData.path || []];
       const fullIssue = {
         ...issueData,
         path: fullPath
@@ -63342,11 +63796,11 @@ var init_types = __esm({
     init_parseUtil();
     init_util();
     ParseInputLazyPath = class {
-      constructor(parent, value, path28, key) {
+      constructor(parent, value, path29, key) {
         this._cachedPath = [];
         this.parent = parent;
         this.data = value;
-        this._path = path28;
+        this._path = path29;
         this._key = key;
       }
       get path() {
@@ -66852,10 +67306,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path28) {
-  if (!path28)
+function getElementAtPath(obj, path29) {
+  if (!path29)
     return obj;
-  return path28.reduce((acc, key) => acc?.[key], obj);
+  return path29.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -67183,11 +67637,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path28, issues) {
+function prefixIssues(path29, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path28);
+    iss.path.unshift(path29);
     return iss;
   });
 }
@@ -67406,16 +67860,16 @@ function flattenError(error51, mapper = (issue2) => issue2.message) {
 }
 function formatError(error51, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error52, path28 = []) => {
+  const processError = (error52, path29 = []) => {
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path28, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path29, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path28, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path29, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path28, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path29, ...issue2.path]);
       } else {
-        const fullpath = [...path28, ...issue2.path];
+        const fullpath = [...path29, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -67442,17 +67896,17 @@ function formatError(error51, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error51, mapper = (issue2) => issue2.message) {
   const result3 = { errors: [] };
-  const processError = (error52, path28 = []) => {
+  const processError = (error52, path29 = []) => {
     var _a3, _b;
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path28, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path29, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path28, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path29, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path28, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path29, ...issue2.path]);
       } else {
-        const fullpath = [...path28, ...issue2.path];
+        const fullpath = [...path29, ...issue2.path];
         if (fullpath.length === 0) {
           result3.errors.push(mapper(issue2));
           continue;
@@ -67484,8 +67938,8 @@ function treeifyError(error51, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path28 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path28) {
+  const path29 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path29) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -81327,13 +81781,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path28 = ref.slice(1).split("/").filter(Boolean);
-  if (path28.length === 0) {
+  const path29 = ref.slice(1).split("/").filter(Boolean);
+  if (path29.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path28[0] === defsKey) {
-    const key = path28[1];
+  if (path29[0] === defsKey) {
+    const key = path29[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -89904,8 +90358,8 @@ var require_utils2 = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path28) {
-      let input = path28;
+    function removeDotSegments(path29) {
+      let input = path29;
       const output = [];
       let nextSlash = -1;
       let len = 0;
@@ -90159,8 +90613,8 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path28, query2] = wsComponent.resourceName.split("?");
-        wsComponent.path = path28 && path28 !== "/" ? path28 : void 0;
+        const [path29, query2] = wsComponent.resourceName.split("?");
+        wsComponent.path = path29 && path29 !== "/" ? path29 : void 0;
         wsComponent.query = query2;
         wsComponent.resourceName = void 0;
       }
@@ -97566,12 +98020,12 @@ function parseTree(text4, errors = [], options2 = ParseOptions.DEFAULT) {
   }
   return result3;
 }
-function findNodeAtLocation(root, path28) {
+function findNodeAtLocation(root, path29) {
   if (!root) {
     return void 0;
   }
   let node2 = root;
-  for (let segment of path28) {
+  for (let segment of path29) {
     if (typeof segment === "string") {
       if (node2.type !== "object" || !Array.isArray(node2.children)) {
         return void 0;
@@ -97961,14 +98415,14 @@ var init_parser = __esm({
 
 // ../../node_modules/jsonc-parser/lib/esm/impl/edit.js
 function setProperty(text4, originalPath, value, options2) {
-  const path28 = originalPath.slice();
+  const path29 = originalPath.slice();
   const errors = [];
   const root = parseTree(text4, errors);
   let parent = void 0;
   let lastSegment = void 0;
-  while (path28.length > 0) {
-    lastSegment = path28.pop();
-    parent = findNodeAtLocation(root, path28);
+  while (path29.length > 0) {
+    lastSegment = path29.pop();
+    parent = findNodeAtLocation(root, path29);
     if (parent === void 0 && value !== void 0) {
       if (typeof lastSegment === "string") {
         value = { [lastSegment]: value };
@@ -98113,8 +98567,8 @@ var init_edit = __esm({
 });
 
 // ../../node_modules/jsonc-parser/lib/esm/main.js
-function modify(text4, path28, value, options2) {
-  return setProperty(text4, path28, value, options2);
+function modify(text4, path29, value, options2) {
+  return setProperty(text4, path29, value, options2);
 }
 function applyEdits(text4, edits) {
   let sortedEdits = edits.slice(0).sort((a, b) => {
@@ -98598,8 +99052,8 @@ function environment(deps) {
 }
 function inspectMcpHost(target, deps = {}) {
   const input = environment(deps);
-  const path28 = resolveMcpTargetConfigPath(target.id, input);
-  if (!path28) {
+  const path29 = resolveMcpTargetConfigPath(target.id, input);
+  if (!path29) {
     return {
       host: target.id,
       label: target.label,
@@ -98610,7 +99064,7 @@ function inspectMcpHost(target, deps = {}) {
     };
   }
   const authority = deps.authority?.() ?? resolvePersistentInstallAuthority({ env: input.env, platform: input.platform });
-  let reportedPath = path28;
+  let reportedPath = path29;
   try {
     let entries;
     if (target.id === "codex") {
@@ -98625,7 +99079,7 @@ function inspectMcpHost(target, deps = {}) {
       }));
     } else {
       const read = deps.readFile ?? ((candidate) => readFileSync6(candidate, "utf8"));
-      const candidates = target.id === "opencode" ? openCodeConfigCandidates(input) : [path28];
+      const candidates = target.id === "opencode" ? openCodeConfigCandidates(input) : [path29];
       const sources = [];
       for (const candidate of candidates) {
         try {
@@ -98759,26 +99213,26 @@ import { dirname as dirname4 } from "node:path";
 function missing(error51) {
   return typeof error51 === "object" && error51 !== null && "code" in error51 && error51.code === "ENOENT";
 }
-function resolveWriteDestination(path28, followFinalSymlink) {
+function resolveWriteDestination(path29, followFinalSymlink) {
   let isLink = false;
   try {
-    isLink = lstatSync4(path28).isSymbolicLink();
+    isLink = lstatSync4(path29).isSymbolicLink();
   } catch (error51) {
-    if (missing(error51)) return path28;
+    if (missing(error51)) return path29;
     throw error51;
   }
-  if (!isLink) return path28;
+  if (!isLink) return path29;
   if (!followFinalSymlink) {
-    throw new Error(`symlink at ${path28} \u2014 refusing to replace a generated plugin through a link`);
+    throw new Error(`symlink at ${path29} \u2014 refusing to replace a generated plugin through a link`);
   }
   try {
-    return realpathSync12(path28);
+    return realpathSync12(path29);
   } catch {
-    throw new Error(`dangling symlink at ${path28} \u2014 refusing to write through it; fix or remove the link`);
+    throw new Error(`dangling symlink at ${path29} \u2014 refusing to write through it; fix or remove the link`);
   }
 }
-function capturePrivateConfigParent(path28) {
-  let current = dirname4(path28);
+function capturePrivateConfigParent(path29) {
+  let current = dirname4(path29);
   while (true) {
     try {
       return { path: current, destination: realpathSync12(current) };
@@ -98790,18 +99244,18 @@ function capturePrivateConfigParent(path28) {
     }
   }
 }
-function atomicWriteFileSync(path28, content3, options2 = {}) {
-  const destination = resolveWriteDestination(path28, options2.followFinalSymlink ?? true);
+function atomicWriteFileSync(path29, content3, options2 = {}) {
+  const destination = resolveWriteDestination(path29, options2.followFinalSymlink ?? true);
   if (options2.expected) {
     if (options2.expected.parent) {
-      const currentParent = capturePrivateConfigParent(path28);
+      const currentParent = capturePrivateConfigParent(path29);
       if (currentParent.path !== options2.expected.parent.path || currentParent.destination !== options2.expected.parent.destination) {
         throw new Error("private configuration parent changed after inspection");
       }
     }
     let currentDestination;
     try {
-      currentDestination = realpathSync12(path28);
+      currentDestination = realpathSync12(path29);
     } catch (error51) {
       if (!missing(error51)) throw error51;
       currentDestination = null;
@@ -98870,7 +99324,7 @@ function defaultEnvironment() {
 function isMissing(error51) {
   return isRecord8(error51) && own4(error51, "code") === "ENOENT";
 }
-function resolvedPath(path28, deps) {
+function resolvedPath(path29, deps) {
   const resolve2 = deps.realpath ?? ((candidate) => {
     try {
       return realpathSync13(candidate);
@@ -98879,11 +99333,11 @@ function resolvedPath(path28, deps) {
       throw error51;
     }
   });
-  return resolve2(path28);
+  return resolve2(path29);
 }
-function readOptional(path28, read) {
+function readOptional(path29, read) {
   try {
-    return read(path28);
+    return read(path29);
   } catch (error51) {
     if (isMissing(error51)) return void 0;
     throw error51;
@@ -98933,8 +99387,8 @@ function selectedSources(sources) {
 }
 function inspectTarget(target, deps) {
   const input = deps.environment ?? defaultEnvironment();
-  const path28 = resolveMcpTargetConfigPath(target.id, input);
-  if (!path28) {
+  const path29 = resolveMcpTargetConfigPath(target.id, input);
+  if (!path29) {
     throw new McpRegistrationError(`no supported ${target.label} local-config path on ${input.platform}`, {
       host: target.id
     }, [target.docs_url], "usage");
@@ -98950,20 +99404,20 @@ function inspectTarget(target, deps) {
         host: target.id
       }, [target.docs_url], "runtime");
     }
-    return { entries, selected: selectMcpRegistration(entries), config: collapseHomeDirectory(path28) };
+    return { entries, selected: selectMcpRegistration(entries), config: collapseHomeDirectory(path29) };
   }
   if (target.id !== "opencode") {
-    const text4 = readOptional(path28, read);
+    const text4 = readOptional(path29, read);
     const entries = text4 === void 0 ? [] : parseClaudeMcpEntries(text4, target.id);
     return {
       entries,
       selected: selectMcpRegistration(entries),
-      config: collapseHomeDirectory(path28),
-      sourcePath: path28,
+      config: collapseHomeDirectory(path29),
+      sourcePath: path29,
       sourceText: text4 ?? "{}\n",
       sourceExists: text4 !== void 0,
-      sourceDestination: text4 === void 0 ? null : resolvedPath(path28, deps) ?? null,
-      sourceParent: capturePrivateConfigParent(path28)
+      sourceDestination: text4 === void 0 ? null : resolvedPath(path29, deps) ?? null,
+      sourceParent: capturePrivateConfigParent(path29)
     };
   }
   if (input.env.OPENCODE_CONFIG_CONTENT?.trim()) {
@@ -99006,7 +99460,7 @@ function inspectTarget(target, deps) {
           configs: standard.map((candidate) => collapseHomeDirectory(candidate.path))
         });
       }
-      source = standard[0] ?? { path: path28, text: "{}\n", entries: [], destination: null, exists: false };
+      source = standard[0] ?? { path: path29, text: "{}\n", entries: [], destination: null, exists: false };
     }
   }
   const root = parseMcpConfigRoot(source.text);
@@ -99063,8 +99517,8 @@ function inspectForMutation(target, deps) {
     }, [target.docs_url], "runtime");
   }
 }
-function editJsonc(text4, path28, value) {
-  const edits = modify(text4, [...path28], value, {
+function editJsonc(text4, path29, value) {
+  const edits = modify(text4, [...path29], value, {
     formattingOptions: { insertSpaces: true, tabSize: 2, eol: "\n" }
   });
   const next = applyEdits(text4, edits);
@@ -99144,7 +99598,7 @@ function applyTarget(target, operation, desired, before, deps) {
   if (!before.sourcePath || before.sourceText === void 0) {
     throw new McpRegistrationError(`no writable ${target.label} configuration source was resolved`);
   }
-  let path28;
+  let path29;
   let value;
   if (target.id === "claude-desktop") {
     const root = parseMcpConfigRoot(before.sourceText);
@@ -99152,14 +99606,14 @@ function applyTarget(target, operation, desired, before, deps) {
     if (servers !== void 0 && !isRecord8(servers)) {
       throw new McpRegistrationError("Claude Desktop mcpServers is not an object");
     }
-    path28 = ["mcpServers", CURRENT_MCP_REGISTRATION];
+    path29 = ["mcpServers", CURRENT_MCP_REGISTRATION];
     value = operation === "install" ? { command: desired.command, args: desired.args } : void 0;
   } else {
-    path28 = before.openCodePath ?? ["mcp", CURRENT_MCP_REGISTRATION];
-    const v2 = path28[1] === "servers";
+    path29 = before.openCodePath ?? ["mcp", CURRENT_MCP_REGISTRATION];
+    const v2 = path29[1] === "servers";
     value = operation === "install" ? v2 ? { type: "local", command: [desired.command, ...desired.args], disabled: false } : { type: "local", command: [desired.command, ...desired.args], enabled: true } : void 0;
   }
-  const next = editJsonc(before.sourceText, path28, value);
+  const next = editJsonc(before.sourceText, path29, value);
   const write = deps.writeFile ?? ((candidate, content3) => atomicWriteFileSync(candidate, content3, {
     expected: {
       destination: before.sourceDestination ?? null,
@@ -100036,10 +100490,10 @@ function targetSets(bases, deps) {
   const env = deps.env ?? process.env;
   return [targetsForBase(cwd), globalHookTargets(home2, env)];
 }
-function readSettings(path28) {
-  if (!existsSync6(path28)) return {};
+function readSettings(path29) {
+  if (!existsSync6(path29)) return {};
   try {
-    return JSON.parse(readFileSync9(path28, "utf8"));
+    return JSON.parse(readFileSync9(path29, "utf8"));
   } catch {
     return {};
   }
@@ -100047,11 +100501,11 @@ function readSettings(path28) {
 function isPlainObject5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function readSettingsForInstall(path28) {
-  if (!existsSync6(path28)) return { ok: true, settings: {} };
+function readSettingsForInstall(path29) {
+  if (!existsSync6(path29)) return { ok: true, settings: {} };
   let raw;
   try {
-    raw = readFileSync9(path28, "utf8");
+    raw = readFileSync9(path29, "utf8");
   } catch (err) {
     return { ok: false, reason: `unreadable (${err instanceof Error ? err.message : String(err)})` };
   }
@@ -100102,8 +100556,8 @@ function readSettingsForInstall(path28) {
   }
   return { ok: true, settings: parsed };
 }
-function writeSettings(path28, settings) {
-  atomicWriteFileSync(path28, `${JSON.stringify(settings, null, 2)}
+function writeSettings(path29, settings) {
+  atomicWriteFileSync(path29, `${JSON.stringify(settings, null, 2)}
 `);
 }
 function buildOpenCodePluginTemplate(options2) {
@@ -100254,10 +100708,10 @@ function generatedConstant(source, name) {
     return void 0;
   }
 }
-function readOpenCodeHookStatus(path28, expectedSource) {
+function readOpenCodeHookStatus(path29, expectedSource) {
   let entry;
   try {
-    entry = lstatSync5(path28);
+    entry = lstatSync5(path29);
   } catch {
     return { installed: false, compatibility: { state: "absent", reason: "plugin file is absent" } };
   }
@@ -100275,7 +100729,7 @@ function readOpenCodeHookStatus(path28, expectedSource) {
   }
   let source;
   try {
-    source = readFileSync9(path28, "utf8");
+    source = readFileSync9(path29, "utf8");
   } catch {
     return { installed: false, compatibility: { state: "unmanaged", reason: "plugin file is unreadable" } };
   }
@@ -100363,60 +100817,60 @@ function readOpenCodeTargetsStatus(targets, expectedSource) {
   }
   return canonical;
 }
-function openCodeClaimPath(path28) {
-  return `${path28}.claim-${process.pid}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+function openCodeClaimPath(path29) {
+  return `${path29}.claim-${process.pid}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
 }
-function restoreOpenCodeClaim(claim, path28) {
+function restoreOpenCodeClaim(claim, path29) {
   try {
     const entry = lstatSync5(claim);
-    if (entry.isSymbolicLink()) symlinkSync(readlinkSync3(claim), path28);
-    else if (entry.isFile()) linkSync3(claim, path28);
+    if (entry.isSymbolicLink()) symlinkSync(readlinkSync3(claim), path29);
+    else if (entry.isFile()) linkSync3(claim, path29);
     else throw new Error("claimed entry is not a regular file or symlink");
   } catch (error51) {
     throw new Error(`OpenCode plugin changed during migration; recovery copy retained at ${collapseHomeDirectory(claim)}`, { cause: error51 });
   }
   rmSync3(claim, { force: true });
 }
-function claimOwnedOpenCodePlugin(path28) {
-  const inspected = readOpenCodeHookStatus(path28);
+function claimOwnedOpenCodePlugin(path29) {
+  const inspected = readOpenCodeHookStatus(path29);
   if (!inspected.installed) return void 0;
-  const claim = openCodeClaimPath(path28);
+  const claim = openCodeClaimPath(path29);
   try {
-    renameSync5(path28, claim);
+    renameSync5(path29, claim);
   } catch (error51) {
     throw new Error("OpenCode plugin changed after inspection; nothing was removed", { cause: error51 });
   }
   const claimed = readOpenCodeHookStatus(claim);
   if (!claimed.installed) {
-    restoreOpenCodeClaim(claim, path28);
+    restoreOpenCodeClaim(claim, path29);
     throw new Error("OpenCode plugin changed after inspection; the changed bytes were preserved");
   }
   return claim;
 }
-function removeOwnedOpenCodePlugin(path28) {
-  const claim = claimOwnedOpenCodePlugin(path28);
+function removeOwnedOpenCodePlugin(path29) {
+  const claim = claimOwnedOpenCodePlugin(path29);
   if (claim === void 0) return false;
   rmSync3(claim, { force: true });
   return true;
 }
-function installOpenCodePlugin(path28, next) {
-  const inspected = readOpenCodeHookStatus(path28, next);
+function installOpenCodePlugin(path29, next) {
+  const inspected = readOpenCodeHookStatus(path29, next);
   if (inspected.compatibility.state === "unmanaged") {
     throw new Error("refusing to overwrite unmanaged OpenCode plugin");
   }
   if (inspected.compatibility.state === "current") return false;
-  const claim = inspected.installed ? claimOwnedOpenCodePlugin(path28) : void 0;
+  const claim = inspected.installed ? claimOwnedOpenCodePlugin(path29) : void 0;
   try {
-    atomicWriteFileSync(path28, next, {
+    atomicWriteFileSync(path29, next, {
       followFinalSymlink: false,
       expected: {
         destination: null,
         content: null,
-        parent: capturePrivateConfigParent(path28)
+        parent: capturePrivateConfigParent(path29)
       }
     });
   } catch (error51) {
-    if (claim !== void 0) restoreOpenCodeClaim(claim, path28);
+    if (claim !== void 0) restoreOpenCodeClaim(claim, path29);
     throw error51;
   }
   if (claim !== void 0) rmSync3(claim, { force: true });
@@ -100456,9 +100910,9 @@ function inspectHookStatus(scope, deps = {}) {
   } catch {
     expectedLaunch = void 0;
   }
-  const inspectSettingsTarget = (path28) => {
-    const status2 = readHookCompatibilityStatus(readSettings(path28));
-    const preflight = readSettingsForInstall(path28);
+  const inspectSettingsTarget = (path29) => {
+    const status2 = readHookCompatibilityStatus(readSettings(path29));
+    const preflight = readSettingsForInstall(path29);
     if (!preflight.ok) {
       return { ...status2, installSafe: false };
     }
@@ -100673,19 +101127,19 @@ async function hook(argv2, deps = {}) {
   }
   let changed = false;
   const notes = [];
-  for (const path28 of [targets.claudeSettings, targets.codexHooks]) {
-    const [updated, didChange] = computeHookUninstall(readSettings(path28));
+  for (const path29 of [targets.claudeSettings, targets.codexHooks]) {
+    const [updated, didChange] = computeHookUninstall(readSettings(path29));
     if (didChange) {
-      writeSettings(path28, updated);
+      writeSettings(path29, updated);
       changed = true;
     }
   }
-  for (const path28 of [targets.opencodePlugin, targets.legacyOpencodePlugin]) {
-    const openCodeStatus = readOpenCodeHookStatus(path28);
+  for (const path29 of [targets.opencodePlugin, targets.legacyOpencodePlugin]) {
+    const openCodeStatus = readOpenCodeHookStatus(path29);
     if (openCodeStatus.installed) {
-      changed = removeOwnedOpenCodePlugin(path28) || changed;
+      changed = removeOwnedOpenCodePlugin(path29) || changed;
     } else if (openCodeStatus.compatibility.state === "unmanaged") {
-      notes.push(`preserved unmanaged OpenCode plugin: ${collapseHomeDirectory(path28)}`);
+      notes.push(`preserved unmanaged OpenCode plugin: ${collapseHomeDirectory(path29)}`);
     }
   }
   stdout(
@@ -100784,7 +101238,7 @@ var init_sync_cli = __esm({
 });
 
 // src/sync-outcomes.ts
-import path22 from "node:path";
+import path23 from "node:path";
 function upstreamHelp(inv) {
   return `if a teammate already shares this project's board, make sure your \`origin\` remote points at the SAME repository they pushed the \`board\` branch to; if nobody has started sharing this project's board yet, run \`${inv} sync --establish\` to start \u2014 until then a local-only board is a supported mode: every local command keeps working, and nothing leaves this machine`;
 }
@@ -100962,7 +101416,7 @@ var init_sync_outcomes = __esm({
       // The in-tree board's write refusal + the viewer's no-comparison-basis refusal.
       "in-tree.sync-refusal": row({
         code: "USAGE",
-        message: (p2) => syncInTreeRefusalMessage(p2.inv, p2.hasOrigin, path22.basename(p2.boardPath)),
+        message: (p2) => syncInTreeRefusalMessage(p2.inv, p2.hasOrigin, path23.basename(p2.boardPath)),
         details: (p2) => ({ path: p2.boardPath, state: "in-tree" }),
         help: (p2) => p2.hasOrigin ? `${p2.inv} sync --establish` : `git remote add ${BOARD_REMOTE} <url>`
       }),
@@ -101422,7 +101876,7 @@ var init_establish_committed = __esm({
 
 // src/commands/sync/establish.ts
 import { existsSync as existsSync7, lstatSync as lstatSync6, readdirSync as readdirSync2, renameSync as renameSync6, rmSync as rmSync4 } from "node:fs";
-import path23 from "node:path";
+import path24 from "node:path";
 function establishNextSteps(inv) {
   return [
     `teammates just run '${inv} sync' \u2014 it provisions automatically`,
@@ -101430,7 +101884,7 @@ function establishNextSteps(inv) {
   ];
 }
 function assertPlainBundleShape(bundlePath, inv) {
-  const bundleDir = path23.basename(bundlePath);
+  const bundleDir = path24.basename(bundlePath);
   const runInitHelp = `${inv} init --create-only --dir ${BUNDLE_DIR}`;
   if (!existsSync7(bundlePath)) {
     throw new CliError(
@@ -101446,7 +101900,7 @@ function assertPlainBundleShape(bundlePath, inv) {
       `'${bundlePath}' must be a real, plain directory \u2014 symlinks and non-directories are never followed by establish`
     );
   }
-  if (existsSync7(path23.join(bundlePath, ".git"))) {
+  if (existsSync7(path24.join(bundlePath, ".git"))) {
     throw new CliError(
       "RUNTIME",
       `'${bundlePath}' already contains its own '.git' \u2014 establish only operates on a plain bundle folder`
@@ -101457,7 +101911,7 @@ function assertPlainBundleShape(bundlePath, inv) {
       help: runInitHelp
     });
   }
-  const indexPath = path23.join(bundlePath, "index.md");
+  const indexPath = path24.join(bundlePath, "index.md");
   if (!existsSync7(indexPath)) {
     throw new CliError(
       "RUNTIME",
@@ -101471,7 +101925,7 @@ function assertPlainBundleShape(bundlePath, inv) {
   }
 }
 function assertFreshSource(top, boardPath, inv) {
-  const bundleDir = path23.basename(boardPath);
+  const bundleDir = path24.basename(boardPath);
   assertPlainBundleShape(boardPath, inv);
   if (folderPresentInCodeIndex(top)) {
     throw new CliError(
@@ -101484,11 +101938,11 @@ function assertFreshSource(top, boardPath, inv) {
 async function assertNotBoundElsewhere(top, boardPath) {
   const binding = await resolveProjectBinding(top);
   if (!binding) return;
-  const boundIsConventional = path23.resolve(binding.target) === boardPath;
+  const boundIsConventional = path24.resolve(binding.target) === boardPath;
   if (boundIsConventional) return;
   throw new CliError(
     "RUNTIME",
-    `a project binding (${binding.file}) points this project's bundle out of the git-sync tier (the selected conventional path is '${path23.basename(boardPath)}/')`,
+    `a project binding (${binding.file}) points this project's bundle out of the git-sync tier (the selected conventional path is '${path24.basename(boardPath)}/')`,
     { help: `fix or remove ${binding.file} if you want to share this bundle over the board branch` }
   );
 }
@@ -101509,7 +101963,7 @@ function removeVerifiedBackup(top, backupPath, expectedCommit, inv) {
   rmSync4(backupPath, { recursive: true, force: false });
 }
 function finishLocalConversion(top, sourcePath, publishedCommit, expectedTree, inv) {
-  const boardPath = path23.join(top, bundleDirNameForProject(top));
+  const boardPath = path24.join(top, bundleDirNameForProject(top));
   const backupPath = `${boardPath}.establish-backup`;
   const remoteCommit = refCommit(top, `refs/remotes/${BOARD_REF}`);
   if (!remoteCommit || !isAncestor(top, publishedCommit, remoteCommit)) {
@@ -101597,7 +102051,7 @@ async function renderEstablished(top, conversion, snapshot2, inv, mode, stdout,
   return { already: false };
 }
 function readGreenfieldState(top) {
-  const boardPath = path23.join(top, bundleDirNameForProject(top));
+  const boardPath = path24.join(top, bundleDirNameForProject(top));
   return {
     boardPath,
     backupPath: `${boardPath}.establish-backup`,
@@ -101642,7 +102096,7 @@ async function publishLocalBoardBranch(top, boardPath, inv, mode, stdout, deps)
       throw new CliError("RUNTIME", "the local board branch could not be provisioned for explicit establishment");
     }
   }
-  const indexPath = path23.join(boardPath, "index.md");
+  const indexPath = path24.join(boardPath, "index.md");
   if (!existsSync7(indexPath) || lstatSync6(indexPath).isSymbolicLink() || !lstatSync6(indexPath).isFile()) {
     throw new CliError("RUNTIME", `the local '${BOARD_BRANCH}' worktree is not a valid bundle (root index.md missing)`);
   }
@@ -101715,7 +102169,7 @@ async function establishBoard(dir, inv, mode, stdout, deps, opts = {}) {
   }
   const committed = committedBundleAtHead(top);
   if (committed !== null) {
-    assertBundleOutsidePrivateState(path23.join(top, committed.bundleDir));
+    assertBundleOutsidePrivateState(path24.join(top, committed.bundleDir));
     return establishCommitted(top, inv, mode, Boolean(opts.yes), committed, stdout);
   }
   fetchOriginRequired(top);
@@ -101956,7 +102410,7 @@ var init_converge = __esm({
 
 // src/commands/sync/show-incoming.ts
 import { promises as fs8 } from "node:fs";
-import path24 from "node:path";
+import path25 from "node:path";
 function showIncomingInTreeNoBasis(inv, reason, ref) {
   return syncOutcomeError("in-tree.show-incoming.no-basis", { inv, reason, ref });
 }
@@ -101979,7 +102433,7 @@ async function showIncoming(id, values, deps, route) {
   const out = values.out?.trim();
   const streamMode = out === "-";
   const run = async () => {
-    if (out && !streamMode) assertPathOutsidePrivateState(path24.resolve(out));
+    if (out && !streamMode) assertPathOutsidePrivateState(path25.resolve(out));
     if (route?.kind === "bound-local") throw syncOutcomeError("show-incoming.no-upstream", { inv });
     if (route?.kind === "bound-board" && route.readiness !== "ready") {
       throw new CliError(
@@ -101987,7 +102441,7 @@ async function showIncoming(id, values, deps, route) {
         "the selected private board has a board-origin rebase pending; --show-incoming cannot recover it"
       );
     }
-    if (!route) assertSearchDirOutsidePrivateState(path24.resolve(values.dir ?? process.cwd()));
+    if (!route) assertSearchDirOutsidePrivateState(path25.resolve(values.dir ?? process.cwd()));
     const dir = route?.kind === "bound-board" ? route.owner.bundleRoot : retargetBoardInterior(values.dir ?? process.cwd());
     const top = repoTopLevel(dir);
     if (!top) {
@@ -101997,7 +102451,7 @@ async function showIncoming(id, values, deps, route) {
         { details: { state: "no-repo" } }
       );
     }
-    if (path24.isAbsolute(id) || id.split("/").some((seg) => seg === "..")) {
+    if (path25.isAbsolute(id) || id.split("/").some((seg) => seg === "..")) {
       throw new CliError("USAGE", `--show-incoming needs a repo-relative doc id or path without '..' segments: ${id}`);
     }
     let readRef = `refs/remotes/${BOARD_REF}`;
@@ -102185,7 +102639,7 @@ var init_bound_board_recovery = __esm({
 });
 
 // src/commands/sync/orchestrate.ts
-import path25 from "node:path";
+import path26 from "node:path";
 import { parseArgs as parseArgs23 } from "node:util";
 function syncLocalOnlyNote(inv) {
   return `a supported mode: every local command works, and your board changes stay on this machine (sync committed nothing). To share the board with teammates, run \`${inv} sync --establish\` \u2014 it publishes the board as a 'board' branch on the repo's 'origin' remote (add one first if the repo has none); teammates then just run sync.`;
@@ -102204,7 +102658,7 @@ async function syncInTree(run) {
   const top = repoTopLevel(run.dir);
   if (!top) throw new CliError("RUNTIME", "not inside a git repository");
   const bundleDir = committedBundleAtHead(top)?.bundleDir ?? bundleDirNameForProject(top);
-  const boardPath = path25.join(top, bundleDir);
+  const boardPath = path26.join(top, bundleDir);
   assertBundleOutsidePrivateState(boardPath);
   if (!run.pullOnly) {
     const hasOrigin = runGit(top, ["remote", "get-url", BOARD_REMOTE]).status === 0;
@@ -102311,7 +102765,7 @@ async function parseSyncInvocation(argv2, inv) {
     }
     limit = Number(raw);
   }
-  assertSearchDirOutsidePrivateState(path25.resolve(values.dir ?? process.cwd()));
+  assertSearchDirOutsidePrivateState(path26.resolve(values.dir ?? process.cwd()));
   let route;
   if (values.dir === void 0 && await resolveProjectBinding(process.cwd())) {
     route = await resolveLocalBundleRoute(void 0);
@@ -102488,7 +102942,7 @@ async function syncCommand(argv2, deps = {}) {
   const initialTop = repoTopLevel(run.dir);
   if (initialTop) {
     const initialBundleDir = committedBundleAtHead(initialTop)?.bundleDir ?? bundleDirNameForProject(initialTop);
-    assertBundleOutsidePrivateState(path25.join(initialTop, initialBundleDir));
+    assertBundleOutsidePrivateState(path26.join(initialTop, initialBundleDir));
   }
   let establishAlreadyNote;
   if (dispatch.establish) {
@@ -102936,7 +103390,7 @@ var init_skill_compatibility = __esm({
 });
 
 // src/commands/skill.ts
-import { createHash as createHash6 } from "node:crypto";
+import { createHash as createHash7 } from "node:crypto";
 import { existsSync as existsSync8, lstatSync as lstatSync7, readFileSync as readFileSync11, readdirSync as readdirSync3, renameSync as renameSync7, rmSync as rmSync5, rmdirSync as rmdirSync3 } from "node:fs";
 import { homedir as homedir16 } from "node:os";
 import { dirname as dirname5, join as join15 } from "node:path";
@@ -102976,7 +103430,7 @@ function resolveSkillAssets(executable) {
   const fileSha256 = Object.fromEntries(
     files.map((relativePath) => [
       relativePath,
-      `sha256:${createHash6("sha256").update(readFileSync11(join15(root, relativePath))).digest("hex")}`
+      `sha256:${createHash7("sha256").update(readFileSync11(join15(root, relativePath))).digest("hex")}`
     ])
   );
   return {
@@ -103299,7 +103753,7 @@ function skillStatusForDir(dir, assets, installCommand = `${cliInvocation()} ski
       const installed = readFileSync11(installedPath);
       const shipped = readFileSync11(join15(assets.root, relativePath));
       if (!installed.equals(shipped)) assetsMatch = false;
-      if (manifest.kind === "v2" && manifest.file_sha256?.[relativePath] !== `sha256:${createHash6("sha256").update(installed).digest("hex")}`) {
+      if (manifest.kind === "v2" && manifest.file_sha256?.[relativePath] !== `sha256:${createHash7("sha256").update(installed).digest("hex")}`) {
         receiptDigestsMatch = false;
       }
     }
@@ -103679,7 +104133,7 @@ The former spelling --scope global remains accepted as an alias for --scope user
 
 // src/commands/home.ts
 import { parseArgs as parseArgs25 } from "node:util";
-import path26 from "node:path";
+import path27 from "node:path";
 function parseHomeArgs(argv2) {
   return parseArgs25({ args: argv2, options: HOME_OPTIONS, allowPositionals: true });
 }
@@ -103730,7 +104184,7 @@ async function defaultSummarizeBundle(dir, route) {
     if (route) await assertResolvedLocalRouteIdentity(route);
   } catch (err) {
     if (err instanceof CliError && err.code === "NOT_FOUND") return null;
-    const root = collapseHomeDirectory(path26.resolve(dir ?? process.cwd()));
+    const root = collapseHomeDirectory(path27.resolve(dir ?? process.cwd()));
     if (err instanceof CliError && err.code === "CONFLICT") {
       return { root, conflict: true, message: err.message };
     }
@@ -103746,11 +104200,11 @@ async function defaultSummarizeBundle(dir, route) {
 }
 async function discoverSummarizeBundle(startDir) {
   try {
-    const root = await findBundleRoot(path26.resolve(startDir));
+    const root = await findBundleRoot(path27.resolve(startDir));
     return root ? defaultSummarizeBundle(root) : null;
   } catch (err) {
     if (err instanceof CliError && err.code === "NOT_FOUND") return null;
-    const root = collapseHomeDirectory(path26.resolve(startDir));
+    const root = collapseHomeDirectory(path27.resolve(startDir));
     if (err instanceof CliError && err.code === "CONFLICT") {
       return { root, conflict: true, message: err.message };
     }
@@ -103846,7 +104300,7 @@ async function defaultLoadBoardStatus(dir, route) {
     if (!top) return null;
     const committed = committedBundleAtHead(top);
     const bundleDir = committed?.bundleDir ?? bundleDirNameForProject(top);
-    const boardPath = path26.join(top, bundleDir);
+    const boardPath = path27.join(top, bundleDir);
     if (!isProvisioned(top)) {
       const remoteRefExists = runGit(top, ["rev-parse", "--verify", "--quiet", `refs/remotes/${BOARD_REF}`]).status === 0;
       const probed = remoteRefExists || runGit(top, ["rev-parse", "--verify", "--quiet", `refs/heads/${BOARD_BRANCH}`]).status === 0;
@@ -103980,7 +104434,7 @@ function buildHomeView(deps, summary, remote, binding, bindingError, board, hook
       const target = ` --dir ${shellArg(binding.target)}`;
       view2.getting_started = `project binding ${binding.file} -> ${binding.target} did not resolve to a bundle \u2014 run \`${deps.invocation()} init --recipe none${target}\` to recreate that bound bundle, or fix/remove the binding before browsing recipes`;
     } else {
-      const createTarget = path26.join(deps.targetDir ?? ".", CONVENTIONAL_BUNDLE_DIR_NAME);
+      const createTarget = path27.join(deps.targetDir ?? ".", CONVENTIONAL_BUNDLE_DIR_NAME);
       const target = ` --dir ${shellArg(createTarget)}`;
       view2.getting_started = `no OKF bundle found in this directory \u2014 run \`${deps.invocation()} init --create-only --recipe none${target}\` to create a blank bundle, or \`${deps.invocation()} recipes\` to compare available workspace setups; create your chosen setup here with \`${deps.invocation()} init --create-only --recipe <name>${target}\``;
     }
@@ -104248,12 +104702,12 @@ ASLITE_NO_UPDATE_CHECK, NO_UPDATE_NOTIFIER, or CI.
 
 // src/commands/session-start.ts
 import { parseArgs as parseArgs26 } from "node:util";
-import path27 from "node:path";
+import path28 from "node:path";
 async function sessionStartPull(dir, budgetMs = SESSION_START_PULL_BUDGET_MS, now = Date.now) {
   const deadline = now() + budgetMs;
   const remaining = () => Math.max(0, deadline - now());
   try {
-    assertSearchDirOutsidePrivateState(path27.resolve(dir ?? process.cwd()));
+    assertSearchDirOutsidePrivateState(path28.resolve(dir ?? process.cwd()));
     const route = dir === void 0 && await resolveProjectBinding(process.cwd()) ? await resolveLocalBundleRoute(void 0) : void 0;
     if (route?.kind === "bound-board" && route.readiness !== "ready") return void 0;
     const owner = route?.kind === "bound-board" ? route.owner : void 0;
@@ -104286,7 +104740,7 @@ async function sessionStartPull(dir, budgetMs = SESSION_START_PULL_BUDGET_MS, no
       const top = repoTopLevel(startDir);
       if (!top) return void 0;
       const bundleDir = committedBundleAtHead(top)?.bundleDir ?? bundleDirNameForProject(top);
-      const boardPath2 = path27.join(top, bundleDir);
+      const boardPath2 = path28.join(top, bundleDir);
       const key2 = resolveBundleKey(boardPath2);
       await defaultSyncStore.refreshMarker(key2);
       if (remaining() < MIN_USEFUL_BUDGET_MS) return { offline: true, boardPath: boardPath2 };
@@ -104723,7 +105177,7 @@ function cappedPaths(dirs) {
   return {
     shown: Math.min(paths.length, PATH_LIMIT),
     total: paths.length,
-    rows: paths.slice(0, PATH_LIMIT).map((path28) => ({ path: path28 }))
+    rows: paths.slice(0, PATH_LIMIT).map((path29) => ({ path: path29 }))
   };
 }
 function dirsWith(targets, disposition) {
@@ -105690,7 +106144,7 @@ var init_setup_plan = __esm({
 });
 
 // src/user-state-migration.ts
-import { createHash as createHash7 } from "node:crypto";
+import { createHash as createHash8 } from "node:crypto";
 import {
   chmod as chmod2,
   lstat as lstat2,
@@ -105707,7 +106161,7 @@ function errno3(error51) {
   return error51?.code;
 }
 function digest(bytes) {
-  return createHash7("sha256").update(bytes).digest("hex");
+  return createHash8("sha256").update(bytes).digest("hex");
 }
 function isRecord10(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
@@ -105853,7 +106307,7 @@ async function ensureMigrationParent(home2) {
   if (!(await stat3(parent)).isDirectory()) throw new Error("canonical state parent is unsafe");
 }
 function migrationTemporaryPath(root, relative2) {
-  const digest2 = createHash7("sha256").update(relative2).digest("hex").slice(0, 24);
+  const digest2 = createHash8("sha256").update(relative2).digest("hex").slice(0, 24);
   return join16(root, dirname6(relative2), `.migration-${digest2}.tmp`);
 }
 async function sweepOwnedStagingTemporaries(root, records) {
@@ -105905,10 +106359,10 @@ function journalBytes(records) {
 `;
 }
 async function removeStaleJournal(root) {
-  const path28 = join16(root, MIGRATION_JOURNAL_FILE_NAME);
-  const raw = await readPrivateStateFile(path28, MAX_CATALOG_BYTES).catch(() => null);
+  const path29 = join16(root, MIGRATION_JOURNAL_FILE_NAME);
+  const raw = await readPrivateStateFile(path29, MAX_CATALOG_BYTES).catch(() => null);
   if (raw === null || parseJournal(raw) === null) return;
-  await unlink4(path28).catch(() => {
+  await unlink4(path29).catch(() => {
   });
 }
 function parseJournal(raw) {