@hasna/skills 0.10.70 → 0.10.72

package/dist/runtime-prerequisites.js

@@ -47,9 +47,9 @@ var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = import.meta.require;
 
 // src/runtime-prerequisites.ts
-import { isAbsolute as isAbsolute5 } from "path";
+import { isAbsolute as isAbsolute7 } from "path";
 // package.json
-var version = "0.10.70";
+var version = "0.10.72";
 var package_default = {
   name: "@hasna/skills",
   version,
@@ -191,8 +191,8 @@ var package_default = {
 };
 
 // src/lib/agent-install-selection.ts
-import { lstatSync as lstatSync4 } from "fs";
-import { dirname as dirname5, join as join7, resolve as resolve6 } from "path";
+import { lstatSync as lstatSync6 } from "fs";
+import { dirname as dirname6, join as join7, resolve as resolve7 } from "path";
 import { homedir as homedir2 } from "os";
 
 // src/lib/agent-adapters.ts
@@ -284,11 +284,11 @@ var NATIVE_SKILL_ROOTS = [
 ];
 
 // src/lib/managed-policy.ts
-import { closeSync as closeSync3, constants as constants3, fstatSync as fstatSync3, lstatSync as lstatSync3, openSync as openSync3, readSync as readSync3 } from "fs";
+import { closeSync as closeSync5, constants as constants5, fstatSync as fstatSync5, lstatSync as lstatSync5, openSync as openSync5, readSync as readSync4 } from "fs";
 import { join as join6 } from "path";
 
 // src/lib/config.ts
-import { existsSync as existsSync2, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { closeSync, constants, existsSync as existsSync2, fstatSync, lstatSync, openSync, readFileSync, statSync, writeFileSync, mkdirSync } from "fs";
 import { join as join2, dirname } from "path";
 
 // src/lib/retired-settings.ts
@@ -424,7 +424,8 @@ function skillsDataRootForHome(home) {
 var ENUM_KEYS = {
   defaultAgent: ["claude", "codex", "gemini", "pi", "opencode", "all"],
   defaultScope: ["global", "project"],
-  format: ["compact", "json", "csv"]
+  format: ["compact", "json", "csv"],
+  sessionPinMigration: ["auto", "off"]
 };
 var STRING_KEYS = ["extensionsDir"];
 function validKeys() {
@@ -495,6 +496,9 @@ function saveConfig(key, value, scope = "project") {
   if (!validKeys().includes(key)) {
     throw new Error(`Unknown config key: ${key}. Valid keys: ${validKeys().join(", ")}`);
   }
+  if (key === "sessionPinMigration" && scope !== "global") {
+    throw new Error(`${key} is read only from the global configuration. Use: skills config set ${key} <auto|off> --global`);
+  }
   const normalized = normalizeConfigValue(key, value);
   if (normalized === undefined) {
     const allowed = allowedValues(key);
@@ -549,14 +553,14 @@ function unsetConfig(key, scope = "project") {
 // src/lib/selection-cache.ts
 import { createHash as createHash2, randomUUID } from "crypto";
 import { spawnSync } from "child_process";
-import { closeSync, constants, fstatSync, fsyncSync, linkSync, lstatSync, mkdirSync as mkdirSync2, openSync, readFileSync as readFileSync3, readlinkSync, readSync, renameSync, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
+import { closeSync as closeSync2, constants as constants2, fstatSync as fstatSync2, fsyncSync, linkSync, lstatSync as lstatSync2, mkdirSync as mkdirSync2, openSync as openSync2, readFileSync as readFileSync3, readlinkSync, readSync, renameSync, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
 import { hostname } from "os";
-import { dirname as dirname2, join as join4, parse, resolve as resolve2 } from "path";
+import { dirname as dirname2, isAbsolute, join as join4, parse, resolve as resolve2 } from "path";
 import { isDeepStrictEqual } from "util";
 
 // src/lib/skill-bundle.ts
 import { createHash } from "crypto";
-import { readFileSync as readFileSync2, readdirSync, statSync } from "fs";
+import { readFileSync as readFileSync2, readdirSync, statSync as statSync2 } from "fs";
 import { join as join3, relative } from "path";
 import { createGunzip } from "zlib";
 
@@ -774,7 +778,7 @@ function walk(root, current, out) {
       continue;
     if (isCredentialFile(entry.name))
       continue;
-    const stats = statSync(absolute);
+    const stats = statSync2(absolute);
     out.push({
       path: rel,
       bytes: ownBytes(readFileSync2(absolute)),
@@ -1289,7 +1293,7 @@ function assertRegularPath(path, createParents = false) {
   for (let index = 0;index < segments.length; index++) {
     cursor = join4(cursor, segments[index]);
     try {
-      const stat = lstatSync(cursor);
+      const stat = lstatSync2(cursor);
       if (stat.isSymbolicLink() || index < segments.length - 1 && !stat.isDirectory()) {
         throw new SkillSelectionError("UNSAFE_CACHE_PATH", "Skills cache paths must not traverse symlinks or non-directories.");
       }
@@ -1305,14 +1309,14 @@ function readRegularFile(path, limit) {
   assertRegularPath(path);
   let fd;
   try {
-    fd = openSync(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+    fd = openSync2(path, constants2.O_RDONLY | constants2.O_NOFOLLOW | constants2.O_NONBLOCK);
   } catch (error) {
     if (error.code === "ENOENT")
       return null;
     throw error;
   }
   try {
-    const stat = fstatSync(fd);
+    const stat = fstatSync2(fd);
     if (!stat.isFile() || stat.size > limit)
       throw new SkillSelectionError("INVALID_CACHE_FILE", "The Skills cache contains an invalid or oversized file.");
     const bytes = Buffer.alloc(stat.size + 1);
@@ -1327,7 +1331,7 @@ function readRegularFile(path, limit) {
       throw new SkillSelectionError("INVALID_CACHE_FILE", "The Skills cache file grew during its bounded read.");
     return bytes.subarray(0, size);
   } finally {
-    closeSync(fd);
+    closeSync2(fd);
   }
 }
 function writeSelectionJson(path, value) {
@@ -1341,13 +1345,13 @@ function atomicWrite(path, bytes, mode, durable = false) {
   assertRegularPath(path, true);
   const temporary = join4(dirname2(path), `.selection-${randomUUID()}.tmp`);
   try {
-    const fd = openSync(temporary, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, mode);
+    const fd = openSync2(temporary, constants2.O_WRONLY | constants2.O_CREAT | constants2.O_EXCL | constants2.O_NOFOLLOW, mode);
     try {
       writeFileSync2(fd, bytes);
       if (durable)
         fsyncSync(fd);
     } finally {
-      closeSync(fd);
+      closeSync2(fd);
     }
     renameSync(temporary, path);
     if (durable)
@@ -1485,11 +1489,19 @@ function assertFreshCachedProfile(receipt, options = {}) {
 function projectSelectionLockPath(projectDir) {
   return join4(resolve2(projectDir), ".skills", SELECTION_LOCK_FILE);
 }
-function readProjectSelection(projectDir) {
-  const receipt = readSelectionJson(projectSelectionLockPath(projectDir));
-  if (receipt)
-    validateSelectionReceipt(receipt);
-  return receipt;
+function readProjectSelectionSnapshot(projectDir) {
+  const path = projectSelectionLockPath(projectDir);
+  const bytes = readRegularFile(path, MAX_PROFILE_DOCUMENT_BYTES);
+  if (!bytes)
+    return null;
+  let receipt;
+  try {
+    receipt = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+  } catch {
+    throw new SkillSelectionError("INVALID_RECEIPT", "The Skills selection receipt is unreadable; sync the profile again.");
+  }
+  validateSelectionReceipt(receipt);
+  return { receipt, lock: { path, sha256: sha256Hex(bytes) } };
 }
 function sessionReceiptPath(sessionId, options = {}) {
   if (!sessionId.trim() || sessionId.length > MAX_SKILL_SESSION_ID_CHARS)
@@ -1515,6 +1527,10 @@ function validateSkillSessionReceipt(receipt, sessionId) {
     if (receipt.parent.sessionId === sessionId)
       throw new SkillSelectionError("INVALID_RECEIPT", "A Skills child session cannot name itself as its parent.");
   }
+  const lock = receipt.projectLock;
+  if (lock !== undefined && (!lock || typeof lock !== "object" || Array.isArray(lock) || Object.keys(lock).sort().join(",") !== "path,sha256" || typeof lock.path !== "string" || !isAbsolute(lock.path) || lock.path.length > 4096 || !/^[a-f0-9]{64}$/.test(lock.sha256))) {
+    throw new SkillSelectionError("INVALID_RECEIPT", "The Skills session receipt contains invalid project lock provenance.");
+  }
 }
 function readSkillSessionSnapshotIfExists(sessionId, options = {}) {
   const path = sessionReceiptPath(sessionId, options), bytes = readRegularFile(path, MAX_PROFILE_DOCUMENT_BYTES);
@@ -1599,14 +1615,14 @@ function localLockIdentity() {
 }
 function readSessionLock(sessionId, options) {
   const path = `${sessionReceiptPath(sessionId, options)}.write-lock`;
-  const before = lstatSync(path, { throwIfNoEntry: false });
+  const before = lstatSync2(path, { throwIfNoEntry: false });
   if (!before)
     return null;
   if (!before.isFile() || ![1, 2].includes(before.nlink) || (before.mode & 63) !== 0 || process.getuid && before.uid !== process.getuid()) {
     throw new SkillSelectionError("SESSION_WRITE_LOCKED", "The session lock is not a private regular file; recovery requires review.");
   }
   const bytes = readRegularFile(path, SESSION_LOCK_MAX_BYTES);
-  const after = lstatSync(path, { throwIfNoEntry: false });
+  const after = lstatSync2(path, { throwIfNoEntry: false });
   if (!bytes || !after?.isFile() || before.dev !== after.dev || before.ino !== after.ino || before.mtimeMs !== after.mtimeMs || before.mode !== after.mode || before.uid !== after.uid || before.gid !== after.gid || before.nlink !== after.nlink) {
     throw new SkillSelectionError("SESSION_WRITE_LOCKED", "The session lock changed during inspection; recovery requires review.");
   }
@@ -1623,7 +1639,7 @@ function readSessionLock(sessionId, options) {
   if (after.nlink === 2) {
     stagingPath = `${path}.${marker.operationId}.prepared`;
     assertRegularPath(stagingPath);
-    const staged = lstatSync(stagingPath, { throwIfNoEntry: false });
+    const staged = lstatSync2(stagingPath, { throwIfNoEntry: false });
     if (marker.publication !== "hard-link-v1" || !staged?.isFile() || staged.dev !== after.dev || staged.ino !== after.ino || staged.nlink !== 2 || staged.mode !== after.mode || staged.uid !== after.uid || staged.gid !== after.gid) {
       throw new SkillSelectionError("SESSION_WRITE_LOCKED", "The session lock has an unbound publication link; recovery requires review.");
     }
@@ -1634,8 +1650,8 @@ function publishSessionLock(path, marker) {
   const stagingPath = `${path}.${marker.operationId}.prepared`;
   const bytes = Buffer.from(`${JSON.stringify({ ...marker, publication: "hard-link-v1" })}
 `);
-  const fd = openSync(stagingPath, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 384);
-  const stat = fstatSync(fd);
+  const fd = openSync2(stagingPath, constants2.O_WRONLY | constants2.O_CREAT | constants2.O_EXCL | constants2.O_NOFOLLOW, 384);
+  const stat = fstatSync2(fd);
   let published = false, handedOff = false;
   try {
     writeFileSync2(fd, bytes);
@@ -1643,7 +1659,7 @@ function publishSessionLock(path, marker) {
     linkSync(stagingPath, path);
     published = true;
     syncDirectory(dirname2(path));
-    const staged = lstatSync(stagingPath);
+    const staged = lstatSync2(stagingPath);
     if (!staged.isFile() || staged.dev !== stat.dev || staged.ino !== stat.ino) {
       throw new SkillSelectionError("SESSION_WRITE_LOCK_CHANGED", "The initialized lock staging inode changed before publication completed.");
     }
@@ -1655,12 +1671,12 @@ function publishSessionLock(path, marker) {
     if (!handedOff) {
       try {
         for (const target of [...published ? [path] : [], stagingPath]) {
-          const current = lstatSync(target, { throwIfNoEntry: false });
+          const current = lstatSync2(target, { throwIfNoEntry: false });
           if (current?.isFile() && current.dev === stat.dev && current.ino === stat.ino)
             unlinkSync(target);
         }
       } finally {
-        closeSync(fd);
+        closeSync2(fd);
       }
     }
   }
@@ -1682,13 +1698,13 @@ function archiveSessionLock(lock, receipt, explicitLocalHost) {
   const guardPath = `${lock.path}.recovery-guard`;
   let guardFd;
   try {
-    guardFd = openSync(guardPath, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 384);
+    guardFd = openSync2(guardPath, constants2.O_WRONLY | constants2.O_CREAT | constants2.O_EXCL | constants2.O_NOFOLLOW, 384);
   } catch (error) {
     if (error.code === "EEXIST")
       return null;
     throw error;
   }
-  const guardStat = fstatSync(guardFd);
+  const guardStat = fstatSync2(guardFd);
   try {
     writeFileSync2(guardFd, `${JSON.stringify({ schemaVersion: 1, pid: process.pid, operationId: randomUUID() })}
 `);
@@ -1734,9 +1750,9 @@ function archiveSessionLock(lock, receipt, explicitLocalHost) {
       syncDirectory(directory);
       syncDirectory(dirname2(lock.path));
       for (const path of archivedPaths) {
-        const before = lstatSync(path, { throwIfNoEntry: false });
+        const before = lstatSync2(path, { throwIfNoEntry: false });
         const bytes = readRegularFile(path, SESSION_LOCK_MAX_BYTES);
-        const after = lstatSync(path, { throwIfNoEntry: false });
+        const after = lstatSync2(path, { throwIfNoEntry: false });
         if (!before?.isFile() || before.dev !== lock.dev || before.ino !== lock.ino || before.nlink !== archivedPaths.length || before.mtimeMs !== lock.mtimeMs || (before.mode & 63) !== 0 || process.getuid && before.uid !== process.getuid() || !bytes || sha256Hex(bytes) !== lock.sha256 || !after?.isFile() || before.dev !== after.dev || before.ino !== after.ino || before.mtimeMs !== after.mtimeMs || before.mode !== after.mode || before.uid !== after.uid || before.gid !== after.gid || before.nlink !== after.nlink) {
           throw new Error("Archived lock ownership or bytes changed");
         }
@@ -1748,8 +1764,8 @@ function archiveSessionLock(lock, receipt, explicitLocalHost) {
     }
     return archivePath;
   } finally {
-    closeSync(guardFd);
-    const current = lstatSync(guardPath, { throwIfNoEntry: false });
+    closeSync2(guardFd);
+    const current = lstatSync2(guardPath, { throwIfNoEntry: false });
     if (current?.isFile() && current.dev === guardStat.dev && current.ino === guardStat.ino)
       unlinkSync(guardPath);
   }
@@ -1761,7 +1777,7 @@ function withSessionWriteLocks(sessionIds, options, action) {
   const owned = [];
   const assertOwned = () => {
     for (const lock of owned) {
-      const current = lstatSync(lock.path, { throwIfNoEntry: false });
+      const current = lstatSync2(lock.path, { throwIfNoEntry: false });
       if (!current?.isFile() || current.dev !== lock.dev || current.ino !== lock.ino) {
         throw new SkillSelectionError("SESSION_WRITE_LOCK_CHANGED", "A session write lock changed during the operation; no replacement is permitted.");
       }
@@ -1805,12 +1821,12 @@ function withSessionWriteLocks(sessionIds, options, action) {
     for (const lock of owned.reverse()) {
       try {
         for (const path of [lock.path, lock.stagingPath]) {
-          const current = lstatSync(path, { throwIfNoEntry: false });
+          const current = lstatSync2(path, { throwIfNoEntry: false });
           if (current?.isFile() && current.dev === lock.dev && current.ino === lock.ino)
             unlinkSync(path);
         }
       } finally {
-        closeSync(lock.fd);
+        closeSync2(lock.fd);
       }
     }
   }
@@ -1861,21 +1877,21 @@ function writeSkillSession(receipt, expected, options = {}) {
 }
 function syncDirectory(path) {
   assertRegularPath(path);
-  const fd = openSync(path, constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW);
+  const fd = openSync2(path, constants2.O_RDONLY | constants2.O_DIRECTORY | constants2.O_NOFOLLOW);
   try {
     fsyncSync(fd);
   } finally {
-    closeSync(fd);
+    closeSync2(fd);
   }
 }
 function archiveBytes(path, bytes) {
   assertRegularPath(path, true);
-  const fd = openSync(path, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 384);
+  const fd = openSync2(path, constants2.O_WRONLY | constants2.O_CREAT | constants2.O_EXCL | constants2.O_NOFOLLOW, 384);
   try {
     writeFileSync2(fd, bytes);
     fsyncSync(fd);
   } finally {
-    closeSync(fd);
+    closeSync2(fd);
   }
 }
 function replaceSkillSession(expected, replacement, plan, options = {}, beforeCommit = () => {}) {
@@ -1921,7 +1937,7 @@ function replaceSkillSession(expected, replacement, plan, options = {}, beforeCo
 }
 
 // src/lib/agent-policy-limits.ts
-import { basename as basename3, isAbsolute as isAbsolute3, join as join5, resolve as resolve5, sep } from "path";
+import { basename as basename4, isAbsolute as isAbsolute5, join as join5, resolve as resolve6, sep as sep2 } from "path";
 
 // src/lib/codex-native-compatibility.ts
 var MEASURED_CODEX_CAPABILITIES = {
@@ -1948,25 +1964,25 @@ var SUPPORTED_CODEX_HOOK_VERSIONS = Object.freeze(Object.keys(MEASURED_CODEX_CAP
 
 // src/lib/claude-marketplace-entry-witness.ts
 import { createHash as createHash4 } from "crypto";
-import { basename as basename2, dirname as dirname4, isAbsolute as isAbsolute2, resolve as resolve4 } from "path";
+import { basename as basename2, dirname as dirname4, isAbsolute as isAbsolute3, resolve as resolve4 } from "path";
 
 // src/lib/claude-settings-witness.ts
 import { createHash as createHash3 } from "crypto";
-import { closeSync as closeSync2, constants as constants2, fstatSync as fstatSync2, lstatSync as lstatSync2, openSync as openSync2, readSync as readSync2 } from "fs";
-import { basename, dirname as dirname3, isAbsolute, resolve as resolve3 } from "path";
+import { closeSync as closeSync3, constants as constants3, fstatSync as fstatSync3, lstatSync as lstatSync3, openSync as openSync3, readSync as readSync2 } from "fs";
+import { basename, dirname as dirname3, isAbsolute as isAbsolute2, resolve as resolve3 } from "path";
 var CLAUDE_SETTINGS_WITNESS_LIMITS = Object.freeze({ bytes: 1024 * 1024, rows: 1024, depth: 32, nodes: 65536, stringCharacters: 16384, pathCharacters: 4096 });
 function need(value, reason) {
   if (!value)
     throw new Error(`Claude settings witness ${reason}`);
 }
 function absolutePath(value) {
-  need(typeof value === "string" && value.length > 0 && value.length <= CLAUDE_SETTINGS_WITNESS_LIMITS.pathCharacters && !/[\x00-\x1f\x7f]/.test(value) && isAbsolute(value) && resolve3(value) === value, "requires a normalized absolute path");
+  need(typeof value === "string" && value.length > 0 && value.length <= CLAUDE_SETTINGS_WITNESS_LIMITS.pathCharacters && !/[\x00-\x1f\x7f]/.test(value) && isAbsolute2(value) && resolve3(value) === value, "requires a normalized absolute path");
 }
 var sameFile = (a, b) => a.dev === b.dev && a.ino === b.ino && a.mode === b.mode && a.uid === b.uid && a.gid === b.gid && a.nlink === b.nlink && a.size === b.size && a.mtimeNs === b.mtimeNs && a.ctimeNs === b.ctimeNs;
 function parents(path) {
   const result = [];
   for (let at = dirname3(path);; at = dirname3(at)) {
-    const stat = lstatSync2(at, { bigint: true });
+    const stat = lstatSync3(at, { bigint: true });
     need(stat.isDirectory() && !stat.isSymbolicLink(), "path traverses a symlink or non-directory");
     result.push([at, stat]);
     if (at === dirname3(at))
@@ -1977,12 +1993,12 @@ function readNativeSettingsWitnessFile(path, budget, filename = "settings.json")
   absolutePath(path);
   need(basename(path) === filename, `requires ${filename}`);
   need(Number.isSafeInteger(budget.remaining) && budget.remaining >= 0, "has an invalid byte budget");
-  const ancestors = parents(path), initial = lstatSync2(path, { bigint: true });
+  const ancestors = parents(path), initial = lstatSync3(path, { bigint: true });
   need(initial.isFile() && !initial.isSymbolicLink() && initial.size <= BigInt(CLAUDE_SETTINGS_WITNESS_LIMITS.bytes), "is not a bounded regular file");
   need(initial.size <= BigInt(budget.remaining), "exceeds its aggregate byte limit");
-  const fd = openSync2(path, constants2.O_RDONLY | constants2.O_NOFOLLOW | constants2.O_NONBLOCK);
+  const fd = openSync3(path, constants3.O_RDONLY | constants3.O_NOFOLLOW | constants3.O_NONBLOCK);
   try {
-    const opened = fstatSync2(fd, { bigint: true });
+    const opened = fstatSync3(fd, { bigint: true });
     need(opened.isFile() && sameFile(initial, opened), "changed during open");
     const bytes = Buffer.alloc(Number(opened.size) + 1);
     let length = 0;
@@ -1992,10 +2008,10 @@ function readNativeSettingsWitnessFile(path, budget, filename = "settings.json")
         break;
       length += count;
     }
-    const after = fstatSync2(fd, { bigint: true }), current = lstatSync2(path, { bigint: true });
+    const after = fstatSync3(fd, { bigint: true }), current = lstatSync3(path, { bigint: true });
     need(current.isFile() && sameFile(opened, after) && sameFile(after, current) && BigInt(length) === opened.size, "changed during read");
     for (const [ancestor, before] of ancestors) {
-      const now = lstatSync2(ancestor, { bigint: true });
+      const now = lstatSync3(ancestor, { bigint: true });
       need(now.isDirectory() && before.dev === now.dev && before.ino === now.ino && before.mode === now.mode, "parent changed during read");
     }
     budget.remaining -= length;
@@ -2005,7 +2021,7 @@ function readNativeSettingsWitnessFile(path, budget, filename = "settings.json")
       throw new Error("Claude settings witness is not strict UTF-8");
     }
   } finally {
-    closeSync2(fd);
+    closeSync3(fd);
   }
 }
 function parse2(text) {
@@ -2375,7 +2391,7 @@ var stringArray = (value) => value?.kind === "array" && value.items.every(isStri
 var stringObject = (value) => value?.kind === "object" && value.entries.every(([, item]) => isString(item));
 function claudeMarketplaceEntrySourceValid(source) {
   const path = source?.path;
-  return typeof path === "string" && path.length > 0 && path.length <= PATH_CHARACTERS && !/[\x00-\x1f\x7f]/.test(path) && isAbsolute2(path) && resolve4(path) === path && basename2(path) === "marketplace.json" && basename2(dirname4(path)) === ".claude-plugin" && typeof source.marketplace === "string" && NAME.test(source.marketplace) && !source.marketplace.includes("..") && typeof source.plugin === "string" && NAME.test(source.plugin);
+  return typeof path === "string" && path.length > 0 && path.length <= PATH_CHARACTERS && !/[\x00-\x1f\x7f]/.test(path) && isAbsolute3(path) && resolve4(path) === path && basename2(path) === "marketplace.json" && basename2(dirname4(path)) === ".claude-plugin" && typeof source.marketplace === "string" && NAME.test(source.marketplace) && !source.marketplace.includes("..") && typeof source.plugin === "string" && NAME.test(source.plugin);
 }
 function canonical2(value) {
   if (value.kind === "string")
@@ -2501,6 +2517,74 @@ function captureClaudeMarketplaceEntry(path, marketplace, plugin, budget = { rem
   return { path, hashMode: CLAUDE_MARKETPLACE_ENTRY_HASH_MODE, marketplace, plugin, sha256: hashClaudeMarketplaceEntry(text, { marketplace, plugin }) };
 }
 
+// src/lib/claude-plugin-cache-marker.ts
+import { createHash as createHash5 } from "crypto";
+import { closeSync as closeSync4, constants as constants4, fstatSync as fstatSync4, lstatSync as lstatSync4, openSync as openSync4, readSync as readSync3 } from "fs";
+import { basename as basename3, dirname as dirname5, isAbsolute as isAbsolute4, resolve as resolve5, sep } from "path";
+var CLAUDE_ORPHAN_MARKER_MODE = "claude-plugin-orphaned-at-v1";
+var CACHE = `${sep}.claude${sep}plugins${sep}cache${sep}`;
+function isClaudePluginCacheOrphanMarker(path) {
+  if (typeof path !== "string" || basename3(path) !== ".orphaned_at" || !isAbsolute4(path) || resolve5(path) !== path || path.includes("\x00"))
+    return false;
+  const at = path.indexOf(CACHE);
+  if (at < 0 || path.indexOf(CACHE, at + 1) >= 0)
+    return false;
+  const parts = path.slice(at + CACHE.length).split(sep);
+  return parts.length === 4 && parts.every((part) => part && part !== "." && part !== "..");
+}
+function same(left, right) {
+  return Boolean(right && right.isFile() && left.dev === right.dev && left.ino === right.ino && left.uid === right.uid && left.mode === right.mode && left.size === right.size && left.mtimeMs === right.mtimeMs && left.ctimeMs === right.ctimeMs);
+}
+function safe(path) {
+  for (let cursor = path;; cursor = dirname5(cursor)) {
+    if (lstatSync4(cursor, { throwIfNoEntry: false })?.isSymbolicLink())
+      throw new Error("Refusing symlink Claude orphan marker input");
+    if (dirname5(cursor) === cursor)
+      break;
+  }
+}
+function hashClaudePluginCacheOrphanMarker(path, budget, changes) {
+  if (!isClaudePluginCacheOrphanMarker(path))
+    throw new Error("Expected a Claude plugin-cache version-root orphan marker");
+  if (changes?.has(path))
+    throw new Error("Claude orphan markers cannot intersect a planned write");
+  safe(path);
+  const before = lstatSync4(path, { throwIfNoEntry: false });
+  if (!before)
+    return null;
+  const uid = process.getuid?.();
+  if (!before.isFile() || uid === undefined || before.uid !== uid || before.size > 32)
+    throw new Error("Invalid Claude orphan marker file or owner");
+  const fd = openSync4(path, constants4.O_RDONLY | constants4.O_NOFOLLOW | constants4.O_NONBLOCK);
+  try {
+    const opened = fstatSync4(fd);
+    if (!same(before, opened))
+      throw new Error("Claude orphan marker changed during open");
+    const bytes = Buffer.alloc(33);
+    let length = 0;
+    while (length < bytes.length) {
+      const count = readSync3(fd, bytes, length, bytes.length - length, null);
+      if (!count)
+        break;
+      length += count;
+    }
+    if (!/^[1-9][0-9]{12}$/.test(bytes.subarray(0, length).toString("latin1")))
+      throw new Error("Malformed Claude orphan marker timestamp");
+    const after = fstatSync4(fd), current = lstatSync4(path, { throwIfNoEntry: false });
+    safe(path);
+    if (!same(opened, after) || !same(after, current) || length !== after.size)
+      throw new Error("Claude orphan marker changed during read");
+    if (budget) {
+      if (length > budget.remaining)
+        throw new Error("Raw discovery aggregate byte limit exceeded");
+      budget.remaining -= length;
+    }
+    return createHash5("sha256").update(`${CLAUDE_ORPHAN_MARKER_MODE}\x00${path}\x00file`).digest("hex");
+  } finally {
+    closeSync4(fd);
+  }
+}
+
 // src/lib/agent-policy-limits.ts
 var AGENT_POLICY_LIMITS = Object.freeze({ bytes: 1024 * 1024, agents: 16, discoverySources: 2048, discoveryRawSourceBytes: 64 * 1024 * 1024, discoveryRawTotalBytes: 256 * 1024 * 1024, discoveryPathLinks: 40, discoveryPathSteps: 256, discoveryPathSourceMetadataBytes: 64 * 1024, discoveryPathTotalMetadataBytes: 8 * 1024 * 1024, discoveryRoots: 512, discoveryDirectories: 64, discoveryDirectoryEntries: 20000, discoveryDirectoryBytes: 8 * 1024 * 1024, builtinNames: 2048, rootAliases: 2, fields: 64, pathCharacters: 4096 });
 function object(value) {
@@ -2555,7 +2639,7 @@ function assertAgentPolicyCollections(policy) {
       text(control.pluginId, 1024);
       text(control.namespace, 64);
       text(control.pluginParent);
-      requireBound(isAbsolute3(control.pluginParent) && resolve5(control.pluginParent) === control.pluginParent && /^[a-f0-9]{64}$/.test(control.manifestSha256));
+      requireBound(isAbsolute5(control.pluginParent) && resolve6(control.pluginParent) === control.pluginParent && /^[a-f0-9]{64}$/.test(control.manifestSha256));
       if (control.remotePluginId !== undefined)
         requireBound(typeof control.remotePluginId === "string" && /^[A-Za-z0-9_~-]{1,1024}$/.test(control.remotePluginId));
       if (control.skillsOnly !== undefined)
@@ -2573,7 +2657,7 @@ function assertAgentPolicyCollections(policy) {
       text(control.pluginId, 1024);
       text(control.namespace, 64);
       text(control.pluginParent);
-      requireBound(!ids.has(control.pluginId) && isAbsolute3(control.pluginParent) && resolve5(control.pluginParent) === control.pluginParent && ["local", "git", "npm"].includes(control.sourceType) && typeof control.sourceSha256 === "string" && /^[a-f0-9]{64}$/.test(control.sourceSha256));
+      requireBound(!ids.has(control.pluginId) && isAbsolute5(control.pluginParent) && resolve6(control.pluginParent) === control.pluginParent && ["local", "git", "npm"].includes(control.sourceType) && typeof control.sourceSha256 === "string" && /^[a-f0-9]{64}$/.test(control.sourceSha256));
       ids.add(control.pluginId);
     }
   }
@@ -2582,7 +2666,7 @@ function assertAgentPolicyCollections(policy) {
       requireBound(agent === "gemini" && object(executable) && Object.keys(executable).length === 3 && executable.command === "gemini");
       for (const path of [executable.path, executable.target]) {
         text(path);
-        requireBound(!/[\x00-\x1f\x7f-\x9f\u200e\u200f\u202a-\u202e\u2066-\u2069]/.test(path) && isAbsolute3(path) && resolve5(path) === path);
+        requireBound(!/[\x00-\x1f\x7f-\x9f\u200e\u200f\u202a-\u202e\u2066-\u2069]/.test(path) && isAbsolute5(path) && resolve6(path) === path);
       }
     }
   if (bridge.disabledBuiltins !== undefined)
@@ -2610,11 +2694,11 @@ function assertAgentPolicyCollections(policy) {
       requireBound(agent === "codex" && value.agent === "codex" && value.method === "reviewed" && Object.keys(proof).every((key) => ["roots", "parents", "directories"].includes(key)) && roots.length + parents2.length > 0 && new Set(roots).size === roots.length && new Set(parents2).size === parents2.length);
       for (const root of roots) {
         text(root);
-        requireBound(isAbsolute3(root) && resolve5(root) === root);
+        requireBound(isAbsolute5(root) && resolve6(root) === root);
       }
       for (const parent of parents2) {
         text(parent);
-        requireBound(isAbsolute3(parent) && resolve5(parent) === parent);
+        requireBound(isAbsolute5(parent) && resolve6(parent) === parent);
       }
       for (const directory of array(proof.directories, AGENT_POLICY_LIMITS.discoveryDirectories)) {
         requireBound(object(directory));
@@ -2634,7 +2718,7 @@ function assertAgentPolicyCollections(policy) {
         text(input.namespace, 64);
         text(input.pluginParent);
         text(input.sourceRoot);
-        requireBound(!ids.has(input.pluginId) && [input.pluginParent, input.sourceRoot].every((path) => isAbsolute3(path) && resolve5(path) === path) && typeof input.sourceSha256 === "string" && /^[a-f0-9]{64}$/.test(input.sourceSha256));
+        requireBound(!ids.has(input.pluginId) && [input.pluginParent, input.sourceRoot].every((path) => isAbsolute5(path) && resolve6(path) === path) && typeof input.sourceSha256 === "string" && /^[a-f0-9]{64}$/.test(input.sourceSha256));
         ids.add(input.pluginId);
       }
       if (proof.directories !== undefined)
@@ -2648,14 +2732,14 @@ function assertAgentPolicyCollections(policy) {
       const proof = record(value.codexSemanticCache, 9), witness = record(proof.witness, 7);
       requireBound(agent === "codex" && value.agent === "codex" && value.method === "reviewed" && [8, 9].includes(Object.keys(proof).length) && Object.keys(proof).every((key) => ["schema", "configPath", "hookRootAlias", "witness", "appOnlyParents", "previousPolicySha256", "supersededSources", "supersededDirectories", "reviewedHookParents"].includes(key)) && proof.schema === "hasna.codex-semantic-cache-discovery.v1" && typeof proof.previousPolicySha256 === "string" && /^[a-f0-9]{64}$/.test(proof.previousPolicySha256) && [6, 7].includes(Object.keys(witness).length) && Object.keys(witness).every((key) => ["schema", "cacheRoot", "controls", "appOnlyParents", "skills", "sha256", "hookParents"].includes(key)) && witness.schema === "hasna.codex-semantic-cache-witness.v1" && typeof witness.sha256 === "string" && /^[a-f0-9]{64}$/.test(witness.sha256));
       text(proof.configPath);
-      requireBound(isAbsolute3(proof.configPath) && resolve5(proof.configPath) === proof.configPath && basename3(proof.configPath) === "config.toml");
+      requireBound(isAbsolute5(proof.configPath) && resolve6(proof.configPath) === proof.configPath && basename4(proof.configPath) === "config.toml");
       text(witness.cacheRoot);
-      requireBound(isAbsolute3(witness.cacheRoot) && resolve5(witness.cacheRoot) === witness.cacheRoot);
+      requireBound(isAbsolute5(witness.cacheRoot) && resolve6(witness.cacheRoot) === witness.cacheRoot);
       if (proof.hookRootAlias !== null) {
         requireBound(object(proof.hookRootAlias) && Object.keys(proof.hookRootAlias).length === 2);
         for (const key of ["alias", "target"]) {
           text(proof.hookRootAlias[key]);
-          requireBound(isAbsolute3(proof.hookRootAlias[key]) && resolve5(proof.hookRootAlias[key]) === proof.hookRootAlias[key]);
+          requireBound(isAbsolute5(proof.hookRootAlias[key]) && resolve6(proof.hookRootAlias[key]) === proof.hookRootAlias[key]);
         }
       }
       const parents2 = array(proof.appOnlyParents, 4096);
@@ -2663,7 +2747,7 @@ function assertAgentPolicyCollections(policy) {
         requireBound(object(parent) && Object.keys(parent).length === 5 && parent.role === "app-only");
         for (const key of ["pluginId", "namespace", "pluginParent", "remotePluginId"])
           text(parent[key]);
-        requireBound(isAbsolute3(parent.pluginParent) && resolve5(parent.pluginParent) === parent.pluginParent);
+        requireBound(isAbsolute5(parent.pluginParent) && resolve6(parent.pluginParent) === parent.pluginParent);
       }
       if (proof.reviewedHookParents !== undefined)
         for (const parent of array(proof.reviewedHookParents, 4096)) {
@@ -2675,9 +2759,9 @@ function assertAgentPolicyCollections(policy) {
             text(parent.remotePluginId);
           else {
             text(parent.marketplaceSourcePath);
-            requireBound(typeof parent.marketplaceSha256 === "string" && /^[a-f0-9]{64}$/.test(parent.marketplaceSha256) && isAbsolute3(parent.marketplaceSourcePath) && resolve5(parent.marketplaceSourcePath) === parent.marketplaceSourcePath && basename3(parent.marketplaceSourcePath) === "marketplace.json");
+            requireBound(typeof parent.marketplaceSha256 === "string" && /^[a-f0-9]{64}$/.test(parent.marketplaceSha256) && isAbsolute5(parent.marketplaceSourcePath) && resolve6(parent.marketplaceSourcePath) === parent.marketplaceSourcePath && basename4(parent.marketplaceSourcePath) === "marketplace.json");
           }
-          requireBound(isAbsolute3(parent.pluginParent) && resolve5(parent.pluginParent) === parent.pluginParent);
+          requireBound(isAbsolute5(parent.pluginParent) && resolve6(parent.pluginParent) === parent.pluginParent);
         }
       for (const row of [...array(witness.controls, 4096), ...array(witness.appOnlyParents, 4096)]) {
         requireBound(object(row));
@@ -2697,9 +2781,9 @@ function assertAgentPolicyCollections(policy) {
             text(row.remotePluginId);
           else {
             text(row.marketplaceSourcePath);
-            requireBound(typeof row.marketplaceSha256 === "string" && /^[a-f0-9]{64}$/.test(row.marketplaceSha256) && isAbsolute3(row.marketplaceSourcePath) && resolve5(row.marketplaceSourcePath) === row.marketplaceSourcePath && basename3(row.marketplaceSourcePath) === "marketplace.json");
+            requireBound(typeof row.marketplaceSha256 === "string" && /^[a-f0-9]{64}$/.test(row.marketplaceSha256) && isAbsolute5(row.marketplaceSourcePath) && resolve6(row.marketplaceSourcePath) === row.marketplaceSourcePath && basename4(row.marketplaceSourcePath) === "marketplace.json");
           }
-          requireBound(isAbsolute3(row.pluginParent) && resolve5(row.pluginParent) === row.pluginParent);
+          requireBound(isAbsolute5(row.pluginParent) && resolve6(row.pluginParent) === row.pluginParent);
           for (const key of ["manifestSha256", "hooksSha256"])
             requireBound(typeof row[key] === "string" && /^[a-f0-9]{64}$/.test(row[key]));
           if (row.installation === "remote-receipt")
@@ -2732,15 +2816,17 @@ function assertAgentPolicyCollections(policy) {
       text(source.path);
       requireBound(source.sha256 === null || typeof source.sha256 === "string" && /^[a-f0-9]{64}$/.test(source.sha256));
       if (source.hashMode !== undefined)
-        requireBound(["bytes", "path-bytes", "claude-plugin-manifest-v1", "claude-plugin-registry", "claude-marketplace-registry", "claude-settings-v1", "claude-settings-v2", "claude-settings-v3", "claude-settings-v4", "claude-marketplace-registry-v2", "codex-settings-v1", "codex-settings-v2", "codex-settings-v3", "codex-settings-v4", "codex-settings-v5", "codex-settings-v6", "executable-v1", "sumi-settings-v1", "claude-marketplace-entry-v1"].includes(source.hashMode) && source.format === undefined && source.fields === undefined && (source.hashMode === "bytes" || source.sha256 !== null));
+        requireBound(["bytes", "path-bytes", CLAUDE_ORPHAN_MARKER_MODE, "claude-plugin-manifest-v1", "claude-plugin-registry", "claude-marketplace-registry", "claude-settings-v1", "claude-settings-v2", "claude-settings-v3", "claude-settings-v4", "claude-marketplace-registry-v2", "codex-settings-v1", "codex-settings-v2", "codex-settings-v3", "codex-settings-v4", "codex-settings-v5", "codex-settings-v6", "executable-v1", "sumi-settings-v1", "claude-marketplace-entry-v1"].includes(source.hashMode) && source.format === undefined && source.fields === undefined && (["bytes", CLAUDE_ORPHAN_MARKER_MODE].includes(source.hashMode) || source.sha256 !== null));
+      if (source.hashMode === CLAUDE_ORPHAN_MARKER_MODE)
+        requireBound(agent === "claude" && value.agent === "claude" && value.method === "reviewed" && isClaudePluginCacheOrphanMarker(source.path) && source.managedPlugins === undefined && source.reviewArtifact === undefined);
       if (source.hashMode === "executable-v1")
-        requireBound(agent === "codex" && value.agent === "codex" && value.method === "reviewed" && value.sources.some((row) => row.hashMode === "codex-settings-v6") && isAbsolute3(source.path) && resolve5(source.path) === source.path);
+        requireBound(agent === "codex" && value.agent === "codex" && value.method === "reviewed" && value.sources.some((row) => row.hashMode === "codex-settings-v6") && isAbsolute5(source.path) && resolve6(source.path) === source.path);
       if (source.hashMode === "codex-settings-v6") {
         const seen = new Set;
         for (const hook of array(source.hookSources, AGENT_POLICY_LIMITS.discoverySources)) {
           requireBound(object(hook) && Object.keys(hook).length === 2 && Object.keys(hook).every((key) => ["path", "sha256"].includes(key)));
           text(hook.path);
-          requireBound(isAbsolute3(hook.path) && resolve5(hook.path) === hook.path && !seen.has(hook.path));
+          requireBound(isAbsolute5(hook.path) && resolve6(hook.path) === hook.path && !seen.has(hook.path));
           seen.add(hook.path);
           requireBound(hook.sha256 === null || typeof hook.sha256 === "string" && /^[a-f0-9]{64}$/.test(hook.sha256));
           requireBound(value.sources.some((row) => row.path === hook.path && row.sha256 === hook.sha256 && [undefined, "bytes"].includes(row.hashMode) && row.format === undefined && row.fields === undefined));
@@ -2748,15 +2834,15 @@ function assertAgentPolicyCollections(policy) {
       } else
         requireBound(source.hookSources === undefined);
       if (source.hashMode === "claude-plugin-manifest-v1")
-        requireBound(agent === "claude" && value.agent === "claude" && ["automatic", "reviewed"].includes(value.method) && !/[\x00-\x1f\x7f]/.test(source.path) && isAbsolute3(source.path) && resolve5(source.path) === source.path && source.path.endsWith(join5(sep, ".claude-plugin", "plugin.json")) && source.managedPlugins === undefined);
+        requireBound(agent === "claude" && value.agent === "claude" && ["automatic", "reviewed"].includes(value.method) && !/[\x00-\x1f\x7f]/.test(source.path) && isAbsolute5(source.path) && resolve6(source.path) === source.path && source.path.endsWith(join5(sep2, ".claude-plugin", "plugin.json")) && source.managedPlugins === undefined);
       if (source.hashMode === "sumi-settings-v1")
-        requireBound(agent === "sumi" && value.agent === "sumi" && value.method === "reviewed" && !/[\x00-\x1f\x7f]/.test(source.path) && isAbsolute3(source.path) && resolve5(source.path) === source.path && basename3(source.path) === "sumi.json");
+        requireBound(agent === "sumi" && value.agent === "sumi" && value.method === "reviewed" && !/[\x00-\x1f\x7f]/.test(source.path) && isAbsolute5(source.path) && resolve6(source.path) === source.path && basename4(source.path) === "sumi.json");
       if (source.hashMode === "codex-settings-v1" || source.hashMode === "codex-settings-v2" || (source.hashMode === "codex-settings-v3" || source.hashMode === "codex-settings-v4" || source.hashMode === "codex-settings-v5" || source.hashMode === "codex-settings-v6"))
-        requireBound(agent === "codex" && value.agent === "codex" && value.method === "reviewed" && !/[\x00-\x1f\x7f]/.test(source.path) && isAbsolute3(source.path) && resolve5(source.path) === source.path && basename3(source.path) === "config.toml");
+        requireBound(agent === "codex" && value.agent === "codex" && value.method === "reviewed" && !/[\x00-\x1f\x7f]/.test(source.path) && isAbsolute5(source.path) && resolve6(source.path) === source.path && basename4(source.path) === "config.toml");
       if (source.hashMode === "claude-settings-v1" || source.hashMode === "claude-settings-v2" || (source.hashMode === "claude-settings-v3" || source.hashMode === "claude-settings-v4"))
-        requireBound(agent === "claude" && value.agent === "claude" && value.method === "reviewed" && !/[\x00-\x1f\x7f]/.test(source.path) && isAbsolute3(source.path) && resolve5(source.path) === source.path && basename3(source.path) === "settings.json");
+        requireBound(agent === "claude" && value.agent === "claude" && value.method === "reviewed" && !/[\x00-\x1f\x7f]/.test(source.path) && isAbsolute5(source.path) && resolve6(source.path) === source.path && basename4(source.path) === "settings.json");
       if (source.hashMode === "claude-marketplace-registry" || source.hashMode === "claude-marketplace-registry-v2")
-        requireBound(agent === "claude" && value.agent === "claude" && value.method === "reviewed" && !/[\x00-\x1f\x7f]/.test(source.path) && isAbsolute3(source.path) && resolve5(source.path) === source.path && basename3(source.path) === "known_marketplaces.json");
+        requireBound(agent === "claude" && value.agent === "claude" && value.method === "reviewed" && !/[\x00-\x1f\x7f]/.test(source.path) && isAbsolute5(source.path) && resolve6(source.path) === source.path && basename4(source.path) === "known_marketplaces.json");
       if (source.hashMode === "claude-marketplace-entry-v1")
         requireBound(agent === "claude" && value.agent === "claude" && value.method === "reviewed" && claudeMarketplaceEntrySourceValid(source));
       if (source.hashMode === "claude-plugin-registry") {
@@ -2775,7 +2861,7 @@ function assertAgentPolicyCollections(policy) {
         requireBound(agent === "codex" && value.method === "reviewed" && source.hashMode === "bytes" && object(artifact) && Object.keys(artifact).length === 6 && Object.keys(artifact).every((key) => ["version", "kind", "storeRoot", "originalPath", "sha256", "catalogSha256"].includes(key)) && artifact.version === 1 && artifact.kind === "codex-native-catalog" && artifact.sha256 === source.sha256 && /^[a-f0-9]{64}$/.test(artifact.catalogSha256));
         for (const path of [artifact.storeRoot, artifact.originalPath]) {
           text(path);
-          requireBound(isAbsolute3(path) && resolve5(path) === path);
+          requireBound(isAbsolute5(path) && resolve6(path) === path);
         }
         requireBound(source.path === join5(artifact.storeRoot, "agent-discovery", "artifacts", artifact.sha256, "catalog.json"));
       }
@@ -2831,14 +2917,14 @@ function readManagedSkillPolicySnapshot(dataDir2 = getDataDirReadOnly()) {
   const path = join6(dataDir2, "agent-policy.json");
   let descriptor, observed = false;
   try {
-    const stat = lstatSync3(path);
+    const stat = lstatSync5(path);
     observed = true;
     if (!stat.isFile() || stat.isSymbolicLink())
       throw refusal();
     if (stat.size > AGENT_POLICY_LIMITS.bytes)
       throw refusal("exceeds its size limit");
-    descriptor = openSync3(path, constants3.O_RDONLY | (constants3.O_NOFOLLOW ?? 0) | constants3.O_NONBLOCK);
-    const opened = fstatSync3(descriptor);
+    descriptor = openSync5(path, constants5.O_RDONLY | (constants5.O_NOFOLLOW ?? 0) | constants5.O_NONBLOCK);
+    const opened = fstatSync5(descriptor);
     if (!opened.isFile())
       throw refusal();
     if (opened.size > AGENT_POLICY_LIMITS.bytes)
@@ -2846,7 +2932,7 @@ function readManagedSkillPolicySnapshot(dataDir2 = getDataDirReadOnly()) {
     const bytes = Buffer.allocUnsafe(AGENT_POLICY_LIMITS.bytes + 1);
     let length = 0;
     while (length < bytes.length) {
-      const count = readSync3(descriptor, bytes, length, bytes.length - length, null);
+      const count = readSync4(descriptor, bytes, length, bytes.length - length, null);
       if (count === 0)
         break;
       length += count;
@@ -2857,7 +2943,7 @@ function readManagedSkillPolicySnapshot(dataDir2 = getDataDirReadOnly()) {
     return { text: text2, value: parseManagedSkillPolicy(text2) };
   } catch (error) {
     if (error.code === "ENOENT" && !observed) {
-      if (lstatSync3(path, { throwIfNoEntry: false }) === undefined)
+      if (lstatSync5(path, { throwIfNoEntry: false }) === undefined)
         return null;
     }
     if (error instanceof SkillSelectionError)
@@ -2865,7 +2951,7 @@ function readManagedSkillPolicySnapshot(dataDir2 = getDataDirReadOnly()) {
     throw refusal();
   } finally {
     if (descriptor !== undefined)
-      closeSync3(descriptor);
+      closeSync5(descriptor);
   }
 }
 function readManagedSkillPolicy(dataDir2 = getDataDirReadOnly()) {
@@ -2887,7 +2973,7 @@ function detectedIntegrationAgents(options = {}) {
     throw new Error("Invalid existing bridge agent inventory");
   const present = (path) => {
     try {
-      return lstatSync4(path, { throwIfNoEntry: false }) !== undefined;
+      return lstatSync6(path, { throwIfNoEntry: false }) !== undefined;
     } catch {
       throw new Error("Agent presence cannot be inspected; review native configuration before hook installation");
     }
@@ -2897,13 +2983,13 @@ function detectedIntegrationAgents(options = {}) {
       return true;
     if (agent === "sumi") {
       const xdg = env.XDG_CONFIG_HOME;
-      const xdgSumi = xdg?.trim() ? resolve6(options.cwd ?? process.cwd(), xdg === "~" ? home : xdg.startsWith("~/") || xdg.startsWith("~\\") ? resolve6(home, xdg.slice(2)) : xdg, "sumi") : null;
-      return ["SUMI_HOME", "SUMI_CONFIG_DIR", "SUMI_CONFIG", "SUMI_CONFIG_CONTENT"].some((key) => env[key] !== undefined) || Bun.which("sumi-paths", { PATH: env.PATH ?? "" }) !== null || NATIVE_SKILL_ROOTS.some(([provider, root]) => provider === "sumi" && present(join7(home, dirname5(root)))) || present(join7(home, ".config", "sumi")) || xdgSumi !== null && present(xdgSumi);
+      const xdgSumi = xdg?.trim() ? resolve7(options.cwd ?? process.cwd(), xdg === "~" ? home : xdg.startsWith("~/") || xdg.startsWith("~\\") ? resolve7(home, xdg.slice(2)) : xdg, "sumi") : null;
+      return ["SUMI_HOME", "SUMI_CONFIG_DIR", "SUMI_CONFIG", "SUMI_CONFIG_CONTENT"].some((key) => env[key] !== undefined) || Bun.which("sumi-paths", { PATH: env.PATH ?? "" }) !== null || NATIVE_SKILL_ROOTS.some(([provider, root]) => provider === "sumi" && present(join7(home, dirname6(root)))) || present(join7(home, ".config", "sumi")) || xdgSumi !== null && present(xdgSumi);
     }
     if (agent === "hermes" && env.HERMES_HOME !== undefined)
       return true;
     const adapter = AGENT_ADAPTERS[agent];
-    return present(join7(home, dirname5(adapter.config))) || NATIVE_SKILL_ROOTS.some(([provider, root]) => provider === agent && dirname5(root) === `.${agent}` && present(join7(home, dirname5(root))));
+    return present(join7(home, dirname6(adapter.config))) || NATIVE_SKILL_ROOTS.some(([provider, root]) => provider === agent && dirname6(root) === `.${agent}` && present(join7(home, dirname6(root))));
   });
   if (!selected.length && !options.allowEmpty)
     throw new Error(`No configured or detected agents; select --agent <agent> explicitly (${INTEGRATION_AGENTS.join(", ")}).`);
@@ -2912,8 +2998,8 @@ function detectedIntegrationAgents(options = {}) {
 
 // src/lib/agent-sumi.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import { accessSync, constants as constants4, existsSync as existsSync4, lstatSync as lstatSync5, realpathSync, statSync as statSync2 } from "fs";
-import { delimiter, isAbsolute as isAbsolute4, join as join8, resolve as resolve7 } from "path";
+import { accessSync, constants as constants6, existsSync as existsSync4, lstatSync as lstatSync7, realpathSync, statSync as statSync3 } from "fs";
+import { delimiter, isAbsolute as isAbsolute6, join as join8, resolve as resolve8 } from "path";
 
 // src/lib/hook-diagnostics.ts
 var CONTEXT_ERROR_CODES = new Set([
@@ -3002,10 +3088,10 @@ function recordWithKeys(value, keys) {
   return value !== null && typeof value === "object" && !Array.isArray(value) && Object.keys(value).length === keys.length && keys.every((key) => Object.hasOwn(value, key));
 }
 function absolutePath2(value) {
-  return typeof value === "string" && value.length > 0 && value.length <= 32768 && !/[\x00-\x1f\x7f]/.test(value) && isAbsolute4(value) && resolve7(value) === value;
+  return typeof value === "string" && value.length > 0 && value.length <= 32768 && !/[\x00-\x1f\x7f]/.test(value) && isAbsolute6(value) && resolve8(value) === value;
 }
 function absoluteInput(value) {
-  return value.length > 0 && value.length <= 32768 && !/[\x00-\x1f\x7f]/.test(value) && isAbsolute4(value);
+  return value.length > 0 && value.length <= 32768 && !/[\x00-\x1f\x7f]/.test(value) && isAbsolute6(value);
 }
 function resolveSumiPathsCommand(pathValue) {
   if (!pathValue)
@@ -3013,10 +3099,10 @@ function resolveSumiPathsCommand(pathValue) {
   for (const directory of pathValue.split(delimiter)) {
     if (!directory || /[\x00-\x1f\x7f]/.test(directory))
       continue;
-    const candidate = resolve7(directory, "sumi-paths");
+    const candidate = resolve8(directory, "sumi-paths");
     try {
-      accessSync(candidate, constants4.X_OK);
-      if (statSync2(candidate).isFile())
+      accessSync(candidate, constants6.X_OK);
+      if (statSync3(candidate).isFile())
         return candidate;
     } catch {}
   }
@@ -3025,7 +3111,7 @@ function resolveSumiPathsCommand(pathValue) {
 function validPathPlan(value, home, cwd) {
   if (!recordWithKeys(value, ["schemaVersion", "kind", "home", "cwd", "roots", "legacyRoots", "configFiles", "skillRoots"]))
     return false;
-  if (value.schemaVersion !== 1 || value.kind !== "sumi-paths" || value.home !== resolve7(home) || value.cwd !== resolve7(cwd))
+  if (value.schemaVersion !== 1 || value.kind !== "sumi-paths" || value.home !== resolve8(home) || value.cwd !== resolve8(cwd))
     return false;
   if (!recordWithKeys(value.roots, SUMI_PATH_KEYS) || !recordWithKeys(value.legacyRoots, SUMI_PATH_KEYS))
     return false;
@@ -3061,7 +3147,7 @@ function sumiPathPlan(home, cwd = process.cwd(), env = process.env) {
     throw new SumiPathResolverError("SUMI_PATH_INPUT_REFUSED");
   const runtimePath = process.env.PATH ?? "";
   const executable = resolveSumiPathsCommand(runtimePath);
-  if (!executable || !isAbsolute4(executable))
+  if (!executable || !isAbsolute6(executable))
     throw new SumiPathResolverError("SUMI_PATH_RESOLVER_UNAVAILABLE");
   const childEnv = { PATH: runtimePath };
   for (const key of SUMI_PATH_SELECTORS)
@@ -3069,8 +3155,8 @@ function sumiPathPlan(home, cwd = process.cwd(), env = process.env) {
       childEnv[key] = env[key];
   let child2;
   try {
-    child2 = spawnSync2(executable, ["--json", "--home", resolve7(home), "--cwd", resolve7(cwd)], {
-      cwd: resolve7(cwd),
+    child2 = spawnSync2(executable, ["--json", "--home", resolve8(home), "--cwd", resolve8(cwd)], {
+      cwd: resolve8(cwd),
       env: childEnv,
       encoding: "buffer",
       timeout: 3000,
@@ -3102,7 +3188,7 @@ function selectedConfigDirectory(plan) {
   const canonical3 = plan.roots.config, legacy = plan.legacyRoots.config;
   if (legacy === null)
     return existsSync4(canonical3) ? realpathSync(canonical3) : canonical3;
-  const canonicalStat = lstatSync5(canonical3, { throwIfNoEntry: false }), legacyStat = lstatSync5(legacy, { throwIfNoEntry: false });
+  const canonicalStat = lstatSync7(canonical3, { throwIfNoEntry: false }), legacyStat = lstatSync7(legacy, { throwIfNoEntry: false });
   if (canonicalStat && legacyStat && realpathSync(canonical3) !== realpathSync(legacy))
     throw new Error("Sumi config roots conflict; complete native home adoption before Skills integration");
   const selected = canonicalStat ? canonical3 : legacyStat ? legacy : canonical3;
@@ -3247,7 +3333,7 @@ function runtimePrerequisites(home, cwd) {
     checked: [],
     code: null
   };
-  if (!isAbsolute5(home) || !isAbsolute5(cwd))
+  if (!isAbsolute7(home) || !isAbsolute7(cwd))
     return { ...result, code: "RUNTIME_PREREQUISITE_INPUT_REFUSED" };
   let agents;
   try {