@hasna/skills 0.10.63 → 0.10.64

package/bin/mcp.js

@@ -23,7 +23,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@hasna/skills",
-    version: "0.10.63",
+    version: "0.10.64",
     description: "Skills library for AI coding agents",
     type: "module",
     bin: {
@@ -23088,6 +23088,53 @@ function assertAgentPolicyCollections(policy) {
           requireBound(directory.sha256 === null || typeof directory.sha256 === "string" && /^[a-f0-9]{64}$/.test(directory.sha256));
         }
     }
+    if (value.codexSemanticCache !== undefined) {
+      const proof = record2(value.codexSemanticCache, 8), witness = record2(proof.witness, 6);
+      requireBound(agent === "codex" && value.agent === "codex" && value.method === "reviewed" && Object.keys(proof).length === 8 && proof.schema === "hasna.codex-semantic-cache-discovery.v1" && typeof proof.previousPolicySha256 === "string" && /^[a-f0-9]{64}$/.test(proof.previousPolicySha256) && Object.keys(witness).length === 6 && 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) && resolve4(proof.configPath) === proof.configPath && basename5(proof.configPath) === "config.toml");
+      text(witness.cacheRoot);
+      requireBound(isAbsolute5(witness.cacheRoot) && resolve4(witness.cacheRoot) === witness.cacheRoot);
+      if (proof.hookRootAlias !== null) {
+        requireBound(object2(proof.hookRootAlias) && Object.keys(proof.hookRootAlias).length === 2);
+        for (const key of ["alias", "target"]) {
+          text(proof.hookRootAlias[key]);
+          requireBound(isAbsolute5(proof.hookRootAlias[key]) && resolve4(proof.hookRootAlias[key]) === proof.hookRootAlias[key]);
+        }
+      }
+      const parents2 = array2(proof.appOnlyParents, 4096);
+      for (const parent of parents2) {
+        requireBound(object2(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) && resolve4(parent.pluginParent) === parent.pluginParent);
+      }
+      for (const row of [...array2(witness.controls, 4096), ...array2(witness.appOnlyParents, 4096)]) {
+        requireBound(object2(row));
+        for (const key of ["pluginId", "namespace", "pluginParent"])
+          text(row[key]);
+        for (const key of ["manifestSha256", "appSha256", "mcpSha256", "receiptSha256"])
+          if (row[key] !== undefined)
+            requireBound(typeof row[key] === "string" && /^[a-f0-9]{64}$/.test(row[key]));
+      }
+      for (const skill of array2(witness.skills, 4096)) {
+        requireBound(object2(skill));
+        for (const key of ["name", "pluginId", "namespace", "pluginParent"])
+          text(skill[key]);
+        for (const rule of array2(skill.disabledRules, 4096))
+          text(rule);
+      }
+      for (const source of array2(proof.supersededSources, AGENT_POLICY_LIMITS.discoverySources)) {
+        requireBound(object2(source));
+        text(source.path);
+        requireBound(source.sha256 === null || typeof source.sha256 === "string" && /^[a-f0-9]{64}$/.test(source.sha256));
+      }
+      for (const directory of array2(proof.supersededDirectories, AGENT_POLICY_LIMITS.discoveryDirectories)) {
+        requireBound(object2(directory));
+        text(directory.path);
+        requireBound(directory.sha256 === null || typeof directory.sha256 === "string" && /^[a-f0-9]{64}$/.test(directory.sha256));
+      }
+    }
     for (const root of array2(value.roots, AGENT_POLICY_LIMITS.discoveryRoots))
       text(root);
     for (const source of array2(value.sources, AGENT_POLICY_LIMITS.discoverySources)) {
@@ -23095,12 +23142,12 @@ function assertAgentPolicyCollections(policy) {
       text(source.path);
       requireBound(source.sha256 === null || typeof source.sha256 === "string" && /^[a-f0-9]{64}$/.test(source.sha256));
       if (source.hashMode !== undefined)
-        requireBound(["bytes", "path-bytes", "claude-plugin-manifest-v1", "claude-plugin-registry", "claude-marketplace-registry", "claude-settings-v1", "claude-settings-v2", "claude-settings-v3", "claude-settings-v4", "claude-marketplace-registry-v2", "codex-settings-v1", "codex-settings-v2", "codex-settings-v3", "codex-settings-v4", "sumi-settings-v1", "claude-marketplace-entry-v1"].includes(source.hashMode) && source.format === undefined && source.fields === undefined && (source.hashMode === "bytes" || source.sha256 !== null));
+        requireBound(["bytes", "path-bytes", "claude-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", "sumi-settings-v1", "claude-marketplace-entry-v1"].includes(source.hashMode) && source.format === undefined && source.fields === undefined && (source.hashMode === "bytes" || source.sha256 !== null));
       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) && resolve4(source.path) === source.path && source.path.endsWith(join10(sep3, ".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) && resolve4(source.path) === source.path && basename5(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"))
+      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"))
         requireBound(agent === "codex" && value.agent === "codex" && value.method === "reviewed" && !/[\x00-\x1f\x7f]/.test(source.path) && isAbsolute5(source.path) && resolve4(source.path) === source.path && basename5(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) && resolve4(source.path) === source.path && basename5(source.path) === "settings.json");
@@ -32731,6 +32778,7 @@ var init_codex_hook_rpc = __esm(() => {
 });
 
 // src/lib/codex-native-skill-catalog.ts
+import { realpathSync as realpathSync4 } from "fs";
 import { isAbsolute as isAbsolute10, normalize as normalize2 } from "path";
 function codexPluginSourceIsConfigControlled(plugin) {
   const remoteRealms = ["openai-curated-remote", "created-by-me-remote", "workspace-directory", "workspace-shared-with-me", "workspace-shared-with-me-private", "workspace-shared-with-me-unlisted"];
@@ -32779,6 +32827,43 @@ function projectCodexInstalledPluginEntries(value) {
     };
   });
 }
