@hasna/skills 0.10.82 → 0.10.88

package/dist/runtime-prerequisites.js

@@ -49,7 +49,7 @@ var __require = import.meta.require;
 // src/runtime-prerequisites.ts
 import { isAbsolute as isAbsolute7 } from "path";
 // package.json
-var version = "0.10.82";
+var version = "0.10.88";
 var package_default = {
   name: "@hasna/skills",
   version,
@@ -191,10 +191,218 @@ var package_default = {
 };
 
 // src/lib/agent-install-selection.ts
-import { lstatSync as lstatSync6 } from "fs";
-import { dirname as dirname6, join as join7, resolve as resolve7 } from "path";
+import { lstatSync as lstatSync7 } from "fs";
+import { dirname as dirname7, join as join9, resolve as resolve8 } from "path";
 import { homedir as homedir2 } from "os";
 
+// src/lib/opencode-hook-protocol.ts
+import { createHash as createHash2 } from "crypto";
+
+// src/lib/agent-bridge.ts
+import { createHash } from "crypto";
+import { lstatSync, readFileSync, readdirSync } from "fs";
+import { join } from "path";
+var CLI_BRIDGE_NAME = "skills-cli";
+var CLI_BRIDGE_VERSION = 1;
+var markdown = `---
+name: skills-cli
+description: Discover, load, author, and run versioned skills through the Skills CLI when a task needs reusable instructions or an executable skill.
+---
+
+Use the Skills CLI as the skill authority for this station.
+
+- Discover available skills with \`skills list --json\` or \`skills search <query> --json\`.
+- Read selected instructions with \`skills load <slug>\`. Use \`skills sync\` to refresh the station's shared selection profile.
+- Create local drafts with \`skills new <name> --kind instruction\` or \`--kind executable\` in the Skills-owned source directory. Validate with \`skills validate <name>\`; use \`skills push --help\` for explicit versioned publication.
+- Run a skill only when the user's task calls for execution. Use \`skills run --help\` and select the intended local or cloud target explicitly.
+
+This bridge contains no skill payloads. Do not copy skill content into agent-native skill directories or load other native skill copies. If a Skills command refuses authority, selection, integrity, or native drift, report that refusal and use its repair guidance; do not substitute bundled or stale local content. Explicit local draft authoring remains available.
+`;
+var CLI_BRIDGE_DIGEST = createHash("sha256").update(markdown).digest("hex");
+var CLI_BRIDGE_FILES = Object.freeze({
+  "SKILL.md": markdown,
+  ".hasna-skills.json": `${JSON.stringify({ managedBy: "@hasna/skills", kind: "cli-bridge", version: CLI_BRIDGE_VERSION, protocol: "selection-v1", contentSha256: CLI_BRIDGE_DIGEST }, null, 2)}
+`
+});
+function isOwnedCliBridge(path, expectedPaths) {
+  if (!expectedPaths.includes(path))
+    return false;
+  try {
+    if (!lstatSync(path).isDirectory())
+      return false;
+    if (JSON.stringify(readdirSync(path).sort()) !== JSON.stringify(Object.keys(CLI_BRIDGE_FILES).sort()))
+      return false;
+    return Object.entries(CLI_BRIDGE_FILES).every(([name, content]) => {
+      const file = join(path, name), stat = lstatSync(file);
+      return stat.isFile() && !stat.isSymbolicLink() && stat.size === Buffer.byteLength(content) && readFileSync(file, "utf8") === content;
+    });
+  } catch {
+    return false;
+  }
+}
+
+// src/lib/opencode-hook-protocol.ts
+var OPENCODE_BRIDGE_BODY_SHA256 = createHash2("sha256").update(CLI_BRIDGE_FILES["SKILL.md"].replace(/^---\n[\s\S]*?\n---\n/, "")).digest("hex");
+var OPENCODE_BRIDGE_DESCRIPTION_SHA256 = createHash2("sha256").update(/^description: (.+)$/m.exec(CLI_BRIDGE_FILES["SKILL.md"])[1]).digest("hex");
+
+// src/lib/agent-opencode.ts
+function renderOpenCodePlugin(command, profile) {
+  return `// Managed by @hasna/skills. Regenerate with skills hook install --agent opencode.
+import { spawn } from "node:child_process";
+import { createHash } from "node:crypto";
+const command = ${JSON.stringify(command)};
+const profile = ${JSON.stringify(profile)};
+const bridgeBodySha256 = ${JSON.stringify(OPENCODE_BRIDGE_BODY_SHA256)};
+const bridgeDescriptionSha256 = ${JSON.stringify(OPENCODE_BRIDGE_DESCRIPTION_SHA256)};
+function digest(text) { return createHash("sha256").update(text).digest("hex"); }
+function canonicalSkill(skill) {
+  return skill?.id === "skills-cli" && skill.name === "skills-cli" && typeof skill.path === "string"
+    && typeof skill.content === "string" && digest(skill.content) === bridgeBodySha256
+    && typeof skill.description === "string" && digest(skill.description) === bridgeDescriptionSha256
+    && (skill.autoinvoke === undefined || skill.autoinvoke === false);
+}
+function refusal() {
+  const error = new Error("Skills verification blocked this request. Review the OpenCode Skills hook configuration, then retry.");
+  error.name = "SkillsHookRefusal";
+  error.skillsHookRefusal = { version: 1, code: "SKILLS_HOOK_REFUSED" };
+  return error;
+}
+export default {
+  id: "local.hasna-skills-cli",
+  async setup(ctx) {
+    if (!ctx?.session?.hook || !ctx?.session?.get || !ctx?.skill?.transform || !ctx?.skill?.list || !ctx?.tool?.hook) throw refusal();
+    const registrations = [], pending = new Set(), sessions = new Set(), prompts = new Map();
+    let disposed = false;
+    function context(input) {
+      if (disposed) return Promise.reject(refusal());
+      return new Promise((resolve, reject) => {
+        // Availability failures may omit optional model context. Native skill
+        // consumption and explicit policy refusals always remain fail-closed.
+        const optional = input.delivery_phase === "context";
+        const chunks = []; let bytes = 0, settled = false, child, timer;
+        const finish = () => { clearTimeout(timer); pending.delete(cancel); };
+        const deny = () => { if (settled) return; settled = true; finish(); reject(refusal()); };
+        const unavailable = code => {
+          if (settled) return;
+          if (!optional || disposed) return deny();
+          settled = true; finish();
+          resolve({ delivered: false, text: "Skills context is unavailable [SKILLS_HOOK_" + code + "]. No Skills instructions were delivered by this hook. Ordinary work may continue. Do not perform actions that depend on unavailable Skills instructions, including previously loaded instructions. Explicit skills load, context and run still require verification. Do not substitute native, unmanaged or stale payloads." });
+        };
+        const stop = code => { unavailable(code); child?.kill("SIGKILL"); };
+        const cancel = () => { deny(); child?.kill("SIGKILL"); };
+        try {
+          child = spawn(command, ["hook", "user-prompt", "--agent", "opencode", "--selection-profile", profile], { cwd: input.cwd, stdio: ["pipe", "pipe", "pipe"] });
+        } catch { unavailable("SPAWN_FAILED"); return; }
+        pending.add(cancel);
+        timer = setTimeout(() => stop("TIMEOUT"), 15000);
+        child.stdout.on("data", chunk => { if (settled) return; bytes += chunk.length; if (bytes > 1048576) stop("OUTPUT_LIMIT"); else chunks.push(chunk); });
+        child.stdout.on("error", () => stop("TRANSPORT_FAILED"));
+        child.stderr.on("data", () => {});
+        child.stderr.on("error", () => stop("TRANSPORT_FAILED"));
+        child.stdin.on("error", () => stop("TRANSPORT_FAILED"));
+        child.on("error", () => unavailable("SPAWN_FAILED"));
+        child.on("close", code => {
+          if (settled) return;
+          if (disposed) return deny();
+          if (code !== 0) return unavailable("CHILD_FAILED");
+          let result;
+          try {
+            result = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+          } catch { unavailable("INVALID_RESPONSE"); return; }
+          if (!result || typeof result !== "object" || Array.isArray(result)) return unavailable("INVALID_RESPONSE");
+          if (result.decision === "block" || result.continue === false) return deny();
+          // hookContextOutput returns exactly {} for a successful empty
+          // context. It never attests native bridge verification.
+          const output = optional && Object.keys(result).length === 0
+            ? { hookEventName: input.hook_event_name, additionalContext: "" }
+            : result.hookSpecificOutput;
+          if (!output || typeof output !== "object" || Array.isArray(output) || output.hookEventName !== input.hook_event_name || typeof output.additionalContext !== "string") return unavailable("INVALID_RESPONSE");
+          if (input.hook_event_name === "BeforeTool" && result.nativeBridgeVerified !== true) return deny();
+          settled = true; finish();
+          resolve({ delivered: true, text: output.additionalContext });
+        });
+        try { child.stdin.end(JSON.stringify(input)); } catch { stop("TRANSPORT_FAILED"); }
+      });
+    }
+    async function input(sessionID, prompt, event) {
+      if (disposed) throw refusal();
+      let session;
+      try { session = await ctx.session.get({ sessionID }); } catch { throw refusal(); }
+      if (disposed || !session || session.id !== sessionID || typeof session.location?.directory !== "string" || (session.parentID !== undefined && typeof session.parentID !== "string") || session.parentID === sessionID) throw refusal();
+      return { hook_event_name: event ?? (!sessions.has(sessionID) ? session.parentID ? "SubagentStart" : "SessionStart" : "UserPromptSubmit"), delivery_phase: event ? "native" : "context", cwd: session.location.directory, session_id: sessionID, parent_session_id: session.parentID ?? null, prompt, restore: true };
+    }
+    async function dispose() {
+      if (disposed) return;
+      disposed = true;
+      for (const cancel of pending) cancel();
+      sessions.clear();
+      prompts.clear();
+      const results = await Promise.allSettled(registrations.reverse().map(registration => Promise.resolve().then(() => registration.dispose())));
+      if (results.some(result => result.status === "rejected")) throw refusal();
+    }
+    try {
+      registrations.push(await ctx.skill.transform(editor => {
+        for (const skill of editor.list()) if (!canonicalSkill(skill)) editor.remove(skill.id);
+      }));
+      async function verifyNativeBridge(sessionID) {
+        let skills;
+        try { skills = await ctx.skill.list(); } catch { throw refusal(); }
+        if (!Array.isArray(skills)) throw refusal();
+        const matches = skills.filter(skill => skill?.id === "skills-cli");
+        if (matches.length !== 1) throw refusal();
+        const skill = matches[0];
+        if (!canonicalSkill(skill)) throw refusal();
+        const metadata = { id: skill.id, name: skill.name, path: skill.path, contentSha256: digest(skill.content), descriptionSha256: digest(skill.description) };
+        await context({ ...await input(sessionID, "", "BeforeTool"), tool_input: { id: "skills-cli" }, native_skill: metadata });
+      }
+      registrations.push(await ctx.tool.hook("execute.before", async event => {
+        if (disposed) throw refusal();
+        if (event.tool !== "skill") return;
+        if (event.input?.id !== "skills-cli") throw refusal();
+        await verifyNativeBridge(event.sessionID);
+      }));
+      registrations.push(await ctx.session.hook("prompt", async event => {
+        if (disposed || typeof event.prompt?.text !== "string" || event.prompt.text.length > 128 * 1024) throw refusal();
+        if (event.prompt.skills !== undefined && (!Array.isArray(event.prompt.skills) || event.prompt.skills.some(skill => skill?.id !== "skills-cli"))) throw refusal();
+        // Attachments materialize immediately after this hook. Check the actual
+        // current registry object and on-disk bridge before native consumption.
+        if (event.prompt.skills?.length) await verifyNativeBridge(event.sessionID);
+        if (disposed) throw refusal();
+        const queued = prompts.get(event.sessionID) ?? [];
+        if (queued.reduce((size, entry) => size + entry.text.length + 1, 0) + event.prompt.text.length > 128 * 1024) throw refusal();
+        queued.push({ text: event.prompt.text });
+        prompts.set(event.sessionID, queued);
+      }));
+      registrations.push(await ctx.session.hook("context", async event => {
+        // Only prompt-hook input has owner-prompt provenance. Keep it transient
+        // until the one delivery-bearing CLI call, including an empty prompt.
+        // Checkpoints, synthetic user-role history and resumes never match.
+        const queued = [...(prompts.get(event.sessionID) ?? [])];
+        const result = await context(await input(event.sessionID, queued.map(entry => entry.text).join("\\n")));
+        if (disposed) throw refusal();
+        if (result.text) event.system.push({ type: "text", text: result.text });
+        // Remove only the prompt events this request consumed. New admission
+        // while the CLI was running belongs to the next model context.
+        const current = prompts.get(event.sessionID);
+        if (current) {
+          const remaining = current.filter(entry => !queued.includes(entry));
+          if (remaining.length) prompts.set(event.sessionID, remaining);
+          else prompts.delete(event.sessionID);
+        }
+        // Retry SessionStart on the next context after an unavailable child,
+        // but never replay prompt text already admitted to this model turn.
+        if (result.delivered) sessions.add(event.sessionID);
+      }));
+      return dispose;
+    } catch {
+      await dispose();
+      throw refusal();
+    }
+  },
+};
+`;
+}
+
 // src/lib/agent-adapters.ts
 var INTEGRATION_AGENTS = ["claude", "codex", "gemini", "opencode", "cursor", "hermes", "sumi"];
 function renderAgentHookCommand(command, agent, profileId, event) {
@@ -206,12 +414,12 @@ var AGENT_ADAPTERS = {
   claude: { root: ".claude/skills", config: ".claude/settings.json", events: ["UserPromptSubmit", "SessionStart", "SubagentStart"], promptContext: true },
   codex: { root: ".codex/skills", config: ".codex/hooks.json", events: ["UserPromptSubmit", "SessionStart", "SubagentStart"], promptContext: true },
   gemini: { root: ".gemini/skills", config: ".gemini/settings.json", events: ["BeforeAgent", "SessionStart"], promptContext: true },
-  opencode: { root: ".config/opencode/skills", config: ".config/opencode/opencode.json", events: ["chat.message"], promptContext: true },
+  opencode: { root: ".config/opencode/skills", config: ".config/opencode/opencode.json", events: ["prompt", "context"], promptContext: true },
   sumi: { root: null, config: null, events: ["prompt", "context"], promptContext: true },
   hermes: { root: ".hermes/skills", config: ".hermes/config.yaml", events: ["pre_llm_call", "pre_tool_call"], promptContext: true, promptFailureMode: "open", toolFailureMode: "supervised-child-errors-block", requiresNativeTrust: true },
   cursor: { root: ".cursor/skills", config: ".cursor/hooks.json", events: ["beforeSubmitPrompt", "sessionStart"], promptContext: false }
 };
-function renderOpenCodePlugin(command, profileId) {
+function renderLegacyOpenCodePlugin(command, profileId) {
   return `// Managed by @hasna/skills. Regenerate with skills hook install --agent opencode.
 import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
@@ -261,8 +469,12 @@ export default async ({ directory }) => {
 };
 `;
 }
+function isManagedOpenCodePlugin(text, command, profileId) {
+  return text === renderOpenCodePlugin(command, profileId) || text === renderLegacyOpenCodePlugin(command, profileId);
+}
 
 // src/lib/native-discovery-roots.ts
+import { dirname, join as join2, resolve } from "path";
 var NATIVE_SKILL_ROOTS = [
   ["claude", ".claude/skills"],
   ["codex", ".codex/skills"],
@@ -282,14 +494,32 @@ var NATIVE_SKILL_ROOTS = [
   ["roo", ".roo/skills"],
   ["copilot", ".github/skills"]
 ];
+function nativeSumiProjectSkillRoots(home, project, resolveSumiRoots) {
+  return [...resolveSumiRoots(home, project), ...[".claude", ".agents"].flatMap((directory) => ["skill", "skills"].map((name) => join2(project, directory, name)))];
+}
+function nativeProjectAncestorDirectories(projects, canonical = resolve) {
+  const directories = new Set;
+  for (const project of projects) {
+    for (let path = canonical(project), depth = 0;; depth++) {
+      if (depth >= 100)
+        throw new Error("NATIVE_SKILL_DRIFT: project ancestor discovery limit exceeded");
+      directories.add(path);
+      const parent = dirname(path);
+      if (parent === path)
+        break;
+      path = parent;
+    }
+  }
+  return [...directories];
+}
 
 // src/lib/managed-policy.ts
-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";
+import { closeSync as closeSync5, constants as constants5, fstatSync as fstatSync5, lstatSync as lstatSync6, openSync as openSync5, readSync as readSync4 } from "fs";
+import { join as join8 } from "path";
 
 // src/lib/config.ts
-import { closeSync, constants, existsSync as existsSync2, fstatSync, lstatSync, openSync, readFileSync, statSync, writeFileSync, mkdirSync } from "fs";
-import { join as join2, dirname } from "path";
+import { closeSync, constants, existsSync as existsSync2, fstatSync, lstatSync as lstatSync2, openSync, readFileSync as readFileSync2, statSync, writeFileSync, mkdirSync } from "fs";
+import { join as join4, dirname as dirname2 } from "path";
 
 // src/lib/retired-settings.ts
 var RETIRED_ENV_SUFFIXES = ["_STORAGE_MODE", "_DEPLOYMENT_MODE", "_CLOUD_MODE"];
@@ -345,7 +575,7 @@ function assertNoRetiredConfigKeys(config, source) {
 // src/lib/app-home.ts
 import { existsSync } from "fs";
 import { homedir } from "os";
-import { join, resolve } from "path";
+import { join as join3, resolve as resolve2 } from "path";
 import { homedir as pathsResolverHomedir } from "os";
 import { join as pathsResolverJoin } from "path";
 var PATHS_RESOLVER_DATA_ENV = "HASNA_DATA_HOME";
@@ -381,7 +611,7 @@ function effectiveHome() {
   return process.env["HOME"] || process.env["USERPROFILE"] || homedir() || "/tmp";
 }
 function legacyDataRoot() {
-  return join(effectiveHome(), ".hasna", "skills");
+  return join3(effectiveHome(), ".hasna", "skills");
 }
 function resolverDataRoot(home = effectiveHome(), env) {
   return dataDir({ app: "skills", home, env });
@@ -390,13 +620,13 @@ function adoptResolverDataRoot(resolved, env = process.env) {
   const dataOverride = env.HASNA_DATA_HOME;
   if (typeof dataOverride === "string" && dataOverride.trim().length > 0)
     return true;
-  return existsSync(join(resolved, DEFAULT_SQLITE_FILENAME)) || existsSync(join(resolved, GLOBAL_CONFIG_FILENAME));
+  return existsSync(join3(resolved, DEFAULT_SQLITE_FILENAME)) || existsSync(join3(resolved, GLOBAL_CONFIG_FILENAME));
 }
 function exactDataRoot() {
   for (const key of [DATA_DIR_ENV, HASNA_SKILLS_HOME_ENV, SKILLS_HOME_ENV]) {
     const dir = process.env[key]?.trim();
     if (dir)
-      return resolve(dir);
+      return resolve2(dir);
   }
   return;
 }
@@ -405,19 +635,19 @@ function getDataRoot() {
   if (exact)
     return exact;
   const resolved = resolverDataRoot();
-  return adoptResolverDataRoot(resolved) ? resolve(resolved) : resolve(legacyDataRoot());
+  return adoptResolverDataRoot(resolved) ? resolve2(resolved) : resolve2(legacyDataRoot());
 }
 function skillsDataRootForHome(home) {
-  const isOwnHome = resolve(home) === resolve(effectiveHome()) || resolve(home) === resolve(homedir());
+  const isOwnHome = resolve2(home) === resolve2(effectiveHome()) || resolve2(home) === resolve2(homedir());
   if (isOwnHome) {
     const exact = exactDataRoot();
     if (exact)
       return exact;
     const resolved2 = resolverDataRoot(home);
-    return adoptResolverDataRoot(resolved2) ? resolve(resolved2) : resolve(join(home, ".hasna", "skills"));
+    return adoptResolverDataRoot(resolved2) ? resolve2(resolved2) : resolve2(join3(home, ".hasna", "skills"));
   }
   const resolved = resolverDataRoot(home, {});
-  return adoptResolverDataRoot(resolved, {}) ? resolve(resolved) : resolve(join(home, ".hasna", "skills"));
+  return adoptResolverDataRoot(resolved, {}) ? resolve2(resolved) : resolve2(join3(home, ".hasna", "skills"));
 }
 
 // src/lib/config.ts
@@ -448,7 +678,7 @@ var INSTALLED_SKILLS_DIRNAME = "installed";
 var SKILLS_CACHE_DIRNAME = "skills";
 var LAYOUT_MIGRATION_RECORD = ".layout-migration.json";
 function isOwnerLayoutMigrated(appDir) {
-  return existsSync2(join2(appDir, SKILLS_CACHE_DIRNAME, LAYOUT_MIGRATION_RECORD));
+  return existsSync2(join4(appDir, SKILLS_CACHE_DIRNAME, LAYOUT_MIGRATION_RECORD));
 }
 function getDataDir() {
   const root = getDataRoot();
@@ -462,16 +692,16 @@ function getDataDirReadOnly() {
 }
 function getConfigPath(scope) {
   if (scope === "global") {
-    return join2(getDataDir(), "config.json");
+    return join4(getDataDir(), "config.json");
   }
-  return join2(process.cwd(), "skills.config.json");
+  return join4(process.cwd(), "skills.config.json");
 }
 function readConfigFile(path) {
   if (!existsSync2(path))
     return {};
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync(path, "utf-8"));
+    parsed = JSON.parse(readFileSync2(path, "utf-8"));
   } catch {
     return {};
   }
@@ -508,7 +738,7 @@ function saveConfig(key, value, scope = "project") {
   let existing = {};
   if (existsSync2(filePath)) {
     try {
-      existing = JSON.parse(readFileSync(filePath, "utf-8"));
+      existing = JSON.parse(readFileSync2(filePath, "utf-8"));
       if (typeof existing !== "object" || existing === null || Array.isArray(existing)) {
         existing = {};
       }
@@ -516,7 +746,7 @@ function saveConfig(key, value, scope = "project") {
       existing = {};
     }
   } else {
-    const dir = dirname(filePath);
+    const dir = dirname2(filePath);
     if (!existsSync2(dir)) {
       mkdirSync(dir, { recursive: true });
     }
@@ -535,7 +765,7 @@ function unsetConfig(key, scope = "project") {
     return false;
   let existing;
   try {
-    const parsed = JSON.parse(readFileSync(filePath, "utf-8"));
+    const parsed = JSON.parse(readFileSync2(filePath, "utf-8"));
     if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
       return false;
     existing = parsed;
@@ -551,17 +781,17 @@ function unsetConfig(key, scope = "project") {
 }
 
 // src/lib/selection-cache.ts
-import { createHash as createHash2, randomUUID } from "crypto";
+import { createHash as createHash4, randomUUID } from "crypto";
 import { spawnSync } from "child_process";
-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 { closeSync as closeSync2, constants as constants2, fstatSync as fstatSync2, fsyncSync, linkSync, lstatSync as lstatSync3, mkdirSync as mkdirSync2, openSync as openSync2, readFileSync as readFileSync4, readlinkSync, readSync, renameSync, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
 import { hostname } from "os";
-import { dirname as dirname2, isAbsolute, join as join4, parse, resolve as resolve2 } from "path";
+import { dirname as dirname3, isAbsolute, join as join6, parse, resolve as resolve3 } from "path";
 import { isDeepStrictEqual } from "util";
 
 // src/lib/skill-bundle.ts
-import { createHash } from "crypto";
-import { readFileSync as readFileSync2, readdirSync, statSync as statSync2 } from "fs";
-import { join as join3, relative } from "path";
+import { createHash as createHash3 } from "crypto";
+import { readFileSync as readFileSync3, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
+import { join as join5, relative } from "path";
 import { createGunzip } from "zlib";
 
 // src/lib/skill-entry-path.ts
@@ -748,7 +978,7 @@ function ownBytes(view) {
   return out;
 }
 function sha256Hex(bytes) {
-  return createHash("sha256").update(bytes).digest("hex");
+  return createHash3("sha256").update(bytes).digest("hex");
 }
 function collectSkillBundleEntries(dir) {
   const entries = [];
@@ -756,8 +986,8 @@ function collectSkillBundleEntries(dir) {
   return entries.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
 }
 function walk(root, current, out) {
-  for (const entry of readdirSync(current, { withFileTypes: true })) {
-    const absolute = join3(current, entry.name);
+  for (const entry of readdirSync2(current, { withFileTypes: true })) {
+    const absolute = join5(current, entry.name);
     const rel = relative(root, absolute).split("\\").join("/");
     const isRootLevel = !rel.includes("/");
     if (ANY_SEGMENT_EXCLUDES.has(entry.name.toLowerCase()))
@@ -781,7 +1011,7 @@ function walk(root, current, out) {
     const stats = statSync2(absolute);
     out.push({
       path: rel,
-      bytes: ownBytes(readFileSync2(absolute)),
+      bytes: ownBytes(readFileSync3(absolute)),
       mode: stats.mode & 64 ? 493 : 420
     });
   }
@@ -1001,7 +1231,7 @@ async function inspectSkillBundle(bundle, options = {}) {
       parser.push(chunk);
       bytesSinceYield += chunk.byteLength;
       if (bytesSinceYield >= 256 * 1024) {
-        await new Promise((resolve2) => setTimeout(resolve2, 0));
+        await new Promise((resolve3) => setTimeout(resolve3, 0));
         bytesSinceYield = 0;
         check();
       }
@@ -1239,14 +1469,14 @@ class SkillSelectionError extends Error {
 var MAX_CACHED_PROFILE_AGE_MS = 24 * 60 * 60 * 1000;
 var SELECTION_LOCK_FILE = "selection.lock.json";
 function selectionCacheRoot(options = {}) {
-  return resolve2(options.cacheDir ?? join4(getDataDirReadOnly(), "selection-cache"));
+  return resolve3(options.cacheDir ?? join6(getDataDirReadOnly(), "selection-cache"));
 }
 function selectionKey(selection) {
   validateSelection(selection);
   return hash([selection.authority, selection.workspaceId, selection.slug, selection.version, selection.bundleDigest]);
 }
 function hash(value) {
-  return createHash2("sha256").update(JSON.stringify(value)).digest("hex");
+  return createHash4("sha256").update(JSON.stringify(value)).digest("hex");
 }
 function validateSelection(selection) {
   if (!selection || !/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(selection.slug) || !isValidSkillVersion(selection.version) || !/^sha256:[a-f0-9]{64}$/.test(selection.bundleDigest) || typeof selection.workspaceId !== "string" || !selection.workspaceId.trim() || selection.authorizationEpoch !== undefined && (typeof selection.authorizationEpoch !== "string" || !/^[a-f0-9]{32}$/.test(selection.authorizationEpoch)) || typeof selection.profileRevision !== "string" || !selection.profileRevision.trim()) {
@@ -1283,25 +1513,35 @@ function validateResolvedProfile(profile, authority) {
 }
 function selectionBundlePath(selection, options = {}) {
   validateSelection(selection);
-  return join4(selectionCacheRoot(options), "objects", hash(selection.authority), hash(selection.workspaceId), `${selection.bundleDigest.slice(7)}.tar.gz`);
+  return join6(selectionCacheRoot(options), "objects", hash(selection.authority), hash(selection.workspaceId), `${selection.bundleDigest.slice(7)}.tar.gz`);
 }
 function assertRegularPath(path, createParents = false) {
-  const absolute = resolve2(path);
+  const absolute = resolve3(path);
   const root = parse(absolute).root;
   let cursor = root;
   const segments = absolute.slice(root.length).split("/");
   for (let index = 0;index < segments.length; index++) {
-    cursor = join4(cursor, segments[index]);
+    cursor = join6(cursor, segments[index]);
     try {
-      const stat = lstatSync2(cursor);
+      const stat = lstatSync3(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.");
       }
     } catch (error) {
       if (error.code !== "ENOENT")
         throw error;
-      if (createParents && index < segments.length - 1)
-        mkdirSync2(cursor, { mode: 448 });
+      if (createParents && index < segments.length - 1) {
+        try {
+          mkdirSync2(cursor, { mode: 448 });
+        } catch (creationError) {
+          if (creationError.code !== "EEXIST")
+            throw creationError;
+        }
+        const parent = lstatSync3(cursor);
+        if (parent.isSymbolicLink() || !parent.isDirectory()) {
+          throw new SkillSelectionError("UNSAFE_CACHE_PATH", "Skills cache paths must not traverse symlinks or non-directories.");
+        }
+      }
     }
   }
 }
@@ -1343,7 +1583,7 @@ function writeSelectionJson(path, value) {
 }
 function atomicWrite(path, bytes, mode, durable = false) {
   assertRegularPath(path, true);
-  const temporary = join4(dirname2(path), `.selection-${randomUUID()}.tmp`);
+  const temporary = join6(dirname3(path), `.selection-${randomUUID()}.tmp`);
   try {
     const fd = openSync2(temporary, constants2.O_WRONLY | constants2.O_CREAT | constants2.O_EXCL | constants2.O_NOFOLLOW, mode);
     try {
@@ -1355,7 +1595,7 @@ function atomicWrite(path, bytes, mode, durable = false) {
     }
     renameSync(temporary, path);
     if (durable)
-      syncDirectory(dirname2(path));
+      syncDirectory(dirname3(path));
   } finally {
     try {
       unlinkSync(temporary);
@@ -1365,6 +1605,16 @@ function atomicWrite(path, bytes, mode, durable = false) {
     }
   }
 }
+function readSelectionFileSnapshot(path, maximumBytes = 4096) {
+  const before = lstatSync3(path, { throwIfNoEntry: false });
+  if (!before)
+    return null;
+  const bytes = readRegularFile(path, maximumBytes);
+  const after = lstatSync3(path, { throwIfNoEntry: false });
+  if (!bytes || !after?.isFile() || after.dev !== before.dev || after.ino !== before.ino)
+    return null;
+  return { bytes, sha256: sha256Hex(bytes), mtimeMs: after.mtimeMs, dev: after.dev, ino: after.ino };
+}
 function readSelectionJson(path, maximumBytes = MAX_PROFILE_DOCUMENT_BYTES) {
   const bytes = readRegularFile(path, Math.min(maximumBytes, MAX_PROFILE_DOCUMENT_BYTES));
   if (!bytes)
@@ -1382,7 +1632,8 @@ async function verifiedEntries(selection, bytes, signal, deadline) {
   signal?.throwIfAborted();
   if (remaining !== undefined && remaining <= 0)
     throw new SkillBundleInspectionError("BUNDLE_TIMEOUT", "Bundle inspection deadline exceeded");
-  const bundle = await inspectSkillBundle(bytes, { signal, ...remaining === undefined ? {} : { limits: { timeoutMs: remaining } } });
+  const inspection = remaining === undefined ? {} : { limits: { timeoutMs: Math.min(remaining, SKILL_BUNDLE_INSPECTION_LIMITS.timeoutMs) } };
+  const bundle = await inspectSkillBundle(bytes, { signal, ...inspection });
   return bundle.entries;
 }
 async function readCachedSelection(selection, options = {}) {
@@ -1455,7 +1706,7 @@ async function cacheSelectionBundle(selection, response, options = {}) {
   return entries;
 }
 function profilePath(profileId, options) {
-  return join4(selectionCacheRoot(options), "profiles", `${hash(profileId)}.json`);
+  return join6(selectionCacheRoot(options), "profiles", `${hash(profileId)}.json`);
 }
 function activateSelectionProfile(profile, options = {}) {
   validateResolvedProfile(profile);
@@ -1487,7 +1738,7 @@ function assertFreshCachedProfile(receipt, options = {}) {
   }
 }
 function projectSelectionLockPath(projectDir) {
-  return join4(resolve2(projectDir), ".skills", SELECTION_LOCK_FILE);
+  return join6(resolve3(projectDir), ".skills", SELECTION_LOCK_FILE);
 }
 function readProjectSelectionSnapshot(projectDir) {
   const path = projectSelectionLockPath(projectDir);
@@ -1506,7 +1757,7 @@ function readProjectSelectionSnapshot(projectDir) {
 function sessionReceiptPath(sessionId, options = {}) {
   if (!sessionId.trim() || sessionId.length > MAX_SKILL_SESSION_ID_CHARS)
     throw new SkillSelectionError("INVALID_SESSION", `A Skills session id must contain 1\u2013${MAX_SKILL_SESSION_ID_CHARS} characters.`);
-  return join4(selectionCacheRoot(options), "sessions", `${hash(sessionId)}.json`);
+  return join6(selectionCacheRoot(options), "sessions", `${hash(sessionId)}.json`);
 }
 function skillSessionGeneration(receipt) {
   return receipt.generation ?? 0;
@@ -1560,7 +1811,7 @@ var SESSION_LOCK_MIN_AGE_MS = 30000;
 function localBootId() {
   try {
     if (process.platform === "linux") {
-      const value = readFileSync3("/proc/sys/kernel/random/boot_id", "utf8").trim();
+      const value = readFileSync4("/proc/sys/kernel/random/boot_id", "utf8").trim();
       return /^[a-f0-9-]{36}$/i.test(value) ? value : null;
     }
     if (process.platform === "darwin") {
@@ -1578,7 +1829,7 @@ function processStart(pid) {
     return { state: "unknown" };
   if (process.platform === "linux") {
     try {
-      const stat = readFileSync3(`/proc/${pid}/stat`, "utf8");
+      const stat = readFileSync4(`/proc/${pid}/stat`, "utf8");
       const close = stat.lastIndexOf(")");
       const start = close < 0 ? undefined : stat.slice(close + 2).trim().split(/\s+/)[19];
       return start && /^\d+$/.test(start) ? { state: "alive", start: `linux:${start}` } : { state: "unknown" };
@@ -1597,7 +1848,16 @@ function processStart(pid) {
   }
   return { state: "unknown" };
 }
+var cachedLocalLockIdentity;
 function localLockIdentity() {
+  if (cachedLocalLockIdentity?.pid === process.pid)
+    return { ...cachedLocalLockIdentity.identity };
+  const identity = probeLocalLockIdentity();
+  if (identity)
+    cachedLocalLockIdentity = { pid: process.pid, identity: { ...identity } };
+  return identity;
+}
+function probeLocalLockIdentity() {
   const bootId = localBootId(), owner = processStart(process.pid);
   if (!bootId || owner.state !== "alive")
     return null;
@@ -1615,14 +1875,14 @@ function localLockIdentity() {
 }
 function readSessionLock(sessionId, options) {
   const path = `${sessionReceiptPath(sessionId, options)}.write-lock`;
-  const before = lstatSync2(path, { throwIfNoEntry: false });
+  const before = lstatSync3(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 = lstatSync2(path, { throwIfNoEntry: false });
+  const after = lstatSync3(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.");
   }
@@ -1639,7 +1899,7 @@ function readSessionLock(sessionId, options) {
   if (after.nlink === 2) {
     stagingPath = `${path}.${marker.operationId}.prepared`;
     assertRegularPath(stagingPath);
-    const staged = lstatSync2(stagingPath, { throwIfNoEntry: false });
+    const staged = lstatSync3(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.");
     }
@@ -1658,20 +1918,20 @@ function publishSessionLock(path, marker) {
     fsyncSync(fd);
     linkSync(stagingPath, path);
     published = true;
-    syncDirectory(dirname2(path));
-    const staged = lstatSync2(stagingPath);
+    syncDirectory(dirname3(path));
+    const staged = lstatSync3(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.");
     }
     unlinkSync(stagingPath);
-    syncDirectory(dirname2(path));
+    syncDirectory(dirname3(path));
     handedOff = true;
     return { path, stagingPath, fd, dev: stat.dev, ino: stat.ino };
   } finally {
     if (!handedOff) {
       try {
         for (const target of [...published ? [path] : [], stagingPath]) {
-          const current = lstatSync2(target, { throwIfNoEntry: false });
+          const current = lstatSync3(target, { throwIfNoEntry: false });
           if (current?.isFile() && current.dev === stat.dev && current.ino === stat.ino)
             unlinkSync(target);
         }
@@ -1709,16 +1969,16 @@ function archiveSessionLock(lock, receipt, explicitLocalHost) {
     writeFileSync2(guardFd, `${JSON.stringify({ schemaVersion: 1, pid: process.pid, operationId: randomUUID() })}
 `);
     fsyncSync(guardFd);
-    const cacheOptions = { cacheDir: dirname2(dirname2(lock.path)) };
+    const cacheOptions = { cacheDir: dirname3(dirname3(lock.path)) };
     const current = readSessionLock(lock.marker.sessionId, cacheOptions);
     if (!current || current.dev !== lock.dev || current.ino !== lock.ino || current.sha256 !== lock.sha256 || current.mtimeMs !== lock.mtimeMs || !writerIsGone(current, explicitLocalHost))
       return null;
     const currentReceipt = readSkillSessionSnapshotIfExists(lock.marker.sessionId, cacheOptions);
     if (currentReceipt?.sha256 !== receipt?.sha256 || currentReceipt?.generation !== receipt?.generation)
       return null;
-    const directory = join4(dirname2(dirname2(lock.path)), "session-lock-recoveries", randomUUID());
-    const archivePath = join4(directory, "original.write-lock");
-    const recordPath = join4(directory, "recovery.json");
+    const directory = join6(dirname3(dirname3(lock.path)), "session-lock-recoveries", randomUUID());
+    const archivePath = join6(directory, "original.write-lock");
+    const recordPath = join6(directory, "recovery.json");
     assertRegularPath(archivePath, true);
     archiveBytes(recordPath, Buffer.from(`${JSON.stringify({
       schemaVersion: 1,
@@ -1733,7 +1993,7 @@ function archiveSessionLock(lock, receipt, explicitLocalHost) {
     })}
 `));
     syncDirectory(directory);
-    syncDirectory(dirname2(directory));
+    syncDirectory(dirname3(directory));
     const finalLock = readSessionLock(lock.marker.sessionId, cacheOptions);
     if (!finalLock || finalLock.dev !== lock.dev || finalLock.ino !== lock.ino || finalLock.sha256 !== lock.sha256 || readSkillSessionSnapshotIfExists(lock.marker.sessionId, cacheOptions)?.sha256 !== receipt?.sha256)
       return null;
@@ -1743,16 +2003,16 @@ function archiveSessionLock(lock, receipt, explicitLocalHost) {
       moved = true;
       const archivedPaths = [archivePath];
       if (finalLock.stagingPath) {
-        const publicationPath = join4(directory, "publication.write-lock");
+        const publicationPath = join6(directory, "publication.write-lock");
         renameSync(finalLock.stagingPath, publicationPath);
         archivedPaths.push(publicationPath);
       }
       syncDirectory(directory);
-      syncDirectory(dirname2(lock.path));
+      syncDirectory(dirname3(lock.path));
       for (const path of archivedPaths) {
-        const before = lstatSync2(path, { throwIfNoEntry: false });
+        const before = lstatSync3(path, { throwIfNoEntry: false });
         const bytes = readRegularFile(path, SESSION_LOCK_MAX_BYTES);
-        const after = lstatSync2(path, { throwIfNoEntry: false });
+        const after = lstatSync3(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");
         }
@@ -1765,19 +2025,68 @@ function archiveSessionLock(lock, receipt, explicitLocalHost) {
     return archivePath;
   } finally {
     closeSync2(guardFd);
-    const current = lstatSync2(guardPath, { throwIfNoEntry: false });
+    const current = lstatSync3(guardPath, { throwIfNoEntry: false });
     if (current?.isFile() && current.dev === guardStat.dev && current.ino === guardStat.ino)
       unlinkSync(guardPath);
   }
 }
-function withSessionWriteLocks(sessionIds, options, action) {
+var SESSION_WRITE_LOCK_WAIT_MS = 2000;
+var SESSION_WRITE_LOCK_RETRY_MIN_MS = 25;
+var SESSION_WRITE_LOCK_RETRY_MAX_MS = 100;
+function lockStatIdentity(path) {
+  try {
+    const stat = lstatSync3(path, { throwIfNoEntry: false });
+    return stat ? `${stat.dev}:${stat.ino}:${stat.mtimeMs}:${stat.ctimeMs}:${stat.nlink}:${stat.size}` : null;
+  } catch {
+    return null;
+  }
+}
+function sleepSync(ms) {
+  if (ms > 0)
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+var SESSION_LOCK_INSPECTIONS = 3;
+function inspectSessionLockSettled(sessionId, options) {
+  const path = `${sessionReceiptPath(sessionId, options)}.write-lock`;
+  let invalid;
+  for (let attempt = 0;attempt < SESSION_LOCK_INSPECTIONS; attempt++) {
+    try {
+      return readSessionLock(sessionId, options);
+    } catch (error) {
+      if (!(error instanceof SkillSelectionError) || error.code !== "SESSION_WRITE_LOCKED")
+        throw error;
+      const seen = lockStatIdentity(path);
+      if (seen !== null && seen === invalid)
+        throw error;
+      invalid = seen;
+      sleepSync(SESSION_WRITE_LOCK_RETRY_MIN_MS);
+    }
+  }
+  return "changing";
+}
+function assertSessionWriteLockReadable(sessionId, options = {}) {
+  for (let attempt = 0;; attempt++) {
+    try {
+      readSessionLock(sessionId, options);
+      return;
+    } catch (error) {
+      if (attempt >= 2 || !(error instanceof SkillSelectionError) || error.code !== "SESSION_WRITE_LOCKED")
+        throw error;
+      sleepSync(SESSION_WRITE_LOCK_RETRY_MIN_MS);
+    }
+  }
+}
+function withSessionWriteLocks(sessionIds, options, action, waitMs = 0) {
   const operationId = randomUUID();
   const identity = localLockIdentity();
+  if (!Number.isFinite(waitMs) || waitMs < 0 || waitMs > SESSION_WRITE_LOCK_WAIT_MS)
+    throw new SkillSelectionError("INVALID_CONTEXT_BUDGET", "A session write lock wait must be within its supported bound.");
+  const waitUntil = performance.now() + waitMs;
   const locks = [...new Set(sessionIds)].map((sessionId) => ({ sessionId, path: `${sessionReceiptPath(sessionId, options)}.write-lock` })).sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
   const owned = [];
   const assertOwned = () => {
     for (const lock of owned) {
-      const current = lstatSync2(lock.path, { throwIfNoEntry: false });
+      const current = lstatSync3(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.");
       }
@@ -1788,11 +2097,14 @@ function withSessionWriteLocks(sessionIds, options, action) {
       assertRegularPath(lock.path, true);
       const marker = { schemaVersion: identity ? 2 : 1, operationId, sessionId: lock.sessionId, pid: process.pid, ...identity };
       let acquired;
-      try {
-        acquired = publishSessionLock(lock.path, marker);
-      } catch (error) {
-        if (error.code !== "EEXIST")
-          throw error;
+      while (!acquired) {
+        try {
+          acquired = publishSessionLock(lock.path, marker);
+          break;
+        } catch (error) {
+          if (error.code !== "EEXIST")
+            throw error;
+        }
         try {
           const stale = readSessionLock(lock.sessionId, options);
           const receipt = stale && readSkillSessionSnapshotIfExists(lock.sessionId, options);
@@ -1805,14 +2117,20 @@ function withSessionWriteLocks(sessionIds, options, action) {
         }
         try {
           acquired = publishSessionLock(lock.path, marker);
+          break;
         } catch (retryError) {
-          if (retryError.code === "EEXIST") {
-            if (!readSessionLock(lock.sessionId, options))
-              throw new SkillSelectionError("SESSION_WRITE_LOCK_CHANGED", "The session lock changed during acquisition.");
-            throw new SkillSelectionError("SESSION_WRITE_BUSY", "Another Skills process owns a required session write lock; retry after it completes. A surviving legacy lock requires explicit recovery review.");
-          }
-          throw retryError;
+          if (retryError.code !== "EEXIST")
+            throw retryError;
+        }
+        const held = inspectSessionLockSettled(lock.sessionId, options);
+        const remaining = waitUntil - performance.now();
+        if (remaining <= 0) {
+          if (!held)
+            throw new SkillSelectionError("SESSION_WRITE_LOCK_CHANGED", "The session lock changed during acquisition.");
+          throw new SkillSelectionError("SESSION_WRITE_BUSY", "Another Skills process owns a required session write lock; retry after it completes. A surviving legacy lock requires explicit recovery review.");
         }
+        if (held)
+          sleepSync(Math.min(remaining, SESSION_WRITE_LOCK_RETRY_MIN_MS + Math.floor(Math.random() * (SESSION_WRITE_LOCK_RETRY_MAX_MS - SESSION_WRITE_LOCK_RETRY_MIN_MS))));
       }
       owned.push(acquired);
     }
@@ -1821,7 +2139,7 @@ function withSessionWriteLocks(sessionIds, options, action) {
     for (const lock of owned.reverse()) {
       try {
         for (const path of [lock.path, lock.stagingPath]) {
-          const current = lstatSync2(path, { throwIfNoEntry: false });
+          const current = lstatSync3(path, { throwIfNoEntry: false });
           if (current?.isFile() && current.dev === lock.dev && current.ino === lock.ino)
             unlinkSync(path);
         }
@@ -1831,8 +2149,8 @@ function withSessionWriteLocks(sessionIds, options, action) {
     }
   }
 }
-function withSessionWriteLock(sessionId, options, action) {
-  return withSessionWriteLocks([sessionId], options, action);
+function withSessionWriteLock(sessionId, options, action, waitMs = 0) {
+  return withSessionWriteLocks([sessionId], options, action, waitMs);
 }
 function sameSnapshot(actual, expected) {
   return actual === null ? expected === null : expected !== null && actual.sessionId === expected.sessionId && actual.generation === expected.generation && actual.receiptSha256 === expected.receiptSha256;
@@ -1873,7 +2191,7 @@ function writeSkillSession(receipt, expected, options = {}) {
         parentChanged();
     }
     writeSelectionJson(sessionReceiptPath(receipt.sessionId, options), next);
-  });
+  }, SESSION_WRITE_LOCK_WAIT_MS);
 }
 function syncDirectory(path) {
   assertRegularPath(path);
@@ -1909,8 +2227,8 @@ function replaceSkillSession(expected, replacement, plan, options = {}, beforeCo
     if (before.receipt.profile.authority !== replacement.profile.authority || before.receipt.profile.workspaceId !== replacement.profile.workspaceId) {
       throw new SkillSelectionError("PROFILE_IDENTITY_MISMATCH", "A session reconciliation cannot change its Skills authority or workspace.");
     }
-    const directory = join4(selectionCacheRoot(options), "session-reconciliations", randomUUID());
-    const archivePath = join4(directory, "original.json"), replacementPath = join4(directory, "replacement.json"), receiptPath = join4(directory, "receipt.json");
+    const directory = join6(selectionCacheRoot(options), "session-reconciliations", randomUUID());
+    const archivePath = join6(directory, "original.json"), replacementPath = join6(directory, "replacement.json"), receiptPath = join6(directory, "receipt.json");
     const afterSha256 = sha256Hex(bytes);
     archiveBytes(archivePath, before.bytes);
     archiveBytes(replacementPath, bytes);
@@ -1918,7 +2236,7 @@ function replaceSkillSession(expected, replacement, plan, options = {}, beforeCo
     archiveBytes(receiptPath, Buffer.from(`${JSON.stringify(receipt)}
 `));
     syncDirectory(directory);
-    syncDirectory(dirname2(directory));
+    syncDirectory(dirname3(directory));
     syncDirectory(selectionCacheRoot(options));
     if (sha256Hex(readRegularFile(archivePath, MAX_PROFILE_DOCUMENT_BYTES)) !== before.sha256 || !sameSnapshot(readSkillSessionSnapshot(replacement.sessionId, options), expected)) {
       throw new SkillSelectionError("SESSION_RECEIPT_CHANGED", "The session or its preservation archive changed before replacement; retained evidence must be reviewed.");
@@ -1933,11 +2251,11 @@ function replaceSkillSession(expected, replacement, plan, options = {}, beforeCo
       throw new SkillSelectionError("SESSION_RECONCILIATION_INCOMPLETE", `Inspect sessions show and the preserved operation receipt at ${receiptPath} before any retry; replacement may already have committed.`);
     }
     return { archivePath, receiptPath, beforeSha256: before.sha256, afterSha256 };
-  });
+  }, SESSION_WRITE_LOCK_WAIT_MS);
 }
 
 // src/lib/agent-policy-limits.ts
-import { basename as basename4, isAbsolute as isAbsolute5, join as join5, resolve as resolve6, sep as sep2 } from "path";
+import { basename as basename4, isAbsolute as isAbsolute5, join as join7, resolve as resolve7, sep as sep2 } from "path";
 
 // src/lib/codex-native-compatibility.ts
 var MEASURED_CODEX_CAPABILITIES = {
@@ -1956,7 +2274,9 @@ var MEASURED_CODEX_CAPABILITIES = {
   "codex-cli 0.161.0": ["hooks", "qualified-skill-catalog", "installed-plugin-review"],
   "codex-cli 0.162.0": ["hooks", "qualified-skill-catalog", "installed-plugin-review"],
   "codex-cli 0.162.1": ["hooks", "qualified-skill-catalog", "installed-plugin-review"],
-  "codex-cli 0.163.0": ["hooks", "qualified-skill-catalog", "installed-plugin-review"]
+  "codex-cli 0.163.0": ["hooks", "qualified-skill-catalog", "installed-plugin-review"],
+  "codex-cli 0.164.0": ["hooks", "qualified-skill-catalog", "installed-plugin-review"],
+  "codex-cli 0.165.0": ["hooks", "qualified-skill-catalog", "installed-plugin-review"]
 };
 function supportsCodexNativeCapability(version2, capability) {
   return typeof version2 === "string" && Object.hasOwn(MEASURED_CODEX_CAPABILITIES, version2) && MEASURED_CODEX_CAPABILITIES[version2].includes(capability);
@@ -1964,37 +2284,41 @@ function supportsCodexNativeCapability(version2, capability) {
 var SUPPORTED_CODEX_HOOK_VERSIONS = Object.freeze(Object.keys(MEASURED_CODEX_CAPABILITIES).filter((version2) => supportsCodexNativeCapability(version2, "hooks")));
 
 // src/lib/claude-marketplace-entry-witness.ts
-import { createHash as createHash4 } from "crypto";
-import { basename as basename2, dirname as dirname4, isAbsolute as isAbsolute3, resolve as resolve4 } from "path";
+import { createHash as createHash6 } from "crypto";
+import { basename as basename2, dirname as dirname5, isAbsolute as isAbsolute3, resolve as resolve5 } from "path";
 
 // src/lib/claude-settings-witness.ts
-import { createHash as createHash3 } from "crypto";
-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";
+import { createHash as createHash5 } from "crypto";
+import { closeSync as closeSync3, constants as constants3, fstatSync as fstatSync3, lstatSync as lstatSync4, openSync as openSync3, readSync as readSync2 } from "fs";
+import { basename, dirname as dirname4, isAbsolute as isAbsolute2, resolve as resolve4 } 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) && isAbsolute2(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) && resolve4(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 = lstatSync3(at, { bigint: true });
+  for (let at = dirname4(path);; at = dirname4(at)) {
+    const stat = lstatSync4(at, { bigint: true });
     need(stat.isDirectory() && !stat.isSymbolicLink(), "path traverses a symlink or non-directory");
     result.push([at, stat]);
-    if (at === dirname3(at))
+    if (at === dirname4(at))
       return result;
   }
 }
 function readNativeSettingsWitnessFile(path, budget, filename = "settings.json") {
   absolutePath(path);
   need(basename(path) === filename, `requires ${filename}`);
+  return readNativeDiscoveryWitnessFile(path, budget);
+}
+function readNativeDiscoveryWitnessFile(path, budget) {
+  absolutePath(path);
   need(Number.isSafeInteger(budget.remaining) && budget.remaining >= 0, "has an invalid byte budget");
-  const ancestors = parents(path), initial = lstatSync3(path, { bigint: true });
+  const ancestors = parents(path), initial = lstatSync4(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 = openSync3(path, constants3.O_RDONLY | constants3.O_NOFOLLOW | constants3.O_NONBLOCK);
@@ -2009,10 +2333,10 @@ function readNativeSettingsWitnessFile(path, budget, filename = "settings.json")
         break;
       length += count;
     }
-    const after = fstatSync3(fd, { bigint: true }), current = lstatSync3(path, { bigint: true });
+    const after = fstatSync3(fd, { bigint: true }), current = lstatSync4(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 = lstatSync3(ancestor, { bigint: true });
+      const now = lstatSync4(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;
@@ -2232,7 +2556,7 @@ function settingsDigest(text, version2 = 1) {
     }
     return true;
   });
-  return createHash3("sha256").update(`hasna.skills.claude-settings.v${version2}\x00`).update(JSON.stringify(canonical(value))).digest("hex");
+  return createHash5("sha256").update(`hasna.skills.claude-settings.v${version2}\x00`).update(JSON.stringify(canonical(value))).digest("hex");
 }
 function hashClaudeSettingsReplacement(text, budget) {
   need(typeof text === "string", "requires settings text");
@@ -2268,7 +2592,7 @@ function upgradeClaudeSettingsWitness(previous, reviewedSettingsPath) {
   need(previous && Object.keys(previous).every((key) => ["path", "hashMode", "sha256"].includes(key)) && (previous.hashMode === undefined || previous.hashMode === "bytes" || previous.hashMode === "claude-settings-v1" || previous.hashMode === "claude-settings-v2") && typeof previous.sha256 === "string" && /^[a-f0-9]{64}$/.test(previous.sha256), "requires an exact legacy settings witness");
   const budget = { remaining: 2 * CLAUDE_SETTINGS_WITNESS_LIMITS.bytes };
   const before = readNativeSettingsWitnessFile(reviewedSettingsPath, budget), current = readNativeSettingsWitnessFile(previous.path, budget);
-  const beforeDigest = previous.hashMode === undefined || previous.hashMode === "bytes" ? createHash3("sha256").update(before).digest("hex") : settingsDigest(before, previous.hashMode === "claude-settings-v1" ? 1 : 2);
+  const beforeDigest = previous.hashMode === undefined || previous.hashMode === "bytes" ? createHash5("sha256").update(before).digest("hex") : settingsDigest(before, previous.hashMode === "claude-settings-v1" ? 1 : 2);
   need(beforeDigest === previous.sha256, "reviewed preimage does not match the legacy witness");
   const sha256 = settingsDigest(current, 3);
   need(settingsDigest(before, 3) === sha256, "non-preference settings changed; explicit discovery review required");
@@ -2288,12 +2612,91 @@ function upgradeClaudeSettingsWitnessV4(previous, reviewedSettingsPath) {
   need(previous && Object.keys(previous).every((key) => ["path", "hashMode", "sha256"].includes(key)) && (previous.hashMode === undefined || previous.hashMode === "bytes" || previous.hashMode === "claude-settings-v1" || previous.hashMode === "claude-settings-v2" || previous.hashMode === "claude-settings-v3") && typeof previous.sha256 === "string" && /^[a-f0-9]{64}$/.test(previous.sha256), "requires an exact prior settings witness");
   const budget = { remaining: 2 * CLAUDE_SETTINGS_WITNESS_LIMITS.bytes };
   const before = readNativeSettingsWitnessFile(reviewedSettingsPath, budget), current = readNativeSettingsWitnessFile(previous.path, budget);
-  const beforeDigest = previous.hashMode === undefined || previous.hashMode === "bytes" ? createHash3("sha256").update(before).digest("hex") : settingsDigest(before, previous.hashMode === "claude-settings-v1" ? 1 : previous.hashMode === "claude-settings-v2" ? 2 : 3);
+  const beforeDigest = previous.hashMode === undefined || previous.hashMode === "bytes" ? createHash5("sha256").update(before).digest("hex") : settingsDigest(before, previous.hashMode === "claude-settings-v1" ? 1 : previous.hashMode === "claude-settings-v2" ? 2 : 3);
   need(beforeDigest === previous.sha256, "reviewed preimage does not match the prior witness");
   const sha256 = settingsDigest(current, 4);
   need(settingsDigest(before, 4) === sha256, "non-preference settings changed; explicit discovery review required");
   return { path: previous.path, hashMode: "claude-settings-v4", sha256 };
 }
+var V5_DISCOVERY_KEY = /skill|plugin|hook|marketplace/i;
+var V5_BOUND_KEYS = new Set(["apiKeyHelper", "awsAuthRefresh", "awsCredentialExport", "otelHeadersHelper", "fileSuggestion", "outputStyle", "agent"]);
+var V5_DISCOVERY_ENV = new Set(["CLAUDE_CONFIG_DIR"]);
+var V5_SKILL_RULE = /^Skill(?:\(|$)/;
+var V5_PERMISSION_LISTS = new Set(["allow", "deny", "ask"]);
+function narrowedClaudeSettings(value) {
+  const entries = [];
+  for (const [key, child] of value.entries) {
+    if (V5_DISCOVERY_KEY.test(key) || V5_BOUND_KEYS.has(key)) {
+      entries.push([key, child]);
+      continue;
+    }
+    if (key === "permissions") {
+      if (child.kind !== "object") {
+        entries.push([key, child]);
+        continue;
+      }
+      const kept = [];
+      for (const [name, rules] of child.entries) {
+        if (name === "additionalDirectories") {
+          kept.push([name, rules]);
+          continue;
+        }
+        if (!V5_PERMISSION_LISTS.has(name))
+          continue;
+        if (rules.kind !== "array") {
+          kept.push([name, rules]);
+          continue;
+        }
+        const skillRules = rules.items.filter((rule) => rule.kind !== "string" || V5_SKILL_RULE.test(rule.value));
+        if (skillRules.length)
+          kept.push([name, { kind: "array", items: skillRules }]);
+      }
+      if (kept.length)
+        entries.push([key, { kind: "object", entries: kept }]);
+      continue;
+    }
+    if (key === "env") {
+      if (child.kind !== "object") {
+        entries.push([key, child]);
+        continue;
+      }
+      const kept = child.entries.filter(([name]) => V5_DISCOVERY_ENV.has(name) || V5_DISCOVERY_KEY.test(name));
+      if (kept.length)
+        entries.push([key, { kind: "object", entries: kept }]);
+    }
+  }
+  return { kind: "object", entries };
+}
+function claudeDiscoveryControlKeys(text) {
+  return narrowedClaudeSettings(parseNativeJsonObject(text)).entries.map(([key]) => key);
+}
+function claudeDiscoveryEnvironmentKeys(text) {
+  const environment = narrowedClaudeSettings(parseNativeJsonObject(text)).entries.find(([key]) => key === "env")?.[1];
+  return environment?.kind === "object" ? environment.entries.map(([key]) => key) : [];
+}
+function settingsDigestV5(text) {
+  return createHash5("sha256").update("hasna.skills.claude-settings.v5\x00").update(JSON.stringify(canonical(narrowedClaudeSettings(parse2(text))))).digest("hex");
+}
+function captureClaudeSettingsV5(path, budget = { remaining: 256 * 1024 * 1024 }) {
+  return { path, hashMode: "claude-settings-v5", sha256: settingsDigestV5(readNativeSettingsWitnessFile(path, budget)) };
+}
+function hashClaudeSettingsReplacementV5(text, budget) {
+  need(typeof text === "string", "requires settings text");
+  const bytes = Buffer.byteLength(text);
+  need(bytes <= CLAUDE_SETTINGS_WITNESS_LIMITS.bytes && Number.isSafeInteger(budget.remaining) && budget.remaining >= bytes, "exceeds its byte limit");
+  budget.remaining -= bytes;
+  return settingsDigestV5(text);
+}
+function upgradeClaudeSettingsWitnessV5(previous, reviewedSettingsPath) {
+  need(previous && Object.keys(previous).every((key) => ["path", "hashMode", "sha256"].includes(key)) && (previous.hashMode === undefined || ["bytes", "claude-settings-v1", "claude-settings-v2", "claude-settings-v3", "claude-settings-v4"].includes(previous.hashMode)) && typeof previous.sha256 === "string" && /^[a-f0-9]{64}$/.test(previous.sha256), "requires an exact prior settings witness");
+  const budget = { remaining: 2 * CLAUDE_SETTINGS_WITNESS_LIMITS.bytes };
+  const before = readNativeSettingsWitnessFile(reviewedSettingsPath, budget), current = readNativeSettingsWitnessFile(previous.path, budget);
+  const beforeDigest = previous.hashMode === undefined || previous.hashMode === "bytes" ? createHash5("sha256").update(before).digest("hex") : settingsDigest(before, previous.hashMode === "claude-settings-v1" ? 1 : previous.hashMode === "claude-settings-v2" ? 2 : previous.hashMode === "claude-settings-v3" ? 3 : 4);
+  need(beforeDigest === previous.sha256, "reviewed preimage does not match the prior witness");
+  const sha256 = settingsDigestV5(current);
+  need(settingsDigestV5(before) === sha256, "discovery settings changed; explicit discovery review required");
+  return { path: previous.path, hashMode: "claude-settings-v5", sha256 };
+}
 function hashNativeJsonControls(text, excludedMetadata) {
   need(Buffer.byteLength(text) <= CLAUDE_SETTINGS_WITNESS_LIMITS.bytes, "exceeds its byte limit");
   const value = parse2(text);
@@ -2303,7 +2706,7 @@ function hashNativeJsonControls(text, excludedMetadata) {
     need(child.kind === "string" && child.value.length <= 128, "has invalid version metadata");
     return false;
   });
-  return createHash3("sha256").update("hasna.skills.native-json-controls.v1\x00").update(JSON.stringify(canonical(value))).digest("hex");
+  return createHash5("sha256").update("hasna.skills.native-json-controls.v1\x00").update(JSON.stringify(canonical(value))).digest("hex");
 }
 function hashSumiNativeJsonControls(text) {
   need(Buffer.byteLength(text) <= CLAUDE_SETTINGS_WITNESS_LIMITS.bytes, "exceeds its byte limit");
@@ -2324,7 +2727,7 @@ function hashSumiNativeJsonControls(text) {
     });
     return child.entries.length > 0;
   });
-  return createHash3("sha256").update("hasna.skills.sumi-settings.v1\x00").update(JSON.stringify(value)).digest("hex");
+  return createHash5("sha256").update("hasna.skills.sumi-settings.v1\x00").update(JSON.stringify(value)).digest("hex");
 }
 
 // src/lib/claude-marketplace-entry-witness.ts
@@ -2392,7 +2795,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) && 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);
+  return typeof path === "string" && path.length > 0 && path.length <= PATH_CHARACTERS && !/[\x00-\x1f\x7f]/.test(path) && isAbsolute3(path) && resolve5(path) === path && basename2(path) === "marketplace.json" && basename2(dirname5(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")
@@ -2505,7 +2908,7 @@ function hashClaudeMarketplaceEntry(text, selector) {
     ["allowCrossMarketplaceDependenciesOn", field(root, "allowCrossMarketplaceDependenciesOn") ?? nullValue]
   ] };
   const projection = { kind: "object", entries: [["marketplace", marketplace], ["plugin", entry]] };
-  return createHash4("sha256").update(DOMAIN).update(canonical2(projection)).digest("hex");
+  return createHash6("sha256").update(DOMAIN).update(canonical2(projection)).digest("hex");
 }
 function captureClaudeMarketplaceEntry(path, marketplace, plugin, budget = { remaining: 256 * 1024 * 1024 }) {
   need2(claudeMarketplaceEntrySourceValid({ path, marketplace, plugin }), "requires a normalized absolute .claude-plugin/marketplace.json path and exact names");
@@ -2519,13 +2922,13 @@ function captureClaudeMarketplaceEntry(path, marketplace, plugin, budget = { rem
 }
 
 // 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";
+import { createHash as createHash7 } from "crypto";
+import { closeSync as closeSync4, constants as constants4, fstatSync as fstatSync4, lstatSync as lstatSync5, openSync as openSync4, readSync as readSync3 } from "fs";
+import { basename as basename3, dirname as dirname6, isAbsolute as isAbsolute4, resolve as resolve6, 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"))
+  if (typeof path !== "string" || basename3(path) !== ".orphaned_at" || !isAbsolute4(path) || resolve6(path) !== path || path.includes("\x00"))
     return false;
   const at = path.indexOf(CACHE);
   if (at < 0 || path.indexOf(CACHE, at + 1) >= 0)
@@ -2537,10 +2940,10 @@ 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())
+  for (let cursor = path;; cursor = dirname6(cursor)) {
+    if (lstatSync5(cursor, { throwIfNoEntry: false })?.isSymbolicLink())
       throw new Error("Refusing symlink Claude orphan marker input");
-    if (dirname5(cursor) === cursor)
+    if (dirname6(cursor) === cursor)
       break;
   }
 }
@@ -2550,7 +2953,7 @@ function hashClaudePluginCacheOrphanMarker(path, budget, changes) {
   if (changes?.has(path))
     throw new Error("Claude orphan markers cannot intersect a planned write");
   safe(path);
-  const before = lstatSync4(path, { throwIfNoEntry: false });
+  const before = lstatSync5(path, { throwIfNoEntry: false });
   if (!before)
     return null;
   const uid = process.getuid?.();
@@ -2571,7 +2974,7 @@ function hashClaudePluginCacheOrphanMarker(path, budget, changes) {
     }
     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 });
+    const after = fstatSync4(fd), current = lstatSync5(path, { throwIfNoEntry: false });
     safe(path);
     if (!same(opened, after) || !same(after, current) || length !== after.size)
       throw new Error("Claude orphan marker changed during read");
@@ -2580,7 +2983,7 @@ function hashClaudePluginCacheOrphanMarker(path, budget, changes) {
         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");
+    return createHash7("sha256").update(`${CLAUDE_ORPHAN_MARKER_MODE}\x00${path}\x00file`).digest("hex");
   } finally {
     closeSync4(fd);
   }
@@ -2640,7 +3043,7 @@ function assertAgentPolicyCollections(policy) {
       text(control.pluginId, 1024);
       text(control.namespace, 64);
       text(control.pluginParent);
-      requireBound(isAbsolute5(control.pluginParent) && resolve6(control.pluginParent) === control.pluginParent && /^[a-f0-9]{64}$/.test(control.manifestSha256));
+      requireBound(isAbsolute5(control.pluginParent) && resolve7(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)
@@ -2658,7 +3061,7 @@ function assertAgentPolicyCollections(policy) {
       text(control.pluginId, 1024);
       text(control.namespace, 64);
       text(control.pluginParent);
-      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));
+      requireBound(!ids.has(control.pluginId) && isAbsolute5(control.pluginParent) && resolve7(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);
     }
   }
@@ -2667,7 +3070,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) && isAbsolute5(path) && resolve6(path) === path);
+        requireBound(!/[\x00-\x1f\x7f-\x9f\u200e\u200f\u202a-\u202e\u2066-\u2069]/.test(path) && isAbsolute5(path) && resolve7(path) === path);
       }
     }
   if (bridge.disabledBuiltins !== undefined)
@@ -2695,11 +3098,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(isAbsolute5(root) && resolve6(root) === root);
+        requireBound(isAbsolute5(root) && resolve7(root) === root);
       }
       for (const parent of parents2) {
         text(parent);
-        requireBound(isAbsolute5(parent) && resolve6(parent) === parent);
+        requireBound(isAbsolute5(parent) && resolve7(parent) === parent);
       }
       for (const directory of array(proof.directories, AGENT_POLICY_LIMITS.discoveryDirectories)) {
         requireBound(object(directory));
@@ -2719,7 +3122,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) => isAbsolute5(path) && resolve6(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) && resolve7(path) === path) && typeof input.sourceSha256 === "string" && /^[a-f0-9]{64}$/.test(input.sourceSha256));
         ids.add(input.pluginId);
       }
       if (proof.directories !== undefined)
@@ -2733,14 +3136,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(isAbsolute5(proof.configPath) && resolve6(proof.configPath) === proof.configPath && basename4(proof.configPath) === "config.toml");
+      requireBound(isAbsolute5(proof.configPath) && resolve7(proof.configPath) === proof.configPath && basename4(proof.configPath) === "config.toml");
       text(witness.cacheRoot);
-      requireBound(isAbsolute5(witness.cacheRoot) && resolve6(witness.cacheRoot) === witness.cacheRoot);
+      requireBound(isAbsolute5(witness.cacheRoot) && resolve7(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(isAbsolute5(proof.hookRootAlias[key]) && resolve6(proof.hookRootAlias[key]) === proof.hookRootAlias[key]);
+          requireBound(isAbsolute5(proof.hookRootAlias[key]) && resolve7(proof.hookRootAlias[key]) === proof.hookRootAlias[key]);
         }
       }
       const parents2 = array(proof.appOnlyParents, 4096);
@@ -2748,7 +3151,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(isAbsolute5(parent.pluginParent) && resolve6(parent.pluginParent) === parent.pluginParent);
+        requireBound(isAbsolute5(parent.pluginParent) && resolve7(parent.pluginParent) === parent.pluginParent);
       }
       if (proof.reviewedHookParents !== undefined)
         for (const parent of array(proof.reviewedHookParents, 4096)) {
@@ -2760,9 +3163,9 @@ function assertAgentPolicyCollections(policy) {
             text(parent.remotePluginId);
           else {
             text(parent.marketplaceSourcePath);
-            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(typeof parent.marketplaceSha256 === "string" && /^[a-f0-9]{64}$/.test(parent.marketplaceSha256) && isAbsolute5(parent.marketplaceSourcePath) && resolve7(parent.marketplaceSourcePath) === parent.marketplaceSourcePath && basename4(parent.marketplaceSourcePath) === "marketplace.json");
           }
-          requireBound(isAbsolute5(parent.pluginParent) && resolve6(parent.pluginParent) === parent.pluginParent);
+          requireBound(isAbsolute5(parent.pluginParent) && resolve7(parent.pluginParent) === parent.pluginParent);
         }
       for (const row of [...array(witness.controls, 4096), ...array(witness.appOnlyParents, 4096)]) {
         requireBound(object(row));
@@ -2782,9 +3185,9 @@ function assertAgentPolicyCollections(policy) {
             text(row.remotePluginId);
           else {
             text(row.marketplaceSourcePath);
-            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(typeof row.marketplaceSha256 === "string" && /^[a-f0-9]{64}$/.test(row.marketplaceSha256) && isAbsolute5(row.marketplaceSourcePath) && resolve7(row.marketplaceSourcePath) === row.marketplaceSourcePath && basename4(row.marketplaceSourcePath) === "marketplace.json");
           }
-          requireBound(isAbsolute5(row.pluginParent) && resolve6(row.pluginParent) === row.pluginParent);
+          requireBound(isAbsolute5(row.pluginParent) && resolve7(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")
@@ -2817,17 +3220,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_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));
+        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-settings-v5", "claude-marketplace-registry-v2", "codex-settings-v1", "codex-settings-v2", "codex-settings-v3", "codex-settings-v4", "codex-settings-v5", "codex-settings-v6", "codex-settings-v7", "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") && isAbsolute5(source.path) && resolve6(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) && resolve7(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(isAbsolute5(hook.path) && resolve6(hook.path) === hook.path && !seen.has(hook.path));
+          requireBound(isAbsolute5(hook.path) && resolve7(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));
@@ -2835,15 +3238,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) && isAbsolute5(source.path) && resolve6(source.path) === source.path && source.path.endsWith(join5(sep2, ".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) && resolve7(source.path) === source.path && source.path.endsWith(join7(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) && 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) && 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) && isAbsolute5(source.path) && resolve6(source.path) === source.path && basename4(source.path) === "settings.json");
+        requireBound(agent === "sumi" && value.agent === "sumi" && value.method === "reviewed" && !/[\x00-\x1f\x7f]/.test(source.path) && isAbsolute5(source.path) && resolve7(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" || source.hashMode === "codex-settings-v7"))
+        requireBound(agent === "codex" && value.agent === "codex" && value.method === "reviewed" && !/[\x00-\x1f\x7f]/.test(source.path) && isAbsolute5(source.path) && resolve7(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" || source.hashMode === "claude-settings-v5"))
+        requireBound(agent === "claude" && value.agent === "claude" && value.method === "reviewed" && !/[\x00-\x1f\x7f]/.test(source.path) && isAbsolute5(source.path) && resolve7(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) && isAbsolute5(source.path) && resolve6(source.path) === source.path && basename4(source.path) === "known_marketplaces.json");
+        requireBound(agent === "claude" && value.agent === "claude" && value.method === "reviewed" && !/[\x00-\x1f\x7f]/.test(source.path) && isAbsolute5(source.path) && resolve7(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") {
@@ -2862,9 +3265,9 @@ 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(isAbsolute5(path) && resolve6(path) === path);
+          requireBound(isAbsolute5(path) && resolve7(path) === path);
         }
-        requireBound(source.path === join5(artifact.storeRoot, "agent-discovery", "artifacts", artifact.sha256, "catalog.json"));
+        requireBound(source.path === join7(artifact.storeRoot, "agent-discovery", "artifacts", artifact.sha256, "catalog.json"));
       }
       if (source.format !== undefined)
         requireBound(["json", "toml", "yaml"].includes(source.format));
@@ -2915,10 +3318,10 @@ function serializeManagedSkillPolicy(value) {
   return text2;
 }
 function readManagedSkillPolicySnapshot(dataDir2 = getDataDirReadOnly()) {
-  const path = join6(dataDir2, "agent-policy.json");
+  const path = join8(dataDir2, "agent-policy.json");
   let descriptor, observed = false;
   try {
-    const stat = lstatSync5(path);
+    const stat = lstatSync6(path);
     observed = true;
     if (!stat.isFile() || stat.isSymbolicLink())
       throw refusal();
@@ -2944,7 +3347,7 @@ function readManagedSkillPolicySnapshot(dataDir2 = getDataDirReadOnly()) {
     return { text: text2, value: parseManagedSkillPolicy(text2) };
   } catch (error) {
     if (error.code === "ENOENT" && !observed) {
-      if (lstatSync5(path, { throwIfNoEntry: false }) === undefined)
+      if (lstatSync6(path, { throwIfNoEntry: false }) === undefined)
         return null;
     }
     if (error instanceof SkillSelectionError)
@@ -2974,7 +3377,7 @@ function detectedIntegrationAgents(options = {}) {
     throw new Error("Invalid existing bridge agent inventory");
   const present = (path) => {
     try {
-      return lstatSync6(path, { throwIfNoEntry: false }) !== undefined;
+      return lstatSync7(path, { throwIfNoEntry: false }) !== undefined;
     } catch {
       throw new Error("Agent presence cannot be inspected; review native configuration before hook installation");
     }
@@ -2984,13 +3387,13 @@ function detectedIntegrationAgents(options = {}) {
       return true;
     if (agent === "sumi") {
       const xdg = env.XDG_CONFIG_HOME;
-      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);
+      const xdgSumi = xdg?.trim() ? resolve8(options.cwd ?? process.cwd(), xdg === "~" ? home : xdg.startsWith("~/") || xdg.startsWith("~\\") ? resolve8(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(join9(home, dirname7(root)))) || present(join9(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, dirname6(adapter.config))) || NATIVE_SKILL_ROOTS.some(([provider, root]) => provider === agent && dirname6(root) === `.${agent}` && present(join7(home, dirname6(root))));
+    return present(join9(home, dirname7(adapter.config))) || NATIVE_SKILL_ROOTS.some(([provider, root]) => provider === agent && dirname7(root) === `.${agent}` && present(join9(home, dirname7(root))));
   });
   if (!selected.length && !options.allowEmpty)
     throw new Error(`No configured or detected agents; select --agent <agent> explicitly (${INTEGRATION_AGENTS.join(", ")}).`);
@@ -2999,8 +3402,8 @@ function detectedIntegrationAgents(options = {}) {
 
 // src/lib/agent-sumi.ts
 import { spawnSync as spawnSync2 } from "child_process";
-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";
+import { accessSync, constants as constants6, existsSync as existsSync4, lstatSync as lstatSync8, realpathSync, statSync as statSync3 } from "fs";
+import { delimiter, isAbsolute as isAbsolute6, join as join10, resolve as resolve9 } from "path";
 
 // src/lib/hook-diagnostics.ts
 var CONTEXT_ERROR_CODES = new Set([
@@ -3064,9 +3467,11 @@ var OPTIONAL_CONTEXT_FAILURES = new Set([
   "CACHED_PROFILE_EXPIRED",
   "CACHED_PROFILE_MISSING",
   "CACHED_BUNDLE_MISSING",
+  "PROFILE_LOCK_MISMATCH",
   "SESSION_RECONCILIATION_REQUIRED",
   "SESSION_RENEWAL_TIMEOUT",
   "SESSION_WRITE_BUSY",
+  "SESSION_WRITE_LOCKED",
   "SESSION_PARENT_CHANGED",
   "SESSION_CONTEXT_CONFLICT",
   "SKILLS_HOOK_TIMEOUT"
@@ -3089,7 +3494,7 @@ 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) && isAbsolute6(value) && resolve8(value) === value;
+  return typeof value === "string" && value.length > 0 && value.length <= 32768 && !/[\x00-\x1f\x7f]/.test(value) && isAbsolute6(value) && resolve9(value) === value;
 }
 function absoluteInput(value) {
   return value.length > 0 && value.length <= 32768 && !/[\x00-\x1f\x7f]/.test(value) && isAbsolute6(value);
@@ -3100,7 +3505,7 @@ function resolveSumiPathsCommand(pathValue) {
   for (const directory of pathValue.split(delimiter)) {
     if (!directory || /[\x00-\x1f\x7f]/.test(directory))
       continue;
-    const candidate = resolve8(directory, "sumi-paths");
+    const candidate = resolve9(directory, "sumi-paths");
     try {
       accessSync(candidate, constants6.X_OK);
       if (statSync3(candidate).isFile())
@@ -3112,7 +3517,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 !== resolve8(home) || value.cwd !== resolve8(cwd))
+  if (value.schemaVersion !== 1 || value.kind !== "sumi-paths" || value.home !== resolve9(home) || value.cwd !== resolve9(cwd))
     return false;
   if (!recordWithKeys(value.roots, SUMI_PATH_KEYS) || !recordWithKeys(value.legacyRoots, SUMI_PATH_KEYS))
     return false;
@@ -3134,11 +3539,11 @@ function validPathPlan(value, home, cwd) {
   const legacyConfigRoot = value.legacyRoots.config;
   if (typeof configRoot !== "string" || legacyConfigRoot !== null && typeof legacyConfigRoot !== "string")
     return false;
-  if (value.configFiles.canonical !== join8(configRoot, "sumi.json") || value.skillRoots.canonical !== join8(configRoot, "skills"))
+  if (value.configFiles.canonical !== join10(configRoot, "sumi.json") || value.skillRoots.canonical !== join10(configRoot, "skills"))
     return false;
   if (legacyConfigRoot === null)
     return value.configFiles.legacy === null && value.skillRoots.legacy === null;
-  return value.configFiles.legacy === join8(legacyConfigRoot, "sumi.json") && value.skillRoots.legacy === join8(legacyConfigRoot, "skills");
+  return value.configFiles.legacy === join10(legacyConfigRoot, "sumi.json") && value.skillRoots.legacy === join10(legacyConfigRoot, "skills");
 }
 function sumiPathPlan(home, cwd = process.cwd(), env = process.env) {
   for (const key of ["SUMI_CONFIG", "SUMI_CONFIG_CONTENT"])
@@ -3156,8 +3561,8 @@ function sumiPathPlan(home, cwd = process.cwd(), env = process.env) {
       childEnv[key] = env[key];
   let child2;
   try {
-    child2 = spawnSync2(executable, ["--json", "--home", resolve8(home), "--cwd", resolve8(cwd)], {
-      cwd: resolve8(cwd),
+    child2 = spawnSync2(executable, ["--json", "--home", resolve9(home), "--cwd", resolve9(cwd)], {
+      cwd: resolve9(cwd),
       env: childEnv,
       encoding: "buffer",
       timeout: 3000,
@@ -3189,7 +3594,7 @@ function selectedConfigDirectory(plan) {
   const canonical3 = plan.roots.config, legacy = plan.legacyRoots.config;
   if (legacy === null)
     return existsSync4(canonical3) ? realpathSync(canonical3) : canonical3;
-  const canonicalStat = lstatSync7(canonical3, { throwIfNoEntry: false }), legacyStat = lstatSync7(legacy, { throwIfNoEntry: false });
+  const canonicalStat = lstatSync8(canonical3, { throwIfNoEntry: false }), legacyStat = lstatSync8(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;
@@ -3205,13 +3610,13 @@ function sumiConfigDirectory(home, env = process.env, cwd = process.cwd()) {
 }
 function sumiSkillRoots(home, cwd = process.cwd(), env = process.env) {
   const plan = sumiPathPlan(home, cwd, env);
-  return [join8(selectedConfigDirectory(plan), "skills")];
+  return [join10(selectedConfigDirectory(plan), "skills")];
 }
 function sumiBridgeRoot(home, cwd = process.cwd(), env = process.env) {
   return sumiSkillRoots(home, cwd, env)[0];
 }
 function sumiConfigPath(home, cwd = process.cwd(), env = process.env) {
-  return join8(sumiConfigDirectory(home, env, cwd), "sumi.json");
+  return join10(sumiConfigDirectory(home, env, cwd), "sumi.json");
 }
 function renderSumiPlugin(command, profile) {
   return renderSumiPluginVersion(command, profile, 3);