+function canonicalPath(path) {
+  try {
+    return realpathSync4(path);
+  } catch {
+    return normalize2(path);
+  }
+}
+function isCodexNativeSkillDisabled(skill, rules) {
+  if (!scalar(skill.name, MAX_NAME_BYTES) || !absolutePath2(skill.path))
+    refuse();
+  if (rules === undefined)
+    return false;
+  if (!Array.isArray(rules) || rules.length > MAX_SKILLS)
+    refuse();
+  let disabled = false;
+  for (const rule of rules) {
+    if (!object5(rule) || typeof rule.enabled !== "boolean")
+      refuse();
+    const hasName = rule.name !== undefined && rule.name !== null;
+    const hasPath = rule.path !== undefined && rule.path !== null;
+    if (hasName === hasPath)
+      refuse();
+    let matches;
+    if (hasName) {
+      if (typeof rule.name !== "string" || !scalar(rule.name.trim(), MAX_NAME_BYTES))
+        refuse();
+      matches = rule.name.trim() === skill.name;
+    } else {
+      if (!absolutePath2(rule.path))
+        refuse();
+      matches = canonicalPath(rule.path) === canonicalPath(skill.path);
+    }
+    if (matches)
+      disabled = !rule.enabled;
+  }
+  return disabled;
+}
 var MAX_SKILLS = 4096, MAX_NAME_BYTES = 1024, MAX_PATH_BYTES = 16384, MAX_PLUGIN_ID_BYTES = 1024, object5 = (value) => value !== null && typeof value === "object" && !Array.isArray(value), scalar = (value, max) => typeof value === "string" && value.length > 0 && value.trim() === value && Buffer.byteLength(value, "utf8") <= max && !/[\u0000-\u001f\u007f]/u.test(value), remotePluginIdentifier = (value) => typeof value === "string" && /^[A-Za-z0-9_~-]{1,1024}$/.test(value), absolutePath2 = (value) => scalar(value, MAX_PATH_BYTES) && isAbsolute10(value);
 var init_codex_native_skill_catalog = __esm(() => {
   init_codex_hook_rpc();
@@ -32788,13 +32873,13 @@ var init_codex_native_skill_catalog = __esm(() => {
 
 // src/lib/codex-plugin-skill-controls.ts
 import { basename as basename6, dirname as dirname12, join as join18, relative as relative5, resolve as resolve11, sep as sep6 } from "path";
-import { lstatSync as lstatSync12, readdirSync as readdirSync6, readlinkSync as readlinkSync3, realpathSync as realpathSync4 } from "fs";
+import { lstatSync as lstatSync12, readdirSync as readdirSync6, readlinkSync as readlinkSync3, realpathSync as realpathSync5 } from "fs";
 function refuse2() {
   throw new Error("CODEX_NATIVE_SKILL_IDENTITY_UNSUPPORTED: review native plugin names and hook controls");
 }
 function remoteInstallationMatches(parent, remotePluginId, read) {
   try {
-    if (!remotePluginIdentifier(remotePluginId) || !lstatSync12(parent).isDirectory() || realpathSync4(parent) !== parent)
+    if (!remotePluginIdentifier(remotePluginId) || !lstatSync12(parent).isDirectory() || realpathSync5(parent) !== parent)
       return false;
     const path = join18(parent, ".codex-remote-plugin-install.json"), stat = lstatSync12(path, { throwIfNoEntry: false });
     if (!stat?.isFile() || stat.isSymbolicLink() || stat.size > 16384)
@@ -32871,6 +32956,9 @@ function isBundledCleanupHooks(root, namespace, value) {
   }
   return true;
 }
+function readCodexPluginRootControls(root, read) {
+  return rootControls(root, read);
+}
 function rootControls(root, read) {
   const manifestPath = join18(root, ".codex-plugin/plugin.json"), manifestFile = lstatSync12(manifestPath, { throwIfNoEntry: false });
   if (!lstatSync12(join18(root, ".codex-plugin"), { throwIfNoEntry: false })?.isDirectory() || !manifestFile?.isFile() || manifestFile.size > 1024 * 1024)
@@ -32893,7 +32981,7 @@ function rootControls(root, read) {
   const mcp = join18(root, ".mcp.json"), mcpPresent = lstatSync12(mcp, { throwIfNoEntry: false });
   if (manifest.hooks !== undefined && (manifest.mcpServers !== undefined || mcpPresent))
     refuse2();
-  if (mcpPresent && (!mcpPresent.isFile() || mcpPresent.isSymbolicLink() || mcpPresent.size > 1024 * 1024 || realpathSync4(mcp) !== mcp))
+  if (mcpPresent && (!mcpPresent.isFile() || mcpPresent.isSymbolicLink() || mcpPresent.size > 1024 * 1024 || realpathSync5(mcp) !== mcp))
     refuse2();
   if (Boolean(mcpPresent) !== (manifest.mcpServers !== undefined))
     refuse2();
@@ -32906,6 +32994,76 @@ function rootControls(root, read) {
   const appSha256 = present ? appControls(app, read) : undefined;
   return { namespace: manifest.name, manifestSha256, ...appSha256 ? { appSha256 } : {}, ...mcpSha256 ? { mcpSha256 } : {} };
 }
+function documentIdentity(document2, cache, read) {
+  if (!document2.startsWith(cache + sep6) || !document2.endsWith(sep6 + "SKILL.md"))
+    refuse2();
+  const text2 = read(document2);
+  if (Buffer.byteLength(text2) > 1024 * 1024)
+    refuse2();
+  const lines = text2.split(/\r?\n/);
+  if (lines[0]?.trim() !== "---")
+    refuse2();
+  const end = lines.findIndex((line, i) => i > 0 && line.trim() === "---");
+  if (end < 2)
+    refuse2();
+  const yaml = lines.slice(1, end).join(`
+`);
+  if (/(?:^|\s)[&*!]|<<\s*:/.test(yaml) || lines.slice(1, end).filter((line) => /^name\s*:/.test(line)).length !== 1)
+    refuse2();
+  let front;
+  try {
+    front = Bun.YAML.parse(yaml);
+  } catch {
+    refuse2();
+  }
+  if (!front || typeof front !== "object" || !identifier2(front.name) || typeof front.description !== "string" || !front.description.trim())
+    refuse2();
+  for (let root = dirname12(document2), depth = 0;root.startsWith(cache + sep6) && depth < 12; root = dirname12(root), depth++) {
+    const path = join18(root, ".codex-plugin", "plugin.json");
+    if (!lstatSync12(path, { throwIfNoEntry: false }))
+      continue;
+    const manifestFile = lstatSync12(path);
+    if (!lstatSync12(join18(root, ".codex-plugin")).isDirectory() || !manifestFile.isFile() || manifestFile.size > 1024 * 1024)
+      refuse2();
+    let manifest;
+    try {
+      const text3 = read(path);
+      hashNativeJsonControls(text3);
+      manifest = JSON.parse(text3);
+    } catch {
+      refuse2();
+    }
+    if (!manifest || typeof manifest !== "object" || Array.isArray(manifest) || !identifier2(manifest.name))
+      refuse2();
+    const declaredVersion = manifest.version === undefined ? "" : typeof manifest.version === "string" ? manifest.version.trim() : null;
+    if (declaredVersion === null || (declaredVersion ? declaredVersion !== basename6(root) : basename6(root) !== CODEX_DEFAULT_AGENT_PLUGIN_VERSION))
+      refuse2();
+    return { name: `${manifest.name}:${front.name}`, namespace: manifest.name, pluginParent: dirname12(root), root };
+  }
+  refuse2();
+}
+function identity3(document2, cache, read) {
+  const parsed = documentIdentity(document2, cache, read);
+  const controls = rootControls(parsed.root, read);
+  if (controls.namespace !== parsed.namespace)
+    refuse2();
+  return { name: parsed.name, pluginParent: parsed.pluginParent, ...controls };
+}
+function classifyCodexPluginCacheDocument(document2, cache, read) {
+  if (!document2.startsWith(cache + sep6))
+    return null;
+  try {
+    const located = documentIdentity(document2, cache, read), parsed = identity3(document2, cache, read);
+    if (!lstatSync12(document2).isFile() || realpathSync5(document2) !== document2 || realpathSync5(located.root) !== located.root || realpathSync5(located.pluginParent) !== located.pluginParent || realpathSync5(join18(located.root, ".codex-plugin/plugin.json")) !== join18(located.root, ".codex-plugin/plugin.json"))
+      return null;
+    const parts = relative5(cache, parsed.pluginParent).split(sep6);
+    if (parts.length !== 2 || parts.some((part) => !identifier2(part)) || parts[1] !== parsed.namespace)
+      return null;
+    return { name: parsed.name, namespace: parsed.namespace, pluginId: `${parts[1]}@${parts[0]}`, pluginParent: parsed.pluginParent, root: located.root, manifestSha256: parsed.manifestSha256 };
+  } catch {
+    return null;
+  }
+}
 function reviewedDisabledCodexPluginParent(cache, parent, controls, rules) {
   try {
     const parts = relative5(cache, parent).split(sep6), enrolled = controls.filter((control) => control.pluginParent === parent);
@@ -32969,7 +33127,7 @@ function reviewedCodexPluginCapabilitiesUnchanged(cache, controls, read, rules)
     for (const parent of new Set(controls.map((control) => control.pluginParent))) {
       if (absentDisabledCodexPluginParent(cache, parent, controls, rules))
         continue;
-      if (!parent.startsWith(cache + sep6) || !lstatSync12(parent, { throwIfNoEntry: false })?.isDirectory() || realpathSync4(parent) !== parent)
+      if (!parent.startsWith(cache + sep6) || !lstatSync12(parent, { throwIfNoEntry: false })?.isDirectory() || realpathSync5(parent) !== parent)
         return false;
       for (const control of controls.filter((control2) => control2.pluginParent === parent)) {
         if (control.remotePluginId !== undefined && !remoteInstallationMatches(parent, control.remotePluginId, read))
@@ -32983,7 +33141,7 @@ function reviewedCodexPluginCapabilitiesUnchanged(cache, controls, read, rules)
         let root = join18(parent, name), stat = lstatSync12(root);
         if (stat.isSymbolicLink()) {
           const target = resolve11(parent, readlinkSync3(root));
-          if (name !== "latest" || dirname12(target) !== parent || !lstatSync12(target).isDirectory() || realpathSync4(target) !== target)
+          if (name !== "latest" || dirname12(target) !== parent || !lstatSync12(target).isDirectory() || realpathSync5(target) !== target)
             return false;
           root = target;
           stat = lstatSync12(root);
@@ -33003,10 +33161,10 @@ function reviewedCodexPluginCapabilitiesUnchanged(cache, controls, read, rules)
 function sourceInputUnchanged(input2, cache, read) {
   try {
     const parts = relative5(cache, input2.pluginParent).split(sep6);
-    if (parts.length !== 2 || parts.some((part) => !identifier2(part)) || parts[1] !== input2.namespace || input2.pluginId !== `${parts[1]}@${parts[0]}` || !codexPluginSourceIsConfigControlled({ id: input2.pluginId, sourceType: "local", sourceSha256: input2.sourceSha256 }) || input2.sourceSha256 !== hashNativeJsonControls(JSON.stringify({ type: "local", path: input2.sourceRoot })) || resolve11(input2.sourceRoot) !== input2.sourceRoot || !lstatSync12(input2.sourceRoot).isDirectory() || realpathSync4(input2.sourceRoot) !== input2.sourceRoot || input2.sourceRoot === cache || input2.sourceRoot.startsWith(cache + sep6) || cache.startsWith(input2.sourceRoot + sep6))
+    if (parts.length !== 2 || parts.some((part) => !identifier2(part)) || parts[1] !== input2.namespace || input2.pluginId !== `${parts[1]}@${parts[0]}` || !codexPluginSourceIsConfigControlled({ id: input2.pluginId, sourceType: "local", sourceSha256: input2.sourceSha256 }) || input2.sourceSha256 !== hashNativeJsonControls(JSON.stringify({ type: "local", path: input2.sourceRoot })) || resolve11(input2.sourceRoot) !== input2.sourceRoot || !lstatSync12(input2.sourceRoot).isDirectory() || realpathSync5(input2.sourceRoot) !== input2.sourceRoot || input2.sourceRoot === cache || input2.sourceRoot.startsWith(cache + sep6) || cache.startsWith(input2.sourceRoot + sep6))
       return false;
     const path = join18(input2.sourceRoot, ".codex-plugin/plugin.json"), stat = lstatSync12(path);
-    if (!stat.isFile() || stat.size > 1024 * 1024 || realpathSync4(path) !== path)
+    if (!stat.isFile() || stat.size > 1024 * 1024 || realpathSync5(path) !== path)
       return false;
     const text2 = read(path);
     hashNativeJsonControls(text2);
@@ -33300,6 +33458,8 @@ function normalize3(config2, version2 = 2) {
       if (isRecord3(profile))
         inference(profile, version2);
   }
+  if (version2 === 5)
+    projectStatusLine(config2);
 }
 function disablesOneSkill(entry) {
   if (!isRecord3(entry) || entry.enabled !== false)
@@ -33437,6 +33597,14 @@ function projectModelAvailabilityNux(config2, text2) {
   }
   return { config: config2, numericSource: text2 };
 }
+function projectStatusLine(config2) {
+  const tui = config2.tui;
+  if (!isRecord3(tui) || !Array.isArray(tui.status_line) || !tui.status_line.every((item) => typeof item === "string"))
+    return;
+  delete tui.status_line;
+  if (!Object.keys(tui).length)
+    delete config2.tui;
+}
 function settingsDigest2(text2, version2 = 2) {
   let config2;
   try {
@@ -33446,7 +33614,7 @@ function settingsDigest2(text2, version2 = 2) {
   }
   need5(isRecord3(config2));
   const mcp = version2 >= 3 ? projectRegularCodexMcp(config2, text2) : { config: config2, numericSource: text2 };
-  const projected = version2 === 4 ? projectModelAvailabilityNux(mcp.config, mcp.numericSource) : mcp;
+  const projected = version2 >= 4 ? projectModelAvailabilityNux(mcp.config, mcp.numericSource) : mcp;
   normalize3(projected.config, version2);
   return sha2(`hasna.skills.codex-settings.v${version2}\x00${JSON.stringify([canonical6(projected.config), numericTokens2(projected.numericSource)])}`);
 }
@@ -33475,6 +33643,14 @@ function hashCodexSettingsReplacementV4(text2, budget2 = { remaining: 256 * 1024
 function captureCodexSettingsV4(path, budget2 = { remaining: 256 * 1024 * 1024 }) {
   return { path, hashMode: "codex-settings-v4", sha256: settingsDigest2(readNativeSettingsWitnessFile(path, budget2, "config.toml"), 4) };
 }
+function hashCodexSettingsReplacementV5(text2, budget2 = { remaining: 256 * 1024 * 1024 }) {
+  need5(Buffer.byteLength(text2) <= 1024 * 1024 && budget2.remaining >= Buffer.byteLength(text2));
+  budget2.remaining -= Buffer.byteLength(text2);
+  return settingsDigest2(text2, 5);
+}
+function captureCodexSettingsV5(path, budget2 = { remaining: 256 * 1024 * 1024 }) {
+  return { path, hashMode: "codex-settings-v5", sha256: settingsDigest2(readNativeSettingsWitnessFile(path, budget2, "config.toml"), 5) };
+}
 var sha2 = (text2) => createHash13("sha256").update(text2).digest("hex"), EFFORT2, VERBOSITY2, MODEL, CODEX_DISCOVERY_PROJECTION_FIELDS, INFERENCE;
 var init_codex_settings_witness = __esm(() => {
   init_codex_settings_witness_v1();
@@ -33488,9 +33664,575 @@ var init_codex_settings_witness = __esm(() => {
   INFERENCE = ["model", "model_reasoning_effort", "model_verbosity"];
 });
 
+// src/lib/codex-semantic-cache-witness.ts
+import { createHash as createHash14 } from "crypto";
+import { constants as constants7, closeSync as closeSync10, fstatSync as fstatSync10, lstatSync as lstatSync13, openSync as openSync10, readSync as readSync5, readdirSync as readdirSync7, realpathSync as realpathSync6 } from "fs";
+import { dirname as dirname13, isAbsolute as isAbsolute11, join as join19, relative as relative6, resolve as resolve12, sep as sep7 } from "path";
+function defaultRead(path) {
+  const before = lstatSync13(path, { throwIfNoEntry: false, bigint: true });
+  if (before === undefined)
+    return refuse3();
+  if (!before.isFile() || before.isSymbolicLink() || before.size > BigInt(MAX_DOCUMENT_BYTES))
+    refuse3();
+  let fd;
+  try {
+    fd = openSync10(path, constants7.O_RDONLY | (constants7.O_NOFOLLOW ?? 0));
+  } catch {
+    return refuse3();
+  }
+  try {
+    const opened = fstatSync10(fd, { bigint: true });
+    if (!opened.isFile() || opened.dev !== before.dev || opened.ino !== before.ino || opened.size !== before.size || opened.size > BigInt(MAX_DOCUMENT_BYTES))
+      refuse3();
+    const chunks = [];
+    let total = 0;
+    while (total <= MAX_DOCUMENT_BYTES) {
+      const chunk = Buffer.alloc(Math.min(64 * 1024, MAX_DOCUMENT_BYTES + 1 - total));
+      const count = readSync5(fd, chunk, 0, chunk.length, null);
+      if (!count)
+        break;
+      total += count;
+      if (total > MAX_DOCUMENT_BYTES)
+        refuse3();
+      chunks.push(chunk.subarray(0, count));
+    }
+    const after = fstatSync10(fd, { bigint: true });
+    if (after.dev !== opened.dev || after.ino !== opened.ino || after.size !== opened.size || after.mtimeNs !== opened.mtimeNs || after.ctimeNs !== opened.ctimeNs || BigInt(total) !== after.size)
+      refuse3();
+    return Buffer.concat(chunks, total).toString("utf8");
+  } finally {
+    closeSync10(fd);
+  }
+}
+function canonical7(value) {
+  if (value === null || typeof value !== "object")
+    return JSON.stringify(value);
+  if (Array.isArray(value))
+    return `[${value.map(canonical7).join(",")}]`;
+  const object6 = value;
+  return `{${Object.keys(object6).sort().map((key) => `${JSON.stringify(key)}:${canonical7(object6[key])}`).join(",")}}`;
+}
+function hash3(value) {
+  return createHash14("sha256").update(canonical7(value)).digest("hex");
+}
+function plainObject(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function exactKeys(value, required2, optional2 = []) {
+  const keys = Object.keys(value).sort();
+  return required2.every((key) => Object.hasOwn(value, key)) && keys.every((key) => required2.includes(key) || optional2.includes(key));
+}
+function validPluginParent(cacheRoot, pluginParent, namespace, pluginId) {
+  if (!isAbsolute11(pluginParent) || resolve12(pluginParent) !== pluginParent)
+    return false;
+  const parts = relative6(cacheRoot, pluginParent).split(sep7);
+  return parts.length === 2 && parts.every(identifier3) && parts[1] === namespace && pluginId === `${namespace}@${parts[0]}`;
+}
+function assertWitnessShape(value) {
+  if (!plainObject(value) || !exactKeys(value, ["schema", "cacheRoot", "controls", "appOnlyParents", "skills", "sha256"]) || value.schema !== CODEX_SEMANTIC_CACHE_WITNESS_SCHEMA || typeof value.cacheRoot !== "string" || !isAbsolute11(value.cacheRoot) || resolve12(value.cacheRoot) !== value.cacheRoot || !digest(value.sha256) || !Array.isArray(value.controls) || value.controls.length === 0 || value.controls.length > 4096 || !Array.isArray(value.appOnlyParents) || value.appOnlyParents.length > 4096 || !Array.isArray(value.skills) || value.skills.length === 0 || value.skills.length > 4096)
+    refuse3();
+  const witness = value;
+  const controlParents = new Set;
+  for (const candidate of witness.controls) {
+    if (!plainObject(candidate))
+      refuse3();
+    const row = candidate;
+    if (!exactKeys(row, ["pluginId", "namespace", "pluginParent", "manifestSha256"], ["remotePluginId", "receiptSha256", "appSha256", "mcpSha256"]) || !identifier3(row.namespace) || typeof row.pluginId !== "string" || !/^[A-Za-z0-9_-]{1,64}@[A-Za-z0-9_-]{1,64}$/.test(row.pluginId) || typeof row.pluginParent !== "string" || !validPluginParent(String(witness.cacheRoot), row.pluginParent, row.namespace, row.pluginId) || !digest(row.manifestSha256) || row.appSha256 !== undefined && !digest(row.appSha256) || row.mcpSha256 !== undefined && !digest(row.mcpSha256) || row.receiptSha256 !== undefined && !digest(row.receiptSha256) || row.remotePluginId !== undefined && (typeof row.remotePluginId !== "string" || !/^[A-Za-z0-9_~-]{1,1024}$/.test(row.remotePluginId)) || row.remotePluginId === undefined !== (row.receiptSha256 === undefined) || controlParents.has(row.pluginParent))
+      refuse3();
+    controlParents.add(row.pluginParent);
+  }
+  const appOnlyParentPaths = new Set;
+  for (const candidate of witness.appOnlyParents) {
+    if (!plainObject(candidate))
+      refuse3();
+    const row = candidate;
+    if (!exactKeys(row, ["role", "pluginId", "namespace", "pluginParent", "remotePluginId", "receiptSha256", "manifestSha256", "appSha256"], ["mcpSha256"]) || row.role !== "app-only" || !identifier3(row.namespace) || typeof row.pluginId !== "string" || !/^[A-Za-z0-9_-]{1,64}@[A-Za-z0-9_-]{1,64}$/.test(row.pluginId) || typeof row.pluginParent !== "string" || !validPluginParent(String(witness.cacheRoot), row.pluginParent, row.namespace, row.pluginId) || typeof row.remotePluginId !== "string" || !/^[A-Za-z0-9_~-]{1,1024}$/.test(row.remotePluginId) || !digest(row.receiptSha256) || !digest(row.manifestSha256) || !digest(row.appSha256) || row.mcpSha256 !== undefined && !digest(row.mcpSha256) || appOnlyParentPaths.has(row.pluginParent) || controlParents.has(row.pluginParent))
+      refuse3();
+    appOnlyParentPaths.add(row.pluginParent);
+  }
+  const skillNames = new Set;
+  const qualifiedNames = new Set;
+  for (const candidate of witness.skills) {
+    if (!plainObject(candidate))
+      refuse3();
+    const row = candidate;
+    if (!exactKeys(row, ["name", "pluginId", "namespace", "pluginParent", "disabledRules"]) || typeof row.name !== "string" || !row.name.startsWith(`${String(row.namespace)}:`) || !identifier3(row.name.slice(String(row.namespace).length + 1)) || !identifier3(row.namespace) || typeof row.pluginId !== "string" || !/^[A-Za-z0-9_-]{1,64}@[A-Za-z0-9_-]{1,64}$/.test(row.pluginId) || typeof row.pluginParent !== "string" || !validPluginParent(String(witness.cacheRoot), row.pluginParent, String(row.namespace), row.pluginId) || !Array.isArray(row.disabledRules) || row.disabledRules.length !== 1 || row.disabledRules.some((rule) => rule !== `name:${String(row.name)}=disabled`) || !controlParents.has(row.pluginParent))
+      refuse3();
+    const qualified = `${row.pluginId}\x00${row.name}`;
+    if (qualifiedNames.has(qualified) || skillNames.has(row.name))
+      refuse3();
+    qualifiedNames.add(qualified);
+    skillNames.add(row.name);
+  }
+  const projection = {
+    schema: witness.schema,
+    cacheRoot: witness.cacheRoot,
+    controls: witness.controls,
+    appOnlyParents: witness.appOnlyParents,
+    skills: witness.skills
+  };
+  if (hash3(projection) !== witness.sha256)
+    refuse3();
+}
+function assertCanonicalDirectory(path) {
+  if (resolve12(path) !== path || realpathSync6(path) !== path)
+    refuse3();
+  for (let cursor = path;; cursor = dirname13(cursor)) {
+    const stat = lstatSync13(cursor, { throwIfNoEntry: false });
+    if (stat && (!stat.isDirectory() || stat.isSymbolicLink()))
+      refuse3();
+    if (dirname13(cursor) === cursor)
+      break;
+  }
+}
+function walkSafeTree(path, state, depth = 0, root = path) {
+  if (depth > 64 || ++state.entries > 16384)
+    refuse3();
+  const names = readdirSync7(path).sort();
+  const files = [];
+  for (const name of names) {
+    if (!name || name === "." || name === ".." || name.includes(sep7) || ++state.entries > 16384)
+      refuse3();
+    const child2 = join19(path, name), stat = lstatSync13(child2, { bigint: true });
+    state.members.push(child2);
+    state.signature.push(`${relative6(root, child2)}\x00${stat.mode}\x00${stat.dev}\x00${stat.ino}\x00${stat.isDirectory() ? 0 : stat.size}`);
+    state.timestamps.set(child2, `${stat.mtimeNs}\x00${stat.ctimeNs}`);
+    if (stat.isSymbolicLink())
+      refuse3();
+    if (stat.isDirectory())
+      files.push(...walkSafeTree(child2, state, depth + 1, root));
+    else if (stat.isFile())
+      files.push(child2);
+    else
+      refuse3();
+  }
+  return files;
+}
+function treeSnapshot(cacheRoot) {
+  const state = { entries: 0, members: [], signature: [], timestamps: new Map };
+  const rootStat = lstatSync13(cacheRoot, { throwIfNoEntry: false, bigint: true });
+  if (rootStat === undefined)
+    return refuse3();
+  if (!rootStat.isDirectory() || rootStat.isSymbolicLink() || realpathSync6(cacheRoot) !== cacheRoot)
+    refuse3();
+  state.signature.push(`.\x00${rootStat.mode}\x00${rootStat.dev}\x00${rootStat.ino}`);
+  state.timestamps.set(cacheRoot, `${rootStat.mtimeNs}\x00${rootStat.ctimeNs}`);
+  const files = walkSafeTree(cacheRoot, state);
+  return { files, state };
+}
+function assertSameTree(before, after, semanticPaths) {
+  if (canonical7([...before.members].sort()) !== canonical7([...after.members].sort()) || canonical7([...before.signature].sort()) !== canonical7([...after.signature].sort()))
+    refuse3();
+  for (const path of semanticPaths)
+    if (before.timestamps.get(path) !== after.timestamps.get(path))
+      refuse3();
+}
+function trackedBoundedRead(read) {
+  const observed = new Map;
+  const stableStat = (path, max) => {
+    const stat = lstatSync13(path, { throwIfNoEntry: false, bigint: true });
+    if (stat === undefined)
+      return refuse3();
+    if (!stat.isFile() || stat.isSymbolicLink() || stat.size > BigInt(max) || realpathSync6(path) !== path)
+      refuse3();
+    return stat;
+  };
+  const guarded = (path) => {
+    const max = path.endsWith(".codex-remote-plugin-install.json") ? MAX_RECEIPT_BYTES : MAX_DOCUMENT_BYTES;
+    const before = stableStat(path, max);
+    const text2 = read(path);
+    if (Buffer.byteLength(text2, "utf8") > max)
+      refuse3();
+    const after = stableStat(path, max);
+    if (after.dev !== before.dev || after.ino !== before.ino || after.size !== before.size || after.mtimeNs !== before.mtimeNs || after.ctimeNs !== before.ctimeNs)
+      refuse3();
+    const sha3 = createHash14("sha256").update(text2).digest("hex");
+    const prior = observed.get(path);
+    if (prior !== undefined && prior !== sha3)
+      refuse3();
+    observed.set(path, sha3);
+    return text2;
+  };
+  return {
+    read: guarded,
+    verify: () => {
+      for (const [path, expected] of observed) {
+        const max = path.endsWith(".codex-remote-plugin-install.json") ? MAX_RECEIPT_BYTES : MAX_DOCUMENT_BYTES;
+        const before = stableStat(path, max);
+        const text2 = read(path);
+        const after = stableStat(path, max);
+        if (Buffer.byteLength(text2, "utf8") > max || createHash14("sha256").update(text2).digest("hex") !== expected || after.dev !== before.dev || after.ino !== before.ino || after.size !== before.size || after.mtimeNs !== before.mtimeNs || after.ctimeNs !== before.ctimeNs)
+          refuse3();
+      }
+    },
+    paths: () => [...observed.keys()]
+  };
+}
+function controlProjection(controls, read) {
+  const byPlugin = new Map;
+  for (const control of controls) {
+    if (!control || !identifier3(control.namespace) || typeof control.pluginId !== "string" || !/^[A-Za-z0-9_-]{1,64}@[A-Za-z0-9_-]{1,64}$/.test(control.pluginId) || typeof control.pluginParent !== "string" || !control.name.startsWith(`${control.namespace}:`) || !identifier3(control.name.slice(control.namespace.length + 1)))
+      refuse3();
+    if (!digest(control.manifestSha256) || control.appSha256 !== undefined && !digest(control.appSha256) || control.mcpSha256 !== undefined && !digest(control.mcpSha256) || control.remotePluginId !== undefined && (typeof control.remotePluginId !== "string" || !/^[A-Za-z0-9_~-]{1,1024}$/.test(control.remotePluginId)))
+      refuse3();
+    const key = `${control.pluginId}\x00${control.pluginParent}`;
+    const row = {
+      pluginId: control.pluginId,
+      namespace: control.namespace,
+      pluginParent: control.pluginParent,
+      ...control.remotePluginId === undefined ? {} : { remotePluginId: control.remotePluginId },
+      manifestSha256: control.manifestSha256,
+      ...control.appSha256 === undefined ? {} : { appSha256: control.appSha256 },
+      ...control.mcpSha256 === undefined ? {} : { mcpSha256: control.mcpSha256 }
+    };
+    if (row.remotePluginId !== undefined) {
+      const receipt = join19(row.pluginParent, ".codex-remote-plugin-install.json"), stat = lstatSync13(receipt, { throwIfNoEntry: false });
+      if (!stat?.isFile() || stat.isSymbolicLink() || stat.size > 16384)
+        refuse3();
+      try {
+        const receiptText = read(receipt), value = JSON.parse(receiptText);
+        if (!value || Array.isArray(value) || typeof value !== "object" || Object.keys(value).length !== 2 || value.schema_version !== 1 || value.remote_plugin_id !== row.remotePluginId)
+          refuse3();
+        row.receiptSha256 = createHash14("sha256").update(receiptText).digest("hex");
+      } catch {
+        refuse3();
+      }
+    }
+    const previous = byPlugin.get(key);
+    if (previous && canonical7(previous) !== canonical7(row))
+      refuse3();
+    byPlugin.set(key, row);
+  }
+  if (!byPlugin.size || byPlugin.size > 4096)
+    refuse3();
+  return [...byPlugin.values()].sort((a, b) => a.pluginId.localeCompare(b.pluginId) || a.pluginParent.localeCompare(b.pluginParent));
+}
+function appOnlyParentProjection(cacheRoot, parents2, read) {
+  if (!Array.isArray(parents2) || parents2.length > 4096)
+    refuse3();
+  const seen = new Set, rows = [];
+  for (const parent of parents2) {
+    if (!parent || Object.keys(parent).sort().join(",") !== "namespace,pluginId,pluginParent,remotePluginId,role" || parent.role !== "app-only" || !identifier3(parent.namespace) || !/^[A-Za-z0-9_-]{1,64}@[A-Za-z0-9_-]{1,64}$/.test(parent.pluginId) || typeof parent.pluginParent !== "string" || typeof parent.remotePluginId !== "string" || !/^[A-Za-z0-9_~-]{1,1024}$/.test(parent.remotePluginId))
+      refuse3();
+    const parts = relative6(cacheRoot, parent.pluginParent).split(sep7);
+    if (resolve12(parent.pluginParent) !== parent.pluginParent || parts.length !== 2 || parts.some((part) => !identifier3(part)) || parent.pluginId !== `${parent.namespace}@${parts[0]}` || parts[1] !== parent.namespace || seen.has(parent.pluginParent))
+      refuse3();
+    seen.add(parent.pluginParent);
+    const parentStat = lstatSync13(parent.pluginParent, { throwIfNoEntry: false });
+    if (!parentStat?.isDirectory() || parentStat.isSymbolicLink() || realpathSync6(parent.pluginParent) !== parent.pluginParent)
+      refuse3();
+    const receipt = join19(parent.pluginParent, ".codex-remote-plugin-install.json"), receiptStat = lstatSync13(receipt, { throwIfNoEntry: false });
+    if (!receiptStat?.isFile() || receiptStat.isSymbolicLink() || receiptStat.size > 16384)
+      refuse3();
+    let receiptText = "";
+    try {
+      receiptText = read(receipt);
+      hashNativeJsonControls(receiptText);
+      const value = JSON.parse(receiptText);
+      if (!value || Array.isArray(value) || typeof value !== "object" || Object.keys(value).length !== 2 || value.schema_version !== 1 || value.remote_plugin_id !== parent.remotePluginId)
+        refuse3();
+    } catch {
+      refuse3();
+    }
+    const versions2 = readdirSync7(parent.pluginParent).filter((name) => name !== ".codex-remote-plugin-install.json");
+    if (!versions2.length || versions2.length > 4096)
+      refuse3();
+    const materializations = versions2.map((version2) => {
+      if (!/^[A-Za-z0-9][A-Za-z0-9._+-]{0,127}$/.test(version2))
+        refuse3();
+      const root = join19(parent.pluginParent, version2), stat = lstatSync13(root, { throwIfNoEntry: false });
+      if (!stat?.isDirectory() || stat.isSymbolicLink() || realpathSync6(root) !== root)
+        refuse3();
+      const rootControls2 = readCodexPluginRootControls(root, read);
+      if (rootControls2.namespace !== parent.namespace || !digest(rootControls2.manifestSha256) || !digest(rootControls2.appSha256) || rootControls2.mcpSha256 !== undefined && !digest(rootControls2.mcpSha256))
+        refuse3();
+      return {
+        manifestSha256: rootControls2.manifestSha256,
+        appSha256: rootControls2.appSha256,
+        ...rootControls2.mcpSha256 === undefined ? {} : { mcpSha256: rootControls2.mcpSha256 }
+      };
+    });
+    const first = materializations[0];
+    if (materializations.some((item) => canonical7(item) !== canonical7(first)))
+      refuse3();
+    rows.push({ ...parent, receiptSha256: createHash14("sha256").update(receiptText).digest("hex"), ...first });
+  }
+  return rows.sort((a, b) => a.pluginId.localeCompare(b.pluginId) || a.pluginParent.localeCompare(b.pluginParent));
+}
+function assertParents(cacheRoot, controls, appOnlyParents, files, members2) {
+  const expected = new Set;
+  const expectedMarkets = new Set;
+  for (const control of [...controls, ...appOnlyParents]) {
+    const rel = relative6(cacheRoot, control.pluginParent), parts = rel.split(sep7);
+    if (resolve12(control.pluginParent) !== control.pluginParent || parts.length !== 2 || parts.some((part) => !identifier3(part)) || control.pluginId !== `${control.namespace}@${parts[0]}` || parts[1] !== control.namespace)
+      refuse3();
+    expected.add(control.pluginParent);
+    expectedMarkets.add(parts[0]);
+  }
+  const actual = new Set;
+  for (const file2 of files) {
+    const rel = relative6(cacheRoot, file2), parts = rel.split(sep7);
+    if (parts.length < 3 || !identifier3(parts[0]) || !identifier3(parts[1]))
+      refuse3();
+    actual.add(join19(cacheRoot, parts[0], parts[1]));
+  }
+  const actualMarkets = readdirSync7(cacheRoot);
+  if (actualMarkets.length !== expectedMarkets.size || actualMarkets.some((market) => !expectedMarkets.has(market)))
+    refuse3();
+  for (const market of actualMarkets) {
+    const marketPath = join19(cacheRoot, market), marketStat = lstatSync13(marketPath);
+    if (!identifier3(market) || !marketStat.isDirectory() || marketStat.isSymbolicLink())
+      refuse3();
+    for (const plugin of readdirSync7(marketPath)) {
+      const parent = join19(marketPath, plugin), stat = lstatSync13(parent);
+      if (!identifier3(plugin) || !stat.isDirectory() || stat.isSymbolicLink())
+        refuse3();
+      actual.add(parent);
+    }
+  }
+  if (actual.size !== expected.size || [...actual].some((parent) => !expected.has(parent)))
+    refuse3();
+  for (const member of members2) {
+    const parts = relative6(cacheRoot, member).split(sep7);
+    if (parts.length < 3)
+      continue;
+    const parent = join19(cacheRoot, parts[0], parts[1]);
+    const root = join19(parent, parts[2]);
+    const base = parts[parts.length - 1];
+    if (parts.includes(".codex-plugin") && (parts.length < 4 || parts[3] !== ".codex-plugin" || (parts.length === 4 ? base !== ".codex-plugin" : parts.length !== 5 || base !== "plugin.json")))
+      refuse3();
+    if ([".app.json", ".mcp.json"].includes(base) && (parts.length !== 4 || dirname13(member) !== root))
+      refuse3();
+    if (parts.includes("hooks"))
+      refuse3();
+  }
+}
+function assertSkillMaterializations(cacheRoot, controls, files, read) {
+  const expectedByRoot = new Map;
+  const byParent = new Map;
+  for (const control of controls) {
+    const group = byParent.get(control.pluginParent) ?? [];
+    group.push(control);
+    byParent.set(control.pluginParent, group);
+  }
+  for (const [parent, rows] of byParent) {
+    const first = rows[0];
+    const expectedControls = {
+      namespace: first.namespace,
+      manifestSha256: first.manifestSha256,
+      ...first.appSha256 === undefined ? {} : { appSha256: first.appSha256 },
+      ...first.mcpSha256 === undefined ? {} : { mcpSha256: first.mcpSha256 }
+    };
+    if (rows.some((row) => canonical7({
+      namespace: row.namespace,
+      manifestSha256: row.manifestSha256,
+      ...row.appSha256 === undefined ? {} : { appSha256: row.appSha256 },
+      ...row.mcpSha256 === undefined ? {} : { mcpSha256: row.mcpSha256 }
+    }) !== canonical7(expectedControls)))
+      refuse3();
+    const expectedNames = new Set(rows.map((row) => row.name));
+    if (expectedNames.size !== rows.length)
+      refuse3();
+    const entries = readdirSync7(parent);
+    let roots = 0;
+    for (const entry of entries) {
+      if (entry === ".codex-remote-plugin-install.json")
+        continue;
+      if (!/^[A-Za-z0-9][A-Za-z0-9._+-]{0,127}$/.test(entry))
+        refuse3();
+      const root = join19(parent, entry), stat = lstatSync13(root, { throwIfNoEntry: false });
+      if (!stat?.isDirectory() || stat.isSymbolicLink() || realpathSync6(root) !== root)
+        refuse3();
+      const actualControls = readCodexPluginRootControls(root, read);
+      const actualProjection = {
+        namespace: actualControls.namespace,
+        manifestSha256: actualControls.manifestSha256,
+        ...actualControls.appSha256 === undefined ? {} : { appSha256: actualControls.appSha256 },
+        ...actualControls.mcpSha256 === undefined ? {} : { mcpSha256: actualControls.mcpSha256 }
+      };
+      if (canonical7(actualProjection) !== canonical7(expectedControls))
+        refuse3();
+      const key = `${first.pluginId}\x00${root}`;
+      expectedByRoot.set(key, expectedNames);
+      roots++;
+    }
+    if (!roots)
+      refuse3();
+  }
+  for (const file2 of files) {
+    if (!file2.endsWith(`${sep7}SKILL.md`))
+      continue;
+    const rel = relative6(cacheRoot, file2).split(sep7);
+    if (rel.length < 4)
+      refuse3();
+    const parent = join19(cacheRoot, rel[0], rel[1]);
+    if (!byParent.has(parent) || !expectedByRoot.has(`${byParent.get(parent)[0].pluginId}\x00${join19(parent, rel[2])}`))
+      refuse3();
+  }
+  return expectedByRoot;
+}
+function effectiveDisabledRules(skill, rules) {
+  if (!Array.isArray(rules))
+    refuse3();
+  const matching = [];
+  for (const candidate of rules) {
+    if (!plainObject(candidate) || typeof candidate.enabled !== "boolean")
+      refuse3();
+    const rule = candidate;
+    const byName = typeof rule.name === "string" && rule.name.trim() === skill.name;
+    let byPath = false;
+    if (typeof rule.path === "string") {
+      if (resolve12(rule.path) !== rule.path)
+        refuse3();
+      let canonicalPath2;
+      try {
+        canonicalPath2 = realpathSync6(rule.path);
+      } catch {
+        canonicalPath2 = resolve12(rule.path);
+      }
+      if (canonicalPath2 === skill.path && rule.path !== canonicalPath2)
+        refuse3();
+      byPath = canonicalPath2 === skill.path;
+    }
+    if ((byName || byPath) && rule.enabled !== false)
+      refuse3();
+    if (byName)
+      matching.push(`name:${skill.name}=disabled`);
+  }
+  if (!isCodexNativeSkillDisabled(skill, rules))
+    refuse3();
+  if (!matching.length)
+    refuse3();
+  return [...new Set(matching)].sort();
+}
+function captureCodexSemanticCacheWitness(options) {
+  const tracked = trackedBoundedRead(options.read ?? defaultRead);
+  const read = tracked.read;
+  try {
+    assertCanonicalDirectory(options.cacheRoot);
+    const initialTree = treeSnapshot(options.cacheRoot);
+    const controls = controlProjection(options.controls, read);
+    const appOnlyParents = appOnlyParentProjection(options.cacheRoot, options.appOnlyParents ?? [], read);
+    const skillParents = new Set(controls.map((control) => control.pluginParent));
+    if (appOnlyParents.some((parent) => skillParents.has(parent.pluginParent)))
+      refuse3();
+    if (!reviewedCodexPluginCapabilitiesUnchanged(options.cacheRoot, options.controls, read, options.rules))
+      refuse3();
+    const files = initialTree.files;
+    assertParents(options.cacheRoot, controls, appOnlyParents, files, initialTree.state.members);
+    const expectedNamesByRoot = assertSkillMaterializations(options.cacheRoot, options.controls, files, read);
+    const docs = files.filter((path) => path.endsWith(`${sep7}SKILL.md`));
+    const skillRows = [];
+    const rootNames = new Map;
+    for (const document2 of docs) {
+      const rel = relative6(options.cacheRoot, document2).split(sep7);
+      if (appOnlyParents.some((parent) => parent.pluginParent === join19(options.cacheRoot, rel[0], rel[1])))
+        refuse3();
+      const documentStat = lstatSync13(document2, { throwIfNoEntry: false });
+      if (!documentStat?.isFile() || documentStat.isSymbolicLink() || documentStat.size > MAX_DOCUMENT_BYTES)
+        refuse3();
+      const identity4 = classifyCodexPluginCacheDocument(document2, options.cacheRoot, read);
+      if (identity4 === null)
+        return refuse3();
+      const row = {
+        name: identity4.name,
+        pluginId: identity4.pluginId,
+        namespace: identity4.namespace,
+        pluginParent: identity4.pluginParent,
+        disabledRules: effectiveDisabledRules({ name: identity4.name, path: document2, enabled: true, pluginId: identity4.pluginId }, options.rules)
+      };
+      const root = identity4.root;
+      const rootKey = `${row.pluginId}\x00${root}`;
+      const names = rootNames.get(rootKey) ?? new Set;
+      if (names.has(row.name))
+        refuse3();
+      names.add(row.name);
+      rootNames.set(rootKey, names);
+      skillRows.push(row);
+    }
+    if (!skillRows.length || skillRows.length > 4096)
+      refuse3();
+    const uniqueNames = new Set(skillRows.map((row) => `${row.pluginId}\x00${row.name}`));
+    const reviewedNames = new Set(options.controls.map((control) => `${control.pluginId}\x00${control.name}`));
+    if (reviewedNames.size !== options.controls.length || new Set(options.controls.map((control) => control.name)).size !== options.controls.length)
+      refuse3();
+    if (uniqueNames.size !== reviewedNames.size || [...uniqueNames].some((name) => !reviewedNames.has(name)))
+      refuse3();
+    if (new Set(skillRows.map((row) => row.name)).size !== reviewedNames.size)
+      refuse3();
+    const byPlugin = new Map;
+    for (const row of skillRows) {
+      const names = byPlugin.get(row.pluginId) ?? new Set;
+      names.add(row.name);
+      byPlugin.set(row.pluginId, names);
+    }
+    for (const [key, expected] of expectedNamesByRoot) {
+      const names = rootNames.get(key);
+      if (!names || names.size !== expected.size || [...expected].some((name) => !names.has(name)))
+        refuse3();
+    }
+    if (rootNames.size !== expectedNamesByRoot.size)
+      refuse3();
+    for (const [key, names] of rootNames) {
+      const pluginId = key.slice(0, key.indexOf("\x00")), expected = byPlugin.get(pluginId);
+      if (!expected || names.size !== expected.size || [...expected].some((name) => !names.has(name)))
+        refuse3();
+    }
+    const skillsByName = new Map;
+    for (const row of skillRows) {
+      const key = `${row.pluginId}\x00${row.name}`, prior = skillsByName.get(key);
+      if (prior && canonical7(prior.disabledRules) !== canonical7(row.disabledRules))
+        refuse3();
+      if (!prior)
+        skillsByName.set(key, row);
+    }
+    const uniqueSkills = [...skillsByName.values()];
+    uniqueSkills.sort((a, b) => a.pluginId.localeCompare(b.pluginId) || a.name.localeCompare(b.name));
+    tracked.verify();
+    const finalTree = treeSnapshot(options.cacheRoot);
+    assertSameTree(initialTree.state, finalTree.state, tracked.paths());
+    const completeProjection = { schema: CODEX_SEMANTIC_CACHE_WITNESS_SCHEMA, cacheRoot: options.cacheRoot, controls, appOnlyParents, skills: uniqueSkills };
+    return { ...completeProjection, sha256: hash3(completeProjection) };
+  } catch (error61) {
+    if (error61 instanceof Error && error61.message.startsWith("CODEX_SEMANTIC_CACHE_WITNESS_UNSUPPORTED"))
+      throw error61;
+    return refuse3();
+  }
+}
+function assertCodexSemanticCacheWitnessUnchanged(previous, current) {
+  assertWitnessShape(previous);
+  assertWitnessShape(current);
+  const priorProjection = {
+    schema: previous.schema,
+    cacheRoot: previous.cacheRoot,
+    controls: previous.controls,
+    appOnlyParents: previous.appOnlyParents,
+    skills: previous.skills
+  };
+  const currentProjection = {
+    schema: current.schema,
+    cacheRoot: current.cacheRoot,
+    controls: current.controls,
+    appOnlyParents: current.appOnlyParents,
+    skills: current.skills
+  };
+  if (hash3(priorProjection) !== previous.sha256 || hash3(currentProjection) !== current.sha256 || canonical7(priorProjection) !== canonical7(currentProjection))
+    refuse3();
+}
+var CODEX_SEMANTIC_CACHE_WITNESS_SCHEMA = "hasna.codex-semantic-cache-witness.v1", identifier3 = (value) => typeof value === "string" && /^[A-Za-z0-9_-]{1,64}$/.test(value), digest = (value) => typeof value === "string" && /^[a-f0-9]{64}$/.test(value), refuse3 = () => {
+  throw new Error("CODEX_SEMANTIC_CACHE_WITNESS_UNSUPPORTED: review Codex plugin cache identity and controls");
+}, MAX_DOCUMENT_BYTES, MAX_RECEIPT_BYTES;
+var init_codex_semantic_cache_witness = __esm(() => {
+  init_claude_settings_witness();
+  init_codex_plugin_skill_controls();
+  init_codex_native_skill_catalog();
+  MAX_DOCUMENT_BYTES = 1024 * 1024;
+  MAX_RECEIPT_BYTES = 16 * 1024;
+});
+
 // src/lib/managed-policy.ts
-import { closeSync as closeSync10, constants as constants7, fstatSync as fstatSync10, lstatSync as lstatSync13, openSync as openSync10, readSync as readSync5 } from "fs";
-import { join as join19 } from "path";
+import { closeSync as closeSync11, constants as constants8, fstatSync as fstatSync11, lstatSync as lstatSync14, openSync as openSync11, readSync as readSync6 } from "fs";
+import { join as join20 } from "path";
 function refusal(reason2 = "is unreadable") {
   return new SkillSelectionError("INVALID_AGENT_POLICY", `The Skills agent loading policy ${reason2}; refusing legacy fallback.`);
 }
@@ -33515,17 +34257,17 @@ function parseManagedSkillPolicy(text2) {
   return value;
 }
 function readManagedSkillPolicySnapshot(dataDir2 = getDataDirReadOnly()) {
-  const path = join19(dataDir2, "agent-policy.json");
+  const path = join20(dataDir2, "agent-policy.json");
   let descriptor, observed = false;
   try {
-    const stat = lstatSync13(path);
+    const stat = lstatSync14(path);
     observed = true;
     if (!stat.isFile() || stat.isSymbolicLink())
       throw refusal();
     if (stat.size > AGENT_POLICY_LIMITS.bytes)
       throw refusal("exceeds its size limit");
-    descriptor = openSync10(path, constants7.O_RDONLY | (constants7.O_NOFOLLOW ?? 0) | constants7.O_NONBLOCK);
-    const opened = fstatSync10(descriptor);
+    descriptor = openSync11(path, constants8.O_RDONLY | (constants8.O_NOFOLLOW ?? 0) | constants8.O_NONBLOCK);
+    const opened = fstatSync11(descriptor);
     if (!opened.isFile())
       throw refusal();
     if (opened.size > AGENT_POLICY_LIMITS.bytes)
@@ -33533,7 +34275,7 @@ function readManagedSkillPolicySnapshot(dataDir2 = getDataDirReadOnly()) {
     const bytes = Buffer.allocUnsafe(AGENT_POLICY_LIMITS.bytes + 1);
     let length = 0;
     while (length < bytes.length) {
-      const count = readSync5(descriptor, bytes, length, bytes.length - length, null);
+      const count = readSync6(descriptor, bytes, length, bytes.length - length, null);
       if (count === 0)
         break;
       length += count;
@@ -33544,7 +34286,7 @@ function readManagedSkillPolicySnapshot(dataDir2 = getDataDirReadOnly()) {
     return { text: text2, value: parseManagedSkillPolicy(text2) };
   } catch (error61) {
     if (error61.code === "ENOENT" && !observed) {
-      if (lstatSync13(path, { throwIfNoEntry: false }) === undefined)
+      if (lstatSync14(path, { throwIfNoEntry: false }) === undefined)
         return null;
     }
     if (error61 instanceof SkillSelectionError)
@@ -33552,7 +34294,7 @@ function readManagedSkillPolicySnapshot(dataDir2 = getDataDirReadOnly()) {
     throw refusal();
   } finally {
     if (descriptor !== undefined)
-      closeSync10(descriptor);
+      closeSync11(descriptor);
   }
 }
 function readManagedSkillPolicy(dataDir2 = getDataDirReadOnly()) {
@@ -33568,7 +34310,7 @@ var init_managed_policy = __esm(() => {
 });
 
 // src/lib/agent-bridge.ts
-import { createHash as createHash14 } from "crypto";
+import { createHash as createHash15 } from "crypto";
 var CLI_BRIDGE_VERSION = 1, 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.
@@ -33584,7 +34326,7 @@ Use the Skills CLI as the skill authority for this station.
 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.
 `, CLI_BRIDGE_DIGEST, CLI_BRIDGE_FILES;
 var init_agent_bridge = __esm(() => {
-  CLI_BRIDGE_DIGEST = createHash14("sha256").update(markdown).digest("hex");
+  CLI_BRIDGE_DIGEST = createHash15("sha256").update(markdown).digest("hex");
   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)}
@@ -33597,16 +34339,16 @@ var init_agent_codex = () => {};
 
 // src/lib/agent-sumi.ts
 import { spawnSync as spawnSync4 } from "child_process";
-import { accessSync, constants as constants8, existsSync as existsSync8, lstatSync as lstatSync14, realpathSync as realpathSync5, statSync as statSync7 } from "fs";
-import { delimiter, isAbsolute as isAbsolute11, join as join20, resolve as resolve12 } from "path";
+import { accessSync, constants as constants9, existsSync as existsSync8, lstatSync as lstatSync15, realpathSync as realpathSync7, statSync as statSync7 } from "fs";
+import { delimiter, isAbsolute as isAbsolute12, join as join21, resolve as resolve13 } from "path";
 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 absolutePath3(value) {
-  return typeof value === "string" && value.length > 0 && value.length <= 32768 && !/[\x00-\x1f\x7f]/.test(value) && isAbsolute11(value) && resolve12(value) === value;
+  return typeof value === "string" && value.length > 0 && value.length <= 32768 && !/[\x00-\x1f\x7f]/.test(value) && isAbsolute12(value) && resolve13(value) === value;
 }
 function absoluteInput(value) {
-  return value.length > 0 && value.length <= 32768 && !/[\x00-\x1f\x7f]/.test(value) && isAbsolute11(value);
+  return value.length > 0 && value.length <= 32768 && !/[\x00-\x1f\x7f]/.test(value) && isAbsolute12(value);
 }
 function resolveSumiPathsCommand(pathValue) {
   if (!pathValue)
@@ -33614,9 +34356,9 @@ function resolveSumiPathsCommand(pathValue) {
   for (const directory of pathValue.split(delimiter)) {
     if (!directory || /[\x00-\x1f\x7f]/.test(directory))
       continue;
-    const candidate = resolve12(directory, "sumi-paths");
+    const candidate = resolve13(directory, "sumi-paths");
     try {
-      accessSync(candidate, constants8.X_OK);
+      accessSync(candidate, constants9.X_OK);
       if (statSync7(candidate).isFile())
         return candidate;
     } catch {}
@@ -33626,7 +34368,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 !== resolve12(home) || value.cwd !== resolve12(cwd))
+  if (value.schemaVersion !== 1 || value.kind !== "sumi-paths" || value.home !== resolve13(home) || value.cwd !== resolve13(cwd))
     return false;
   if (!recordWithKeys(value.roots, SUMI_PATH_KEYS) || !recordWithKeys(value.legacyRoots, SUMI_PATH_KEYS))
     return false;
@@ -33648,11 +34390,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 !== join20(configRoot, "sumi.json") || value.skillRoots.canonical !== join20(configRoot, "skills"))
+  if (value.configFiles.canonical !== join21(configRoot, "sumi.json") || value.skillRoots.canonical !== join21(configRoot, "skills"))
     return false;
   if (legacyConfigRoot === null)
     return value.configFiles.legacy === null && value.skillRoots.legacy === null;
-  return value.configFiles.legacy === join20(legacyConfigRoot, "sumi.json") && value.skillRoots.legacy === join20(legacyConfigRoot, "skills");
+  return value.configFiles.legacy === join21(legacyConfigRoot, "sumi.json") && value.skillRoots.legacy === join21(legacyConfigRoot, "skills");
 }
 function sumiPathPlan(home, cwd = process.cwd(), env = process.env) {
   for (const key of ["SUMI_CONFIG", "SUMI_CONFIG_CONTENT"])
@@ -33662,7 +34404,7 @@ function sumiPathPlan(home, cwd = process.cwd(), env = process.env) {
     throw new SumiPathResolverError("SUMI_PATH_INPUT_REFUSED");
   const runtimePath = process.env.PATH ?? "";
   const executable = resolveSumiPathsCommand(runtimePath);
-  if (!executable || !isAbsolute11(executable))
+  if (!executable || !isAbsolute12(executable))
     throw new SumiPathResolverError("SUMI_PATH_RESOLVER_UNAVAILABLE");
   const childEnv = { PATH: runtimePath };
   for (const key of SUMI_PATH_SELECTORS)
@@ -33670,8 +34412,8 @@ function sumiPathPlan(home, cwd = process.cwd(), env = process.env) {
       childEnv[key] = env[key];
   let child2;
   try {
-    child2 = spawnSync4(executable, ["--json", "--home", resolve12(home), "--cwd", resolve12(cwd)], {
-      cwd: resolve12(cwd),
+    child2 = spawnSync4(executable, ["--json", "--home", resolve13(home), "--cwd", resolve13(cwd)], {
+      cwd: resolve13(cwd),
       env: childEnv,
       encoding: "buffer",
       timeout: 3000,
@@ -33700,17 +34442,17 @@ function sumiPathPlan(home, cwd = process.cwd(), env = process.env) {
   return result;
 }
 function selectedConfigDirectory(plan) {
-  const canonical7 = plan.roots.config, legacy = plan.legacyRoots.config;
+  const canonical8 = plan.roots.config, legacy = plan.legacyRoots.config;
   if (legacy === null)
-    return existsSync8(canonical7) ? realpathSync5(canonical7) : canonical7;
-  const canonicalStat = lstatSync14(canonical7, { throwIfNoEntry: false }), legacyStat = lstatSync14(legacy, { throwIfNoEntry: false });
-  if (canonicalStat && legacyStat && realpathSync5(canonical7) !== realpathSync5(legacy))
+    return existsSync8(canonical8) ? realpathSync7(canonical8) : canonical8;
+  const canonicalStat = lstatSync15(canonical8, { throwIfNoEntry: false }), legacyStat = lstatSync15(legacy, { throwIfNoEntry: false });
+  if (canonicalStat && legacyStat && realpathSync7(canonical8) !== realpathSync7(legacy))
     throw new Error("Sumi config roots conflict; complete native home adoption before Skills integration");
-  const selected = canonicalStat ? canonical7 : legacyStat ? legacy : canonical7;
+  const selected = canonicalStat ? canonical8 : legacyStat ? legacy : canonical8;
   if (!existsSync8(selected))
     return selected;
-  const physical = realpathSync5(selected);
-  if ((canonicalStat?.isSymbolicLink() || legacyStat?.isSymbolicLink()) && ![canonical7, legacy].includes(physical))
+  const physical = realpathSync7(selected);
+  if ((canonicalStat?.isSymbolicLink() || legacyStat?.isSymbolicLink()) && ![canonical8, legacy].includes(physical))
     throw new Error("Sumi config alias must resolve to its canonical or legacy root");
   return physical;
 }
@@ -33718,7 +34460,7 @@ function sumiConfigDirectory(home, env = process.env, cwd = process.cwd()) {
   return selectedConfigDirectory(sumiPathPlan(home, cwd, env));
 }
 function sumiConfigPath(home, cwd = process.cwd(), env = process.env) {
-  return join20(sumiConfigDirectory(home, env, cwd), "sumi.json");
+  return join21(sumiConfigDirectory(home, env, cwd), "sumi.json");
 }
 var SUMI_PATH_SELECTORS, SUMI_PATH_KEYS, SUMI_PATH_OUTPUT_LIMIT, SumiPathResolverError;
 var init_agent_sumi = __esm(() => {
@@ -33736,9 +34478,9 @@ var init_agent_sumi = __esm(() => {
 });
 
 // src/lib/codex-hook-trust-files.ts
-import { closeSync as closeSync11, constants as constants9, fstatSync as fstatSync11, fsyncSync as fsyncSync2, lstatSync as lstatSync15, openSync as openSync11, readlinkSync as readlinkSync4, readSync as readSync6, writeFileSync as writeFileSync4 } from "fs";
-import { createHash as createHash15 } from "crypto";
-import { dirname as dirname13, isAbsolute as isAbsolute12, resolve as resolve13 } from "path";
+import { closeSync as closeSync12, constants as constants10, fstatSync as fstatSync12, fsyncSync as fsyncSync2, lstatSync as lstatSync16, openSync as openSync12, readlinkSync as readlinkSync4, readSync as readSync7, writeFileSync as writeFileSync4 } from "fs";
+import { createHash as createHash16 } from "crypto";
+import { dirname as dirname14, isAbsolute as isAbsolute13, resolve as resolve14 } from "path";
 function need6(value, code) {
   if (!value)
     throw new Error(`CODEX_HOOK_TRUST_${code}`);
@@ -33747,37 +34489,37 @@ function trustedAncestorOwner(uid) {
   return BigInt(uid) === 0n || BigInt(uid) === BigInt(process.getuid());
 }
 function safeParents(file2) {
-  for (let p = dirname13(file2);; p = dirname13(p)) {
-    const s = lstatSync15(p);
+  for (let p = dirname14(file2);; p = dirname14(p)) {
+    const s = lstatSync16(p);
     need6(s.isDirectory() && !s.isSymbolicLink() && trustedAncestorOwner(s.uid), "UNSAFE_PARENT");
     need6((s.mode & 18) === 0 || s.uid === 0 && (s.mode & 512) !== 0, "UNSAFE_PARENT");
-    if (dirname13(p) === p)
+    if (dirname14(p) === p)
       break;
   }
 }
 function snapshot(file2, privateFile = false, options = {}) {
   const readOnlyPackage = options.readOnlyPackage === true && !privateFile;
   safeParents(file2);
-  const initial = lstatSync15(file2, { bigint: true });
+  const initial = lstatSync16(file2, { bigint: true });
   need6(initial.isFile() && initial.uid === BigInt(process.getuid()) && (initial.nlink === 1n || readOnlyPackage && initial.nlink > 1n) && (initial.mode & 0o022n) === 0n && (!privateFile || (initial.mode & 0o777n) === 0o600n), "UNSAFE_FILE");
   need6(initial.size <= 8n * 1024n * 1024n, "FILE_BOUND");
-  const fd = openSync11(file2, constants9.O_RDONLY | constants9.O_NOFOLLOW | constants9.O_NONBLOCK);
+  const fd = openSync12(file2, constants10.O_RDONLY | constants10.O_NOFOLLOW | constants10.O_NONBLOCK);
   try {
-    const before = fstatSync11(fd, { bigint: true });
+    const before = fstatSync12(fd, { bigint: true });
     need6(sameStat(initial, before), "INPUT_CHANGED");
     const bytes = Buffer.alloc(Number(before.size) + 1);
     let length = 0;
     while (length < bytes.length) {
-      const n2 = readSync6(fd, bytes, length, bytes.length - length, null);
+      const n2 = readSync7(fd, bytes, length, bytes.length - length, null);
       if (!n2)
         break;
       length += n2;
     }
-    need6(length === Number(before.size) && sameStat(before, fstatSync11(fd, { bigint: true })) && sameStat(before, lstatSync15(file2, { bigint: true })), "INPUT_CHANGED");
+    need6(length === Number(before.size) && sameStat(before, fstatSync12(fd, { bigint: true })) && sameStat(before, lstatSync16(file2, { bigint: true })), "INPUT_CHANGED");
     const content = bytes.subarray(0, length), text2 = new TextDecoder("utf-8", { fatal: true }).decode(content);
-    return { file: file2, privateFile, readOnlyPackage, text: text2, bytes: content, stat: before, sha256: createHash15("sha256").update(content).digest("hex") };
+    return { file: file2, privateFile, readOnlyPackage, text: text2, bytes: content, stat: before, sha256: createHash16("sha256").update(content).digest("hex") };
   } finally {
-    closeSync11(fd);
+    closeSync12(fd);
   }
 }
 function unchanged2(before) {
@@ -33839,47 +34581,47 @@ var init_runtime_launcher = __esm(() => {
 });
 
 // src/lib/retained-review-artifacts.ts
-import { createHash as createHash16 } from "crypto";
-import { constants as constants10, closeSync as closeSync12, fstatSync as fstatSync12, fsyncSync as fsyncSync3, lstatSync as lstatSync16, mkdirSync as mkdirSync5, openSync as openSync12, readSync as readSync7, writeSync as writeSync2 } from "fs";
-import { dirname as dirname14, isAbsolute as isAbsolute13, join as join21, resolve as resolve14, sep as sep7 } from "path";
+import { createHash as createHash17 } from "crypto";
+import { constants as constants11, closeSync as closeSync13, fstatSync as fstatSync13, fsyncSync as fsyncSync3, lstatSync as lstatSync17, mkdirSync as mkdirSync5, openSync as openSync13, readSync as readSync8, writeSync as writeSync2 } from "fs";
+import { dirname as dirname15, isAbsolute as isAbsolute14, join as join22, resolve as resolve15, sep as sep8 } from "path";
 function keys(value, names) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value) && Object.keys(value).length === names.length && names.every((name) => Object.hasOwn(value, name)));
 }
 function safe3(path) {
-  need7(typeof path === "string" && path.length <= AGENT_POLICY_LIMITS.pathCharacters && isAbsolute13(path) && resolve14(path) === path && !/[\x00-\x1f\x7f]/.test(path));
-  for (let cursor = path;; cursor = dirname14(cursor)) {
-    const stat = lstatSync16(cursor, { throwIfNoEntry: false });
+  need7(typeof path === "string" && path.length <= AGENT_POLICY_LIMITS.pathCharacters && isAbsolute14(path) && resolve15(path) === path && !/[\x00-\x1f\x7f]/.test(path));
+  for (let cursor = path;; cursor = dirname15(cursor)) {
+    const stat = lstatSync17(cursor, { throwIfNoEntry: false });
     need7(!stat?.isSymbolicLink());
     if (cursor !== path && stat)
       need7(stat.isDirectory());
-    if (dirname14(cursor) === cursor)
+    if (dirname15(cursor) === cursor)
       break;
   }
 }
 function readExact(path) {
   safe3(path);
-  const before = lstatSync16(path, { throwIfNoEntry: false });
+  const before = lstatSync17(path, { throwIfNoEntry: false });
   need7(before?.isFile() && before.nlink === 1 && before.size <= AGENT_POLICY_LIMITS.discoveryRawSourceBytes && (before.mode & 63) === 0 && (process.getuid === undefined || before.uid === process.getuid()));
-  const fd = openSync12(path, constants10.O_RDONLY | constants10.O_NOFOLLOW | constants10.O_NONBLOCK);
+  const fd = openSync13(path, constants11.O_RDONLY | constants11.O_NOFOLLOW | constants11.O_NONBLOCK);
   try {
-    const opened = fstatSync12(fd);
+    const opened = fstatSync13(fd);
     need7(opened.dev === before.dev && opened.ino === before.ino && opened.size === before.size && opened.mode === before.mode && opened.uid === before.uid && opened.nlink === 1);
     const bytes = Buffer.alloc(opened.size);
     let offset = 0;
     while (offset < bytes.length) {
-      const count = readSync7(fd, bytes, offset, bytes.length - offset, null);
+      const count = readSync8(fd, bytes, offset, bytes.length - offset, null);
       need7(count > 0);
       offset += count;
     }
-    need7(readSync7(fd, Buffer.alloc(1), 0, 1, null) === 0);
-    const after = fstatSync12(fd), current = lstatSync16(path, { throwIfNoEntry: false });
+    need7(readSync8(fd, Buffer.alloc(1), 0, 1, null) === 0);
+    const after = fstatSync13(fd), current = lstatSync17(path, { throwIfNoEntry: false });
     safe3(path);
     need7(current && opened.dev === current.dev && opened.ino === current.ino && opened.mode === current.mode && opened.uid === current.uid && opened.size === current.size && opened.mtimeMs === current.mtimeMs && opened.ctimeMs === current.ctimeMs && current.nlink === 1 && opened.mode === after.mode && opened.uid === after.uid && after.nlink === 1 && opened.size === after.size && opened.mtimeMs === after.mtimeMs && opened.ctimeMs === after.ctimeMs);
     const text2 = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes);
     need7(Buffer.from(text2).equals(bytes));
     return text2;
   } finally {
-    closeSync12(fd);
+    closeSync13(fd);
   }
 }
 function catalogDigest(text2) {
@@ -33887,7 +34629,7 @@ function catalogDigest(text2) {
   try {
     catalog = JSON.parse(text2);
   } catch {
-    return refuse3();
+    return refuse4();
   }
   need7(catalog && typeof catalog === "object" && !Array.isArray(catalog) && Object.keys(catalog).every((key) => ["version", "cwd", "skills", "plugins"].includes(key)) && typeof catalog.version === "string" && supportsCodexNativeCapability(catalog.version, "installed-plugin-review"));
   const skills = projectCodexNativeSkillCatalog({ data: [{ cwd: catalog.cwd, errors: [], skills: catalog.skills }] }, catalog.cwd);
@@ -33895,32 +34637,32 @@ function catalogDigest(text2) {
   return sha3(JSON.stringify({ version: catalog.version, cwd: catalog.cwd, skills, ...plugins === undefined ? {} : { plugins } }));
 }
 function retainedArtifactPath(metadata) {
-  return join21(metadata.storeRoot, "agent-discovery", "artifacts", metadata.sha256, "catalog.json");
+  return join22(metadata.storeRoot, "agent-discovery", "artifacts", metadata.sha256, "catalog.json");
 }
 function validRetainedArtifact(value) {
-  return keys(value, ["version", "kind", "storeRoot", "originalPath", "sha256", "catalogSha256"]) && value.version === 1 && value.kind === "codex-native-catalog" && hex3(value.sha256) && hex3(value.catalogSha256) && [value.storeRoot, value.originalPath].every((path) => typeof path === "string" && isAbsolute13(path) && resolve14(path) === path && path.length <= AGENT_POLICY_LIMITS.pathCharacters && !/[\x00-\x1f\x7f]/.test(path));
+  return keys(value, ["version", "kind", "storeRoot", "originalPath", "sha256", "catalogSha256"]) && value.version === 1 && value.kind === "codex-native-catalog" && hex3(value.sha256) && hex3(value.catalogSha256) && [value.storeRoot, value.originalPath].every((path) => typeof path === "string" && isAbsolute14(path) && resolve15(path) === path && path.length <= AGENT_POLICY_LIMITS.pathCharacters && !/[\x00-\x1f\x7f]/.test(path));
 }
 function privateStore(storeRoot) {
   safe3(storeRoot);
-  const stat = lstatSync16(storeRoot, { throwIfNoEntry: false });
+  const stat = lstatSync17(storeRoot, { throwIfNoEntry: false });
   need7(!stat || stat.isDirectory() && (stat.mode & 18) === 0 && (process.getuid === undefined || stat.uid === process.getuid()));
 }
 function verifyRetainedReviewArtifact(source, storeRoot) {
   const artifact = source.reviewArtifact;
-  need7(validRetainedArtifact(artifact) && source.hashMode === "bytes" && source.sha256 === artifact.sha256 && source.format === undefined && source.fields === undefined && source.managedPlugins === undefined && source.path === retainedArtifactPath(artifact) && (storeRoot === undefined || artifact.storeRoot === resolve14(storeRoot)));
+  need7(validRetainedArtifact(artifact) && source.hashMode === "bytes" && source.sha256 === artifact.sha256 && source.format === undefined && source.fields === undefined && source.managedPlugins === undefined && source.path === retainedArtifactPath(artifact) && (storeRoot === undefined || artifact.storeRoot === resolve15(storeRoot)));
   privateStore(artifact.storeRoot);
   const text2 = readExact(source.path);
   need7(sha3(text2) === artifact.sha256 && catalogDigest(text2) === artifact.catalogSha256);
-  for (let parent = dirname14(source.path);parent !== artifact.storeRoot; parent = dirname14(parent)) {
-    const stat = lstatSync16(parent);
+  for (let parent = dirname15(source.path);parent !== artifact.storeRoot; parent = dirname15(parent)) {
+    const stat = lstatSync17(parent);
     need7(stat.isDirectory() && (stat.mode & 63) === 0 && (process.getuid === undefined || stat.uid === process.getuid()));
   }
 }
-var sha3 = (bytes) => createHash16("sha256").update(bytes).digest("hex"), hex3 = (value) => typeof value === "string" && /^[a-f0-9]{64}$/.test(value), refuse3 = () => {
+var sha3 = (bytes) => createHash17("sha256").update(bytes).digest("hex"), hex3 = (value) => typeof value === "string" && /^[a-f0-9]{64}$/.test(value), refuse4 = () => {
   throw new Error("REVIEW_ARTIFACT_INVALID");
 }, need7 = (condition) => {
   if (!condition)
-    refuse3();
+    refuse4();
 };
 var init_retained_review_artifacts = __esm(() => {
   init_agent_policy_limits();
@@ -33937,6 +34679,8 @@ var init_agent_integration = __esm(() => {
   init_codex_native_skill_catalog();
   init_codex_settings_witness();
   init_claude_settings_witness();
+  init_codex_native_compatibility();
+  init_codex_semantic_cache_witness();
   init_native_discovery_roots();
   init_config();
   init_managed_policy();
@@ -33987,12 +34731,12 @@ var init_skill_aliases = __esm(() => {
 
 // src/lib/project-state.ts
 import { existsSync as existsSync9, mkdirSync as mkdirSync6, readFileSync as readFileSync13, writeFileSync as writeFileSync5 } from "fs";
-import { join as join22 } from "path";
+import { join as join23 } from "path";
 function getProjectStateDir(targetDir = process.cwd()) {
-  return join22(targetDir, SKILLS_PROJECT_DIR);
+  return join23(targetDir, SKILLS_PROJECT_DIR);
 }
 function getProjectConfigPath(targetDir = process.cwd()) {
-  return join22(getProjectStateDir(targetDir), PROJECT_CONFIG_FILE);
+  return join23(getProjectStateDir(targetDir), PROJECT_CONFIG_FILE);
 }
 function loadProjectConfig(targetDir = process.cwd()) {
   const path = getProjectConfigPath(targetDir);
@@ -34108,7 +34852,7 @@ var init_project_state = __esm(() => {
 
 // src/lib/installer.ts
 import { existsSync as existsSync10, readFileSync as readFileSync14, rmSync } from "fs";
-import { join as join23 } from "path";
+import { join as join24 } from "path";
 import { homedir as homedir2 } from "os";
 function getSkillPath(name) {
   const skillName = normalizeSkillName(getCanonicalSkillName(name));
@@ -34118,7 +34862,7 @@ function getSkillPath(name) {
   const extensionPath = findExtensionSkillPath(skillName);
   if (extensionPath)
     return extensionPath;
-  return join23(getPortableSkillsRoot(), skillName);
+  return join24(getPortableSkillsRoot(), skillName);
 }
 function getCanonicalSkillName(name) {
   return getSkill(name)?.name ?? resolveSkillAlias(normalizeSkillSlug(name));
@@ -34172,11 +34916,11 @@ function getAgentSkillsDir(agent, scope = "global", projectDir) {
   const base = projectDir || process.cwd();
   switch (agent) {
     case "pi":
-      return scope === "project" ? join23(base, ".pi", "skills") : join23(homedir2(), ".pi", "agent", "skills");
+      return scope === "project" ? join24(base, ".pi", "skills") : join24(homedir2(), ".pi", "agent", "skills");
     case "opencode":
-      return scope === "project" ? join23(base, ".opencode", "skills") : join23(homedir2(), ".config", "opencode", "skills");
+      return scope === "project" ? join24(base, ".opencode", "skills") : join24(homedir2(), ".config", "opencode", "skills");
     default:
-      return scope === "project" ? join23(base, `.${agent}`, "skills") : join23(homedir2(), `.${agent}`, "skills");
+      return scope === "project" ? join24(base, `.${agent}`, "skills") : join24(homedir2(), `.${agent}`, "skills");
   }
 }
 function warnMissingDependencies(name, targetDir) {
@@ -34191,7 +34935,7 @@ function warnMissingDependencies(name, targetDir) {
   }
 }
 function readBundledSkillVersion(name) {
-  const pkgPath = join23(getSkillPath(name), "package.json");
+  const pkgPath = join24(getSkillPath(name), "package.json");
   if (!existsSync10(pkgPath))
     return "unknown";
   try {
@@ -34261,11 +35005,11 @@ var init_skill_doc_file = __esm(() => {
 
 // src/lib/skillinfo.ts
 import { existsSync as existsSync11, readFileSync as readFileSync15 } from "fs";
-import { join as join24 } from "path";
+import { join as join25 } from "path";
 function isInstructionSkillDir(skillPath, meta3) {
   if (meta3?.kind === "instruction")
     return true;
-  const skillMdPath = join24(skillPath, "SKILL.md");
+  const skillMdPath = join25(skillPath, "SKILL.md");
   if (!existsSync11(skillMdPath))
     return false;
   try {
@@ -34279,9 +35023,9 @@ function getSkillDocs(name) {
   if (!existsSync11(skillPath))
     return null;
   return {
-    skillMd: readIfExists(join24(skillPath, "SKILL.md")),
-    readme: readIfExists(join24(skillPath, "README.md")),
-    claudeMd: readIfExists(join24(skillPath, "CLAUDE.md"))
+    skillMd: readIfExists(join25(skillPath, "SKILL.md")),
+    readme: readIfExists(join25(skillPath, "README.md")),
+    claudeMd: readIfExists(join25(skillPath, "CLAUDE.md"))
   };
 }
 function getSkillBestDoc(name, file2) {
@@ -34297,14 +35041,14 @@ function getSkillRequirements(name) {
     return null;
   const texts = [];
   for (const file2 of ["SKILL.md", "README.md", "CLAUDE.md", ".env.example", ".env.local.example"]) {
-    const content = readIfExists(join24(skillPath, file2));
+    const content = readIfExists(join25(skillPath, file2));
     if (content)
       texts.push(content);
   }
   const meta3 = getSkill(name);
   let dependencies = {};
   try {
-    dependencies = JSON.parse(readFileSync15(join24(skillPath, "package.json"), "utf8")).dependencies || {};
+    dependencies = JSON.parse(readFileSync15(join25(skillPath, "package.json"), "utf8")).dependencies || {};
   } catch {}
   return getSkillRequirementsFromContent(name, texts, dependencies, meta3);
 }
@@ -34366,7 +35110,7 @@ async function runSkill(name, args, options = {}) {
       error: `Skill '${name}' is an instruction skill (kind: instruction) and is not runnable. Instruction skills are consumed by coding agents via SKILL.md, not executed with 'skills run'.`
     };
   }
-  const pkgPath = join24(skillPath, "package.json");
+  const pkgPath = join25(skillPath, "package.json");
   if (!existsSync11(pkgPath)) {
     return { exitCode: 1, error: `No package.json in skill '${name}'` };
   }
@@ -34386,12 +35130,12 @@ async function runSkill(name, args, options = {}) {
   } catch {
     return { exitCode: 1, error: `Failed to parse package.json for skill '${name}'` };
   }
-  const entryPath = join24(skillPath, entryPoint2);
+  const entryPath = join25(skillPath, entryPoint2);
   if (!existsSync11(entryPath)) {
     return { exitCode: 1, error: `Entry point '${entryPoint2}' not found in skill '${name}'` };
   }
   const env = { ...process.env, ...options.env };
-  if (!existsSync11(join24(skillPath, "node_modules")) || hasDependencyPreparationMarker(skillPath)) {
+  if (!existsSync11(join25(skillPath, "node_modules")) || hasDependencyPreparationMarker(skillPath)) {
     const failure = await prepareSkillDependencies(skillPath, env, options.preparationTimeoutMs);
     if (failure)
       return failure;
@@ -34417,7 +35161,7 @@ async function runSkill(name, args, options = {}) {
 function detectProjectSkills(cwd = process.cwd()) {
   let pkg;
   try {
-    pkg = JSON.parse(readFileSync15(join24(cwd, "package.json"), "utf8"));
+    pkg = JSON.parse(readFileSync15(join25(cwd, "package.json"), "utf8"));
   } catch {
     return { detected: [], recommended: [] };
   }
@@ -34622,7 +35366,7 @@ var init_selection_resolver = __esm(() => {
 });
 
 // src/lib/plugin-projection.ts
-import { createHash as createHash17 } from "crypto";
+import { createHash as createHash18 } from "crypto";
 function pluginRefusal(message) {
   throw new SkillSelectionError("PLUGIN_ADMISSION_REFUSED", message);
 }
@@ -34700,26 +35444,26 @@ function pluginFileWitnesses(entries) {
     return { path: item.path, mode: item.mode, size: item.bytes.byteLength, sha256: pluginHash(item.bytes) };
   });
 }
-var PLUGIN_PROJECTION_LIMITS, pluginHash = (bytes) => createHash17("sha256").update(bytes).digest("hex");
+var PLUGIN_PROJECTION_LIMITS, pluginHash = (bytes) => createHash18("sha256").update(bytes).digest("hex");
 var init_plugin_projection = __esm(() => {
   init_selection_cache();
   PLUGIN_PROJECTION_LIMITS = Object.freeze({ files: 1024, bytes: 64 * 1024 * 1024, fileBytes: 16 * 1024 * 1024, metadataBytes: 512 * 1024, registrations: 64, history: 128 });
 });
 
 // src/lib/plugin-projection-store.ts
-import { constants as constants11, closeSync as closeSync13, fchmodSync, fstatSync as fstatSync13, fsyncSync as fsyncSync4, linkSync as linkSync2, lstatSync as lstatSync17, mkdirSync as mkdirSync7, openSync as openSync13, opendirSync as opendirSync2, readSync as readSync8, renameSync as renameSync2, rmdirSync as rmdirSync2, rmSync as rmSync2, unlinkSync as unlinkSync3, writeSync as writeSync3 } from "fs";
-import { dirname as dirname15, isAbsolute as isAbsolute14, join as join25, parse as parse10, resolve as resolve15 } from "path";
+import { constants as constants12, closeSync as closeSync14, fchmodSync, fstatSync as fstatSync14, fsyncSync as fsyncSync4, linkSync as linkSync2, lstatSync as lstatSync18, mkdirSync as mkdirSync7, openSync as openSync14, opendirSync as opendirSync2, readSync as readSync9, renameSync as renameSync2, rmdirSync as rmdirSync2, rmSync as rmSync2, unlinkSync as unlinkSync3, writeSync as writeSync3 } from "fs";
+import { dirname as dirname16, isAbsolute as isAbsolute15, join as join26, parse as parse10, resolve as resolve16 } from "path";
 function stat(path) {
   try {
-    return lstatSync17(path, { bigint: true });
+    return lstatSync18(path, { bigint: true });
   } catch (error61) {
     if (missing(error61))
       return null;
     return pluginRefusal("Cannot inspect plugin filesystem entry");
   }
 }
-function canonical7(path) {
-  pluginNeed(typeof path === "string" && path.length <= 8192 && isAbsolute14(path) && resolve15(path) === path && !/[\x00-\x1f\x7f]/.test(path), "Plugin storage paths must be canonical absolute paths");
+function canonical8(path) {
+  pluginNeed(typeof path === "string" && path.length <= 8192 && isAbsolute15(path) && resolve16(path) === path && !/[\x00-\x1f\x7f]/.test(path), "Plugin storage paths must be canonical absolute paths");
 }
 function owner(stats, system = false) {
   const current = uid();
@@ -34729,12 +35473,12 @@ function same3(left, right, identityOnly = false) {
   pluginNeed(right && left.dev === right.dev && left.ino === right.ino && left.mode === right.mode && left.uid === right.uid && left.gid === right.gid && (identityOnly || left.size === right.size && left.nlink === right.nlink && left.mtimeNs === right.mtimeNs && left.ctimeNs === right.ctimeNs), "Plugin filesystem entry changed during access");
 }
 function ancestors(path, create = false) {
-  canonical7(path);
-  const result = [], parent = dirname15(path), filesystemRoot = parse10(parent).root;
+  canonical8(path);
+  const result = [], parent = dirname16(path), filesystemRoot = parse10(parent).root;
   let current = filesystemRoot;
   for (const segment of ["", ...parent.slice(filesystemRoot.length).split("/").filter(Boolean)]) {
     if (segment)
-      current = join25(current, segment);
+      current = join26(current, segment);
     let currentStat = stat(current);
     if (!currentStat && create) {
       try {
@@ -34780,19 +35524,19 @@ function readBytes(path, maximum, kind) {
   fileShape(before, maximum, kind);
   let fd;
   try {
-    fd = openSync13(path, READ_FLAGS);
-    const opened = fstatSync13(fd, { bigint: true });
+    fd = openSync14(path, READ_FLAGS);
+    const opened = fstatSync14(fd, { bigint: true });
     same3(before, opened);
     fileShape(opened, maximum, kind);
     const bytes = new Uint8Array(Number(opened.size));
     let offset = 0;
     while (offset < bytes.byteLength) {
-      const count = readSync8(fd, bytes, offset, bytes.byteLength - offset, null);
+      const count = readSync9(fd, bytes, offset, bytes.byteLength - offset, null);
       pluginNeed(count > 0, "Plugin file changed while being read");
       offset += count;
     }
-    pluginNeed(readSync8(fd, new Uint8Array(1), 0, 1, null) === 0, "Plugin file grew while being read");
-    same3(opened, fstatSync13(fd, { bigint: true }));
+    pluginNeed(readSync9(fd, new Uint8Array(1), 0, 1, null) === 0, "Plugin file grew while being read");
+    same3(opened, fstatSync14(fd, { bigint: true }));
     same3(opened, stat(path));
     verifyAncestors(chain);
     return bytes;
@@ -34802,7 +35546,7 @@ function readBytes(path, maximum, kind) {
     return pluginRefusal("Cannot safely read plugin file");
   } finally {
     if (fd !== undefined)
-      closeSync13(fd);
+      closeSync14(fd);
   }
 }
 function exactPaths(entries) {
@@ -34832,7 +35576,7 @@ function directoryNames(path) {
 function snapshotPluginTree(root, options = {}) {
   const chain = ancestors(root), entries = [], files = [], directories = [];
   let bytes = 0, visited = 0;
-  const visit3 = (directory, relative6) => {
+  const visit3 = (directory, relative7) => {
     const before = stat(directory);
     pluginNeed(before && before.isDirectory() && !before.isSymbolicLink(), "Plugin tree must contain real directories");
     const names = directoryNames(directory);
@@ -34840,18 +35584,18 @@ function snapshotPluginTree(root, options = {}) {
     directories.push({ path: directory, stat: before, names });
     for (const name of names) {
       pluginNeed(++visited <= PLUGIN_PROJECTION_LIMITS.files * 50, "Plugin tree membership exceeds its limit");
-      const path = relative6 ? `${relative6}/${name}` : name;
+      const path = relative7 ? `${relative7}/${name}` : name;
       pluginNeed(new TextEncoder().encode(path).byteLength <= 100 && !/[\\:\x00-\x1f\x7f]/u.test(path), "Plugin entry path exceeds its limit or is unsafe");
-      const absolute = join25(directory, name), entryStat = stat(absolute);
+      const absolute = join26(directory, name), entryStat = stat(absolute);
       pluginNeed(entryStat, "Plugin tree member disappeared");
-      if (relative6 === "" && name === ".orphaned_at" && (options.nativeRuntime === "claude-2.1.274" || options.nativeRuntime === "claude-2.1.276")) {
+      if (relative7 === "" && name === ".orphaned_at" && (options.nativeRuntime === "claude-2.1.274" || options.nativeRuntime === "claude-2.1.276")) {
         const bytes2 = readBytes(absolute, 32, "native-pin");
         pluginNeed(/^[1-9][0-9]{12}$/.test(new TextDecoder().decode(bytes2)), "Malformed native orphan timestamp");
         same3(entryStat, stat(absolute));
         files.push({ path: absolute, stat: entryStat });
         continue;
       }
-      if (relative6 === "" && name === ".in_use" && (options.nativeRuntime === "claude-2.1.274" || options.nativeRuntime === "claude-2.1.276")) {
+      if (relative7 === "" && name === ".in_use" && (options.nativeRuntime === "claude-2.1.274" || options.nativeRuntime === "claude-2.1.276")) {
         pluginNeed(entryStat.isDirectory() && !entryStat.isSymbolicLink(), "Native plugin pins require a real directory");
         owner(entryStat);
         const pins = directoryNames(absolute);
@@ -34859,7 +35603,7 @@ function snapshotPluginTree(root, options = {}) {
         directories.push({ path: absolute, stat: entryStat, names: pins });
         for (const pin of pins) {
           pluginNeed(/^[1-9][0-9]{0,9}$/.test(pin) && Number(pin) <= 2147483647, "Unrecognized native plugin pin name");
-          const pinPath = join25(absolute, pin), pinStat = stat(pinPath);
+          const pinPath = join26(absolute, pin), pinStat = stat(pinPath);
           pluginNeed(pinStat, "Native plugin pin disappeared");
           const bytes2 = readBytes(pinPath, 4096, "native-pin");
           let value;
@@ -34925,8 +35669,8 @@ function readPluginJson(path) {
 var READ_FLAGS, WRITE_FLAGS, uid = () => typeof process.getuid === "function" ? BigInt(process.getuid()) : undefined, missing = (error61) => Boolean(error61 && typeof error61 === "object" && "code" in error61 && error61.code === "ENOENT");
 var init_plugin_projection_store = __esm(() => {
   init_plugin_projection();
-  READ_FLAGS = constants11.O_RDONLY | constants11.O_NOFOLLOW | constants11.O_NONBLOCK;
-  WRITE_FLAGS = constants11.O_WRONLY | constants11.O_CREAT | constants11.O_EXCL | constants11.O_NOFOLLOW | constants11.O_NONBLOCK;
+  READ_FLAGS = constants12.O_RDONLY | constants12.O_NOFOLLOW | constants12.O_NONBLOCK;
+  WRITE_FLAGS = constants12.O_WRONLY | constants12.O_CREAT | constants12.O_EXCL | constants12.O_NOFOLLOW | constants12.O_NONBLOCK;
 });
 
 // src/lib/selected-manifest.ts
@@ -34956,7 +35700,7 @@ var init_selected_manifest = __esm(() => {
 });
 
 // src/lib/plugin-admission.ts
-import { isAbsolute as isAbsolute15, join as join26, resolve as resolve16 } from "path";
+import { isAbsolute as isAbsolute16, join as join27, resolve as resolve17 } from "path";
 function validatePluginTarget(value) {
   pluginKeys(value, ["schemaVersion", "pluginId", "registrations", "native", "resolver"]);
   pluginNeed(value.schemaVersion === 1, "Invalid plugin admission target");
@@ -34966,7 +35710,7 @@ function validatePluginTarget(value) {
   for (const registration of value.registrations) {
     pluginKeys(registration, ["scope", "projectPath"]);
     pluginNeed(registration.scope === "user" || registration.scope === "project", "Unsupported plugin registration scope");
-    pluginNeed(registration.scope === "user" ? registration.projectPath === null : typeof registration.projectPath === "string" && isAbsolute15(registration.projectPath) && resolve16(registration.projectPath) === registration.projectPath, "Plugin scope requires its exact project path");
+    pluginNeed(registration.scope === "user" ? registration.projectPath === null : typeof registration.projectPath === "string" && isAbsolute16(registration.projectPath) && resolve17(registration.projectPath) === registration.projectPath, "Plugin scope requires its exact project path");
     const key = JSON.stringify([registration.scope, registration.projectPath]);
     pluginNeed(!scopes.has(key), "Duplicate plugin registration scope");
     scopes.add(key);
@@ -34974,7 +35718,7 @@ function validatePluginTarget(value) {
   for (const key of ["native", "resolver"]) {
     pluginKeys(value[key], key === "native" ? ["version", "executable", "digest"] : ["executable", "digest"]);
     pluginText(value[key].executable);
-    pluginNeed(isAbsolute15(value[key].executable) && resolve16(value[key].executable) === value[key].executable, "Plugin executable must have a canonical absolute path");
+    pluginNeed(isAbsolute16(value[key].executable) && resolve17(value[key].executable) === value[key].executable, "Plugin executable must have a canonical absolute path");
     pluginDigest(value[key].digest);
   }
   pluginNeed(["2.1.274", "2.1.276"].includes(value.native.version), "Plugin admission requires a certified Claude command-source runtime (2.1.274 or 2.1.276)");
@@ -35117,12 +35861,12 @@ function pluginResolverCommand(binding) {
 }
 function pluginBindingPath(storeRoot, id) {
   pluginNeed(/^[a-f0-9]{64}$/.test(id), "Invalid plugin binding identifier");
-  return join26(storeRoot, "bindings", `${id}.json`);
+  return join27(storeRoot, "bindings", `${id}.json`);
 }
-function pluginReceiptPath(storeRoot, id, digest) {
+function pluginReceiptPath(storeRoot, id, digest2) {
   pluginNeed(/^[a-f0-9]{64}$/.test(id), "Invalid plugin binding identifier");
-  pluginDigest(digest);
-  return join26(storeRoot, "receipts", id, `${digest.slice(7)}.json`);
+  pluginDigest(digest2);
+  return join27(storeRoot, "receipts", id, `${digest2.slice(7)}.json`);
 }
 function readPluginBinding(storeRoot, id) {
   const value = readPluginJson(pluginBindingPath(storeRoot, id));
@@ -35131,18 +35875,18 @@ function readPluginBinding(storeRoot, id) {
   pluginNeed(bindingId(binding) === id, "Plugin admission binding changed");
   return binding;
 }
-function readPluginAdmissionReceipt(storeRoot, id, digest) {
-  const value = readPluginJson(pluginReceiptPath(storeRoot, id, digest));
+function readPluginAdmissionReceipt(storeRoot, id, digest2) {
+  const value = readPluginJson(pluginReceiptPath(storeRoot, id, digest2));
   pluginKeys(value, ["schemaVersion", "plan", "materializedPath", "admittedAt"]);
   pluginNeed(value.schemaVersion === 3, "Unsupported plugin admission receipt; schema version 3 is required");
   validatePlan(value.plan);
   const receipt = value;
   receipt.plan.files = normalizedWitnesses(receipt.plan.files);
   receipt.plan.removed = normalizedWitnesses(receipt.plan.removed);
-  pluginNeed(receipt.plan.bindingId === id && receipt.plan.planDigest === digest, "Plugin receipt identity differs from its filename");
+  pluginNeed(receipt.plan.bindingId === id && receipt.plan.planDigest === digest2, "Plugin receipt identity differs from its filename");
   const binding = readPluginBinding(storeRoot, id);
   pluginNeed(canonicalJson(binding) === canonicalJson(receipt.plan.binding) && receipt.plan.sourceCommand === pluginResolverCommand(binding), "Plugin receipt binding changed");
-  pluginNeed(receipt.materializedPath === join26(storeRoot, "objects", id, digest.slice(7)), "Plugin receipt points outside its immutable materialization");
+  pluginNeed(receipt.materializedPath === join27(storeRoot, "objects", id, digest2.slice(7)), "Plugin receipt points outside its immutable materialization");
   pluginText(receipt.admittedAt, 64);
   pluginNeed(Number.isFinite(Date.parse(receipt.admittedAt)), "Invalid plugin admission time");
   return receipt;
@@ -35159,8 +35903,8 @@ var init_plugin_admission = __esm(() => {
 });
 
 // src/lib/plugin-discovery.ts
-import { closeSync as closeSync14, constants as constants12, fstatSync as fstatSync14, lstatSync as lstatSync18, openSync as openSync14, opendirSync as opendirSync3, readSync as readSync9 } from "fs";
-import { basename as basename7, dirname as dirname16, isAbsolute as isAbsolute16, join as join27, resolve as resolve17 } from "path";
+import { closeSync as closeSync15, constants as constants13, fstatSync as fstatSync15, lstatSync as lstatSync19, openSync as openSync15, opendirSync as opendirSync3, readSync as readSync10 } from "fs";
+import { basename as basename7, dirname as dirname17, isAbsolute as isAbsolute17, join as join28, resolve as resolve18 } from "path";
 function validateManagedPluginWitnesses(value) {
   pluginNeed(Array.isArray(value) && value.length > 0 && value.length <= PLUGIN_PROJECTION_LIMITS.registrations, "Invalid managed plugin witness collection");
   const seen = new Set;
@@ -35169,35 +35913,35 @@ function validateManagedPluginWitnesses(value) {
     pluginNeed(typeof item.bindingId === "string" && /^[a-f0-9]{64}$/.test(item.bindingId) && !seen.has(item.bindingId), "Invalid or duplicate managed plugin witness");
     seen.add(item.bindingId);
     pluginText(item.storeRoot);
-    pluginNeed(isAbsolute16(item.storeRoot) && resolve17(item.storeRoot) === item.storeRoot, "Invalid plugin receipt store path");
+    pluginNeed(isAbsolute17(item.storeRoot) && resolve18(item.storeRoot) === item.storeRoot, "Invalid plugin receipt store path");
   }
 }
 function safe4(path) {
   pluginText(path);
-  pluginNeed(isAbsolute16(path) && resolve17(path) === path, "Invalid plugin registry path");
-  for (let at = path;; at = dirname16(at)) {
-    pluginNeed(!lstatSync18(at, { throwIfNoEntry: false })?.isSymbolicLink(), "Plugin registry path traverses a symlink");
-    if (at === dirname16(at))
+  pluginNeed(isAbsolute17(path) && resolve18(path) === path, "Invalid plugin registry path");
+  for (let at = path;; at = dirname17(at)) {
+    pluginNeed(!lstatSync19(at, { throwIfNoEntry: false })?.isSymbolicLink(), "Plugin registry path traverses a symlink");
+    if (at === dirname17(at))
       break;
   }
 }
 function readRegistry(path) {
   safe4(path);
-  const initial = lstatSync18(path);
+  const initial = lstatSync19(path);
   pluginNeed(initial.isFile() && initial.size <= 1024 * 1024, "Plugin registry is not a bounded regular file");
-  const fd = openSync14(path, constants12.O_RDONLY | constants12.O_NOFOLLOW | constants12.O_NONBLOCK);
+  const fd = openSync15(path, constants13.O_RDONLY | constants13.O_NOFOLLOW | constants13.O_NONBLOCK);
   try {
-    const opened = fstatSync14(fd);
+    const opened = fstatSync15(fd);
     pluginNeed(opened.isFile() && opened.ino === initial.ino && opened.dev === initial.dev, "Plugin registry changed during open");
     const bytes = Buffer.alloc(1024 * 1024 + 1);
     let length = 0;
     while (length < bytes.length) {
-      const count = readSync9(fd, bytes, length, bytes.length - length, null);
+      const count = readSync10(fd, bytes, length, bytes.length - length, null);
       if (!count)
         break;
       length += count;
     }
-    const after = fstatSync14(fd), current = lstatSync18(path);
+    const after = fstatSync15(fd), current = lstatSync19(path);
     safe4(path);
     pluginNeed(length <= 1024 * 1024 && length === opened.size && after.size === opened.size && after.mtimeMs === opened.mtimeMs && after.ctimeMs === opened.ctimeMs && current.dev === opened.dev && current.ino === opened.ino && current.mtimeMs === opened.mtimeMs && current.ctimeMs === opened.ctimeMs, "Plugin registry changed during read");
     let value;
@@ -35209,7 +35953,7 @@ function readRegistry(path) {
     pluginNeed(pluginObject(value) && value.version === 2 && pluginObject(value.plugins), "Unsupported native plugin registry schema");
     return { value, rawDigest: pluginHash(bytes.subarray(0, length)) };
   } finally {
-    closeSync14(fd);
+    closeSync15(fd);
   }
 }
 function nativeVersionMatches(version2, receipt) {
@@ -35227,7 +35971,7 @@ function hashManagedPluginRegistry(path, managed) {
     seen.add(target.pluginId);
     const rows = plugins[target.pluginId];
     pluginNeed(Array.isArray(rows) && rows.length === target.registrations.length, "Managed plugin registration membership changed");
-    const [name, market] = target.pluginId.split("@"), cacheRoot = join27(dirname16(path), "cache", market, name);
+    const [name, market] = target.pluginId.split("@"), cacheRoot = join28(dirname17(path), "cache", market, name);
     const scopes = new Set, approvals = new Map, currentFiles = new Map;
     plugins[target.pluginId] = rows.map((row) => {
       pluginNeed(pluginObject(row), "Invalid managed plugin registration");
@@ -35240,11 +35984,11 @@ function hashManagedPluginRegistry(path, managed) {
       pluginText(row.sourceProducerPath);
       pluginText(row.lastUpdated, 64);
       pluginNeed(Number.isFinite(Date.parse(row.lastUpdated)), "Invalid managed plugin update timestamp");
-      pluginNeed(/^(?:[A-Za-z0-9][A-Za-z0-9._+-]*-)?[a-f0-9]{12}$/.test(row.version) && row.installPath === join27(cacheRoot, row.version), "Managed plugin cache path or version is outside its registration");
+      pluginNeed(/^(?:[A-Za-z0-9][A-Za-z0-9._+-]*-)?[a-f0-9]{12}$/.test(row.version) && row.installPath === join28(cacheRoot, row.version), "Managed plugin cache path or version is outside its registration");
       const approval = (producer) => {
         pluginText(producer);
-        const digest = `sha256:${basename7(producer)}`;
-        const receipt2 = readPluginAdmissionReceipt(witness.storeRoot, witness.bindingId, digest);
+        const digest2 = `sha256:${basename7(producer)}`;
+        const receipt2 = readPluginAdmissionReceipt(witness.storeRoot, witness.bindingId, digest2);
         pluginNeed(receipt2.materializedPath === producer, "Managed producer path is not an approved immutable projection");
         if (!verified.has(producer)) {
           verifiedBytes += receipt2.plan.files.reduce((total, file2) => total + file2.size, 0);
@@ -35270,7 +36014,7 @@ function hashManagedPluginRegistry(path, managed) {
       return Object.fromEntries(Object.entries(row).filter(([key]) => !["version", "installPath", "sourceProducerPath", "previousProducerPaths", "lastUpdated"].includes(key)));
     });
     safe4(cacheRoot);
-    const before = lstatSync18(cacheRoot);
+    const before = lstatSync19(cacheRoot);
     pluginNeed(before.isDirectory(), "Invalid managed plugin cache root");
     const directory = opendirSync3(cacheRoot), names = [];
     try {
@@ -35283,17 +36027,17 @@ function hashManagedPluginRegistry(path, managed) {
       directory.closeSync();
     }
     for (const version2 of names.sort()) {
-      const files = pluginFileWitnesses(snapshotPluginTree(join27(cacheRoot, version2), { nativeRuntime: `claude-${target.native.version}` }));
+      const files = pluginFileWitnesses(snapshotPluginTree(join28(cacheRoot, version2), { nativeRuntime: `claude-${target.native.version}` }));
       verifiedBytes += files.reduce((total, file2) => total + file2.size, 0);
       pluginNeed(verifiedBytes <= 256 * 1024 * 1024, "Managed plugin verification exceeds its aggregate byte budget");
       const serialized = JSON.stringify(files);
-      const expected = currentFiles.get(join27(cacheRoot, version2));
+      const expected = currentFiles.get(join28(cacheRoot, version2));
       pluginNeed(expected === undefined || serialized === expected, "Current native cache differs from its exact registered producer receipt");
       pluginNeed([...approvals.values()].some((receipt) => nativeVersionMatches(version2, receipt) && JSON.stringify(receipt.plan.files) === serialized), "A retained native plugin cache version differs from every approved projection");
     }
     for (const row of rows)
       pluginNeed(names.includes(row.version), "Managed native plugin installation is missing");
-    const after = lstatSync18(cacheRoot);
+    const after = lstatSync19(cacheRoot);
     safe4(cacheRoot);
     pluginNeed(before.dev === after.dev && before.ino === after.ino && before.mtimeMs === after.mtimeMs && before.ctimeMs === after.ctimeMs, "Managed cache version membership changed during verification");
   }
@@ -35307,23 +36051,23 @@ var init_plugin_discovery = __esm(() => {
 });
 
 // src/lib/claude-marketplace-registry.ts
-import { createHash as createHash18 } from "crypto";
-import { closeSync as closeSync15, constants as constants13, fstatSync as fstatSync15, lstatSync as lstatSync19, openSync as openSync15, readSync as readSync10 } from "fs";
-import { basename as basename8, dirname as dirname17, isAbsolute as isAbsolute17, resolve as resolve18 } from "path";
+import { createHash as createHash19 } from "crypto";
+import { closeSync as closeSync16, constants as constants14, fstatSync as fstatSync16, lstatSync as lstatSync20, openSync as openSync16, readSync as readSync11 } from "fs";
+import { basename as basename8, dirname as dirname18, isAbsolute as isAbsolute18, resolve as resolve19 } from "path";
 function need8(value, reason2) {
   if (!value)
     throw new Error(`Claude marketplace registry ${reason2}`);
 }
 function absolutePath4(value) {
-  need8(typeof value === "string" && value.length > 0 && value.length <= CLAUDE_MARKETPLACE_REGISTRY_LIMITS.pathCharacters && !/[\x00-\x1f\x7f]/.test(value) && isAbsolute17(value) && resolve18(value) === value, "requires a normalized absolute path");
+  need8(typeof value === "string" && value.length > 0 && value.length <= CLAUDE_MARKETPLACE_REGISTRY_LIMITS.pathCharacters && !/[\x00-\x1f\x7f]/.test(value) && isAbsolute18(value) && resolve19(value) === value, "requires a normalized absolute path");
 }
 function parents2(path) {
   const result = [];
-  for (let at = dirname17(path);; at = dirname17(at)) {
-    const stat2 = lstatSync19(at, { bigint: true });
+  for (let at = dirname18(path);; at = dirname18(at)) {
+    const stat2 = lstatSync20(at, { bigint: true });
     need8(stat2.isDirectory() && !stat2.isSymbolicLink(), "path traverses a symlink or non-directory");
     result.push([at, stat2]);
-    if (at === dirname17(at))
+    if (at === dirname18(at))
       return result;
   }
 }
@@ -35331,25 +36075,25 @@ function readRegistry2(path, budget2) {
   absolutePath4(path);
   need8(basename8(path) === "known_marketplaces.json", "requires known_marketplaces.json");
   need8(Number.isSafeInteger(budget2.remaining) && budget2.remaining >= 0, "has an invalid byte budget");
-  const ancestors2 = parents2(path), initial = lstatSync19(path, { bigint: true });
+  const ancestors2 = parents2(path), initial = lstatSync20(path, { bigint: true });
   need8(initial.isFile() && !initial.isSymbolicLink() && initial.size <= BigInt(CLAUDE_MARKETPLACE_REGISTRY_LIMITS.bytes), "is not a bounded regular file");
   need8(initial.size <= BigInt(budget2.remaining), "exceeds its aggregate byte limit");
-  const fd = openSync15(path, constants13.O_RDONLY | constants13.O_NOFOLLOW | constants13.O_NONBLOCK);
+  const fd = openSync16(path, constants14.O_RDONLY | constants14.O_NOFOLLOW | constants14.O_NONBLOCK);
   try {
-    const opened = fstatSync15(fd, { bigint: true });
+    const opened = fstatSync16(fd, { bigint: true });
     need8(opened.isFile() && sameFile2(initial, opened), "changed during open");
     const bytes = Buffer.alloc(Number(opened.size) + 1);
     let length = 0;
     while (length < bytes.length) {
-      const count = readSync10(fd, bytes, length, bytes.length - length, null);
+      const count = readSync11(fd, bytes, length, bytes.length - length, null);
       if (!count)
         break;
       length += count;
     }
-    const after = fstatSync15(fd, { bigint: true }), current = lstatSync19(path, { bigint: true });
+    const after = fstatSync16(fd, { bigint: true }), current = lstatSync20(path, { bigint: true });
     need8(current.isFile() && sameFile2(opened, after) && sameFile2(after, current) && BigInt(length) === opened.size, "changed during read");
     for (const [ancestor, before] of ancestors2) {
-      const now = lstatSync19(ancestor, { bigint: true });
+      const now = lstatSync20(ancestor, { bigint: true });
       need8(now.isDirectory() && before.dev === now.dev && before.ino === now.ino && before.mode === now.mode, "parent changed during read");
     }
     budget2.remaining -= length;
@@ -35359,7 +36103,7 @@ function readRegistry2(path, budget2) {
       throw new Error("Claude marketplace registry is not strict UTF-8");
     }
   } finally {
-    closeSync15(fd);
+    closeSync16(fd);
   }
 }
 function parse11(text2) {
@@ -35436,7 +36180,7 @@ function parse11(text2) {
   need8(root.entries.length <= CLAUDE_MARKETPLACE_REGISTRY_LIMITS.rows, "exceeds its marketplace row limit");
   return root;
 }
-function exactKeys(value, keys2) {
+function exactKeys2(value, keys2) {
   return value?.kind === "object" && value.entries.length === keys2.length && value.entries.every(([key]) => keys2.includes(key));
 }
 function textField(value) {
@@ -35444,8 +36188,8 @@ function textField(value) {
   return value.value;
 }
 function normalizeRow(row, version2 = 1) {
-  if (!exactKeys(row, ["source", "installLocation", "lastUpdated"])) {
-    if (version2 !== 2 || !exactKeys(row, ["source", "installLocation", "lastUpdated", "autoUpdate"]))
+  if (!exactKeys2(row, ["source", "installLocation", "lastUpdated"])) {
+    if (version2 !== 2 || !exactKeys2(row, ["source", "installLocation", "lastUpdated", "autoUpdate"]))
       return;
     const autoUpdate = field2(row, "autoUpdate");
     need8(autoUpdate?.kind === "literal" && (autoUpdate.value === "true" || autoUpdate.value === "false"), "contains an invalid automatic-update preference");
@@ -35457,7 +36201,7 @@ function normalizeRow(row, version2 = 1) {
   if (type?.kind !== "string" || !["github", "directory"].includes(type.value))
     return;
   const location = type.value === "github" ? "repo" : "path";
-  if (!exactKeys(source, ["source", location]))
+  if (!exactKeys2(source, ["source", location]))
     return;
   const sourceLocation = textField(field2(source, location));
   if (type.value === "directory")
@@ -35473,14 +36217,14 @@ function captureClaudeMarketplaceRegistry(path, budget2 = { remaining: 256 * 102
   const value = parse11(readRegistry2(path, budget2));
   for (const [, row] of value.entries)
     normalizeRow(row);
-  const sha2562 = createHash18("sha256").update("hasna.skills.claude-marketplace-registry.v1\x00").update(JSON.stringify(value)).digest("hex");
+  const sha2562 = createHash19("sha256").update("hasna.skills.claude-marketplace-registry.v1\x00").update(JSON.stringify(value)).digest("hex");
   return { path, hashMode: "claude-marketplace-registry", sha256: sha2562 };
 }
 function captureClaudeMarketplaceRegistryV2(path, budget2 = { remaining: 256 * 1024 * 1024 }) {
   const value = parse11(readRegistry2(path, budget2));
   for (const [, row] of value.entries)
     normalizeRow(row, 2);
-  const sha2562 = createHash18("sha256").update("hasna.skills.claude-marketplace-registry.v2\x00").update(JSON.stringify(value)).digest("hex");
+  const sha2562 = createHash19("sha256").update("hasna.skills.claude-marketplace-registry.v2\x00").update(JSON.stringify(value)).digest("hex");
   return { path, hashMode: "claude-marketplace-registry-v2", sha256: sha2562 };
 }
 var CLAUDE_MARKETPLACE_REGISTRY_LIMITS, sameFile2 = (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, field2 = (object6, key) => object6.entries.find(([name]) => name === key)?.[1];
@@ -35502,7 +36246,7 @@ var init_codex_hook_additions_review = __esm(() => {
 });
 
 // src/lib/codex-hook-discovery-recovery.ts
-import { createHash as createHash19 } from "crypto";
+import { createHash as createHash20 } from "crypto";
 function assertCodexHookDiscoveryRecovery(binding, witness) {
   const proof = proofs2.get(witness);
   need6(!!proof && binding.agent === "codex" && witness.discoverySha256 === discoveryDigest(binding), "RECONCILE_DISCOVERY_RECOVERY_CHANGED");
@@ -35517,7 +36261,7 @@ function verifiesCodexHookDiscoverySource(binding, source, currentDigest, witnes
   need6(source.sha256 === witness.beforeSha256 && currentDigest === witness.currentSha256, "RECONCILE_DISCOVERY_RECOVERY_CHANGED");
   return true;
 }
-var sha4 = (text2) => createHash19("sha256").update(text2).digest("hex"), fields, discoveryDigest = (binding) => {
+var sha4 = (text2) => createHash20("sha256").update(text2).digest("hex"), fields, discoveryDigest = (binding) => {
   const controls = binding.codexDisabledPluginSkills;
   if (!Object.hasOwn(binding, "codexDisabledPluginSkills") || Array.isArray(controls) && controls.length === 0) {
     const { codexDisabledPluginSkills: _controls, ...withoutControls } = binding;
@@ -35535,16 +36279,16 @@ var init_codex_hook_discovery_recovery = __esm(() => {
 });
 
 // src/lib/agent-discovery.ts
-import { createHash as createHash20 } from "crypto";
-import { lstatSync as lstatSync20, readFileSync as readFileSync16, readdirSync as readdirSync7, realpathSync as realpathSync6 } from "fs";
-import { basename as basename9, dirname as dirname18, isAbsolute as isAbsolute18, join as join28, resolve as resolve19, sep as sep8 } from "path";
+import { createHash as createHash21 } from "crypto";
+import { lstatSync as lstatSync21, readFileSync as readFileSync16, readdirSync as readdirSync8, realpathSync as realpathSync8 } from "fs";
+import { basename as basename9, dirname as dirname19, isAbsolute as isAbsolute19, join as join29, relative as relative7, resolve as resolve20, sep as sep9 } from "path";
 import { isDeepStrictEqual as isDeepStrictEqual4 } from "util";
 function discoveryExecutable(agent) {
   const command = DISCOVERY_RUNTIME_COMMANDS[agent];
   const found = command ? Bun.which(command) : null;
   if (!command || !found)
     return null;
-  const path = resolve19(found), target = realpathOrNull(path);
+  const path = resolve20(found), target = realpathOrNull(path);
   return target === null ? null : { command, path, target };
 }
 function parseConfig(text2, path, toml = false) {
@@ -35558,12 +36302,12 @@ function parseConfig(text2, path, toml = false) {
   }
 }
 function safe5(path) {
-  if (!isAbsolute18(path) || path.includes("\x00"))
+  if (!isAbsolute19(path) || path.includes("\x00"))
     throw new Error("Expected an absolute native discovery path");
-  for (let cursor = path;; cursor = dirname18(cursor)) {
-    if (lstatSync20(cursor, { throwIfNoEntry: false })?.isSymbolicLink())
+  for (let cursor = path;; cursor = dirname19(cursor)) {
+    if (lstatSync21(cursor, { throwIfNoEntry: false })?.isSymbolicLink())
       throw new Error(`Refusing symlink native discovery input: ${cursor}`);
-    if (dirname18(cursor) === cursor)
+    if (dirname19(cursor) === cursor)
       break;
   }
 }
@@ -35571,27 +36315,27 @@ function read(path, changes) {
   safe5(path);
   if (changes?.has(path))
     return changes.get(path);
-  const stat2 = lstatSync20(path, { throwIfNoEntry: false });
+  const stat2 = lstatSync21(path, { throwIfNoEntry: false });
   if (!stat2)
     return null;
   if (!stat2.isFile() || stat2.size > 16 * 1024 * 1024)
     throw new Error(`Unsupported or oversized native discovery input: ${path}`);
   return readFileSync16(path, "utf8");
 }
-function assertReviewedClaudeCacheClosures(home, config2, review, canonical8) {
+function assertReviewedClaudeCacheClosures(home, config2, review, canonical9) {
   const enabledIds = Object.entries(config2.enabledPlugins ?? {}).filter(([, enabled]) => enabled === true).map(([id]) => id);
   if (enabledIds.length === 0)
     return;
-  const registryPath = canonical8(join28(home, ".claude/plugins/installed_plugins.json"));
-  const cacheAliasRoot = join28(home, ".claude/plugins/cache");
-  const cacheRoot = canonical8(cacheAliasRoot);
+  const registryPath = canonical9(join29(home, ".claude/plugins/installed_plugins.json"));
+  const cacheAliasRoot = join29(home, ".claude/plugins/cache");
+  const cacheRoot = canonical9(cacheAliasRoot);
   const registryText = read(registryPath);
   if (registryText === null)
     return;
   const registry2 = parseConfig(registryText, registryPath);
   if (registry2.version !== 2 || !registry2.plugins || typeof registry2.plugins !== "object" || Array.isArray(registry2.plugins))
     throw new Error("Reviewed Claude installed plugin registrations are invalid");
-  const cachePath = (path) => typeof path === "string" && isAbsolute18(path) && resolve19(path) === path && [cacheAliasRoot, cacheRoot].some((root) => path === root || path.startsWith(root + sep8));
+  const cachePath = (path) => typeof path === "string" && isAbsolute19(path) && resolve20(path) === path && [cacheAliasRoot, cacheRoot].some((root) => path === root || path.startsWith(root + sep9));
   const activeRoots = new Set;
   for (const id of enabledIds) {
     const rows = registry2.plugins[id];
@@ -35603,13 +36347,13 @@ function assertReviewedClaudeCacheClosures(home, config2, review, canonical8) {
       if (!row || typeof row !== "object" || Array.isArray(row) || typeof row.installPath !== "string") {
         throw new Error("Reviewed Claude enabled plugin registration requires an object with an installPath string");
       }
-      if ([cacheAliasRoot, cacheRoot].some((root) => row.installPath === root || row.installPath.startsWith(root + sep8))) {
+      if ([cacheAliasRoot, cacheRoot].some((root) => row.installPath === root || row.installPath.startsWith(root + sep9))) {
         if (!cachePath(row.installPath) || row.installPath.length > AGENT_POLICY_LIMITS.pathCharacters || row.version !== undefined && (typeof row.version !== "string" || basename9(row.installPath) !== row.version)) {
           throw new Error("Reviewed Claude discovery has a malformed active cache registration");
         }
-        if (row.scope === "user" && (row.projectPath === undefined || row.projectPath === null)) {} else if (row.scope === "project" && typeof row.projectPath === "string" && isAbsolute18(row.projectPath) && resolve19(row.projectPath) === row.projectPath && row.projectPath.length <= AGENT_POLICY_LIMITS.pathCharacters) {} else
+        if (row.scope === "user" && (row.projectPath === undefined || row.projectPath === null)) {} else if (row.scope === "project" && typeof row.projectPath === "string" && isAbsolute19(row.projectPath) && resolve20(row.projectPath) === row.projectPath && row.projectPath.length <= AGENT_POLICY_LIMITS.pathCharacters) {} else
           throw new Error("Reviewed Claude discovery has an unsupported active cache registration scope");
-        activeRoots.add(canonical8(row.installPath));
+        activeRoots.add(canonical9(row.installPath));
       }
     }
   }
@@ -35625,11 +36369,11 @@ function assertReviewedClaudeCacheClosures(home, config2, review, canonical8) {
   };
   for (const root of activeRoots) {
     safe5(root);
-    const rootStat = lstatSync20(root, { throwIfNoEntry: false });
-    if (!rootStat?.isDirectory() || realpathSync6(root) !== root)
+    const rootStat = lstatSync21(root, { throwIfNoEntry: false });
+    if (!rootStat?.isDirectory() || realpathSync8(root) !== root)
       throw new Error("Reviewed Claude active cache plugin root is missing or unsafe");
-    const manifestPath = join28(root, ".claude-plugin/plugin.json");
-    const manifestStat = lstatSync20(manifestPath, { throwIfNoEntry: false });
+    const manifestPath = join29(root, ".claude-plugin/plugin.json");
+    const manifestStat = lstatSync21(manifestPath, { throwIfNoEntry: false });
     let manifest;
     if (manifestStat) {
       if (!manifestStat.isFile())
@@ -35644,37 +36388,37 @@ function assertReviewedClaudeCacheClosures(home, config2, review, canonical8) {
     } else if (!review.sources.some((source) => source.path === manifestPath && source.hashMode === "path-bytes" && source.sha256 !== null && source.format === undefined && source.fields === undefined && source.managedPlugins === undefined)) {
       throw new Error("Reviewed Claude active cache plugin manifest absence requires a path-bytes witness");
     }
-    const roots = new Set([join28(root, "skills")]);
-    if (lstatSync20(join28(root, "SKILL.md"), { throwIfNoEntry: false })?.isFile())
+    const roots = new Set([join29(root, "skills")]);
+    if (lstatSync21(join29(root, "SKILL.md"), { throwIfNoEntry: false })?.isFile())
       roots.add(root);
     const declared = manifest?.skills === undefined ? ["./skills"] : typeof manifest.skills === "string" ? [manifest.skills] : manifest.skills;
     if (!Array.isArray(declared) || declared.some((path) => typeof path !== "string"))
       throw new Error("Reviewed Claude active cache plugin has unsupported skill paths");
     for (const value of declared) {
-      const path = resolve19(root, value);
-      if (path !== root && !path.startsWith(root + sep8))
+      const path = resolve20(root, value);
+      if (path !== root && !path.startsWith(root + sep9))
         throw new Error("Reviewed Claude active cache plugin skill path escapes its root");
-      roots.add(path.endsWith(`${sep8}SKILL.md`) ? dirname18(path) : path);
+      roots.add(path.endsWith(`${sep9}SKILL.md`) ? dirname19(path) : path);
     }
     for (const skillRoot of roots)
       if (!review.roots.includes(skillRoot))
         throw new Error("Reviewed Claude active cache plugin skill root is not covered");
-    const hooksPath = join28(root, "hooks/hooks.json");
-    const hooksStat = lstatSync20(hooksPath, { throwIfNoEntry: false });
+    const hooksPath = join29(root, "hooks/hooks.json");
+    const hooksStat = lstatSync21(hooksPath, { throwIfNoEntry: false });
     if (hooksStat) {
       if (!hooksStat.isFile())
         throw new Error("Reviewed Claude plugin hook manifest is unsupported");
       requireSource(hooksPath, "hook manifest");
     }
     if (typeof manifest?.hooks === "string")
-      requireSource(resolve19(root, manifest.hooks), "manifest-declared hook source");
+      requireSource(resolve20(root, manifest.hooks), "manifest-declared hook source");
   }
 }
 function projectNativeDiscoveryFields(text2, format, fields2, path) {
   const object6 = format === "yaml" ? parseHermesConfig(text2) : parseConfig(text2, path, format === "toml");
   if (!object6 || typeof object6 !== "object" || Array.isArray(object6))
     throw new Error("Expected native discovery configuration object");
-  return digest(JSON.stringify(Object.fromEntries(fields2.map((field3) => [field3, object6[field3] ?? null]))));
+  return digest2(JSON.stringify(Object.fromEntries(fields2.map((field3) => [field3, object6[field3] ?? null]))));
 }
 function isSupersededSettingsProjection(agent, configPath, source) {
   if (agent === "sumi")
@@ -35684,7 +36428,7 @@ function isSupersededSettingsProjection(agent, configPath, source) {
 function supersedesSettingsProjection(agent, sources, configPath) {
   if (agent === "sumi")
     return sources.some((source) => source.path === configPath && source.hashMode === "sumi-settings-v1");
-  return agent === "codex" && sources.some((source) => source.path === configPath && (source.hashMode === "codex-settings-v2" || (source.hashMode === "codex-settings-v3" || source.hashMode === "codex-settings-v4")));
+  return agent === "codex" && sources.some((source) => source.path === configPath && (source.hashMode === "codex-settings-v2" || (source.hashMode === "codex-settings-v3" || source.hashMode === "codex-settings-v4" || source.hashMode === "codex-settings-v5")));
 }
 function projected(source, changes, budget2 = discoveryByteBudget()) {
   if (source.reviewArtifact !== undefined)
@@ -35697,13 +36441,13 @@ function projected(source, changes, budget2 = discoveryByteBudget()) {
       throw new Error(`Native discovery input changed; run skills hook install with a fresh discovery review: ${source.path}`);
     return changes?.has(source.path) ? hashSumiSettingsReplacement(changes.get(source.path), budget2) : current;
   }
-  if (source.hashMode === "codex-settings-v1" || source.hashMode === "codex-settings-v2" || (source.hashMode === "codex-settings-v3" || source.hashMode === "codex-settings-v4")) {
+  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")) {
     if (source.format !== undefined || source.fields !== undefined || source.managedPlugins !== undefined || typeof source.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(source.sha256))
       throw new Error("Codex settings witnesses require exact typed metadata");
-    const current = (source.hashMode === "codex-settings-v4" ? captureCodexSettingsV4 : source.hashMode === "codex-settings-v3" ? captureCodexSettingsV3 : source.hashMode === "codex-settings-v2" ? captureCodexSettingsV2 : captureCodexSettings)(source.path, budget2).sha256;
+    const current = (source.hashMode === "codex-settings-v5" ? captureCodexSettingsV5 : source.hashMode === "codex-settings-v4" ? captureCodexSettingsV4 : source.hashMode === "codex-settings-v3" ? captureCodexSettingsV3 : source.hashMode === "codex-settings-v2" ? captureCodexSettingsV2 : captureCodexSettings)(source.path, budget2).sha256;
     if (current !== source.sha256)
       throw new Error(`Native discovery input changed; run skills hook install with a fresh discovery review: ${source.path}`);
-    return changes?.has(source.path) ? (source.hashMode === "codex-settings-v4" ? hashCodexSettingsReplacementV4 : source.hashMode === "codex-settings-v3" ? hashCodexSettingsReplacementV3 : source.hashMode === "codex-settings-v2" ? hashCodexSettingsReplacementV2 : hashCodexSettingsReplacement)(changes.get(source.path), budget2) : current;
+    return changes?.has(source.path) ? (source.hashMode === "codex-settings-v5" ? hashCodexSettingsReplacementV5 : source.hashMode === "codex-settings-v4" ? hashCodexSettingsReplacementV4 : source.hashMode === "codex-settings-v3" ? hashCodexSettingsReplacementV3 : source.hashMode === "codex-settings-v2" ? hashCodexSettingsReplacementV2 : hashCodexSettingsReplacement)(changes.get(source.path), budget2) : current;
   }
   if (source.hashMode === "claude-settings-v1" || source.hashMode === "claude-settings-v2" || (source.hashMode === "claude-settings-v3" || source.hashMode === "claude-settings-v4")) {
     if (source.format !== undefined || source.fields !== undefined || source.managedPlugins !== undefined || typeof source.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(source.sha256))
@@ -35755,7 +36499,7 @@ function projected(source, changes, budget2 = discoveryByteBudget()) {
   if (text2 === null)
     return null;
   if (!source.format)
-    return digest(text2);
+    return digest2(text2);
   return projectNativeDiscoveryFields(text2, source.format, source.fields ?? [], source.path);
 }
 function absentCodexSkillRoots(binding) {
@@ -35764,18 +36508,18 @@ function absentCodexSkillRoots(binding) {
     return [];
   if (binding.agent !== "codex" || !Array.isArray(controls) || controls.length > 4096)
     throw new Error("Invalid disabled Codex discovery proof");
-  if (binding.method !== "reviewed" || controls.every((control) => lstatSync20(control.pluginParent, { throwIfNoEntry: false })))
+  if (binding.method !== "reviewed" || controls.every((control) => lstatSync21(control.pluginParent, { throwIfNoEntry: false })))
     return [];
-  const cache = dirname18(dirname18(controls[0].pluginParent)), config2 = join28(dirname18(dirname18(cache)), "config.toml");
+  const cache = dirname19(dirname19(controls[0].pluginParent)), config2 = join29(dirname19(dirname19(cache)), "config.toml");
   const source = binding.sources.find((source2) => source2.path === config2 && source2.sha256 !== null && source2.format === undefined && source2.fields === undefined);
   if (!source || projected(source) !== source.sha256)
     throw new Error("Missing current disabled Codex configuration witness");
   const rules = Bun.TOML.parse(read(config2)).skills?.config ?? [];
   return [...new Set(controls.map((control) => control.pluginParent))].filter((parent) => !codexDirectHookSelects(cache, parent) && absentDisabledCodexPluginParent(cache, parent, controls, rules));
 }
-function codexDirectHookSelects(cache, root) {
-  const codex = dirname18(dirname18(cache)), config2 = Bun.TOML.parse(read(join28(codex, "config.toml")) ?? "");
-  const hooks = read(join28(codex, "hooks.json"));
+function codexDirectHookSelects(cache, root, configPath = join29(dirname19(dirname19(cache)), "config.toml")) {
+  const codex = dirname19(configPath), config2 = Bun.TOML.parse(read(configPath) ?? "");
+  const hooks = read(join29(codex, "hooks.json"));
   if (hooks !== null)
     hashNativeJsonControls(hooks);
   return JSON.stringify(config2.hooks ?? {}).includes(root) || hooks !== null && JSON.stringify(JSON.parse(hooks)).includes(root);
@@ -35787,7 +36531,7 @@ function retiredCodexRoots(binding) {
   const controls = binding.codexDisabledPluginSkills;
   if (binding.agent !== "codex" || binding.method !== "reviewed" || !Array.isArray(controls) || !controls.length || !Array.isArray(proof.roots) || proof.roots.length > AGENT_POLICY_LIMITS.discoveryRoots || new Set(proof.roots).size !== proof.roots.length || !Array.isArray(proof.directories) || proof.parents !== undefined && (!Array.isArray(proof.parents) || proof.parents.length > AGENT_POLICY_LIMITS.discoveryRoots || new Set(proof.parents).size !== proof.parents.length) || !proof.roots.length && !proof.parents?.length)
     throw new Error("Invalid retired Codex materialization proof");
-  const cache = dirname18(dirname18(controls[0].pluginParent)), config2 = join28(dirname18(dirname18(cache)), "config.toml");
+  const cache = dirname19(dirname19(controls[0].pluginParent)), config2 = join29(dirname19(dirname19(cache)), "config.toml");
   const source = binding.sources.find((source2) => source2.path === config2 && source2.sha256 !== null && source2.format === undefined && source2.fields === undefined);
   if (!source || projected(source) !== source.sha256)
     throw new Error("Missing current retired Codex configuration witness");
@@ -35795,7 +36539,7 @@ function retiredCodexRoots(binding) {
   if ((proof.parents ?? []).some((parent) => codexDirectHookSelects(cache, parent) || !reviewedDisabledCodexPluginParent(cache, parent, controls, rules)) || !reviewedCodexPluginCapabilitiesUnchanged(cache, controls, (path) => read(path), rules))
     throw new Error("Retired Codex parent capabilities changed");
   for (const root of proof.roots) {
-    const manifest = binding.sources.find((source2) => source2.path === join28(root, ".codex-plugin/plugin.json") && source2.sha256 !== null && source2.format === undefined && source2.fields === undefined && [undefined, "bytes"].includes(source2.hashMode));
+    const manifest = binding.sources.find((source2) => source2.path === join29(root, ".codex-plugin/plugin.json") && source2.sha256 !== null && source2.format === undefined && source2.fields === undefined && [undefined, "bytes"].includes(source2.hashMode));
     if (!manifest || codexDirectHookSelects(cache, root) || !reviewedRetiredCodexRoot(cache, root, controls, rules, (path) => read(path), true))
       throw new Error("Retired Codex materialization changed");
   }
@@ -35804,7 +36548,7 @@ function retiredCodexRoots(binding) {
 function retainableAbsentSource(source) {
   if (source.format !== undefined || source.fields !== undefined || source.managedPlugins !== undefined)
     return false;
-  return [undefined, "bytes"].includes(source.hashMode) || source.hashMode === "claude-plugin-manifest-v1" && source.sha256 !== null && source.path.endsWith(join28(sep8, ".claude-plugin", "plugin.json"));
+  return [undefined, "bytes"].includes(source.hashMode) || source.hashMode === "claude-plugin-manifest-v1" && source.sha256 !== null && source.path.endsWith(join29(sep9, ".claude-plugin", "plugin.json"));
 }
 function absentRetiredClaudeRoots(binding) {
   if (binding.agent !== "claude" || binding.method !== "reviewed")
@@ -35813,17 +36557,17 @@ function absentRetiredClaudeRoots(binding) {
   for (const source of binding.sources) {
     if (!retainableAbsentSource(source) || source.sha256 === null)
       continue;
-    const marker = sep8 + ".claude" + sep8 + "plugins" + sep8 + "cache" + sep8, at = source.path.indexOf(marker);
+    const marker = sep9 + ".claude" + sep9 + "plugins" + sep9 + "cache" + sep9, at = source.path.indexOf(marker);
     if (at < 0 || source.path.indexOf(marker, at + 1) >= 0)
       continue;
-    const cache = source.path.slice(0, at + marker.length - 1), parts = source.path.slice(at + marker.length).split(sep8);
+    const cache = source.path.slice(0, at + marker.length - 1), parts = source.path.slice(at + marker.length).split(sep9);
     if (parts.length < 4 || parts.slice(0, 3).some((part) => !part || part === "." || part === ".."))
       continue;
-    const root = join28(cache, ...parts.slice(0, 3));
+    const root = join29(cache, ...parts.slice(0, 3));
     safe5(root);
-    if (lstatSync20(root, { throwIfNoEntry: false }))
+    if (lstatSync21(root, { throwIfNoEntry: false }))
       continue;
-    const claude = dirname18(dirname18(cache)), settings = join28(claude, "settings.json"), registry2 = join28(claude, "plugins/installed_plugins.json");
+    const claude = dirname19(dirname19(cache)), settings = join29(claude, "settings.json"), registry2 = join29(claude, "plugins/installed_plugins.json");
     const full = (path) => binding.sources.find((item) => item.path === path && item.sha256 !== null && item.format === undefined && item.fields === undefined);
     const configSource = full(settings), registrySource = full(registry2);
     if (!configSource || !registrySource || projected(configSource) !== configSource.sha256 || projected(registrySource) !== registrySource.sha256)
@@ -35840,15 +36584,15 @@ function absentRetiredClaudeRoots(binding) {
       if (!row || typeof row !== "object" || Array.isArray(row))
         return null;
       const value = row;
-      if (typeof value.installPath !== "string" || /[\x00-\x1f\x7f]/.test(value.installPath) || !isAbsolute18(value.installPath) || resolve19(value.installPath) !== value.installPath || value.installPath.length > AGENT_POLICY_LIMITS.pathCharacters)
+      if (typeof value.installPath !== "string" || /[\x00-\x1f\x7f]/.test(value.installPath) || !isAbsolute19(value.installPath) || resolve20(value.installPath) !== value.installPath || value.installPath.length > AGENT_POLICY_LIMITS.pathCharacters)
         return null;
       if (value.scope === "user")
         return value.projectPath === undefined || value.projectPath === null ? "user\x00" : null;
       if (value.scope === "project")
-        return typeof value.projectPath === "string" && !/[\x00-\x1f\x7f]/.test(value.projectPath) && value.projectPath.length <= AGENT_POLICY_LIMITS.pathCharacters && isAbsolute18(value.projectPath) && resolve19(value.projectPath) === value.projectPath ? `project\x00${value.projectPath}` : null;
+        return typeof value.projectPath === "string" && !/[\x00-\x1f\x7f]/.test(value.projectPath) && value.projectPath.length <= AGENT_POLICY_LIMITS.pathCharacters && isAbsolute19(value.projectPath) && resolve20(value.projectPath) === value.projectPath ? `project\x00${value.projectPath}` : null;
       return null;
     };
-    if (Object.values(installed.plugins).some((value) => !Array.isArray(value) || value.some((row) => !row || typeof row.installPath !== "string" || row.installPath === root || row.installPath.startsWith(root + sep8) || root.startsWith(row.installPath + sep8))))
+    if (Object.values(installed.plugins).some((value) => !Array.isArray(value) || value.some((row) => !row || typeof row.installPath !== "string" || row.installPath === root || row.installPath.startsWith(root + sep9) || root.startsWith(row.installPath + sep9))))
       continue;
     const rows = installed.plugins[id];
     if (!Array.isArray(rows) || rows.length < 1)
@@ -35866,36 +36610,94 @@ function absentRetiredClaudeRoots(binding) {
     if (!targetValid || !targetScopes.has("user\x00"))
       continue;
     const active = rows[0]?.installPath;
-    if (typeof active !== "string" || rows[0]?.version !== basename9(active) || dirname18(active) !== dirname18(root) || active === root || !lstatSync20(active, { throwIfNoEntry: false })?.isDirectory() || realpathSync6(active) !== active)
+    if (typeof active !== "string" || rows[0]?.version !== basename9(active) || dirname19(active) !== dirname19(root) || active === root || !lstatSync21(active, { throwIfNoEntry: false })?.isDirectory() || realpathSync8(active) !== active)
       continue;
-    const activeManifest = full(join28(active, ".claude-plugin/plugin.json"));
+    const activeManifest = full(join29(active, ".claude-plugin/plugin.json"));
     if (!activeManifest || projected(activeManifest) !== activeManifest.sha256)
       continue;
     result.add(root);
   }
   return [...result];
 }
-function verifyAgentDiscovery(binding, codexRecovery) {
+function codexSemanticCacheSourceRole(source, cacheRoot, parents3) {
+  if (!isAbsolute19(source.path) || resolve20(source.path) !== source.path || /[\x00-\x1f\x7f]/.test(source.path) || source.format !== undefined || source.fields !== undefined || source.managedPlugins !== undefined || source.reviewArtifact !== undefined || source.hashMode !== undefined && source.hashMode !== "bytes")
+    return false;
+  const parts = relative7(cacheRoot, source.path).split(sep9);
+  if (parts.length < 3 || !parents3.includes(join29(cacheRoot, parts[0], parts[1])))
+    return false;
+  const tail = parts.slice(3).join("/");
+  return parts.length === 5 && tail === ".codex-plugin/plugin.json" && source.sha256 !== null || parts.length === 4 && [".app.json", ".mcp.json"].includes(tail) && source.sha256 !== null || source.sha256 === null && (parts.length === 4 && tail === "SKILL.md" || parts.length === 5 && tail === "hooks/hooks.json");
+}
+function codexSemanticCacheDirectoryRole(path, cacheRoot) {
+  return isAbsolute19(path) && resolve20(path) === path && !/[\x00-\x1f\x7f]/.test(path) && (path === cacheRoot || path.startsWith(cacheRoot + sep9));
+}
+function assertCodexSemanticCacheHookSafety(cacheRoot, parents3, configPath, hookRootAlias = null) {
+  const selectionRoots = [cacheRoot, ...parents3];
+  if (hookRootAlias !== null) {
+    if (!hookRootAlias || Object.keys(hookRootAlias).length !== 2 || [hookRootAlias.alias, hookRootAlias.target].some((path) => typeof path !== "string" || !isAbsolute19(path) || resolve20(path) !== path || /[\x00-\x1f\x7f]/.test(path)) || hookRootAlias.target !== dirname19(configPath) || cacheRoot !== join29(hookRootAlias.target, "plugins/cache") || !lstatSync21(hookRootAlias.alias, { throwIfNoEntry: false })?.isSymbolicLink() || realpathSync8(hookRootAlias.alias) !== hookRootAlias.target || realpathSync8(hookRootAlias.target) !== hookRootAlias.target)
+      throw new Error("Reviewed semantic cache hook alias changed");
+    selectionRoots.push(...selectionRoots.map((root) => join29(hookRootAlias.alias, relative7(hookRootAlias.target, root))));
+  }
+  selectionRoots.push("plugins/cache");
+  if (selectionRoots.some((parent) => codexDirectHookSelects(cacheRoot, parent, configPath)))
+    throw new Error("Direct native hooks select a projected Codex cache input");
+}
+function verifyCodexSemanticCacheDiscovery(binding, reviewedRootAliases) {
+  const proof = binding.codexSemanticCache;
+  if (!proof)
+    return;
+  if (reviewedRootAliases !== undefined) {
+    const alias = reviewedRootAliases.find((alias2) => alias2.agent === "codex");
+    const expected = alias ? { alias: alias.alias, target: alias.target } : null;
+    if (!isDeepStrictEqual4(proof.hookRootAlias, expected))
+      throw new Error("Semantic cache hook alias differs from reviewed root binding");
+  }
+  const controls = binding.codexDisabledPluginSkills;
+  if (binding.agent !== "codex" || binding.method !== "reviewed" || !controls?.length || proof.schema !== "hasna.codex-semantic-cache-discovery.v1" || !/^[a-f0-9]{64}$/.test(proof.previousPolicySha256) || !Array.isArray(proof.appOnlyParents) || !Array.isArray(proof.supersededSources) || !Array.isArray(proof.supersededDirectories))
+    throw new Error("Invalid Codex semantic cache discovery proof");
+  const cacheRoot = proof.witness.cacheRoot;
+  if (controls.some((control) => dirname19(dirname19(control.pluginParent)) !== cacheRoot))
+    throw new Error("Codex semantic cache names another enrolled cache");
+  const parents3 = [...new Set([...controls.map((control) => control.pluginParent), ...proof.appOnlyParents.map((parent) => parent.pluginParent)])];
+  const sources = binding.sources.filter((source) => codexSemanticCacheSourceRole(source, cacheRoot, parents3));
+  const directories = (binding.directories ?? []).filter((directory) => codexSemanticCacheDirectoryRole(directory.path, cacheRoot));
+  if (!directories.length || !isDeepStrictEqual4(sources, proof.supersededSources) || !isDeepStrictEqual4(directories, proof.supersededDirectories))
+    throw new Error("Codex semantic cache provenance changed");
+  const configPath = proof.configPath;
+  if (!isAbsolute19(configPath) || resolve20(configPath) !== configPath || basename9(configPath) !== "config.toml" || /[\x00-\x1f\x7f]/.test(configPath))
+    throw new Error("Invalid semantic cache configuration source");
+  const configSource = binding.sources.find((source) => source.path === configPath && source.sha256 !== null && source.format === undefined && source.fields === undefined);
+  if (!configSource || projected(configSource) !== configSource.sha256)
+    throw new Error("Codex semantic cache requires unchanged reviewed configuration");
+  assertCodexSemanticCacheHookSafety(cacheRoot, parents3, configPath, proof.hookRootAlias);
+  const rules = parseConfig(read(configPath), configPath, true).skills?.config ?? [];
+  const current = captureCodexSemanticCacheWitness({ cacheRoot, controls, appOnlyParents: proof.appOnlyParents, rules });
+  assertCodexSemanticCacheWitnessUnchanged(proof.witness, current);
+  return proof;
+}
+function verifyAgentDiscovery(binding, codexRecovery, reviewedRootAliases) {
   if (codexRecovery)
     assertCodexHookDiscoveryRecovery(binding, codexRecovery);
   if (!binding || !Array.isArray(binding.sources) || !Array.isArray(binding.roots) || binding.sources.length > AGENT_POLICY_LIMITS.discoverySources || binding.roots.length > AGENT_POLICY_LIMITS.discoveryRoots)
     throw new Error("Invalid native discovery binding");
   if (binding.agent === "hermes" && !binding.directories?.length)
     throw new Error("Hermes discovery requires directory membership coverage; run skills hook install with a fresh discovery review");
+  const semanticCache = verifyCodexSemanticCacheDiscovery(binding, reviewedRootAliases);
+  const semanticDirectory = (path) => Boolean(semanticCache && codexSemanticCacheDirectoryRole(path, semanticCache.witness.cacheRoot));
   const installationRoots = codexInstallationRoots(binding);
   const retiredRoots = retiredCodexRoots(binding);
-  const installationInput = (path) => installationRoots.some((root) => path === root || path.startsWith(root + sep8));
+  const installationInput = (path) => installationRoots.some((root) => path === root || path.startsWith(root + sep9));
   if (binding.directories !== undefined) {
     const projected2 = binding.codexInstallationInputs?.directories ?? [];
-    const ancestors2 = binding.directories.filter((directory) => installationRoots.some((root) => root.startsWith(directory.path + sep8)));
+    const ancestors2 = binding.directories.filter((directory) => installationRoots.some((root) => root.startsWith(directory.path + sep9)));
     if (projected2.length !== ancestors2.length || projected2.some((directory) => !ancestors2.some((original) => original.path === directory.path)))
       throw new Error("Missing installation input directory projection");
-    const ordinary = binding.directories.filter((directory) => !installationInput(directory.path) && !ancestors2.includes(directory));
+    const ordinary = binding.directories.filter((directory) => !installationInput(directory.path) && !ancestors2.includes(directory) && !semanticDirectory(directory.path));
     if (binding.codexRetiredMaterializations) {
-      const projection = binding.codexRetiredMaterializations.directories;
+      const projection = binding.codexRetiredMaterializations.directories.filter((directory) => !semanticDirectory(directory.path));
       if (projection.length !== ordinary.length || projection.some((item, index) => item.path !== ordinary[index]?.path))
         throw new Error("Missing retired Codex directory projection");
-      const omitted = [...retiredRoots, ...(binding.codexRetiredMaterializations.parents ?? []).filter((parent) => !lstatSync20(parent, { throwIfNoEntry: false }))];
+      const omitted = [...retiredRoots, ...(binding.codexRetiredMaterializations.parents ?? []).filter((parent) => !lstatSync21(parent, { throwIfNoEntry: false }))];
       if (projection.every((item) => Array.isArray(item.entries)))
         verifyDiscoveryDirectoryProjection(projection, omitted);
       else {
@@ -35909,7 +36711,7 @@ function verifyAgentDiscovery(binding, codexRecovery) {
       verifyDiscoveryDirectories(ordinary);
     verifyDiscoveryDirectories(projected2, installationRoots);
   }
-  const absentRoots = [...absentCodexSkillRoots(binding), ...absentRetiredClaudeRoots(binding), ...retiredRoots.filter((root) => !lstatSync20(root, { throwIfNoEntry: false }))];
+  const absentRoots = [...absentCodexSkillRoots(binding), ...absentRetiredClaudeRoots(binding), ...retiredRoots.filter((root) => !lstatSync21(root, { throwIfNoEntry: false }))];
   const budget2 = discoveryByteBudget();
   for (const source of binding.sources) {
     assertMarketplaceBinding(binding, source);
@@ -35919,11 +36721,15 @@ function verifyAgentDiscovery(binding, codexRecovery) {
       throw new Error("Invalid native discovery projection");
     if (source.sha256 !== null && !/^[a-f0-9]{64}$/.test(source.sha256))
       throw new Error("Invalid native discovery digest");
+    if (semanticCache?.supersededSources.some((previous) => isDeepStrictEqual4(previous, source))) {
+      safe5(source.path);
+      continue;
+    }
     if (installationInput(source.path)) {
       safe5(source.path);
       continue;
     }
-    if (absentRoots.some((root) => source.path.startsWith(root + sep8)) && retainableAbsentSource(source)) {
+    if (absentRoots.some((root) => source.path.startsWith(root + sep9)) && retainableAbsentSource(source)) {
       safe5(source.path);
       continue;
     }
@@ -35935,7 +36741,7 @@ function verifyAgentDiscovery(binding, codexRecovery) {
     safe5(root);
   for (const root of absentRoots) {
     safe5(root);
-    if (lstatSync20(root, { throwIfNoEntry: false }))
+    if (lstatSync21(root, { throwIfNoEntry: false }))
       throw new Error("Retired native materialization changed during discovery verification");
   }
 }
@@ -35945,13 +36751,13 @@ function codexInstallationRoots(binding) {
     return [];
   if (binding.agent !== "codex" || binding.method !== "reviewed" || !supportsCodexNativeCapability(proof.version, "installed-plugin-review") || !/^[a-f0-9]{64}$/.test(proof.catalogSha256) || !Array.isArray(proof.plugins) || !proof.plugins.length)
     throw new Error("Invalid native installation input proof");
-  const cache = dirname18(dirname18(proof.plugins[0].pluginParent));
-  const config2 = join28(dirname18(dirname18(cache)), "config.toml"), home = dirname18(dirname18(dirname18(cache)));
+  const cache = dirname19(dirname19(proof.plugins[0].pluginParent));
+  const config2 = join29(dirname19(dirname19(cache)), "config.toml"), home = dirname19(dirname19(dirname19(cache)));
   const configSource = binding.sources.find((source) => source.path === config2 && source.sha256 !== null && (!source.format || source.format === "toml" && source.fields?.includes("plugins")));
-  const nativeRoots = NATIVE_SKILL_ROOTS.filter(([agent]) => agent === "codex").map(([, path]) => join28(home, path));
-  if (!configSource || proof.plugins.some((input2) => nativeRoots.some((root) => root === input2.sourceRoot || root.startsWith(input2.sourceRoot + sep8) || input2.sourceRoot.startsWith(root + sep8)) || binding.sources.some((source) => basename9(source.path) === "config.toml" && (source.path === input2.sourceRoot || source.path.startsWith(input2.sourceRoot + sep8)))))
+  const nativeRoots = NATIVE_SKILL_ROOTS.filter(([agent]) => agent === "codex").map(([, path]) => join29(home, path));
+  if (!configSource || proof.plugins.some((input2) => nativeRoots.some((root) => root === input2.sourceRoot || root.startsWith(input2.sourceRoot + sep9) || input2.sourceRoot.startsWith(root + sep9)) || binding.sources.some((source) => basename9(source.path) === "config.toml" && (source.path === input2.sourceRoot || source.path.startsWith(input2.sourceRoot + sep9)))))
     throw new Error("Native installation input overlaps configuration or loading roots");
-  if (proof.plugins.some((input2) => dirname18(dirname18(input2.pluginParent)) !== cache || !binding.sources.some((source) => source.path === join28(input2.sourceRoot, ".codex-plugin/plugin.json") && source.sha256 !== null && source.format === undefined && source.fields === undefined)))
+  if (proof.plugins.some((input2) => dirname19(dirname19(input2.pluginParent)) !== cache || !binding.sources.some((source) => source.path === join29(input2.sourceRoot, ".codex-plugin/plugin.json") && source.sha256 !== null && source.format === undefined && source.fields === undefined)))
     throw new Error("Missing native installation input source witness");
   return reviewedCodexPluginSourceRoots(cache, proof.plugins, (path) => {
     const text2 = read(path);
@@ -35961,11 +36767,11 @@ function codexInstallationRoots(binding) {
   });
 }
 function assertMarketplaceBinding(binding, source) {
-  if (source.hashMode === "claude-plugin-manifest-v1" && (binding.agent !== "claude" || basename9(source.path) !== "plugin.json" || !source.path.endsWith(join28(sep8, ".claude-plugin", "plugin.json"))))
+  if (source.hashMode === "claude-plugin-manifest-v1" && (binding.agent !== "claude" || basename9(source.path) !== "plugin.json" || !source.path.endsWith(join29(sep9, ".claude-plugin", "plugin.json"))))
     throw new Error("Claude plugin manifest witnesses require Claude plugin discovery");
   if (source.hashMode === "sumi-settings-v1" && (binding.agent !== "sumi" || binding.method !== "reviewed" || basename9(source.path) !== "sumi.json"))
     throw new Error("Sumi settings witnesses require explicit reviewed Sumi configuration");
-  if ((source.hashMode === "codex-settings-v1" || source.hashMode === "codex-settings-v2" || (source.hashMode === "codex-settings-v3" || source.hashMode === "codex-settings-v4")) && (binding.agent !== "codex" || binding.method !== "reviewed" || basename9(source.path) !== "config.toml"))
+  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")) && (binding.agent !== "codex" || binding.method !== "reviewed" || basename9(source.path) !== "config.toml"))
     throw new Error("Codex settings witnesses require explicit reviewed Codex configuration");
   if ((source.hashMode === "claude-settings-v1" || source.hashMode === "claude-settings-v2" || (source.hashMode === "claude-settings-v3" || source.hashMode === "claude-settings-v4")) && (binding.agent !== "claude" || binding.method !== "reviewed" || basename9(source.path) !== "settings.json"))
     throw new Error("Claude settings witnesses require explicit reviewed Claude configuration");
@@ -35977,13 +36783,13 @@ function assertMarketplaceBinding(binding, source) {
 function agentDiscoveryConfigPath(home, agent) {
   if (agent === "sumi")
     return sumiConfigPath(home);
-  return join28(home, agent === "hermes" ? ".hermes/config.yaml" : agent === "opencode" ? ".config/opencode/opencode.json" : `.${agent}/${agent === "codex" ? "config.toml" : agent === "cursor" ? "hooks.json" : "settings.json"}`);
+  return join29(home, agent === "hermes" ? ".hermes/config.yaml" : agent === "opencode" ? ".config/opencode/opencode.json" : `.${agent}/${agent === "codex" ? "config.toml" : agent === "cursor" ? "hooks.json" : "settings.json"}`);
 }
 function resolveAgentDiscovery(options) {
-  const canonical8 = options.canonical ?? resolve19, home = resolve19(options.home), agent = options.agent;
+  const canonical9 = options.canonical ?? resolve20, home = resolve20(options.home), agent = options.agent;
   const sources = [], roots = new Set, builtinNames = [];
   const witness = (path, format, fields2, hashMode) => {
-    const source = { path: canonical8(path), sha256: null, ...format ? { format, fields: fields2 } : {}, ...hashMode ? { hashMode } : {} };
+    const source = { path: canonical9(path), sha256: null, ...format ? { format, fields: fields2 } : {}, ...hashMode ? { hashMode } : {} };
     source.sha256 = projected(source);
     sources.push(source);
     return read(source.path);
@@ -36001,42 +36807,42 @@ function resolveAgentDiscovery(options) {
   const review = options.reviewed?.agents.find((item) => item.agent === agent);
   if (agent === "sumi") {
     const directory = sumiConfigDirectory(home);
-    if (witness(join28(directory, "sumi.jsonc")) !== null)
+    if (witness(join29(directory, "sumi.jsonc")) !== null)
       unresolved("JSONC configuration requires a supported format adapter");
-    for (const root of [directory, join28(home, ".claude"), join28(home, ".agents")])
+    for (const root of [directory, join29(home, ".claude"), join29(home, ".agents")])
       for (const name of ["skill", "skills"])
-        roots.add(canonical8(join28(root, name)));
+        roots.add(canonical9(join29(root, name)));
     if (config2.skills !== undefined && (!Array.isArray(config2.skills) || config2.skills.some((path) => typeof path !== "string")))
       unresolved("skills must be a string array");
     for (const value of config2.skills ?? []) {
-      if (typeof value !== "string" || /[\0$]/.test(value) || !value || !(isAbsolute18(value) || value.startsWith("~/")))
+      if (typeof value !== "string" || /[\0$]/.test(value) || !value || !(isAbsolute19(value) || value.startsWith("~/")))
         unresolved("remote or relative skill sources need a dedicated discovery adapter");
-      roots.add(canonical8(value.startsWith("~/") ? join28(home, value.slice(2)) : value));
+      roots.add(canonical9(value.startsWith("~/") ? join29(home, value.slice(2)) : value));
     }
     for (const key of ["plugin", "plugins"])
       if (config2[key] !== undefined && !Array.isArray(config2[key]))
         unresolved(`${key} must be an array`);
-    const plugins = [join28(directory, "plugin"), join28(directory, "plugins")];
+    const plugins = [join29(directory, "plugin"), join29(directory, "plugins")];
     for (const path of plugins) {
       safe5(path);
-      if (lstatSync20(path, { throwIfNoEntry: false })?.isDirectory())
-        for (const name of readdirSync7(path).sort()) {
+      if (lstatSync21(path, { throwIfNoEntry: false })?.isDirectory())
+        for (const name of readdirSync8(path).sort()) {
           if (name === "skills-cli.js" && path === plugins[1])
             continue;
-          const target = join28(path, name);
-          if (!lstatSync20(target).isFile())
+          const target = join29(path, name);
+          if (!lstatSync21(target).isFile())
             unresolved("local plugin packages need a dedicated discovery adapter");
           witness(target);
         }
     }
     for (const root of roots) {
       safe5(root);
-      if (lstatSync20(root, { throwIfNoEntry: false })?.isDirectory() && readdirSync7(root).some((name) => name.endsWith(".md")))
+      if (lstatSync21(root, { throwIfNoEntry: false })?.isDirectory() && readdirSync8(root).some((name) => name.endsWith(".md")))
         unresolved("flat markdown skills require a dedicated native migration adapter");
     }
   }
   if (agent === "hermes") {
-    const profile = witness(join28(home, ".hermes/active_profile"));
+    const profile = witness(join29(home, ".hermes/active_profile"));
     if (profile?.trim() && profile.trim() !== "default")
       unresolved("a non-default profile is active");
     const declared = config2.skills?.external_dirs ?? [], paths = typeof declared === "string" ? [declared] : declared;
@@ -36050,7 +36856,7 @@ function resolveAgentDiscovery(options) {
         continue;
       if (normalized.startsWith("~") && normalized !== "~" && !normalized.startsWith("~/"))
         unresolved("user-specific tilde expansion requires a separate discovery adapter");
-      const path = normalized === "~" ? home : normalized.startsWith("~/") ? join28(home, normalized.slice(2)) : resolve19(home, ".hermes", normalized);
+      const path = normalized === "~" ? home : normalized.startsWith("~/") ? join29(home, normalized.slice(2)) : resolve20(home, ".hermes", normalized);
       safe5(path);
       roots.add(path);
     }
@@ -36059,24 +36865,24 @@ function resolveAgentDiscovery(options) {
     const executable = options.executable === undefined ? discoveryExecutable(agent) : options.executable;
     if (executable) {
       let packageRoot;
-      for (let directory = dirname18(executable.target), depth = 0;depth < 8; directory = dirname18(directory), depth++) {
-        const path = join28(directory, "package.json"), raw = read(path);
+      for (let directory = dirname19(executable.target), depth = 0;depth < 8; directory = dirname19(directory), depth++) {
+        const path = join29(directory, "package.json"), raw = read(path);
         if (raw !== null && parseConfig(raw, path).name === "@google/gemini-cli") {
           packageRoot = directory;
           witness(path);
           break;
         }
-        if (dirname18(directory) === directory)
+        if (dirname19(directory) === directory)
           break;
       }
       if (!packageRoot)
         unresolved("installed Gemini package layout is not recognized");
-      const builtinRoot = join28(packageRoot, "bundle/builtin");
+      const builtinRoot = join29(packageRoot, "bundle/builtin");
       safe5(builtinRoot);
-      if (!lstatSync20(builtinRoot, { throwIfNoEntry: false })?.isDirectory())
+      if (!lstatSync21(builtinRoot, { throwIfNoEntry: false })?.isDirectory())
         unresolved("installed Gemini builtin root is missing");
-      for (const name of readdirSync7(builtinRoot).sort()) {
-        const text2 = witness(join28(builtinRoot, name, "SKILL.md"));
+      for (const name of readdirSync8(builtinRoot).sort()) {
+        const text2 = witness(join29(builtinRoot, name, "SKILL.md"));
         const match = text2?.match(/^---\r?\n[\s\S]*?^name:\s*([a-z0-9][a-z0-9-]*)\s*$/m);
         if (!match?.[1] || builtinNames.includes(match[1]))
           unresolved("installed Gemini builtin name is missing or ambiguous");
@@ -36089,11 +36895,16 @@ function resolveAgentDiscovery(options) {
     if (retained.agent !== agent || retained.method !== "reviewed")
       unresolved("invalid retained review");
     verifyAgentDiscovery(retained);
-    if (!retained.sources.some((source) => source.path === canonical8(configPath) && source.format === undefined && source.fields === undefined))
+    if (!retained.sources.some((source) => source.path === canonical9(configPath) && source.format === undefined && source.fields === undefined))
       unresolved("retained review is missing the full agent configuration source");
-    if (retained.sources.some((source) => (source.hashMode === "sumi-settings-v1" || source.hashMode === "claude-settings-v1" || source.hashMode === "claude-settings-v2" || (source.hashMode === "claude-settings-v3" || source.hashMode === "claude-settings-v4" || (source.hashMode === "codex-settings-v1" || source.hashMode === "codex-settings-v2" || (source.hashMode === "codex-settings-v3" || source.hashMode === "codex-settings-v4")))) && source.path !== canonical8(configPath)))
+    if (retained.sources.some((source) => (source.hashMode === "sumi-settings-v1" || source.hashMode === "claude-settings-v1" || source.hashMode === "claude-settings-v2" || (source.hashMode === "claude-settings-v3" || source.hashMode === "claude-settings-v4" || (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.path !== canonical9(configPath)))
       unresolved("retained settings witness names another configuration source");
-    const covered = supersedesSettingsProjection(agent, retained.sources, canonical8(configPath)) ? sources.filter((source) => !isSupersededSettingsProjection(agent, canonical8(configPath), source)) : sources;
+    let covered = supersedesSettingsProjection(agent, retained.sources, canonical9(configPath)) ? sources.filter((source) => !isSupersededSettingsProjection(agent, canonical9(configPath), source)) : sources;
+    if (retained.codexSemanticCache) {
+      const proof = retained.codexSemanticCache;
+      const parents3 = [...new Set([...(retained.codexDisabledPluginSkills ?? []).map((control) => control.pluginParent), ...proof.appOnlyParents.map((parent) => parent.pluginParent)])];
+      covered = covered.filter((source) => !codexSemanticCacheSourceRole(source, proof.witness.cacheRoot, parents3));
+    }
     if (covered.some((source) => !retained.sources.some((saved) => isDeepStrictEqual4(saved, source))) || [...roots].some((root) => !retained.roots.includes(root)) || agent === "gemini" && JSON.stringify(retained.builtinNames) !== JSON.stringify(builtinNames))
       unresolved("retained review is missing current runtime discovery coverage");
     return retained;
@@ -36105,16 +36916,16 @@ function resolveAgentDiscovery(options) {
     if (review.sources.some((source) => source.format !== undefined || source.fields !== undefined))
       throw new Error("Explicit discovery reviews require full source-file hashes");
     verifyAgentDiscovery(supplied);
-    if (review.sources.some((source) => (source.hashMode === "sumi-settings-v1" || source.hashMode === "claude-settings-v1" || source.hashMode === "claude-settings-v2" || (source.hashMode === "claude-settings-v3" || source.hashMode === "claude-settings-v4" || (source.hashMode === "codex-settings-v1" || source.hashMode === "codex-settings-v2" || (source.hashMode === "codex-settings-v3" || source.hashMode === "codex-settings-v4")))) && source.path !== canonical8(configPath)))
+    if (review.sources.some((source) => (source.hashMode === "sumi-settings-v1" || source.hashMode === "claude-settings-v1" || source.hashMode === "claude-settings-v2" || (source.hashMode === "claude-settings-v3" || source.hashMode === "claude-settings-v4" || (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.path !== canonical9(configPath)))
       throw new Error("Semantic settings witnesses must name the configured agent configuration source");
-    if (!review.sources.some((source) => source.path === canonical8(configPath)))
+    if (!review.sources.some((source) => source.path === canonical9(configPath)))
       throw new Error("Discovery review must include the agent configuration source");
-    const reviewedSources = supersedesSettingsProjection(agent, review.sources, canonical8(configPath)) ? sources.filter((source) => !isSupersededSettingsProjection(agent, canonical8(configPath), source)) : sources;
+    const reviewedSources = supersedesSettingsProjection(agent, review.sources, canonical9(configPath)) ? sources.filter((source) => !isSupersededSettingsProjection(agent, canonical9(configPath), source)) : sources;
     const reviewedSourcesWithManifestProjection = review.sources.map((source) => {
-      if (agent !== "claude" || source.sha256 === null || source.format !== undefined || source.fields !== undefined || source.managedPlugins !== undefined || source.hashMode !== undefined && source.hashMode !== "bytes" || basename9(source.path) !== "plugin.json" || !source.path.endsWith(join28(sep8, ".claude-plugin", "plugin.json")))
+      if (agent !== "claude" || source.sha256 === null || source.format !== undefined || source.fields !== undefined || source.managedPlugins !== undefined || source.hashMode !== undefined && source.hashMode !== "bytes" || basename9(source.path) !== "plugin.json" || !source.path.endsWith(join29(sep9, ".claude-plugin", "plugin.json")))
         return source;
-      const pluginRoot = dirname18(dirname18(source.path)), hooksPath = join28(pluginRoot, "hooks/hooks.json");
-      const hookStat = lstatSync20(hooksPath, { throwIfNoEntry: false });
+      const pluginRoot = dirname19(dirname19(source.path)), hooksPath = join29(pluginRoot, "hooks/hooks.json");
+      const hookStat = lstatSync21(hooksPath, { throwIfNoEntry: false });
       const text2 = read(source.path);
       if (text2 === null)
         throw new Error("Reviewed Claude plugin manifest is missing");
@@ -36128,58 +36939,58 @@ function resolveAgentDiscovery(options) {
       if (manifest.hooks !== undefined) {
         if (typeof manifest.hooks !== "string")
           throw new Error("Reviewed Claude plugin manifest has an unsupported hooks target");
-        const declaredHookPath = resolve19(pluginRoot, manifest.hooks);
-        if (!declaredHookPath.startsWith(pluginRoot + sep8))
+        const declaredHookPath = resolve20(pluginRoot, manifest.hooks);
+        if (!declaredHookPath.startsWith(pluginRoot + sep9))
           throw new Error("Reviewed Claude plugin hooks target escapes its root");
         reviewedHookPaths.add(declaredHookPath);
       }
       for (const hooksFile of reviewedHookPaths)
-        if (!review.sources.some((hook) => hook.path === canonical8(hooksFile) && hook.sha256 !== null && hook.format === undefined && hook.fields === undefined && hook.managedPlugins === undefined && (hook.hashMode === undefined || hook.hashMode === "bytes")))
+        if (!review.sources.some((hook) => hook.path === canonical9(hooksFile) && hook.sha256 !== null && hook.format === undefined && hook.fields === undefined && hook.managedPlugins === undefined && (hook.hashMode === undefined || hook.hashMode === "bytes")))
           throw new Error("Reviewed Claude plugin manifest requires separately reviewed exact hook file sources");
       return { path: source.path, sha256: manifestSha256, hashMode: "claude-plugin-manifest-v1" };
     });
     if (agent === "claude")
-      assertReviewedClaudeCacheClosures(home, config2, review, canonical8);
+      assertReviewedClaudeCacheClosures(home, config2, review, canonical9);
     const combined = [...reviewedSources, ...reviewedSourcesWithManifestProjection];
     const unique = combined.filter((source, index) => combined.findIndex((candidate) => isDeepStrictEqual4(candidate, source)) === index);
     return { ...supplied, roots: [...new Set([...roots, ...supplied.roots])].sort(), sources: unique, ...agent === "gemini" ? { builtinNames } : {} };
   }
   function plugin(root) {
-    root = canonical8(root);
+    root = canonical9(root);
     safe5(root);
-    const manifestPath = join28(root, agent === "claude" ? ".claude-plugin/plugin.json" : ".codex-plugin/plugin.json");
+    const manifestPath = join29(root, agent === "claude" ? ".claude-plugin/plugin.json" : ".codex-plugin/plugin.json");
     const raw = witness(manifestPath, undefined, undefined, agent === "claude" ? "claude-plugin-manifest-v1" : undefined);
     if (raw === null)
       unresolved("plugin manifest missing");
     const manifest = parseConfig(raw, manifestPath);
-    const hooks = witness(join28(root, "hooks/hooks.json"));
+    const hooks = witness(join29(root, "hooks/hooks.json"));
     if (manifest.hooks !== undefined || hooks !== null)
       unresolved("plugin hooks require a separate no-skill-injection review");
-    const commands = join28(root, "commands");
+    const commands = join29(root, "commands");
     safe5(commands);
-    if (agent === "claude" && (manifest.commands !== undefined || lstatSync20(commands, { throwIfNoEntry: false })?.isDirectory() && readdirSync7(commands).length))
+    if (agent === "claude" && (manifest.commands !== undefined || lstatSync21(commands, { throwIfNoEntry: false })?.isDirectory() && readdirSync8(commands).length))
       unresolved("legacy command discovery requires retirement or a dedicated format adapter");
-    const rootSkill = witness(join28(root, "SKILL.md"));
+    const rootSkill = witness(join29(root, "SKILL.md"));
     if (rootSkill !== null)
       roots.add(root);
     const declared = manifest.skills === undefined ? ["./skills"] : typeof manifest.skills === "string" ? [manifest.skills] : manifest.skills;
     if (!Array.isArray(declared) || declared.some((path) => typeof path !== "string"))
       unresolved("unsupported plugin skill paths");
     if (agent === "claude")
-      roots.add(join28(root, "skills"));
+      roots.add(join29(root, "skills"));
     for (const value of declared) {
-      const path = resolve19(root, value);
-      if (path !== root && !path.startsWith(root + sep8))
+      const path = resolve20(root, value);
+      if (path !== root && !path.startsWith(root + sep9))
         unresolved("plugin skill path escapes its root");
-      roots.add(path.endsWith(`${sep8}SKILL.md`) ? dirname18(path) : path);
+      roots.add(path.endsWith(`${sep9}SKILL.md`) ? dirname19(path) : path);
     }
   }
   if (agent === "claude") {
-    const registrations = witness(join28(home, ".claude/plugins/installed_plugins.json"));
-    const installed = registrations === null ? {} : parseConfig(registrations, join28(home, ".claude/plugins/installed_plugins.json")).plugins;
-    const commands = canonical8(join28(home, ".claude/commands"));
+    const registrations = witness(join29(home, ".claude/plugins/installed_plugins.json"));
+    const installed = registrations === null ? {} : parseConfig(registrations, join29(home, ".claude/plugins/installed_plugins.json")).plugins;
+    const commands = canonical9(join29(home, ".claude/commands"));
     safe5(commands);
-    if (lstatSync20(commands, { throwIfNoEntry: false })?.isDirectory() && readdirSync7(commands).length)
+    if (lstatSync21(commands, { throwIfNoEntry: false })?.isDirectory() && readdirSync8(commands).length)
       unresolved("legacy home command discovery requires a dedicated format adapter");
     for (const [id, enabled] of Object.entries(config2.enabledPlugins ?? {})) {
       if (enabled === false)
@@ -36199,37 +37010,37 @@ function resolveAgentDiscovery(options) {
         unresolved("unsupported plugin enablement");
       const split = id.lastIndexOf("@"), name = id.slice(0, split), marketplace = id.slice(split + 1);
       const market = config2.marketplaces?.[marketplace] ?? (marketplace === "personal" ? { source_type: "local", source: home } : undefined);
-      if (split < 1 || market?.source_type !== "local" || typeof market.source !== "string" || !isAbsolute18(market.source))
+      if (split < 1 || market?.source_type !== "local" || typeof market.source !== "string" || !isAbsolute19(market.source))
         unresolved("enabled plugin marketplace is not an explicit local source");
-      const catalogText = witness(join28(market.source, ".agents/plugins/marketplace.json"));
+      const catalogText = witness(join29(market.source, ".agents/plugins/marketplace.json"));
       if (catalogText === null)
         unresolved("marketplace catalog missing");
-      const catalog = parseConfig(catalogText, join28(market.source, ".agents/plugins/marketplace.json")), matches = Array.isArray(catalog.plugins) ? catalog.plugins.filter((item) => item.name === name) : [];
+      const catalog = parseConfig(catalogText, join29(market.source, ".agents/plugins/marketplace.json")), matches = Array.isArray(catalog.plugins) ? catalog.plugins.filter((item) => item.name === name) : [];
       if (matches.length !== 1 || matches[0]?.source?.source !== "local" || typeof matches[0]?.source?.path !== "string")
         unresolved("plugin catalog source is missing or ambiguous");
-      plugin(resolve19(market.source, matches[0].source.path));
+      plugin(resolve20(market.source, matches[0].source.path));
     }
   } else if (agent === "opencode") {
-    if (witness(join28(home, ".config/opencode/opencode.jsonc")) !== null || witness(join28(home, ".config/opencode/config.json")) !== null)
+    if (witness(join29(home, ".config/opencode/opencode.jsonc")) !== null || witness(join29(home, ".config/opencode/config.json")) !== null)
       unresolved("additional config layers require review");
     if ((config2.plugin?.length ?? 0) > 0 || config2.skills?.urls?.length)
       unresolved("external plugin or remote skill source");
     for (const path of config2.skills?.paths ?? []) {
-      if (typeof path !== "string" || !isAbsolute18(path))
+      if (typeof path !== "string" || !isAbsolute19(path))
         unresolved("relative or malformed added skill root");
       roots.add(path);
     }
-    const localPlugins = join28(home, ".config/opencode/plugins");
+    const localPlugins = join29(home, ".config/opencode/plugins");
     safe5(localPlugins);
-    if (lstatSync20(localPlugins, { throwIfNoEntry: false }) && readdirSync7(localPlugins).some((name) => name !== "skills-cli.js"))
+    if (lstatSync21(localPlugins, { throwIfNoEntry: false }) && readdirSync8(localPlugins).some((name) => name !== "skills-cli.js"))
       unresolved("additional local plugin hooks require review");
   } else if (agent === "sumi") {
-    if ((config2.plugin?.length ?? 0) > 0 || (config2.plugins?.length ?? 0) > 0 || sources.some((source) => source.path !== canonical8(configPath) && source.path !== canonical8(join28(sumiConfigDirectory(home), "sumi.jsonc")) && source.sha256 !== null))
+    if ((config2.plugin?.length ?? 0) > 0 || (config2.plugins?.length ?? 0) > 0 || sources.some((source) => source.path !== canonical9(configPath) && source.path !== canonical9(join29(sumiConfigDirectory(home), "sumi.jsonc")) && source.sha256 !== null))
       unresolved("external or foreign local plugins require review");
   } else if (agent === "hermes") {
-    for (const directory of [join28(home, ".hermes/plugins"), join28(home, ".hermes/hermes-agent")]) {
+    for (const directory of [join29(home, ".hermes/plugins"), join29(home, ".hermes/hermes-agent")]) {
       safe5(directory);
-      if (lstatSync20(directory, { throwIfNoEntry: false }))
+      if (lstatSync21(directory, { throwIfNoEntry: false }))
         unresolved("installed runtime/plugin discovery requires reviewed source bindings");
     }
     if (Bun.which("hermes") || Object.keys(config2.plugins ?? {}).length)
@@ -36237,32 +37048,32 @@ function resolveAgentDiscovery(options) {
   } else if (agent === "gemini") {
     if (Object.keys(config2.extensions ?? {}).length || config2.skills?.paths?.length)
       unresolved("custom extension or skill paths");
-    const directory = join28(home, ".gemini/extensions");
+    const directory = join29(home, ".gemini/extensions");
     safe5(directory);
-    if (lstatSync20(directory, { throwIfNoEntry: false }))
-      for (const name of readdirSync7(directory)) {
-        const root = join28(directory, name);
+    if (lstatSync21(directory, { throwIfNoEntry: false }))
+      for (const name of readdirSync8(directory)) {
+        const root = join29(directory, name);
         safe5(root);
-        if (!lstatSync20(root)?.isDirectory())
+        if (!lstatSync21(root)?.isDirectory())
           continue;
-        const raw = witness(join28(root, "gemini-extension.json"));
+        const raw = witness(join29(root, "gemini-extension.json"));
         if (raw === null)
           unresolved("extension registration missing");
-        const manifest = parseConfig(raw, join28(root, "gemini-extension.json"));
-        if (manifest.hooks !== undefined || witness(join28(root, "hooks/hooks.json")) !== null || witness(join28(root, ".gemini-extension-install.json")) !== null)
+        const manifest = parseConfig(raw, join29(root, "gemini-extension.json"));
+        if (manifest.hooks !== undefined || witness(join29(root, "hooks/hooks.json")) !== null || witness(join29(root, ".gemini-extension-install.json")) !== null)
           unresolved("extension hooks or linked registration require review");
-        roots.add(join28(root, "skills"));
+        roots.add(join29(root, "skills"));
       }
   }
-  return { agent, roots: [...roots].sort(), sources, method: "automatic", ...agent === "gemini" ? { builtinNames } : {}, ...agent === "hermes" ? { directories: captureDiscoveryDirectories([join28(home, ".hermes/plugins"), join28(home, ".hermes/hermes-agent")].map((path) => canonical8(path))) } : {} };
+  return { agent, roots: [...roots].sort(), sources, method: "automatic", ...agent === "gemini" ? { builtinNames } : {}, ...agent === "hermes" ? { directories: captureDiscoveryDirectories([join29(home, ".hermes/plugins"), join29(home, ".hermes/hermes-agent")].map((path) => canonical9(path))) } : {} };
 }
 var DISCOVERY_RUNTIME_COMMANDS, realpathOrNull = (path) => {
   try {
-    return realpathSync6(path);
+    return realpathSync8(path);
   } catch {
     return null;
   }
-}, digest = (text2) => createHash20("sha256").update(text2).digest("hex");
+}, digest2 = (text2) => createHash21("sha256").update(text2).digest("hex");
 var init_agent_discovery = __esm(() => {
   init_sumi_settings_witness();
   init_agent_policy_limits();
@@ -36283,16 +37094,17 @@ var init_agent_discovery = __esm(() => {
   init_native_discovery_roots();
   init_codex_native_compatibility();
   init_retained_review_artifacts();
+  init_codex_semantic_cache_witness();
   init_agent_discovery_directories();
   DISCOVERY_RUNTIME_COMMANDS = Object.freeze({ gemini: "gemini" });
 });
 
 // src/lib/authoring-path.ts
-import { lstatSync as lstatSync21, realpathSync as realpathSync7 } from "fs";
+import { lstatSync as lstatSync22, realpathSync as realpathSync9 } from "fs";
 import { homedir as homedir3 } from "os";
-import { basename as basename10, dirname as dirname19, join as join29, resolve as resolve20, sep as sep9 } from "path";
+import { basename as basename10, dirname as dirname20, join as join30, resolve as resolve21, sep as sep10 } from "path";
 function pathParts(path) {
-  return resolve20(path).split(sep9).filter(Boolean);
+  return resolve21(path).split(sep10).filter(Boolean);
 }
 function nativeRootMatch(path) {
   const parts = pathParts(path);
@@ -36306,24 +37118,24 @@ function nativeRootMatch(path) {
   return;
 }
 function physicalPath(path) {
-  let cursor = resolve20(path);
+  let cursor = resolve21(path);
   const suffix = [];
-  while (!lstatSync21(cursor, { throwIfNoEntry: false })) {
+  while (!lstatSync22(cursor, { throwIfNoEntry: false })) {
     suffix.unshift(basename10(cursor));
-    const parent = dirname19(cursor);
+    const parent = dirname20(cursor);
     if (parent === cursor)
-      return resolve20(path);
+      return resolve21(path);
     cursor = parent;
   }
-  return resolve20(realpathSync7(cursor), ...suffix);
+  return resolve21(realpathSync9(cursor), ...suffix);
 }
 function contains(root, path) {
-  return path === root || path.startsWith(root + sep9);
+  return path === root || path.startsWith(root + sep10);
 }
 function configuredRoots(home, explicitHome) {
-  const homeData = join29(home, ".hasna", "skills");
+  const homeData = join30(home, ".hasna", "skills");
   const homePolicy = readManagedSkillPolicySnapshot(homeData);
-  const configuredPolicy = !explicitHome && resolve20(getDataDirReadOnly()) !== resolve20(homeData) ? readManagedSkillPolicySnapshot(getDataDirReadOnly()) : null;
+  const configuredPolicy = !explicitHome && resolve21(getDataDirReadOnly()) !== resolve21(homeData) ? readManagedSkillPolicySnapshot(getDataDirReadOnly()) : null;
   const policy = homePolicy ?? configuredPolicy;
   const bridge = policy?.value.bridge;
   if (bridge && (typeof bridge.home !== "string" || physicalPath(bridge.home) !== physicalPath(home))) {
@@ -36352,8 +37164,8 @@ function configuredRoots(home, explicitHome) {
       admitBinding(binding);
       continue;
     }
-    const nativeHome = join29(home, agent === "opencode" ? ".config/opencode" : `.${agent}`);
-    if (!lstatSync21(nativeHome, { throwIfNoEntry: false }))
+    const nativeHome = join30(home, agent === "opencode" ? ".config/opencode" : `.${agent}`);
+    if (!lstatSync22(nativeHome, { throwIfNoEntry: false }))
       continue;
     roots.push(...resolveAgentDiscovery({ home, agent, canonical: physicalPath }).roots);
   }
@@ -36362,22 +37174,22 @@ function configuredRoots(home, explicitHome) {
 function assertPortableAuthoringPath(path, options = {}) {
   if (typeof path !== "string" || !path || path.includes("\x00"))
     throw new Error("Invalid portable authoring path");
-  const lexical = resolve20(path);
+  const lexical = resolve21(path);
   const physical = physicalPath(lexical);
   const candidates = [lexical, physical];
   let native = candidates.map(nativeRootMatch).find(Boolean);
-  const home = resolve20(options.homeDir ?? homedir3());
-  const defaults = NATIVE_DISCOVERY_ROOTS.map((parts) => join29(home, ...parts));
-  defaults.push(join29(home, ".codex/plugins/cache"), join29(home, ".claude/plugins/cache"), join29(home, ".claude/plugins/synced"), join29(home, ".gemini/extensions"));
+  const home = resolve21(options.homeDir ?? homedir3());
+  const defaults = NATIVE_DISCOVERY_ROOTS.map((parts) => join30(home, ...parts));
+  defaults.push(join30(home, ".codex/plugins/cache"), join30(home, ".claude/plugins/cache"), join30(home, ".claude/plugins/synced"), join30(home, ".gemini/extensions"));
   for (const root of defaults) {
-    if (candidates.some((candidate) => contains(resolve20(root), candidate) || contains(physicalPath(root), candidate)))
+    if (candidates.some((candidate) => contains(resolve21(root), candidate) || contains(physicalPath(root), candidate)))
       native ??= root;
   }
   if (native) {
     throw new Error(`Refusing portable Skills authoring below native discovery root '${native}': ${lexical}. Set HASNA_SKILLS_DIR to a private authoring corpus outside native roots.`);
   }
   for (const root of configuredRoots(home, options.homeDir !== undefined)) {
-    if (candidates.some((candidate) => contains(resolve20(root), candidate) || contains(physicalPath(root), candidate))) {
+    if (candidates.some((candidate) => contains(resolve21(root), candidate) || contains(physicalPath(root), candidate))) {
       throw new Error(`Refusing portable Skills authoring below configured native discovery root: ${lexical}`);
     }
   }
@@ -36397,29 +37209,29 @@ import {
   existsSync as existsSync12,
   mkdirSync as mkdirSync8,
   mkdtempSync,
-  readdirSync as readdirSync8,
-  realpathSync as realpathSync8,
+  readdirSync as readdirSync9,
+  realpathSync as realpathSync10,
   renameSync as renameSync3,
   rmSync as rmSync3,
   statSync as statSync8,
   writeFileSync as writeFileSync6
 } from "fs";
-import { basename as basename11, dirname as dirname20, isAbsolute as isAbsolute19, join as join30, normalize as normalize4, relative as relative6, resolve as resolve21, sep as sep10 } from "path";
+import { basename as basename11, dirname as dirname21, isAbsolute as isAbsolute20, join as join31, normalize as normalize4, relative as relative8, resolve as resolve22, sep as sep11 } from "path";
 function getPortableSkillsRoot(options = {}) {
   return resolvePortableSkillsRoot(options, true);
 }
 function resolvePortableSkillsRoot(options, migrate) {
   if (options.rootDir)
     return options.rootDir;
-  const appDir = options.homeDir ? join30(options.homeDir, ".hasna", "skills") : migrate ? getDataDir() : getDataDirReadOnly();
-  const cache = join30(appDir, SKILLS_CACHE_DIRNAME);
+  const appDir = options.homeDir ? join31(options.homeDir, ".hasna", "skills") : migrate ? getDataDir() : getDataDirReadOnly();
+  const cache = join31(appDir, SKILLS_CACHE_DIRNAME);
   if (isOwnerLayoutMigrated(appDir) && safeIsDirectory(cache))
     return cache;
-  const installed = join30(appDir, INSTALLED_SKILLS_DIRNAME);
+  const installed = join31(appDir, INSTALLED_SKILLS_DIRNAME);
   return installed;
 }
 function getPortableSkillPath(name, options = {}) {
-  return join30(getPortableSkillsRoot(options), normalizePortableSkillName(name));
+  return join31(getPortableSkillsRoot(options), normalizePortableSkillName(name));
 }
 function findPortableSkill(name, options = {}) {
   let normalized;
@@ -36442,10 +37254,10 @@ function listPortableSkills(options = {}) {
   if (!safeIsDirectory(root))
     return [];
   const skills = [];
-  for (const entry of readdirSync8(root).sort()) {
+  for (const entry of readdirSync9(root).sort()) {
     if (entry.startsWith("."))
       continue;
-    const path = join30(root, entry);
+    const path = join31(root, entry);
     if (!safeIsDirectory(path))
       continue;
     try {
@@ -36478,9 +37290,9 @@ function isOfficialSkillName(name) {
 function scaffoldPortableSkill(name, options = {}) {
   const skillName = normalizeNewPortableSkillName(name);
   const readOnlyRoot = resolvePortableSkillsRoot(options, false);
-  assertPortableAuthoringPath(join30(readOnlyRoot, skillName), options);
+  assertPortableAuthoringPath(join31(readOnlyRoot, skillName), options);
   const root = getPortableSkillsRoot(options);
-  const skillPath = join30(root, skillName);
+  const skillPath = join31(root, skillName);
   assertPortableAuthoringPath(skillPath, options);
   if (existsSync12(skillPath)) {
     if (!options.overwrite)
@@ -36499,20 +37311,20 @@ function scaffoldPortableSkill(name, options = {}) {
   return { name: skillName, path: skillPath, manifest, created: true };
 }
 function physicalImportPath(path) {
-  let ancestor = resolve21(path);
+  let ancestor = resolve22(path);
   const suffix = [];
   while (!existsSync12(ancestor)) {
     suffix.unshift(basename11(ancestor));
-    ancestor = dirname20(ancestor);
+    ancestor = dirname21(ancestor);
   }
-  return join30(realpathSync8(ancestor), ...suffix);
+  return join31(realpathSync10(ancestor), ...suffix);
 }
 function assertDisjointImportPaths(source, destination) {
-  const sourcePath = realpathSync8(source);
+  const sourcePath = realpathSync10(source);
   const destinationPath = physicalImportPath(destination);
   const contains2 = (parent, child2) => {
-    const path = relative6(parent, child2);
-    return path === "" || !isAbsolute19(path) && path !== ".." && !path.startsWith(`..${sep10}`);
+    const path = relative8(parent, child2);
+    return path === "" || !isAbsolute20(path) && path !== ".." && !path.startsWith(`..${sep11}`);
   };
   if (contains2(sourcePath, destinationPath) || contains2(destinationPath, sourcePath)) {
     throw new Error("Source and destination skill directories must not overlap");
@@ -36531,11 +37343,11 @@ function portPortableSkill(sourcePath, options = {}) {
     const via = explicitName ? `Name '${skillName}' matches a bundled official skill.` : `Inferred name '${skillName}'${sourceSlug && sourceSlug !== skillName ? ` (from source folder '${basename11(absoluteSource)}')` : ""} matches a bundled official skill.`;
     throw new Error(`${via} Importing it would shadow the official '${skillName}'. ` + `Pass --name to choose a different name, or --allow-shadow to override deliberately.`);
   }
-  const readOnlyDestination = join30(resolvePortableSkillsRoot(options, false), skillName);
+  const readOnlyDestination = join31(resolvePortableSkillsRoot(options, false), skillName);
   assertPortableAuthoringPath(readOnlyDestination, options);
   assertDisjointImportPaths(absoluteSource, readOnlyDestination);
   const root = getPortableSkillsRoot(options);
-  const destination = join30(root, skillName);
+  const destination = join31(root, skillName);
   assertPortableAuthoringPath(destination, options);
   assertDisjointImportPaths(absoluteSource, destination);
   if (existsSync12(destination)) {
@@ -36543,7 +37355,7 @@ function portPortableSkill(sourcePath, options = {}) {
       throw new Error(`Skill '${skillName}' already exists at ${destination}`);
     rmSync3(destination, { recursive: true, force: true });
   }
-  mkdirSync8(dirname20(destination), { recursive: true });
+  mkdirSync8(dirname21(destination), { recursive: true });
   copySkillDirectory(absoluteSource, destination);
   const base = {
     ...inferred,
@@ -36567,8 +37379,8 @@ function validatePortableSkillDirectory(name, skillPath) {
   const warnings = [...base.warnings];
   let manifest;
   if (existsSync12(skillPath)) {
-    const skillJsonPath = join30(skillPath, "skill.json");
-    const skillMdPath = join30(skillPath, "SKILL.md");
+    const skillJsonPath = join31(skillPath, "skill.json");
+    const skillMdPath = join31(skillPath, "SKILL.md");
     if (!existsSync12(skillJsonPath) && !existsSync12(skillMdPath)) {
       add3(issues, "portable.manifest_missing", "Missing portable manifest: expected SKILL.md frontmatter and/or skill.json");
     }
@@ -36588,7 +37400,7 @@ function validatePortableSkillDirectory(name, skillPath) {
         add3(issues, "portable.version_missing", "Portable manifest missing version");
       }
       const contractIssues = validatePortableManifestContract(manifest, {
-        strict: existsSync12(join30(skillPath, "skill.json")),
+        strict: existsSync12(join31(skillPath, "skill.json")),
         skillPath
       });
       for (const issue2 of contractIssues)
@@ -36628,7 +37440,7 @@ function validatePortableSkillDirectory(name, skillPath) {
               add3(issues, "portable.command_entry_unsafe", `Command '${command.name}' entry '${command.entry}' must stay inside the skill directory`);
               continue;
             }
-            const entryPath = join30(skillPath, command.entry);
+            const entryPath = join31(skillPath, command.entry);
             if (!existsSync12(entryPath))
               add3(issues, "portable.command_entry_missing", `Command '${command.name}' entry '${command.entry}' is missing`);
             else if (statSync8(entryPath).isDirectory())
@@ -36639,7 +37451,7 @@ function validatePortableSkillDirectory(name, skillPath) {
     } catch (error61) {
       add3(issues, "portable.manifest_invalid", error61.message);
     }
-    if (manifest?.kind !== "instruction" && !existsSync12(join30(skillPath, "AGENTS.md"))) {
+    if (manifest?.kind !== "instruction" && !existsSync12(join31(skillPath, "AGENTS.md"))) {
       add3(issues, "portable.agents_missing", "Missing AGENTS.md with build-out instructions for coding agents");
     }
   }
@@ -36677,7 +37489,7 @@ function safeIsDirectory(path) {
   }
 }
 function isSafeRelativePath2(value) {
-  if (!value.trim() || isAbsolute19(value))
+  if (!value.trim() || isAbsolute20(value))
     return false;
   const normalized = normalize4(value).replace(/\\/g, "/");
   return normalized !== ".." && !normalized.startsWith("../") && !normalized.includes("/../");
@@ -36866,8 +37678,8 @@ var init_search = __esm(() => {
 });
 
 // src/lib/registry.ts
-import { existsSync as existsSync13, readFileSync as readFileSync17, readdirSync as readdirSync9 } from "fs";
-import { join as join31 } from "path";
+import { existsSync as existsSync13, readFileSync as readFileSync17, readdirSync as readdirSync10 } from "fs";
+import { join as join32 } from "path";
 function parseSkillMdFrontmatter(content) {
   const match = content.match(/^---\n([\s\S]*?)\n---/);
   if (!match)
@@ -36904,11 +37716,11 @@ function discoverSkillsInDir(dir, source = "custom") {
     return [];
   const result = [];
   try {
-    const entries = readdirSync9(dir, { withFileTypes: true });
+    const entries = readdirSync10(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory())
         continue;
-      const skillMdPath = join31(dir, entry.name, "SKILL.md");
+      const skillMdPath = join32(dir, entry.name, "SKILL.md");
       if (!existsSync13(skillMdPath))
         continue;
       let content;
@@ -36928,7 +37740,7 @@ function discoverSkillsInDir(dir, source = "custom") {
         category: fm.category || "Development Tools",
         tags: fm.tags || [],
         ...fm.kind ? { kind: fm.kind } : {},
-        ...isHostedMetadataSkillDir(join31(dir, entry.name)) ? { serverOwned: true } : {},
+        ...isHostedMetadataSkillDir(join32(dir, entry.name)) ? { serverOwned: true } : {},
         source
       });
     }
@@ -36940,12 +37752,12 @@ function findExtensionSkillPath(name) {
   if (!config2.extensionsDir || !existsSync13(config2.extensionsDir))
     return null;
   try {
-    const entries = readdirSync9(config2.extensionsDir, { withFileTypes: true });
+    const entries = readdirSync10(config2.extensionsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory())
         continue;
-      const skillDir = join31(config2.extensionsDir, entry.name);
-      const skillMdPath = join31(skillDir, "SKILL.md");
+      const skillDir = join32(config2.extensionsDir, entry.name);
+      const skillMdPath = join32(skillDir, "SKILL.md");
       if (!existsSync13(skillMdPath))
         continue;
       let content;
@@ -37362,7 +38174,7 @@ var init_v4 = __esm(() => {
 });
 
 // src/lib/canonical-json.ts
-import { createHash as createHash21 } from "crypto";
+import { createHash as createHash22 } from "crypto";
 function canonicalJson2(value, maximumBytes = 2 * 1024 * 1024) {
   return canonicalJsonAtDepth(value, maximumBytes, 64);
 }
@@ -37406,7 +38218,7 @@ function canonicalJsonAtDepth(value, maximumBytes, maximumDepth) {
   return visit3(value, 0);
 }
 function canonicalJsonSha256(value, maximumBytes) {
-  return createHash21("sha256").update(canonicalJson2(value, maximumBytes)).digest("hex");
+  return createHash22("sha256").update(canonicalJson2(value, maximumBytes)).digest("hex");
 }
 var init_canonical_json = () => {};
 
@@ -37516,14 +38328,14 @@ function requireResult(value) {
   if (!value)
     throw new RemoteRecurringReadError;
 }
-function termsIntegrity(terms, hash3, identity3, own2) {
-  requireResult(terms.organizationId === identity3.organization.id && (!own2 || terms.approvedByUserId === identity3.user.id && terms.approvedMembershipId === identity3.user.membershipId));
-  requireResult(canonicalJsonSha256(terms) === hash3);
+function termsIntegrity(terms, hash4, identity4, own2) {
+  requireResult(terms.organizationId === identity4.organization.id && (!own2 || terms.approvedByUserId === identity4.user.id && terms.approvedMembershipId === identity4.user.membershipId));
+  requireResult(canonicalJsonSha256(terms) === hash4);
   requireResult(canonicalJsonSha256({ skill: terms.skill, input: terms.input, args: terms.args, runtime: terms.runtime }) === terms.payloadSha256);
   requireResult(Date.parse(terms.expiresAt) > Date.parse(terms.startsAt));
 }
-function previewIntegrity(value, identity3) {
-  termsIntegrity(value.terms, value.termsSha256, identity3, true);
+function previewIntegrity(value, identity4) {
+  termsIntegrity(value.terms, value.termsSha256, identity4, true);
   requireResult(Date.parse(value.approvalDeadline) > Date.parse(value.quote.quotedAt));
   const anchor2 = Date.parse(value.terms.startsAt), end = Date.parse(value.terms.expiresAt), cadence = value.terms.everyMinutes * 60000;
   requireResult(value.firstDueInstants.every((at, i) => Date.parse(at) === anchor2 + i * cadence && Date.parse(at) < end));
@@ -37531,7 +38343,7 @@ function previewIntegrity(value, identity3) {
   const day = Date.parse(value.firstPeriod.startsAt);
   requireResult(day % 86400000 === 0 && day <= anchor2 && anchor2 < Date.parse(value.firstPeriod.endsAt) && Date.parse(value.firstPeriod.endsAt) === day + 86400000);
 }
-function parseRecurringResult(action, value, input2, identity3) {
+function parseRecurringResult(action, value, input2, identity4) {
   const wrappers = { preview: 1, draft: 1, activate: 2, list: 3, get: 1, occurrences: 0, revoke: 0 };
   canonicalJsonAtDepth(value, 64 * 1024 * 1024, 64 + wrappers[action]);
   const result = results[action].parse(value);
@@ -37540,7 +38352,7 @@ function parseRecurringResult(action, value, input2, identity3) {
   const row = input2;
   if (action === "preview" || action === "draft") {
     const p = result;
-    previewIntegrity(p, identity3);
+    previewIntegrity(p, identity4);
     if (action === "draft")
       requireResult(p.draftId === row.draftId);
     else {
@@ -37559,7 +38371,7 @@ function parseRecurringResult(action, value, input2, identity3) {
   }
   const views = action === "list" ? result.items : action === "get" ? [result] : action === "activate" ? [result.consent] : [];
   for (const view of views) {
-    termsIntegrity(view.terms, view.termsSha256, identity3, action === "activate");
+    termsIntegrity(view.terms, view.termsSha256, identity4, action === "activate");
     requireResult(view.state === "revoked" === (view.revokedAt !== null));
     if (action === "get")
       requireResult(view.consentId === row.consentId);
@@ -37585,7 +38397,7 @@ function parseRecurringResult(action, value, input2, identity3) {
   }
   return result;
 }
-var RecurringInputError, RemoteRecurringUnavailableError, RemoteRecurringReadError, RemoteRecurringUnconfirmedError, failures, RemoteRecurringError, uuid3, instant2, integer2, digest2, list, inputs, capabilityNames, budget2, period, preview, consent, refusal2, occurrence, revocation, page = (item) => exports_external.object({ contractVersion: exports_external.literal(1), items: exports_external.array(item).max(100), nextCursor: exports_external.string().min(1).max(2048).nullable() }), results;
+var RecurringInputError, RemoteRecurringUnavailableError, RemoteRecurringReadError, RemoteRecurringUnconfirmedError, failures, RemoteRecurringError, uuid3, instant2, integer2, digest3, list, inputs, capabilityNames, budget2, period, preview, consent, refusal2, occurrence, revocation, page = (item) => exports_external.object({ contractVersion: exports_external.literal(1), items: exports_external.array(item).max(100), nextCursor: exports_external.string().min(1).max(2048).nullable() }), results;
 var init_remote_recurring = __esm(() => {
   init_v4();
   init_canonical_json();
@@ -37651,7 +38463,7 @@ var init_remote_recurring = __esm(() => {
   uuid3 = exports_external.string().regex(/^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/);
   instant2 = exports_external.string().max(32).datetime();
   integer2 = exports_external.number().int().min(0).max(MAX_RECURRING_CREDITS);
-  digest2 = exports_external.string().regex(/^[a-f0-9]{64}$/);
+  digest3 = exports_external.string().regex(/^[a-f0-9]{64}$/);
   list = exports_external.object({ limit: exports_external.number().int().min(1).max(100).optional(), cursor: exports_external.string().min(1).max(2048).optional() }).strict();
   inputs = {
     preview: recurringRequestSchema,
@@ -37677,7 +38489,7 @@ var init_remote_recurring = __esm(() => {
     contractVersion: exports_external.literal(1),
     draftId: uuid3,
     terms: recurringTermsSchema,
-    termsSha256: digest2,
+    termsSha256: digest3,
     quote: exports_external.object({ costCredits: integer2, quotedAt: instant2, admissionReprices: exports_external.literal(true) }),
     approvalDeadline: instant2,
     firstDueInstants: exports_external.array(instant2).min(1).max(5),
@@ -37689,7 +38501,7 @@ var init_remote_recurring = __esm(() => {
     consentId: uuid3,
     scheduleId: uuid3,
     terms: recurringTermsSchema,
-    termsSha256: digest2,
+    termsSha256: digest3,
     state: exports_external.enum(["active", "revoked", "expired"]),
     activatedAt: instant2,
     revokedAt: instant2.nullable(),
@@ -37943,10 +38755,10 @@ function sessionToken(value) {
   return value;
 }
 function parseWorkspaceSession(value, expected) {
-  const identity3 = parseWorkspaceIdentity(value, expected.userId);
-  if (identity3.user.membershipId !== expected.membershipId)
+  const identity4 = parseWorkspaceIdentity(value, expected.userId);
+  if (identity4.user.membershipId !== expected.membershipId)
     throw new WorkspaceIdentityMismatchError;
-  return { token: sessionToken(value.token), ...identity3 };
+  return { token: sessionToken(value.token), ...identity4 };
 }
 function parseWorkspaceLogin(value, expectedUserId) {
   const user = record5(value) && value.user;
@@ -38157,13 +38969,13 @@ var init_remote_workspace_leave = __esm(() => {
 
 // src/lib/auth-store.ts
 import { chmodSync, existsSync as existsSync14, mkdirSync as mkdirSync9, readFileSync as readFileSync18, renameSync as renameSync4, statSync as statSync9, unlinkSync as unlinkSync4, writeFileSync as writeFileSync7 } from "fs";
-import { basename as basename12, dirname as dirname21, join as join32 } from "path";
+import { basename as basename12, dirname as dirname22, join as join33 } from "path";
 function getAuthFilePath(env = process.env) {
   return skillsCredentialFilePath(env);
 }
 function getIdentityFilePath(env = process.env) {
   const file2 = skillsCredentialFilePath(env);
-  return join32(dirname21(file2), basename12(file2).replace(/^credentials/, "identity") + ".json");
+  return join33(dirname22(file2), basename12(file2).replace(/^credentials/, "identity") + ".json");
 }
 function getApiUrl(action, env = process.env, options = {}) {
   return requireSkillsApiOrigin(action, env, options);
@@ -38391,10 +39203,10 @@ async function readQuoteUnavailableCode(response) {
   let timer;
   let deadlineExceeded = false;
   const expired = Symbol("quote body deadline");
-  const deadline = new Promise((resolve22) => {
+  const deadline = new Promise((resolve23) => {
     timer = setTimeout(() => {
       deadlineExceeded = true;
-      resolve22(expired);
+      resolve23(expired);
       reader.cancel().catch(() => {});
     }, 1500);
   });
@@ -38697,16 +39509,16 @@ class RemoteSkillsClient {
   async listAccountWorkspaces(expectedUserId) {
     const expected = expectedUserId === undefined ? undefined : workspaceExpectedUserId(expectedUserId);
     const connection = new RemoteSkillsClient(this.apiKey, this.apiUrl);
-    let identity3;
+    let identity4;
     if (expected !== undefined) {
       const value = await connection.requestWorkspaceSelection("/api/auth/whoami");
       if (!value || typeof value !== "object" || value.authMethod !== "jwt")
         throw new RemoteWorkspaceSelectionError("/api/v1/account/workspaces", "INTERACTIVE_SESSION_REQUIRED");
-      identity3 = parseWorkspaceIdentity(value, expected);
+      identity4 = parseWorkspaceIdentity(value, expected);
     }
     const result = parseAccountWorkspaces(await connection.requestWorkspaceSelection("/api/v1/account/workspaces"));
     const current = result.workspaces.find((workspace) => workspace.current);
-    if (identity3 && (current.membershipId !== identity3.user.membershipId || current.organization.id !== identity3.organization.id))
+    if (identity4 && (current.membershipId !== identity4.user.membershipId || current.organization.id !== identity4.organization.id))
       throw new WorkspaceIdentityMismatchError;
     return result;
   }
@@ -38724,10 +39536,10 @@ class RemoteSkillsClient {
     const verified = await new RemoteSkillsClient(selected.token, connection.apiUrl).requestWorkspaceSelection("/api/auth/whoami");
     if (!verified || typeof verified !== "object" || verified.authMethod !== "jwt")
       throw new RemoteWorkspaceSelectionError("/api/v1/account/workspaces/switch", "INTERACTIVE_SESSION_REQUIRED");
-    const identity3 = parseWorkspaceIdentity(verified, target.userId);
-    if (identity3.user.membershipId !== target.membershipId || identity3.organization.id !== selected.organization.id)
+    const identity4 = parseWorkspaceIdentity(verified, target.userId);
+    if (identity4.user.membershipId !== target.membershipId || identity4.organization.id !== selected.organization.id)
       throw new WorkspaceIdentityMismatchError;
-    return { token: selected.token, ...identity3 };
+    return { token: selected.token, ...identity4 };
   }
   async requestWorkspaceSelection(path, options) {
     let response;
@@ -38811,8 +39623,8 @@ class RemoteSkillsClient {
     const value = await connection.requestWorkspaceSelection("/api/auth/whoami");
     if (!value || typeof value !== "object" || value.authMethod !== "jwt")
       throw new RemoteWorkspaceLeaveError("INTERACTIVE_SESSION_REQUIRED");
-    const identity3 = parseWorkspaceIdentity(value, captured.context.userId);
-    if (identity3.user.membershipId !== captured.context.membershipId)
+    const identity4 = parseWorkspaceIdentity(value, captured.context.userId);
+    if (identity4.user.membershipId !== captured.context.membershipId)
       throw new WorkspaceIdentityMismatchError;
     let response, body;
     try {
@@ -38827,7 +39639,7 @@ class RemoteSkillsClient {
         throw new RemoteWorkspaceLeaveError(code);
       throw new RemoteWorkspaceLeaveUnconfirmedError;
     }
-    return parseWorkspaceLeaveResult(body, captured.context.membershipId, identity3.organization.id);
+    return parseWorkspaceLeaveResult(body, captured.context.membershipId, identity4.organization.id);
   }
   listWorkspaceInvitations(context, options = {}) {
     return this.requestWorkspaceInvitation(context, "list", options);
@@ -38853,8 +39665,8 @@ class RemoteSkillsClient {
     const identityValue = await connection.requestWorkspaceSelection("/api/auth/whoami");
     if (!identityValue || typeof identityValue !== "object" || identityValue.authMethod !== "jwt")
       throw new RemoteWorkspaceInvitationError("INTERACTIVE_SESSION_REQUIRED");
-    const identity3 = parseWorkspaceIdentity(identityValue, target.userId);
-    if (identity3.user.membershipId !== target.membershipId)
+    const identity4 = parseWorkspaceIdentity(identityValue, target.userId);
+    if (identity4.user.membershipId !== target.membershipId)
       throw new WorkspaceIdentityMismatchError;
     const request = invitationRequest(action, captured), read2 = action === "list" || action === "get";
     let response, value;
@@ -38871,7 +39683,7 @@ class RemoteSkillsClient {
       throw read2 ? new RemoteWorkspaceInvitationReadError : new RemoteWorkspaceInvitationUnconfirmedError;
     }
     try {
-      return parseInvitationResult(action, value, captured, identity3.organization.id);
+      return parseInvitationResult(action, value, captured, identity4.organization.id);
     } catch {
       throw read2 ? new RemoteWorkspaceInvitationReadError : new RemoteWorkspaceInvitationUnconfirmedError;
     }
@@ -38912,7 +39724,7 @@ class RemoteSkillsClient {
     } catch {
       throw new RemoteRecurringUnavailableError;
     }
-    let identity3, identityValue;
+    let identity4, identityValue;
     try {
       const response = await connection.request("/api/auth/whoami");
       if (!response.ok) {
@@ -38921,8 +39733,8 @@ class RemoteSkillsClient {
       }
       identityValue = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(await readBoundedResponse(response, 64 * 1024)));
       const observedUser = identityValue.user?.id;
-      identity3 = parseWorkspaceIdentity(identityValue, target?.userId ?? workspaceExpectedUserId(observedUser));
-      if (target && identity3.user.membershipId !== target.membershipId)
+      identity4 = parseWorkspaceIdentity(identityValue, target?.userId ?? workspaceExpectedUserId(observedUser));
+      if (target && identity4.user.membershipId !== target.membershipId)
         throw new WorkspaceIdentityMismatchError;
     } catch {
       throw new RemoteRecurringReadError;
@@ -38932,16 +39744,16 @@ class RemoteSkillsClient {
         throw new RemoteRecurringError("RECURRING_HUMAN_APPROVAL_REQUIRED");
       assertRecurringCapability(capability, "draft");
       const selected = captured;
-      const draft = await connection.dispatchRecurring("draft", { draftId: selected.draftId }, identity3);
+      const draft = await connection.dispatchRecurring("draft", { draftId: selected.draftId }, identity4);
       if (!draft || draft.termsSha256 !== selected.approval.acceptedTermsSha256)
         throw new RemoteRecurringError("RECURRING_TERMS_UNAVAILABLE");
     }
     let selectedConsent;
     if (action === "occurrences") {
       assertRecurringCapability(capability, "get");
-      selectedConsent = await connection.dispatchRecurring("get", { consentId: captured.consentId }, identity3);
+      selectedConsent = await connection.dispatchRecurring("get", { consentId: captured.consentId }, identity4);
     }
-    const result = await connection.dispatchRecurring(action, captured, identity3);
+    const result = await connection.dispatchRecurring(action, captured, identity4);
     if (action === "occurrences") {
       const items = result.items;
       if (items.length && (!selectedConsent || items.some((item) => item.scheduleId !== selectedConsent.scheduleId)))
@@ -38949,7 +39761,7 @@ class RemoteSkillsClient {
     }
     return result;
   }
-  async dispatchRecurring(action, input2, identity3) {
+  async dispatchRecurring(action, input2, identity4) {
     const request = recurringRequest(action, input2);
     let response, value;
     try {
@@ -38969,7 +39781,7 @@ class RemoteSkillsClient {
     try {
       if (response.status !== 200 || value === null)
         throw new RemoteRecurringReadError;
-      return parseRecurringResult(action, value, input2, identity3);
+      return parseRecurringResult(action, value, input2, identity4);
     } catch {
       throw request.read ? new RemoteRecurringReadError : new RemoteRecurringUnconfirmedError;
     }
@@ -39632,13 +40444,13 @@ var init_remote_invitation_recovery = __esm(() => {
 });
 
 // src/lib/remote-private-publications.ts
-import { createHash as createHash22 } from "crypto";
+import { createHash as createHash23 } from "crypto";
 function checkedPublicationDeclaration(value) {
-  if (!exact(value, ["idempotencyKey", "version", "expectedCurrentVersionId", "manifestText", "archiveSha256", "archiveByteSize"]) || !publicationUuid(value.idempotencyKey) || !(value.expectedCurrentVersionId === null || publicationUuid(value.expectedCurrentVersionId)) || typeof value.version !== "string" || !value.version || value.version.length > 128 || /[\p{Cc}\p{Cs}]/u.test(value.version) || typeof value.manifestText !== "string" || Buffer.byteLength(value.manifestText) > 16384 || !hash3(value.archiveSha256) || !Number.isSafeInteger(value.archiveByteSize) || Number(value.archiveByteSize) < 1 || Number(value.archiveByteSize) > PRIVATE_PUBLICATION_MAX_BYTES)
+  if (!exact(value, ["idempotencyKey", "version", "expectedCurrentVersionId", "manifestText", "archiveSha256", "archiveByteSize"]) || !publicationUuid(value.idempotencyKey) || !(value.expectedCurrentVersionId === null || publicationUuid(value.expectedCurrentVersionId)) || typeof value.version !== "string" || !value.version || value.version.length > 128 || /[\p{Cc}\p{Cs}]/u.test(value.version) || typeof value.manifestText !== "string" || Buffer.byteLength(value.manifestText) > 16384 || !hash4(value.archiveSha256) || !Number.isSafeInteger(value.archiveByteSize) || Number(value.archiveByteSize) < 1 || Number(value.archiveByteSize) > PRIVATE_PUBLICATION_MAX_BYTES)
     return bad();
   try {
     const manifest = JSON.parse(value.manifestText);
-    if (!record9(manifest) || manifest.version !== value.version || validatePortableManifestContract(manifest, { strict: true }).length || !hash3(manifest.provenance?.content_hash))
+    if (!record9(manifest) || manifest.version !== value.version || validatePortableManifestContract(manifest, { strict: true }).length || !hash4(manifest.provenance?.content_hash))
       return bad();
   } catch {
     return bad();
@@ -39646,7 +40458,7 @@ function checkedPublicationDeclaration(value) {
   return Object.freeze({ ...value });
 }
 function checkedPublicationView(value, skillId, intentId, declaration) {
-  if (!exact(value, ["id", "skillId", "version", "expectedCurrentVersionId", "archiveSha256", "archiveByteSize", "state", "expiresAt", "createdAt", "versionId"]) || !publicationUuid(value.id) || value.skillId !== skillId || intentId !== undefined && value.id !== intentId || typeof value.version !== "string" || !value.version || value.version.length > 128 || /[\p{Cc}\p{Cs}]/u.test(value.version) || !(value.expectedCurrentVersionId === null || publicationUuid(value.expectedCurrentVersionId)) || !hash3(value.archiveSha256) || !Number.isSafeInteger(value.archiveByteSize) || Number(value.archiveByteSize) < 1 || Number(value.archiveByteSize) > PRIVATE_PUBLICATION_MAX_BYTES || typeof value.state !== "string" || !["awaiting_upload", "queued", "verifying", "needs_attention", "committed", "rejected", "cancelled", "expired"].includes(value.state) || !date5(value.expiresAt) || !date5(value.createdAt) || !(value.versionId === null || publicationUuid(value.versionId)) || value.state === "committed" && value.versionId === null)
+  if (!exact(value, ["id", "skillId", "version", "expectedCurrentVersionId", "archiveSha256", "archiveByteSize", "state", "expiresAt", "createdAt", "versionId"]) || !publicationUuid(value.id) || value.skillId !== skillId || intentId !== undefined && value.id !== intentId || typeof value.version !== "string" || !value.version || value.version.length > 128 || /[\p{Cc}\p{Cs}]/u.test(value.version) || !(value.expectedCurrentVersionId === null || publicationUuid(value.expectedCurrentVersionId)) || !hash4(value.archiveSha256) || !Number.isSafeInteger(value.archiveByteSize) || Number(value.archiveByteSize) < 1 || Number(value.archiveByteSize) > PRIVATE_PUBLICATION_MAX_BYTES || typeof value.state !== "string" || !["awaiting_upload", "queued", "verifying", "needs_attention", "committed", "rejected", "cancelled", "expired"].includes(value.state) || !date5(value.expiresAt) || !date5(value.createdAt) || !(value.versionId === null || publicationUuid(value.versionId)) || value.state === "committed" && value.versionId === null)
     return invalid4();
   if (declaration && ["version", "expectedCurrentVersionId", "archiveSha256", "archiveByteSize"].some((k) => value[k] !== declaration[k]))
     return invalid4();
@@ -39877,12 +40689,12 @@ class RemotePrivatePublicationsClient {
       previous = view;
       if (!["queued", "verifying"].includes(view.state) || Date.now() >= until)
         return view;
-      await new Promise((resolve22) => {
+      await new Promise((resolve23) => {
         const timer = setTimeout(done, Math.min(1000, until - Date.now()));
         function done() {
           clearTimeout(timer);
           options.signal?.removeEventListener("abort", done);
-          resolve22();
+          resolve23();
         }
         options.signal?.addEventListener("abort", done, { once: true });
       });
@@ -39893,7 +40705,7 @@ var PRIVATE_PUBLICATION_MAX_BYTES, failures2, PrivatePublicationError, bad = ()
   throw new PrivatePublicationError("INVALID_PUBLICATION_INPUT", "Invalid publication input or recovery data.");
 }, invalid4 = () => {
   throw new PrivatePublicationError("INVALID_PUBLICATION_RESPONSE", "The server returned an invalid publication result.");
-}, publicationUuid = (v) => typeof v === "string" && /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/.test(v), hash3 = (v) => typeof v === "string" && /^[a-f0-9]{64}$/.test(v), record9 = (v) => !!v && typeof v === "object" && !Array.isArray(v), exact = (v, keys2) => record9(v) && Object.keys(v).sort().join(",") === keys2.sort().join(","), date5 = (v) => typeof v === "string" && /^\d{4}-\d\d-\d\dT[0-9:.]+(?:Z|[+-](?:[01]\d|2[0-3]):[0-5]\d)$/.test(v) && Number.isFinite(Date.parse(v)), publicationSha256 = (bytes) => createHash22("sha256").update(bytes).digest("hex");
+}, publicationUuid = (v) => typeof v === "string" && /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/.test(v), hash4 = (v) => typeof v === "string" && /^[a-f0-9]{64}$/.test(v), record9 = (v) => !!v && typeof v === "object" && !Array.isArray(v), exact = (v, keys2) => record9(v) && Object.keys(v).sort().join(",") === keys2.sort().join(","), date5 = (v) => typeof v === "string" && /^\d{4}-\d\d-\d\dT[0-9:.]+(?:Z|[+-](?:[01]\d|2[0-3]):[0-5]\d)$/.test(v) && Number.isFinite(Date.parse(v)), publicationSha256 = (bytes) => createHash23("sha256").update(bytes).digest("hex");
 var init_remote_private_publications = __esm(() => {
   init_fleet_credentials();
   init_remote_workspace_selection();
@@ -40170,10 +40982,10 @@ var init_remote_auth = __esm(() => {
 });
 
 // src/lib/workspace-profile.ts
-import { constants as constants14, closeSync as closeSync16, fstatSync as fstatSync16, lstatSync as lstatSync22, mkdirSync as mkdirSync10, mkdtempSync as mkdtempSync2, openSync as openSync16, readFileSync as readFileSync19, renameSync as renameSync5, rmSync as rmSync4, writeFileSync as writeFileSync8 } from "fs";
+import { constants as constants15, closeSync as closeSync17, fstatSync as fstatSync17, lstatSync as lstatSync23, mkdirSync as mkdirSync10, mkdtempSync as mkdtempSync2, openSync as openSync17, readFileSync as readFileSync19, renameSync as renameSync5, rmSync as rmSync4, writeFileSync as writeFileSync8 } from "fs";
 function stat2(path) {
   try {
-    return lstatSync22(path);
+    return lstatSync23(path);
   } catch (error61) {
     if (error61.code === "ENOENT")
       return null;
@@ -40183,17 +40995,17 @@ function stat2(path) {
 function safeText(file2) {
   if (stat2(file2) === null)
     return null;
-  const fd = openSync16(file2, constants14.O_RDONLY | constants14.O_NOFOLLOW | constants14.O_NONBLOCK);
+  const fd = openSync17(file2, constants15.O_RDONLY | constants15.O_NOFOLLOW | constants15.O_NONBLOCK);
   try {
-    const s = fstatSync16(fd);
+    const s = fstatSync17(fd);
     if (!s.isFile() || s.size > 65536 || ![256, 384].includes(s.mode & 4095) || process.getuid && s.uid !== process.getuid())
       return fail("The selected profile must use bounded owner-only regular files.");
     return readFileSync19(fd, "utf8");
   } finally {
-    closeSync16(fd);
+    closeSync17(fd);
   }
 }
-function checkIdentityMetadata(file2, identity3) {
+function checkIdentityMetadata(file2, identity4) {
   const text3 = safeText(file2);
   if (text3 === null)
     return;
@@ -40205,7 +41017,7 @@ function checkIdentityMetadata(file2, identity3) {
   }
   if (!value || typeof value !== "object" || Array.isArray(value))
     return fail("The profile identity metadata is invalid.");
-  for (const [key, expected] of Object.entries({ userId: identity3.user.id, orgId: identity3.organization.id })) {
+  for (const [key, expected] of Object.entries({ userId: identity4.user.id, orgId: identity4.organization.id })) {
     if (value[key] !== undefined && value[key] !== expected)
       return fail("The profile identity metadata does not match its authenticated key. Sign in again before managing this workspace.");
   }
@@ -40227,10 +41039,10 @@ function prepareProfileWorkspace(action, source = process.env) {
     const connection = await resolveSkillsConnection(env);
     if (!connection || connection.apiOrigin !== origin)
       return fail("The selected profile has no usable credential for this server.");
-    const identity3 = await keyIdentity(connection.apiKey, origin);
-    checkIdentityMetadata(getIdentityFilePath(env), identity3);
+    const identity4 = await keyIdentity(connection.apiKey, origin);
+    checkIdentityMetadata(getIdentityFilePath(env), identity4);
     unchanged3();
-    const context = { userId: identity3.user.id, membershipId: identity3.user.membershipId };
+    const context = { userId: identity4.user.id, membershipId: identity4.user.membershipId };
     return { origin, context, unchanged: unchanged3 };
   } };
 }
@@ -40311,15 +41123,15 @@ async function prepareRecurringCustomer(requested, source = process.env) {
     await assertCurrent();
     const value = await new RemoteSkillsClient(connection.apiKey, connection.apiOrigin).getIdentity();
     const user = value.user;
-    const identity3 = parseWorkspaceIdentity(value, context?.userId ?? workspaceExpectedUserId(user?.id));
+    const identity4 = parseWorkspaceIdentity(value, context?.userId ?? workspaceExpectedUserId(user?.id));
     await assertCurrent();
-    if (value.authMethod !== "api_key" || context && identity3.user.membershipId !== context.membershipId)
+    if (value.authMethod !== "api_key" || context && identity4.user.membershipId !== context.membershipId)
       changed();
-    const binding = JSON.stringify([identity3.user.id, identity3.user.membershipId, identity3.organization.id]);
+    const binding = JSON.stringify([identity4.user.id, identity4.user.membershipId, identity4.organization.id]);
     if (originalIdentity !== undefined && originalIdentity !== binding)
       changed();
     originalIdentity = binding;
-    if (verification(identity3.user.email) !== normalized)
+    if (verification(identity4.user.email) !== normalized)
       throw new RecurringCustomerError("RECURRING_ACCOUNT_EMAIL_MISMATCH", "Use the selected account's current email. No verification request or recurring activation was submitted.");
     return normalized;
   }
@@ -40402,8 +41214,8 @@ var init_recurring_customer = __esm(() => {
 });
 
 // src/lib/recurring-recovery.ts
-import { constants as constants15, closeSync as closeSync17, fsyncSync as fsyncSync5, fstatSync as fstatSync17, lstatSync as lstatSync23, mkdirSync as mkdirSync11, openSync as openSync17, readSync as readSync11, realpathSync as realpathSync9, renameSync as renameSync6, unlinkSync as unlinkSync5, writeFileSync as writeFileSync9 } from "fs";
-import { dirname as dirname22, isAbsolute as isAbsolute20, join as join33, resolve as resolve22 } from "path";
+import { constants as constants16, closeSync as closeSync18, fsyncSync as fsyncSync5, fstatSync as fstatSync18, lstatSync as lstatSync24, mkdirSync as mkdirSync11, openSync as openSync18, readSync as readSync12, realpathSync as realpathSync11, renameSync as renameSync6, unlinkSync as unlinkSync5, writeFileSync as writeFileSync9 } from "fs";
+import { dirname as dirname23, isAbsolute as isAbsolute21, join as join34, resolve as resolve23 } from "path";
 import { randomUUID as randomUUID2 } from "crypto";
 
 class RecoveryOwner {
@@ -40411,75 +41223,75 @@ class RecoveryOwner {
   parents = [];
   constructor(directory) {
     this.directory = directory;
-    if (!isAbsolute20(directory) || resolve22(directory) !== directory || realpathSync9(directory) !== directory)
+    if (!isAbsolute21(directory) || resolve23(directory) !== directory || realpathSync11(directory) !== directory)
       invalid5();
-    for (let path = directory;; path = dirname22(path)) {
-      const stat3 = lstatSync23(path);
+    for (let path = directory;; path = dirname23(path)) {
+      const stat3 = lstatSync24(path);
       if (!stat3.isDirectory() || stat3.isSymbolicLink())
         invalid5();
       this.parents.push({ path, dev: stat3.dev, ino: stat3.ino });
-      if (path === dirname22(path))
+      if (path === dirname23(path))
         break;
     }
     this.assert();
   }
   assert() {
-    if (realpathSync9(this.directory) !== this.directory)
+    if (realpathSync11(this.directory) !== this.directory)
       invalid5();
     for (const prior of this.parents) {
-      const now = lstatSync23(prior.path);
+      const now = lstatSync24(prior.path);
       if (!now.isDirectory() || now.isSymbolicLink() || now.dev !== prior.dev || now.ino !== prior.ino)
         invalid5();
     }
-    const own2 = lstatSync23(this.directory);
+    const own2 = lstatSync24(this.directory);
     if ((own2.mode & 511) !== 448 || (own2.mode & 3584) !== 0 || process.getuid && own2.uid !== process.getuid())
       invalid5();
   }
   read(name) {
     this.assert();
-    const fd = openSync17(join33(this.directory, name), constants15.O_RDONLY | constants15.O_NOFOLLOW | constants15.O_NONBLOCK);
+    const fd = openSync18(join34(this.directory, name), constants16.O_RDONLY | constants16.O_NOFOLLOW | constants16.O_NONBLOCK);
     try {
-      const before = fstatSync17(fd);
+      const before = fstatSync18(fd);
       if (!before.isFile() || before.nlink !== 1 || (before.mode & 4095) !== 384 || before.size < 1 || before.size > 8192 || process.getuid && before.uid !== process.getuid())
         invalid5();
       const bytes = Buffer.alloc(before.size + 1);
       let size = 0;
       while (size < bytes.length) {
-        const n2 = readSync11(fd, bytes, size, bytes.length - size, size);
+        const n2 = readSync12(fd, bytes, size, bytes.length - size, size);
         if (!n2)
           break;
         size += n2;
       }
-      const after = fstatSync17(fd), path = lstatSync23(join33(this.directory, name));
+      const after = fstatSync18(fd), path = lstatSync24(join34(this.directory, name));
       if (size !== before.size || after.size !== before.size || before.mtimeMs !== after.mtimeMs || before.ctimeMs !== after.ctimeMs || path.dev !== before.dev || path.ino !== before.ino || !path.isFile() || path.isSymbolicLink())
         invalid5();
       this.assert();
       return new TextDecoder("utf-8", { fatal: true }).decode(bytes.subarray(0, size));
     } finally {
-      closeSync17(fd);
+      closeSync18(fd);
     }
   }
   write(name, value) {
     this.assert();
     const bytes = canonicalJson2(value, 8192) + `
 `;
-    const fd = openSync17(join33(this.directory, name), constants15.O_WRONLY | constants15.O_CREAT | constants15.O_EXCL | constants15.O_NOFOLLOW, 384);
+    const fd = openSync18(join34(this.directory, name), constants16.O_WRONLY | constants16.O_CREAT | constants16.O_EXCL | constants16.O_NOFOLLOW, 384);
     try {
       writeFileSync9(fd, bytes);
       fsyncSync5(fd);
     } finally {
-      closeSync17(fd);
+      closeSync18(fd);
     }
     this.assert();
     this.sync();
   }
   sync() {
     this.assert();
-    const fd = openSync17(this.directory, constants15.O_RDONLY | constants15.O_NOFOLLOW);
+    const fd = openSync18(this.directory, constants16.O_RDONLY | constants16.O_NOFOLLOW);
     try {
       fsyncSync5(fd);
     } finally {
-      closeSync17(fd);
+      closeSync18(fd);
     }
   }
   saveState(state, expected) {
@@ -40490,30 +41302,30 @@ class RecoveryOwner {
     if (this.read("state.json") !== expected)
       invalid5();
     this.assert();
-    renameSync6(join33(this.directory, name), join33(this.directory, "state.json"));
+    renameSync6(join34(this.directory, name), join34(this.directory, "state.json"));
     this.sync();
   }
   async locked(action) {
     this.assert();
     let fd;
     try {
-      fd = openSync17(join33(this.directory, "operation.lock"), constants15.O_WRONLY | constants15.O_CREAT | constants15.O_EXCL | constants15.O_NOFOLLOW, 384);
+      fd = openSync18(join34(this.directory, "operation.lock"), constants16.O_WRONLY | constants16.O_CREAT | constants16.O_EXCL | constants16.O_NOFOLLOW, 384);
     } catch {
       throw new RecurringCustomerError("RECURRING_RECOVERY_BUSY", "Recovery is locked. Confirm the original process has stopped before explicitly reconciling the retained lock; no request was retried.");
     }
-    const owner2 = fstatSync17(fd);
+    const owner2 = fstatSync18(fd);
     try {
       writeFileSync9(fd, JSON.stringify({ pid: process.pid }));
       fsyncSync5(fd);
       this.sync();
       return await action();
     } finally {
-      closeSync17(fd);
+      closeSync18(fd);
       this.assert();
-      const now = lstatSync23(join33(this.directory, "operation.lock"));
+      const now = lstatSync24(join34(this.directory, "operation.lock"));
       if (owner2.dev !== now.dev || owner2.ino !== now.ino || !now.isFile() || now.isSymbolicLink())
         invalid5();
-      unlinkSync5(join33(this.directory, "operation.lock"));
+      unlinkSync5(join34(this.directory, "operation.lock"));
       this.sync();
     }
   }
@@ -40546,7 +41358,7 @@ function base(customer, organizationId) {
   };
 }
 function create(directory, intent) {
-  if (!isAbsolute20(directory) || resolve22(directory) !== directory || realpathSync9(dirname22(directory)) !== dirname22(directory))
+  if (!isAbsolute21(directory) || resolve23(directory) !== directory || realpathSync11(dirname23(directory)) !== dirname23(directory))
     invalid5();
   mkdirSync11(directory, { mode: 448 });
   const owner2 = new RecoveryOwner(directory), checked = intentSchema.parse(intent), intentSha256 = canonicalJsonSha256(checked);
@@ -40709,12 +41521,12 @@ var init_recurring_recovery = __esm(() => {
 });
 
 // src/lib/recurring-surface.ts
-import { isAbsolute as isAbsolute21 } from "path";
+import { isAbsolute as isAbsolute22 } from "path";
 function recurringMcpSchema(action) {
   return action === "activate" ? recurringSurfaceSchemas.activate.extend({ code, confirm: exports_external.literal(true) }) : recurringSurfaceSchemas[action];
 }
-function expectedDraft(draft, hash4) {
-  if (!draft || draft.termsSha256 !== hash4)
+function expectedDraft(draft, hash5) {
+  if (!draft || draft.termsSha256 !== hash5)
     throw new RemoteRecurringError("RECURRING_TERMS_UNAVAILABLE");
   return draft;
 }
@@ -40814,7 +41626,7 @@ var init_recurring_surface = __esm(() => {
   uuid13 = exports_external.string().regex(/^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/);
   context = { userId: uuid13.optional(), membershipId: uuid13.optional() };
   page2 = { limit: exports_external.number().int().min(1).max(100).optional(), cursor: exports_external.string().min(1).max(2048).optional() };
-  directory = exports_external.string().max(4096).refine(isAbsolute21, "Use an absolute recovery directory");
+  directory = exports_external.string().max(4096).refine(isAbsolute22, "Use an absolute recovery directory");
   email4 = exports_external.string().trim().toLowerCase().email().max(254);
   code = exports_external.string().regex(/^\d{6}$/);
   recurringSurfaceSchemas = {
@@ -42643,21 +43455,21 @@ var init_credential_state = __esm(() => {
 });
 
 // src/lib/run-state.ts
-import { createHash as createHash23, randomBytes } from "crypto";
-import { existsSync as existsSync15, mkdirSync as mkdirSync12, readFileSync as readFileSync20, readdirSync as readdirSync10, statSync as statSync10, writeFileSync as writeFileSync10 } from "fs";
-import { extname, join as join34, relative as relative7 } from "path";
+import { createHash as createHash24, randomBytes } from "crypto";
+import { existsSync as existsSync15, mkdirSync as mkdirSync12, readFileSync as readFileSync20, readdirSync as readdirSync11, statSync as statSync10, writeFileSync as writeFileSync10 } from "fs";
+import { extname, join as join35, relative as relative9 } from "path";
 function createSkillRun(params, targetDir = process.cwd()) {
   const now = new Date;
   const id = createRunId(now);
   const day = now.toISOString().slice(0, 10);
   const skillName = normalizeSkillName(params.skill);
   const root = getProjectStateDir(targetDir);
-  const runDir = join34(root, "runs", day, id);
-  const logsDir = join34(runDir, "logs");
-  const exportDir = join34(root, "exports", skillName, id);
+  const runDir = join35(root, "runs", day, id);
+  const logsDir = join35(runDir, "logs");
+  const exportDir = join35(root, "exports", skillName, id);
   mkdirSync12(logsDir, { recursive: true });
   mkdirSync12(exportDir, { recursive: true });
-  mkdirSync12(join34(root, "tmp"), { recursive: true });
+  mkdirSync12(join35(root, "tmp"), { recursive: true });
   const record10 = {
     id,
     skill: skillName,
@@ -42709,22 +43521,22 @@ function updateSkillRun(context2, patch) {
   return context2.record;
 }
 function writeRunLogs(context2, stdout = "", stderr = "") {
-  writeFileSync10(join34(context2.logsDir, "stdout.log"), stdout);
-  writeFileSync10(join34(context2.logsDir, "stderr.log"), stderr);
+  writeFileSync10(join35(context2.logsDir, "stdout.log"), stdout);
+  writeFileSync10(join35(context2.logsDir, "stderr.log"), stderr);
 }
 function appendRunEvent(context2, event, data = {}) {
   const line = JSON.stringify({ ts: new Date().toISOString(), event, ...data }) + `
 `;
-  const path = join34(context2.runDir, "events.ndjson");
+  const path = join35(context2.runDir, "events.ndjson");
   const previous = existsSync15(path) ? readFileSync20(path, "utf-8") : "";
   writeFileSync10(path, previous + line);
 }
 function findSkillRun(runId, targetDir = process.cwd()) {
-  const runsRoot = join34(getProjectStateDir(targetDir), "runs");
+  const runsRoot = join35(getProjectStateDir(targetDir), "runs");
   if (!existsSync15(runsRoot))
     return null;
-  for (const day of readdirSync10(runsRoot)) {
-    const record10 = readRunRecord(join34(runsRoot, day, runId));
+  for (const day of readdirSync11(runsRoot)) {
+    const record10 = readRunRecord(join35(runsRoot, day, runId));
     if (record10)
       return record10;
   }
@@ -42741,11 +43553,11 @@ function skillRunEnv(context2) {
   };
 }
 function writeRunRecord(context2) {
-  writeFileSync10(join34(context2.runDir, "run.json"), JSON.stringify(context2.record, null, 2) + `
+  writeFileSync10(join35(context2.runDir, "run.json"), JSON.stringify(context2.record, null, 2) + `
 `);
 }
 function writeArtifactsManifest(context2, artifacts) {
-  writeFileSync10(join34(context2.runDir, "artifacts.json"), JSON.stringify({ runId: context2.record.id, artifacts }, null, 2) + `
+  writeFileSync10(join35(context2.runDir, "artifacts.json"), JSON.stringify({ runId: context2.record.id, artifacts }, null, 2) + `
 `);
 }
 function collectRunArtifacts(context2) {
@@ -42758,14 +43570,14 @@ function collectRunArtifacts(context2) {
     artifacts.push({
       path: toProjectRelative(context2.targetDir, path),
       mime: mimeForPath(path),
-      sha256: createHash23("sha256").update(bytes).digest("hex"),
+      sha256: createHash24("sha256").update(bytes).digest("hex"),
       sizeBytes: stat3.size
     });
   }
   return artifacts.sort((a, b) => a.path.localeCompare(b.path));
 }
 function readRunRecord(runDir) {
-  const path = join34(runDir, "run.json");
+  const path = join35(runDir, "run.json");
   if (!existsSync15(path))
     return null;
   try {
@@ -42776,8 +43588,8 @@ function readRunRecord(runDir) {
 }
 function walkFiles(dir) {
   const files = [];
-  for (const entry of readdirSync10(dir)) {
-    const full = join34(dir, entry);
+  for (const entry of readdirSync11(dir)) {
+    const full = join35(dir, entry);
     if (statSync10(full).isDirectory())
       files.push(...walkFiles(full));
     else
@@ -42789,7 +43601,7 @@ function createRunId(now) {
   return `run_${now.getTime().toString(36)}_${randomBytes(4).toString("hex")}`;
 }
 function toProjectRelative(targetDir, path) {
-  const rel = relative7(targetDir, path).split(/[\\/]/).join("/");
+  const rel = relative9(targetDir, path).split(/[\\/]/).join("/");
   return rel.startsWith(".") ? rel : `./${rel}`;
 }
 function mimeForPath(path) {
@@ -43030,11 +43842,11 @@ var init_cloud_executions = __esm(() => {
 // node_modules/@hasna/secrets/dist/sdk.js
 import { isIP as isIP2 } from "net";
 import { spawnSync as spawnSync5 } from "child_process";
-import { closeSync as closeSync18, fstatSync as fstatSync18, openSync as openSync18, readFileSync as readFileSync21 } from "fs";
+import { closeSync as closeSync19, fstatSync as fstatSync19, openSync as openSync19, readFileSync as readFileSync21 } from "fs";
 import { O_NOFOLLOW as O_NOFOLLOW3, O_NONBLOCK as O_NONBLOCK3, O_RDONLY as O_RDONLY3 } from "constants";
 import { createRequire as createRequire2 } from "module";
 import { hostname as osHostname2 } from "os";
-import { isAbsolute as isAbsolute22, join as join35 } from "path";
+import { isAbsolute as isAbsolute23, join as join36 } from "path";
 import { createRequire as createRequire22 } from "module";
 function envToken2(name) {
   return name.toUpperCase().replace(/-/g, "_");
@@ -43058,21 +43870,21 @@ function homeDir2(env) {
 }
 function absoluteOverride2(env, key) {
   const value = env[key]?.trim();
-  return value && isAbsolute22(value) ? value : null;
+  return value && isAbsolute23(value) ? value : null;
 }
 function hasnaHomeDir2(env) {
   const override = absoluteOverride2(env, HASNA_HOME_ENV_KEY2);
   if (override)
     return override;
   const home = homeDir2(env);
-  return home ? join35(home, HASNA_HOME_DIR2) : null;
+  return home ? join36(home, HASNA_HOME_DIR2) : null;
 }
 function appConfigDir2(name, env) {
   const configRoot = absoluteOverride2(env, HASNA_CONFIG_HOME_ENV_KEY2);
   if (configRoot)
-    return join35(configRoot, name);
+    return join36(configRoot, name);
   const root = hasnaHomeDir2(env);
-  return root ? join35(root, name, CONFIG_SUBDIR2) : null;
+  return root ? join36(root, name, CONFIG_SUBDIR2) : null;
 }
 function credentialDiskSourceList2(name, env, profile = null) {
   if (!SAFE_APP_SLUG2.test(name))
@@ -43081,7 +43893,7 @@ function credentialDiskSourceList2(name, env, profile = null) {
   if (!directory2)
     return [];
   const file2 = profile ? `${CREDENTIALS_FILE2}-${profile}` : CREDENTIALS_FILE2;
-  return [{ path: join35(directory2, file2), tier: "disk" }];
+  return [{ path: join36(directory2, file2), tier: "disk" }];
 }
 function credentialDiskSources2(name, env) {
   return credentialDiskSourceList2(name, env, null).map((s) => s.path);
@@ -43135,7 +43947,7 @@ function readAppConfigFile2(path) {
   };
   let fd = -1;
   try {
-    fd = openSync18(path, O_RDONLY3 | O_NOFOLLOW3 | O_NONBLOCK3);
+    fd = openSync19(path, O_RDONLY3 | O_NOFOLLOW3 | O_NONBLOCK3);
   } catch (error61) {
     const code2 = error61.code;
     if (code2 === "ENOENT" || code2 === "ENOTDIR")
@@ -43145,7 +43957,7 @@ function readAppConfigFile2(path) {
     unsafe(`the path could not be opened (${code2 ?? "unknown error"})`);
   }
   try {
-    const before = fstatSync18(fd);
+    const before = fstatSync19(fd);
     if (!before.isFile())
       unsafe("the path is not a regular file");
     if (!configFileModeAllowed2(before.mode)) {
@@ -43157,14 +43969,14 @@ function readAppConfigFile2(path) {
     if (before.size > MAX_CREDENTIAL_FILE_BYTES2)
       unsafe("the file exceeds the size limit");
     const bytes = readFileSync21(fd);
-    const after = fstatSync18(fd);
+    const after = fstatSync19(fd);
     if (!configFileReadsCoherent2(before, after)) {
       unsafe("the file changed while being read");
     }
     return parseEnvFile2(bytes.toString("utf8"));
   } finally {
     if (fd !== -1)
-      closeSync18(fd);
+      closeSync19(fd);
   }
 }
 function readCredentialFile2(path, apiKeyKeys) {
@@ -44195,7 +45007,7 @@ function createSecretsClientFromEnv(env = process.env, overrides = {}) {
   });
   return new SecretsClient({ ...clientOverrides, baseUrl, apiKey });
 }
-var __esm2 = (fn, res) => () => (fn && (res = fn(fn = 0)), res), CREDENTIAL_PROFILE_ENV_KEY2 = "HASNA_PROFILE", CredentialResolutionError2, CredentialFileUnsafeError2, HASNA_HOME_ENV_KEY2 = "HASNA_HOME", HASNA_CONFIG_HOME_ENV_KEY2 = "HASNA_CONFIG_HOME", KEYCHAIN_STATION_ENV_KEY2 = "HASNA_STATION", HASNA_HOME_DIR2 = ".hasna", CONFIG_SUBDIR2 = "config", CREDENTIALS_FILE2 = "credentials", KEYCHAIN_SECURITY_BIN2 = "/usr/bin/security", KEYCHAIN_SERVICE_PREFIX2 = "hasna.credentials", KEYCHAIN_ITEM_NOT_FOUND_STATUS2 = 44, KEYCHAIN_SPAWN_TIMEOUT_MS2 = 1e4, MAX_CREDENTIAL_FILE_BYTES2, SAFE_APP_SLUG2, SAFE_PROFILE2, ILLEGAL_IN_HEADER_VALUE2, VAULT_POINTER_SHAPE2, CREDENTIAL_SHAPED_KEY2, INSPECT_CUSTOM2, CREDENTIAL_SEAL2, CALLER_SUPPLIED_CREDENTIAL_PROVIDER_SOURCE = "caller-supplied CredentialProvider", AMBIENT_ENVIRONMENT2, SECRETS_PACKAGE_SPECIFIER, requireSecretsSdk2, DEFAULT_FLEET_GATEWAY_ORIGIN2 = "https://api.hasna.com", DEFAULT_AUTHORITY_SOURCE = "default", ASCII_CONTROL_PATTERN2, DNS_LABEL_PATTERN2, ClientTransportConfigurationError2, HasnaHttpError, DEFAULT_RETRY_STATUSES, IDEMPOTENT_METHODS2, AUTHORITY_OVERRIDE_HEADERS2, defaultSleep = (ms) => new Promise((resolve23) => setTimeout(resolve23, ms)), init_transport2, MAX_CREDENTIAL_FILE_BYTES22, INSPECT_CUSTOM22, CREDENTIAL_SEAL22, AMBIENT_ENVIRONMENT22, SECRETS_PACKAGE_SPECIFIER2, requireSecretsSdk22, IDEMPOTENT_METHODS22, AUTHORITY_OVERRIDE_HEADERS22, init_storage, PATHS_RESOLVER_APP_SLUG_RE2, SQLITE_SIDECAR_FILES, LEGACY_SERVICE_FILES, init_data_dir, SecretsTestIsolationError, TEST_ENTRYPOINT_RE, init_test_isolation, init_client, ApiError;
+var __esm2 = (fn, res) => () => (fn && (res = fn(fn = 0)), res), CREDENTIAL_PROFILE_ENV_KEY2 = "HASNA_PROFILE", CredentialResolutionError2, CredentialFileUnsafeError2, HASNA_HOME_ENV_KEY2 = "HASNA_HOME", HASNA_CONFIG_HOME_ENV_KEY2 = "HASNA_CONFIG_HOME", KEYCHAIN_STATION_ENV_KEY2 = "HASNA_STATION", HASNA_HOME_DIR2 = ".hasna", CONFIG_SUBDIR2 = "config", CREDENTIALS_FILE2 = "credentials", KEYCHAIN_SECURITY_BIN2 = "/usr/bin/security", KEYCHAIN_SERVICE_PREFIX2 = "hasna.credentials", KEYCHAIN_ITEM_NOT_FOUND_STATUS2 = 44, KEYCHAIN_SPAWN_TIMEOUT_MS2 = 1e4, MAX_CREDENTIAL_FILE_BYTES2, SAFE_APP_SLUG2, SAFE_PROFILE2, ILLEGAL_IN_HEADER_VALUE2, VAULT_POINTER_SHAPE2, CREDENTIAL_SHAPED_KEY2, INSPECT_CUSTOM2, CREDENTIAL_SEAL2, CALLER_SUPPLIED_CREDENTIAL_PROVIDER_SOURCE = "caller-supplied CredentialProvider", AMBIENT_ENVIRONMENT2, SECRETS_PACKAGE_SPECIFIER, requireSecretsSdk2, DEFAULT_FLEET_GATEWAY_ORIGIN2 = "https://api.hasna.com", DEFAULT_AUTHORITY_SOURCE = "default", ASCII_CONTROL_PATTERN2, DNS_LABEL_PATTERN2, ClientTransportConfigurationError2, HasnaHttpError, DEFAULT_RETRY_STATUSES, IDEMPOTENT_METHODS2, AUTHORITY_OVERRIDE_HEADERS2, defaultSleep = (ms) => new Promise((resolve24) => setTimeout(resolve24, ms)), init_transport2, MAX_CREDENTIAL_FILE_BYTES22, INSPECT_CUSTOM22, CREDENTIAL_SEAL22, AMBIENT_ENVIRONMENT22, SECRETS_PACKAGE_SPECIFIER2, requireSecretsSdk22, IDEMPOTENT_METHODS22, AUTHORITY_OVERRIDE_HEADERS22, init_storage, PATHS_RESOLVER_APP_SLUG_RE2, SQLITE_SIDECAR_FILES, LEGACY_SERVICE_FILES, init_data_dir, SecretsTestIsolationError, TEST_ENTRYPOINT_RE, init_test_isolation, init_client, ApiError;
 var init_sdk = __esm(() => {
   init_transport2 = __esm2(() => {
     CredentialResolutionError2 = class CredentialResolutionError3 extends Error {
@@ -44330,75 +45142,75 @@ var init_sdk = __esm(() => {
 });
 
 // src/lib/execution-secrets.ts
-import { constants as constants16, closeSync as closeSync19, fstatSync as fstatSync19, openSync as openSync19, readSync as readSync12, realpathSync as realpathSync10 } from "fs";
+import { constants as constants17, closeSync as closeSync20, fstatSync as fstatSync20, openSync as openSync20, readSync as readSync13, realpathSync as realpathSync12 } from "fs";
 import { hostname as stationHostname } from "os";
 function selectedSecretBindingsTemplate(scope, names, createClient = createSecretsClientFromEnv) {
   let secretsAuthority;
   try {
     secretsAuthority = createClient().baseUrl;
   } catch {
-    return refuse4("LOCAL_SECRET_UNAVAILABLE", "Configure the Secrets CLI authority and authentication before preparing execution bindings.");
+    return refuse5("LOCAL_SECRET_UNAVAILABLE", "Configure the Secrets CLI authority and authentication before preparing execution bindings.");
   }
   const { authority, workspaceId, profileRevision, slug: slug2, version: version2, bundleDigest } = scope.selection;
   return {
     schema: "hasna.skills-secret-bindings.v1",
     selection: { authority, workspaceId, profileId: scope.profileId, profileRevision, slug: slug2, version: version2, bundleDigest },
-    consumer: { stationId: process.env.HASNA_STATION || stationHostname(), workspaceDirectory: realpathSync10(scope.cwd) },
+    consumer: { stationId: process.env.HASNA_STATION || stationHostname(), workspaceDirectory: realpathSync12(scope.cwd) },
     secretsAuthority,
     bindings: Object.fromEntries(names.map((name) => [name, ""]))
   };
 }
-function refuse4(code2, message) {
+function refuse5(code2, message) {
   throw new SkillSelectionError(code2, message);
 }
 function record10(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
-function exactKeys2(value, keys2) {
+function exactKeys3(value, keys2) {
   return Object.keys(value).length === keys2.length && keys2.every((key) => Object.hasOwn(value, key));
 }
-function identifier3(value) {
+function identifier4(value) {
   return typeof value === "string" && value.length > 0 && value.length <= 2048 && !/[\x00-\x20\x7f]/.test(value);
 }
 function declaredSecretNames(value) {
   if (value === undefined)
     return [];
   if (!Array.isArray(value) || value.length > 32 || value.some((name) => typeof name !== "string" || !/^[A-Z][A-Z0-9_]{0,127}$/.test(name)) || new Set(value).size !== value.length) {
-    return refuse4("INVALID_SKILL_MANIFEST", "Runtime environment references must be unique uppercase identifiers (at most 32).");
+    return refuse5("INVALID_SKILL_MANIFEST", "Runtime environment references must be unique uppercase identifiers (at most 32).");
   }
   if (value.some((name) => /^(?:PATH|HOME|TMPDIR|TEMP|TMP|LANG|LC_ALL|TERM|SHELL|ENV|BASH_ENV|IFS|NODE_OPTIONS|NODE_PATH)$/.test(name) || /^(?:SKILLS_|BUN_|PYTHON|LD_|DYLD_)/.test(name))) {
-    return refuse4("INVALID_SKILL_MANIFEST", "Runtime environment references cannot override execution controls.");
+    return refuse5("INVALID_SKILL_MANIFEST", "Runtime environment references cannot override execution controls.");
   }
   return value;
 }
 function validateSelectedSecretBindings(value, scope, names) {
-  if (!record10(value) || !exactKeys2(value, ["schema", "selection", "consumer", "secretsAuthority", "bindings"]) || value.schema !== "hasna.skills-secret-bindings.v1" || !record10(value.selection) || !exactKeys2(value.selection, ["authority", "workspaceId", "profileId", "profileRevision", "slug", "version", "bundleDigest"]) || !record10(value.consumer) || !exactKeys2(value.consumer, ["stationId", "workspaceDirectory"]) || !record10(value.bindings)) {
-    return refuse4("INVALID_SECRET_BINDINGS", "Secret bindings do not match the hasna.skills-secret-bindings.v1 contract.");
+  if (!record10(value) || !exactKeys3(value, ["schema", "selection", "consumer", "secretsAuthority", "bindings"]) || value.schema !== "hasna.skills-secret-bindings.v1" || !record10(value.selection) || !exactKeys3(value.selection, ["authority", "workspaceId", "profileId", "profileRevision", "slug", "version", "bundleDigest"]) || !record10(value.consumer) || !exactKeys3(value.consumer, ["stationId", "workspaceDirectory"]) || !record10(value.bindings)) {
+    return refuse5("INVALID_SECRET_BINDINGS", "Secret bindings do not match the hasna.skills-secret-bindings.v1 contract.");
   }
   for (const [key, expected] of Object.entries({ authority: scope.selection.authority, workspaceId: scope.selection.workspaceId, profileId: scope.profileId, profileRevision: scope.selection.profileRevision, slug: scope.selection.slug, version: scope.selection.version, bundleDigest: scope.selection.bundleDigest })) {
     if (value.selection[key] !== expected)
-      return refuse4("SECRET_BINDING_SCOPE_MISMATCH", "Secret bindings do not match the exact selected authority, workspace, profile, revision, version and digest.");
+      return refuse5("SECRET_BINDING_SCOPE_MISMATCH", "Secret bindings do not match the exact selected authority, workspace, profile, revision, version and digest.");
   }
   let workspaceDirectory;
   try {
-    workspaceDirectory = realpathSync10(scope.cwd);
+    workspaceDirectory = realpathSync12(scope.cwd);
   } catch {
-    return refuse4("SECRET_BINDING_CONSUMER_MISMATCH", "The execution workspace cannot be resolved.");
+    return refuse5("SECRET_BINDING_CONSUMER_MISMATCH", "The execution workspace cannot be resolved.");
   }
   if (value.consumer.stationId !== (process.env.HASNA_STATION || stationHostname()) || value.consumer.workspaceDirectory !== workspaceDirectory) {
-    return refuse4("SECRET_BINDING_CONSUMER_MISMATCH", "Secret bindings do not match this station and canonical workspace directory.");
+    return refuse5("SECRET_BINDING_CONSUMER_MISMATCH", "Secret bindings do not match this station and canonical workspace directory.");
   }
   try {
-    if (!identifier3(value.secretsAuthority))
+    if (!identifier4(value.secretsAuthority))
       throw new Error;
     const url2 = new URL(value.secretsAuthority);
     if (url2.protocol !== "https:" && !(url2.protocol === "http:" && ["127.0.0.1", "[::1]", "localhost"].includes(url2.hostname)) || url2.username || url2.password || url2.search || url2.hash || !url2.pathname.endsWith("/v1") || url2.href !== value.secretsAuthority)
       throw new Error;
   } catch {
-    return refuse4("INVALID_SECRET_BINDINGS", "Secret bindings require a canonical HTTPS Secrets /v1 authority (loopback HTTP is allowed).");
+    return refuse5("INVALID_SECRET_BINDINGS", "Secret bindings require a canonical HTTPS Secrets /v1 authority (loopback HTTP is allowed).");
   }
-  if (!exactKeys2(value.bindings, names) || Object.values(value.bindings).some((key) => !identifier3(key) || !/^[A-Za-z0-9][A-Za-z0-9._/-]*$/.test(key) || key.split("/").some((part) => !part || part === "." || part === ".."))) {
-    return refuse4("INVALID_SECRET_BINDINGS", "Bind every declared environment name exactly once to a vault key; undeclared bindings and values are refused.");
+  if (!exactKeys3(value.bindings, names) || Object.values(value.bindings).some((key) => !identifier4(key) || !/^[A-Za-z0-9][A-Za-z0-9._/-]*$/.test(key) || key.split("/").some((part) => !part || part === "." || part === ".."))) {
+    return refuse5("INVALID_SECRET_BINDINGS", "Bind every declared environment name exactly once to a vault key; undeclared bindings and values are refused.");
   }
   return structuredClone(value);
 }
@@ -44409,10 +45221,10 @@ async function resolveSelectedSecrets(bindings, createClient = createSecretsClie
   try {
     client = createClient();
   } catch {
-    return refuse4("LOCAL_SECRET_UNAVAILABLE", "The configured Secrets client could not authenticate. No ambient credential fallback was attempted.");
+    return refuse5("LOCAL_SECRET_UNAVAILABLE", "The configured Secrets client could not authenticate. No ambient credential fallback was attempted.");
   }
   if (client.baseUrl !== bindings.secretsAuthority)
-    return refuse4("SECRET_BINDING_AUTHORITY_MISMATCH", "The configured Secrets authority differs from the reviewed binding. No secret was requested.");
+    return refuse5("SECRET_BINDING_AUTHORITY_MISMATCH", "The configured Secrets authority differs from the reviewed binding. No secret was requested.");
   const env = {};
   const signal = AbortSignal.timeout(15000);
   try {
@@ -44424,7 +45236,7 @@ async function resolveSelectedSecrets(bindings, createClient = createSecretsClie
     }
     return env;
   } catch {
-    return refuse4("LOCAL_SECRET_UNAVAILABLE", "A declared secret could not be resolved, was invalid, or has expired. The skill was not started; no fallback was attempted.");
+    return refuse5("LOCAL_SECRET_UNAVAILABLE", "A declared secret could not be resolved, was invalid, or has expired. The skill was not started; no fallback was attempted.");
   }
 }
 function redactExecutionSecrets(text3, env) {
@@ -44572,10 +45384,10 @@ __export(exports_selected_run, {
   prepareSelectedSecretBindings: () => prepareSelectedSecretBindings,
   executeSelectedLocal: () => executeSelectedLocal
 });
-import { createHash as createHash24 } from "crypto";
+import { createHash as createHash25 } from "crypto";
 import { spawn as spawn2 } from "child_process";
-import { mkdirSync as mkdirSync13, mkdtempSync as mkdtempSync3, writeFileSync as writeFileSync11, realpathSync as realpathSync11 } from "fs";
-import { dirname as dirname23, join as join36, resolve as resolve23 } from "path";
+import { mkdirSync as mkdirSync13, mkdtempSync as mkdtempSync3, writeFileSync as writeFileSync11, realpathSync as realpathSync13 } from "fs";
+import { dirname as dirname24, join as join37, resolve as resolve24 } from "path";
 import { tmpdir, hostname as stationHostname2 } from "os";
 async function resolveSelectedRun(spec, profileId, options = {}) {
   const context2 = await resolveSelectionContext(profileId, options);
@@ -44655,7 +45467,7 @@ async function executeSelectedLocal(selected, options = {}) {
         throw new SkillSelectionError("INVALID_SECRET_BINDINGS", "Explicit environment values must be bounded strings without NUL bytes.");
       secretEnv[name] = value;
     }
-  const runDirectory = mkdtempSync3(join36(tmpdir(), "skills-execution-"));
+  const runDirectory = mkdtempSync3(join37(tmpdir(), "skills-execution-"));
   const paths = new SkillEntryPaths;
   for (const entry of entries) {
     paths.add(entry.path, 100, () => {
@@ -44663,12 +45475,12 @@ async function executeSelectedLocal(selected, options = {}) {
     }, () => {
       throw new SkillSelectionError("INVALID_BUNDLE_PATH", "The execution bundle path exceeds its limit.");
     });
-    const destination = join36(runDirectory, entry.path);
-    mkdirSync13(dirname23(destination), { recursive: true, mode: 448 });
+    const destination = join37(runDirectory, entry.path);
+    mkdirSync13(dirname24(destination), { recursive: true, mode: 448 });
     writeFileSync11(destination, entry.bytes, { flag: "wx", mode: entry.mode & 511 });
   }
   env.SKILLS_INPUT_JSON = input2;
-  env.SKILLS_WORKSPACE_DIR = resolve23(options.cwd ?? process.cwd());
+  env.SKILLS_WORKSPACE_DIR = resolve24(options.cwd ?? process.cwd());
   env.SKILLS_RUN_DIR = runDirectory;
   if (runtime.version) {
     const version2 = await subprocess([executable, ...runtimeName === "bun" ? ["--no-env-file"] : [], "--version"], runDirectory, env, "", Math.min(timeoutMs, 5000));
@@ -44681,7 +45493,7 @@ async function executeSelectedLocal(selected, options = {}) {
     const { authority: authority2, workspaceId, profileRevision, slug: slug2, version: version2, bundleDigest } = selection2;
     const request2 = {
       selection: { authority: authority2, workspaceId, profileId, profileRevision, slug: slug2, version: version2, bundleDigest },
-      consumer: { stationId: process.env.HASNA_STATION || stationHostname2(), workspaceDirectory: realpathSync11(options.cwd ?? process.cwd()) }
+      consumer: { stationId: process.env.HASNA_STATION || stationHostname2(), workspaceDirectory: realpathSync13(options.cwd ?? process.cwd()) }
     };
     const grant = await (options.resolveExecutionGrant ?? resolveExecutionGrant)(request2);
     if (!grant || !grantIdentifier(grant.policyRevision) || !grantIdentifier(grant.grantId))
@@ -44691,20 +45503,20 @@ async function executeSelectedLocal(selected, options = {}) {
   }
   if (bindings)
     secretEnv = await resolveSelectedSecrets(bindings, options.createSecretsClient);
-  const result = await subprocess([executable, ...runtimeName === "bun" ? ["--no-env-file"] : [], join36(runDirectory, declaredEntry), ...args], runDirectory, { ...env, ...secretEnv }, input2, timeoutMs);
+  const result = await subprocess([executable, ...runtimeName === "bun" ? ["--no-env-file"] : [], join37(runDirectory, declaredEntry), ...args], runDirectory, { ...env, ...secretEnv }, input2, timeoutMs);
   result.stdout = redactExecutionSecrets(result.stdout, secretEnv);
   result.stderr = redactExecutionSecrets(result.stderr, secretEnv);
   const receipt = {
     selection: selection2,
     target: "local",
     runtime: runtimeName,
-    inputDigest: `sha256:${createHash24("sha256").update(input2).digest("hex")}`,
+    inputDigest: `sha256:${createHash25("sha256").update(input2).digest("hex")}`,
     runDirectory,
     ...executionGrant ? { executionGrant } : {},
     ...bindings ? { secretBinding: { schema: bindings.schema, selection: bindings.selection, consumer: bindings.consumer, secretsAuthority: bindings.secretsAuthority, bindings: bindings.bindings } } : {},
     ...result
   };
-  writeFileSync11(join36(runDirectory, ".execution-receipt.json"), JSON.stringify({ ...receipt, stdout: undefined, stderr: undefined }), { mode: 384 });
+  writeFileSync11(join37(runDirectory, ".execution-receipt.json"), JSON.stringify({ ...receipt, stdout: undefined, stderr: undefined }), { mode: 384 });
   return receipt;
 }
 async function subprocess(command, cwd, env, input2, timeoutMs) {
@@ -44893,8 +45705,8 @@ var init_blog_article = __esm(() => {
 });
 
 // src/mcp/operation-tools.ts
-import { existsSync as existsSync16, readdirSync as readdirSync11, statSync as statSync11 } from "fs";
-import { join as join37 } from "path";
+import { existsSync as existsSync16, readdirSync as readdirSync12, statSync as statSync11 } from "fs";
+import { join as join38 } from "path";
 function registerOperationTools(server) {
   server.registerTool("cloud_skill_eligibility", {
     title: "Cloud Skill Eligibility",
@@ -45370,8 +46182,8 @@ function registerOperationTools(server) {
       let skillCount = 0;
       if (exists) {
         try {
-          skillCount = readdirSync11(agentSkillsPath).filter((f) => {
-            const full = join37(agentSkillsPath, f);
+          skillCount = readdirSync12(agentSkillsPath).filter((f) => {
+            const full = join38(agentSkillsPath, f);
             return !f.startsWith(".") && statSync11(full).isDirectory();
           }).length;
         } catch {}
@@ -45439,14 +46251,14 @@ var init_operation_tools = __esm(() => {
 
 // src/lib/feedback.ts
 import { appendFileSync, existsSync as existsSync17, mkdirSync as mkdirSync14 } from "fs";
-import { dirname as dirname24, join as join38 } from "path";
+import { dirname as dirname25, join as join39 } from "path";
 import { Database } from "bun:sqlite";
 function getFeedbackDbPath() {
-  return join38(getDataDir(), "skills.db");
+  return join39(getDataDir(), "skills.db");
 }
 function getFeedbackDb() {
   const dbPath = getFeedbackDbPath();
-  const dir = dirname24(dbPath);
+  const dir = dirname25(dbPath);
   if (!existsSync17(dir))
     mkdirSync14(dir, { recursive: true });
   const db = new Database(dbPath);
@@ -45474,8 +46286,8 @@ function saveFeedback(input2) {
     throw new Error("Feedback message is required");
   const category = input2.category ?? "general";
   if (isApiMode()) {
-    const path = join38(getDataDir(), "feedback.jsonl");
-    const dir = dirname24(path);
+    const path = join39(getDataDir(), "feedback.jsonl");
+    const dir = dirname25(path);
     if (!existsSync17(dir))
       mkdirSync14(dir, { recursive: true });
     appendFileSync(path, JSON.stringify({ message, category, email: input2.email ?? null, agent: input2.agent ?? null, version: input2.version ?? null, createdAt: new Date().toISOString() }) + `
@@ -45639,9 +46451,9 @@ var init_resource_meta_tools = __esm(() => {
 
 // src/lib/scheduler.ts
 import { existsSync as existsSync18, readFileSync as readFileSync22, writeFileSync as writeFileSync12, mkdirSync as mkdirSync15 } from "fs";
-import { join as join39 } from "path";
+import { join as join40 } from "path";
 function getSchedulesPath(targetDir = process.cwd()) {
-  return join39(targetDir, ".skills", "schedules.json");
+  return join40(targetDir, ".skills", "schedules.json");
 }
 function loadSchedules(targetDir = process.cwd()) {
   const path = getSchedulesPath(targetDir);
@@ -45654,7 +46466,7 @@ function loadSchedules(targetDir = process.cwd()) {
 }
 function saveSchedules(data, targetDir = process.cwd()) {
   const path = getSchedulesPath(targetDir);
-  const dir = join39(targetDir, ".skills");
+  const dir = join40(targetDir, ".skills");
   if (!existsSync18(dir))
     mkdirSync15(dir, { recursive: true });
   writeFileSync12(path, JSON.stringify(data, null, 2));
@@ -45926,16 +46738,16 @@ var init_schedule_tools = __esm(() => {
 });
 
 // src/lib/native-storage.ts
-import { createHash as createHash25, createHmac } from "crypto";
+import { createHash as createHash26, createHmac } from "crypto";
 import {
   existsSync as existsSync19,
   mkdirSync as mkdirSync16,
   readFileSync as readFileSync23,
-  readdirSync as readdirSync12,
+  readdirSync as readdirSync13,
   statSync as statSync12,
   writeFileSync as writeFileSync13
 } from "fs";
-import { dirname as dirname25, join as join40, normalize as normalize5, relative as relative8, sep as sep11 } from "path";
+import { dirname as dirname26, join as join41, normalize as normalize5, relative as relative10, sep as sep12 } from "path";
 function resolveSkillsNativeStorageConfig(env = process.env) {
   assertNoRetiredModeEnvVars(env, {
     app: SKILLS_ENV_NAMESPACE,
@@ -45976,7 +46788,7 @@ function getSkillsNativeStorageStatus(options = {}) {
     local: {
       dataDir: getDataDir(),
       projectStateDir: getProjectStateDir(targetDir),
-      feedbackDbPath: join40(getDataDir(), "skills.db")
+      feedbackDbPath: join41(getDataDir(), "skills.db")
     },
     remote: {
       databaseConfigured: Boolean(config2.databaseUrl),
@@ -45999,11 +46811,11 @@ function exportSkillsLocalSnapshot(targetDir = process.cwd(), options = {}) {
   if (existsSync19(projectStateDir)) {
     for (const filePath of walkFiles2(projectStateDir)) {
       const bytes = readFileSync23(filePath);
-      const relativePath = toPosix(relative8(targetDir, filePath));
+      const relativePath = toPosix(relative10(targetDir, filePath));
       files.push({
         path: relativePath,
         sizeBytes: bytes.byteLength,
-        sha256: createHash25("sha256").update(bytes).digest("hex"),
+        sha256: createHash26("sha256").update(bytes).digest("hex"),
         ...options.includeFileContents ? { contentBase64: Buffer.from(bytes).toString("base64") } : {}
       });
     }
@@ -46056,8 +46868,8 @@ function parsePositiveInteger(value) {
 }
 function walkFiles2(dir) {
   const files = [];
-  for (const entry of readdirSync12(dir)) {
-    const full = join40(dir, entry);
+  for (const entry of readdirSync13(dir)) {
+    const full = join41(dir, entry);
     const stats = statSync12(full);
     if (stats.isDirectory())
       files.push(...walkFiles2(full));
@@ -46295,73 +47107,73 @@ var init_private_publication_customer = __esm(() => {
 });
 
 // src/lib/private-publication-recovery.ts
-import { constants as constants17, closeSync as closeSync20, fsyncSync as fsyncSync6, fstatSync as fstatSync20, lstatSync as lstatSync24, mkdirSync as mkdirSync17, openSync as openSync20, readSync as readSync13, realpathSync as realpathSync12, renameSync as renameSync7, unlinkSync as unlinkSync6, writeFileSync as writeFileSync14 } from "fs";
-import { dirname as dirname26, isAbsolute as isAbsolute23, join as join41, resolve as resolve24 } from "path";
+import { constants as constants18, closeSync as closeSync21, fsyncSync as fsyncSync6, fstatSync as fstatSync21, lstatSync as lstatSync25, mkdirSync as mkdirSync17, openSync as openSync21, readSync as readSync14, realpathSync as realpathSync14, renameSync as renameSync7, unlinkSync as unlinkSync6, writeFileSync as writeFileSync14 } from "fs";
+import { dirname as dirname27, isAbsolute as isAbsolute24, join as join42, resolve as resolve25 } from "path";
 import { randomUUID as randomUUID3 } from "crypto";
 function safeDirectory(directory2) {
-  if (!isAbsolute23(directory2) || directory2 !== resolve24(directory2) || realpathSync12(directory2) !== directory2)
+  if (!isAbsolute24(directory2) || directory2 !== resolve25(directory2) || realpathSync14(directory2) !== directory2)
     return fail2();
-  for (let path = directory2;; path = dirname26(path)) {
-    const stat3 = lstatSync24(path);
+  for (let path = directory2;; path = dirname27(path)) {
+    const stat3 = lstatSync25(path);
     if (!stat3.isDirectory() || stat3.isSymbolicLink())
       return fail2();
-    if (path === dirname26(path))
+    if (path === dirname27(path))
       break;
   }
-  const own2 = lstatSync24(directory2);
+  const own2 = lstatSync25(directory2);
   if ((own2.mode & 63) !== 0 || process.getuid && own2.uid !== process.getuid())
     return fail2();
   return { dev: own2.dev, ino: own2.ino };
 }
-function unchangedDirectory(directory2, identity3) {
+function unchangedDirectory(directory2, identity4) {
   const now = safeDirectory(directory2);
-  if (now.dev !== identity3.dev || now.ino !== identity3.ino)
+  if (now.dev !== identity4.dev || now.ino !== identity4.ino)
     return fail2();
 }
 function readOwned(directory2, name, max) {
-  const identity3 = safeDirectory(directory2), file2 = join41(directory2, name);
-  const fd = openSync20(file2, constants17.O_RDONLY | constants17.O_NOFOLLOW);
+  const identity4 = safeDirectory(directory2), file2 = join42(directory2, name);
+  const fd = openSync21(file2, constants18.O_RDONLY | constants18.O_NOFOLLOW);
   try {
-    const stat3 = fstatSync20(fd);
+    const stat3 = fstatSync21(fd);
     if (!stat3.isFile() || stat3.nlink !== 1 || stat3.size > max || stat3.size < 1 || (stat3.mode & 63) !== 0 || process.getuid && stat3.uid !== process.getuid())
       return fail2();
     const buffer = Buffer.alloc(Math.min(max, stat3.size) + 1);
     let length = 0;
     while (length < buffer.length) {
-      const count = readSync13(fd, buffer, length, buffer.length - length, length);
+      const count = readSync14(fd, buffer, length, buffer.length - length, length);
       if (count === 0)
         break;
       length += count;
     }
-    const bytes = buffer.subarray(0, length), after = fstatSync20(fd);
-    unchangedDirectory(directory2, identity3);
+    const bytes = buffer.subarray(0, length), after = fstatSync21(fd);
+    unchangedDirectory(directory2, identity4);
     if (bytes.length !== stat3.size || stat3.size !== after.size || stat3.mtimeMs !== after.mtimeMs || stat3.ctimeMs !== after.ctimeMs)
       return fail2();
     return bytes;
   } finally {
-    closeSync20(fd);
+    closeSync21(fd);
   }
 }
 function writeOwned(directory2, name, bytes) {
-  const fd = openSync20(join41(directory2, name), constants17.O_WRONLY | constants17.O_CREAT | constants17.O_EXCL | constants17.O_NOFOLLOW, 384);
+  const fd = openSync21(join42(directory2, name), constants18.O_WRONLY | constants18.O_CREAT | constants18.O_EXCL | constants18.O_NOFOLLOW, 384);
   try {
     writeFileSync14(fd, bytes);
     fsyncSync6(fd);
   } finally {
-    closeSync20(fd);
+    closeSync21(fd);
   }
 }
 function save(directory2, value) {
-  const identity3 = safeDirectory(directory2), temporary = `.receipt-${randomUUID3()}.json`;
+  const identity4 = safeDirectory(directory2), temporary = `.receipt-${randomUUID3()}.json`;
   writeOwned(directory2, temporary, JSON.stringify(value) + `
 `);
-  unchangedDirectory(directory2, identity3);
-  renameSync7(join41(directory2, temporary), join41(directory2, "receipt.json"));
-  const fd = openSync20(directory2, constants17.O_RDONLY | constants17.O_NOFOLLOW);
+  unchangedDirectory(directory2, identity4);
+  renameSync7(join42(directory2, temporary), join42(directory2, "receipt.json"));
+  const fd = openSync21(directory2, constants18.O_RDONLY | constants18.O_NOFOLLOW);
   try {
     fsyncSync6(fd);
   } finally {
-    closeSync20(fd);
+    closeSync21(fd);
   }
 }
 function bind(client, receipt) {
@@ -46369,23 +47181,23 @@ function bind(client, receipt) {
     throw new PrivatePublicationError("PUBLICATION_IDENTITY_CHANGED", "The fresh session does not match the recovery directory's server, account and membership.");
 }
 async function locked(directory2, action) {
-  const identity3 = safeDirectory(directory2), file2 = join41(directory2, "operation.lock");
+  const identity4 = safeDirectory(directory2), file2 = join42(directory2, "operation.lock");
   let fd;
   try {
-    fd = openSync20(file2, constants17.O_WRONLY | constants17.O_CREAT | constants17.O_EXCL | constants17.O_NOFOLLOW, 384);
+    fd = openSync21(file2, constants18.O_WRONLY | constants18.O_CREAT | constants18.O_EXCL | constants18.O_NOFOLLOW, 384);
   } catch {
     throw new PrivatePublicationError("PUBLICATION_RECOVERY_BUSY", "Another operation holds this recovery directory. If it crashed, confirm that process has stopped before explicitly removing operation.lock and resuming.");
   }
-  const lock = fstatSync20(fd);
+  const lock = fstatSync21(fd);
   try {
     writeFileSync14(fd, JSON.stringify({ pid: process.pid }) + `
 `);
     fsyncSync6(fd);
     return await action();
   } finally {
-    closeSync20(fd);
-    unchangedDirectory(directory2, identity3);
-    const now = lstatSync24(file2);
+    closeSync21(fd);
+    unchangedDirectory(directory2, identity4);
+    const now = lstatSync25(file2);
     if (now.dev !== lock.dev || now.ino !== lock.ino || !now.isFile() || now.isSymbolicLink())
       fail2();
     unlinkSync6(file2);
@@ -46437,15 +47249,15 @@ async function preparePrivatePublication(client, sourceDirectory, recoveryDirect
     phase: "prepared",
     intent: null
   };
-  if (!isAbsolute23(recoveryDirectory) || resolve24(recoveryDirectory) !== recoveryDirectory || realpathSync12(dirname26(recoveryDirectory)) !== dirname26(recoveryDirectory))
+  if (!isAbsolute24(recoveryDirectory) || resolve25(recoveryDirectory) !== recoveryDirectory || realpathSync14(dirname27(recoveryDirectory)) !== dirname27(recoveryDirectory))
     return fail2();
   mkdirSync17(recoveryDirectory, { mode: 448 });
   safeDirectory(recoveryDirectory);
-  const parent = openSync20(dirname26(recoveryDirectory), constants17.O_RDONLY | constants17.O_NOFOLLOW);
+  const parent = openSync21(dirname27(recoveryDirectory), constants18.O_RDONLY | constants18.O_NOFOLLOW);
   try {
     fsyncSync6(parent);
   } finally {
-    closeSync20(parent);
+    closeSync21(parent);
   }
   writeOwned(recoveryDirectory, "bundle.tgz", packed.bytes);
   save(recoveryDirectory, receipt);
@@ -46538,10 +47350,10 @@ var init_private_publication_recovery = __esm(() => {
 });
 
 // src/mcp/private-publication-tools.ts
-import { isAbsolute as isAbsolute24 } from "path";
+import { isAbsolute as isAbsolute25 } from "path";
 function registerPrivatePublicationTools(server) {
   const uuid9 = exports_external.string().regex(/^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/);
-  const directory2 = exports_external.string().max(4096).refine(isAbsolute24, "Use an absolute local directory");
+  const directory2 = exports_external.string().max(4096).refine(isAbsolute25, "Use an absolute local directory");
   const verification2 = { email: exports_external.string().email().max(254), code: exports_external.string().regex(/^\d{6}$/), userId: uuid9, membershipId: uuid9, recoveryDirectory: directory2 };
   const description = "Manage a private source publication using fresh workspace-bound verification and a host-local recovery directory. Publishing requires explicit UUID current-version comparison and upload consent. Resume reuses immutable saved bytes and intent; an uncertain PUT is finalized for server verification, never uploaded twice. Sessions and signed URLs are not returned or persisted. Private execution is unavailable. Host request history may contain the supplied verification code.";
   const handler = (action) => async (value) => {
@@ -46974,19 +47786,19 @@ async function connectMcpForNode() {
   return { server: server2, transport };
 }
 function readBody(req) {
-  return new Promise((resolve25, reject) => {
+  return new Promise((resolve26, reject) => {
     const chunks = [];
     req.on("data", (chunk) => chunks.push(Buffer.from(chunk)));
     req.on("end", () => {
       const raw = Buffer.concat(chunks).toString("utf-8");
       if (!raw.trim()) {
-        resolve25(undefined);
+        resolve26(undefined);
         return;
       }
       try {
-        resolve25(JSON.parse(raw));
+        resolve26(JSON.parse(raw));
       } catch {
-        resolve25(undefined);
+        resolve26(undefined);
       }
     });
     req.on("error", reject);
@@ -47028,9 +47840,9 @@ async function startSkillsMcpHttpServer(options = {}) {
       }
     }
   });
-  await new Promise((resolve25, reject) => {
+  await new Promise((resolve26, reject) => {
     httpServer.once("error", reject);
-    httpServer.listen(port, hostname4, () => resolve25());
+    httpServer.listen(port, hostname4, () => resolve26());
   });
   const address = httpServer.address();
   const listenPort = typeof address === "object" && address ? address.port : port;