@hasna/skills 0.10.45 → 0.10.47

package/bin/mcp.js

@@ -20019,7 +20019,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@hasna/skills",
-    version: "0.10.45",
+    version: "0.10.47",
     description: "Skills library for AI coding agents",
     type: "module",
     bin: {
@@ -38209,8 +38209,323 @@ var init_agent_adapters = __esm(() => {
   INTEGRATION_AGENTS = ["claude", "codex", "gemini", "opencode", "cursor", "hermes", "sumi"];
 });
 
+// src/lib/claude-settings-witness.ts
+import { createHash as createHash2 } from "crypto";
+import { closeSync as closeSync5, constants as constants2, fstatSync as fstatSync5, lstatSync as lstatSync5, openSync as openSync5, readSync as readSync2 } from "fs";
+import { basename as basename3, dirname as dirname4, isAbsolute as isAbsolute3, resolve as resolve2 } from "path";
+function need(value, reason) {
+  if (!value)
+    throw new Error(`Claude settings witness ${reason}`);
+}
+function absolutePath(value) {
+  need(typeof value === "string" && value.length > 0 && value.length <= CLAUDE_SETTINGS_WITNESS_LIMITS.pathCharacters && !/[\x00-\x1f\x7f]/.test(value) && isAbsolute3(value) && resolve2(value) === value, "requires a normalized absolute path");
+}
+function parents(path) {
+  const result = [];
+  for (let at = dirname4(path);; at = dirname4(at)) {
+    const stat = lstatSync5(at, { bigint: true });
+    need(stat.isDirectory() && !stat.isSymbolicLink(), "path traverses a symlink or non-directory");
+    result.push([at, stat]);
+    if (at === dirname4(at))
+      return result;
+  }
+}
+function readNativeSettingsWitnessFile(path, budget, filename = "settings.json") {
+  absolutePath(path);
+  need(basename3(path) === filename, `requires ${filename}`);
+  need(Number.isSafeInteger(budget.remaining) && budget.remaining >= 0, "has an invalid byte budget");
+  const ancestors = parents(path), initial = lstatSync5(path, { bigint: true });
+  need(initial.isFile() && !initial.isSymbolicLink() && initial.size <= BigInt(CLAUDE_SETTINGS_WITNESS_LIMITS.bytes), "is not a bounded regular file");
+  need(initial.size <= BigInt(budget.remaining), "exceeds its aggregate byte limit");
+  const fd = openSync5(path, constants2.O_RDONLY | constants2.O_NOFOLLOW | constants2.O_NONBLOCK);
+  try {
+    const opened = fstatSync5(fd, { bigint: true });
+    need(opened.isFile() && sameFile(initial, opened), "changed during open");
+    const bytes = Buffer.alloc(Number(opened.size) + 1);
+    let length = 0;
+    while (length < bytes.length) {
+      const count = readSync2(fd, bytes, length, bytes.length - length, null);
+      if (!count)
+        break;
+      length += count;
+    }
+    const after = fstatSync5(fd, { bigint: true }), current = lstatSync5(path, { bigint: true });
+    need(current.isFile() && sameFile(opened, after) && sameFile(after, current) && BigInt(length) === opened.size, "changed during read");
+    for (const [ancestor, before] of ancestors) {
+      const now = lstatSync5(ancestor, { bigint: true });
+      need(now.isDirectory() && before.dev === now.dev && before.ino === now.ino && before.mode === now.mode, "parent changed during read");
+    }
+    budget.remaining -= length;
+    try {
+      return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes.subarray(0, length));
+    } catch {
+      throw new Error("Claude settings witness is not strict UTF-8");
+    }
+  } finally {
+    closeSync5(fd);
+  }
+}
+function parse6(text) {
+  let at = 0, nodes = 0;
+  const numberPattern = /-?(?:0|[1-9][0-9]*)(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?/y;
+  const space = () => {
+    while (at < text.length && /[\x20\t\r\n]/.test(text[at]))
+      at++;
+  };
+  function string5() {
+    need(text[at] === '"', "contains invalid JSON");
+    const start = at++;
+    while (at < text.length) {
+      const character = text[at++];
+      if (character === '"') {
+        let value2;
+        try {
+          value2 = JSON.parse(text.slice(start, at));
+        } catch {
+          throw new Error("Claude settings witness contains invalid JSON string");
+        }
+        need(value2.length <= CLAUDE_SETTINGS_WITNESS_LIMITS.stringCharacters, "exceeds its string limit");
+        return value2;
+      }
+      if (character === "\\")
+        at++;
+    }
+    throw new Error("Claude settings witness contains an unterminated JSON string");
+  }
+  function value(depth) {
+    need(depth <= CLAUDE_SETTINGS_WITNESS_LIMITS.depth && ++nodes <= CLAUDE_SETTINGS_WITNESS_LIMITS.nodes, "exceeds its nesting or node limit");
+    space();
+    const character = text[at];
+    if (character === '"')
+      return { kind: "string", value: string5() };
+    if (character === "{" || character === "[") {
+      at++;
+      space();
+      const object4 = character === "{", end = object4 ? "}" : "]", entries = [], items = [], keys = new Set;
+      if (text[at] !== end)
+        while (true) {
+          if (object4) {
+            space();
+            const key = string5();
+            need(!keys.has(key), "contains a duplicate JSON key");
+            keys.add(key);
+            space();
+            need(text[at++] === ":", "contains invalid JSON");
+            entries.push([key, value(depth + 1)]);
+          } else
+            items.push(value(depth + 1));
+          space();
+          if (text[at] === end)
+            break;
+          need(text[at++] === ",", "contains invalid JSON");
+        }
+      at++;
+      return object4 ? { kind: "object", entries } : { kind: "array", items };
+    }
+    for (const literal3 of ["true", "false", "null"])
+      if (text.startsWith(literal3, at)) {
+        at += literal3.length;
+        return { kind: "literal", value: literal3 };
+      }
+    numberPattern.lastIndex = at;
+    const number5 = numberPattern.exec(text);
+    need(number5, "contains invalid JSON");
+    at += number5[0].length;
+    return { kind: "number", value: number5[0] };
+  }
+  const root = value(0);
+  space();
+  need(at === text.length && root.kind === "object", "requires a JSON object without trailing content");
+  need(root.entries.length <= CLAUDE_SETTINGS_WITNESS_LIMITS.rows, "exceeds its settings field limit");
+  return root;
+}
+function canonical(value) {
+  if (value.kind === "object")
+    return { kind: "object", entries: value.entries.map(([key, child]) => [key, canonical(child)]).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0) };
+  if (value.kind === "array")
+    return { kind: "array", items: value.items.map(canonical) };
+  return value;
+}
+function inferencePreference(key, child, version2) {
+  if (key === "skipDangerousModePermissionPrompt") {
+    need(child.kind === "literal" && (child.value === "true" || child.value === "false"), "contains an invalid dialog acknowledgment");
+    return false;
+  }
+  if (key === "effortLevel") {
+    need(child.kind === "string" && PERSISTED_EFFORT_LEVELS.has(child.value), "contains an invalid persisted effort level");
+    return true;
+  }
+  if (key !== "modelSettings")
+    return false;
+  need(child.kind === "object", "requires an object of model preferences");
+  child.entries = child.entries.filter(([model, preferences]) => {
+    if (version2 === 2 && !BUILTIN_MODEL_SELECTIONS.has(model) || preferences.kind !== "object" || preferences.entries.length !== 1 || preferences.entries[0][0] !== "effortLevel")
+      return true;
+    const effort = preferences.entries[0][1];
+    need(effort.kind === "string" && PERSISTED_EFFORT_LEVELS.has(effort.value), "contains an invalid persisted model effort level");
+    return false;
+  });
+  return child.entries.length === 0;
+}
+function settingsDigest(text, version2 = 1) {
+  const value = parse6(text);
+  value.entries = value.entries.filter(([key, child]) => {
+    if (version2 !== 1 && inferencePreference(key, child, version2))
+      return false;
+    if (key === "model") {
+      need(child.kind === "string", "contains an invalid model selection");
+      return !BUILTIN_MODEL_SELECTIONS.has(child.value);
+    }
+    if (BOOLEAN_PREFERENCES.has(key)) {
+      need(child.kind === "literal" && (child.value === "true" || child.value === "false"), "contains an invalid display preference");
+      return false;
+    }
+    if (Object.hasOwn(ENUM_PREFERENCES, key)) {
+      need(child.kind === "string" && ENUM_PREFERENCES[key].includes(child.value), "contains an invalid display preference");
+      return false;
+    }
+    return true;
+  });
+  return createHash2("sha256").update(`hasna.skills.claude-settings.v${version2}\x00`).update(JSON.stringify(canonical(value))).digest("hex");
+}
+function hashClaudeSettingsReplacement(text, budget) {
+  need(typeof text === "string", "requires settings text");
+  const bytes = Buffer.byteLength(text);
+  need(bytes <= CLAUDE_SETTINGS_WITNESS_LIMITS.bytes && Number.isSafeInteger(budget.remaining) && budget.remaining >= bytes, "exceeds its byte limit");
+  budget.remaining -= bytes;
+  return settingsDigest(text);
+}
+function captureClaudeSettings(path, budget = { remaining: 256 * 1024 * 1024 }) {
+  return { path, hashMode: "claude-settings-v1", sha256: settingsDigest(readNativeSettingsWitnessFile(path, budget)) };
+}
+function captureClaudeSettingsV2(path, budget = { remaining: 256 * 1024 * 1024 }) {
+  return { path, hashMode: "claude-settings-v2", sha256: settingsDigest(readNativeSettingsWitnessFile(path, budget), 2) };
+}
+function hashClaudeSettingsReplacementV2(text, budget) {
+  need(typeof text === "string", "requires settings text");
+  const bytes = Buffer.byteLength(text);
+  need(bytes <= CLAUDE_SETTINGS_WITNESS_LIMITS.bytes && Number.isSafeInteger(budget.remaining) && budget.remaining >= bytes, "exceeds its byte limit");
+  budget.remaining -= bytes;
+  return settingsDigest(text, 2);
+}
+function captureClaudeSettingsV3(path, budget = { remaining: 256 * 1024 * 1024 }) {
+  return { path, hashMode: "claude-settings-v3", sha256: settingsDigest(readNativeSettingsWitnessFile(path, budget), 3) };
+}
+function hashClaudeSettingsReplacementV3(text, budget) {
+  need(typeof text === "string", "requires settings text");
+  const bytes = Buffer.byteLength(text);
+  need(bytes <= CLAUDE_SETTINGS_WITNESS_LIMITS.bytes && Number.isSafeInteger(budget.remaining) && budget.remaining >= bytes, "exceeds its byte limit");
+  budget.remaining -= bytes;
+  return settingsDigest(text, 3);
+}
+function hashNativeJsonControls(text, excludedMetadata) {
+  need(Buffer.byteLength(text) <= CLAUDE_SETTINGS_WITNESS_LIMITS.bytes, "exceeds its byte limit");
+  const value = parse6(text);
+  value.entries = value.entries.filter(([key, child]) => {
+    if (key !== excludedMetadata)
+      return true;
+    need(child.kind === "string" && child.value.length <= 128, "has invalid version metadata");
+    return false;
+  });
+  return createHash2("sha256").update("hasna.skills.native-json-controls.v1\x00").update(JSON.stringify(canonical(value))).digest("hex");
+}
+function hashSumiNativeJsonControls(text) {
+  need(Buffer.byteLength(text) <= CLAUDE_SETTINGS_WITNESS_LIMITS.bytes, "exceeds its byte limit");
+  const value = parse6(text);
+  value.entries = value.entries.filter(([key, child]) => {
+    if (key === "$schema" || key === "username") {
+      need(child.kind === "string", "has invalid Sumi display metadata");
+      return false;
+    }
+    if (key !== "experimental")
+      return true;
+    need(child.kind === "object", "requires Sumi experimental controls to be an object");
+    child.entries = child.entries.filter(([name, option]) => {
+      if (name !== "statusline" && name !== "compact_tools")
+        return true;
+      need(option.kind === "literal" && (option.value === "true" || option.value === "false"), "has invalid Sumi display preference");
+      return false;
+    });
+    return child.entries.length > 0;
+  });
+  return createHash2("sha256").update("hasna.skills.sumi-settings.v1\x00").update(JSON.stringify(value)).digest("hex");
+}
+var CLAUDE_SETTINGS_WITNESS_LIMITS, sameFile = (a, b) => a.dev === b.dev && a.ino === b.ino && a.mode === b.mode && a.uid === b.uid && a.gid === b.gid && a.nlink === b.nlink && a.size === b.size && a.mtimeNs === b.mtimeNs && a.ctimeNs === b.ctimeNs, BOOLEAN_PREFERENCES, ENUM_PREFERENCES, BUILTIN_MODEL_SELECTIONS, PERSISTED_EFFORT_LEVELS;
+var init_claude_settings_witness = __esm(() => {
+  CLAUDE_SETTINGS_WITNESS_LIMITS = Object.freeze({ bytes: 1024 * 1024, rows: 1024, depth: 32, nodes: 65536, stringCharacters: 16384, pathCharacters: 4096 });
+  BOOLEAN_PREFERENCES = new Set([
+    "autoScrollEnabled",
+    "axScreenReader",
+    "emojiCompletionEnabled",
+    "prefersReducedMotion",
+    "showTurnDuration",
+    "spinnerTipsEnabled",
+    "syntaxHighlightingDisabled",
+    "terminalProgressBarEnabled",
+    "terminalTitleFromRename",
+    "verbose",
+    "wheelScrollAccelerationEnabled"
+  ]);
+  ENUM_PREFERENCES = Object.freeze({
+    editorMode: ["normal", "vim"],
+    tui: ["default", "fullscreen"],
+    viewMode: ["default", "verbose", "focus"]
+  });
+  BUILTIN_MODEL_SELECTIONS = new Set([
+    "default",
+    "best",
+    "fable",
+    "fable[1m]",
+    "sonnet",
+    "sonnet[1m]",
+    "opus",
+    "opus[1m]",
+    "haiku",
+    "opusplan",
+    "claude-fable-5-1",
+    "claude-fable-5",
+    "claude-fable-5[1m]",
+    "claude-opus-5",
+    "claude-sonnet-5",
+    "claude-haiku-4-5-20251001",
+    "claude-opus-4-6",
+    "claude-sonnet-4-5",
+    "claude-sonnet-4-5-20250929",
+    "claude-opus-4-8",
+    "claude-opus-4-8[1m]",
+    "claude-opus-4-7",
+    "claude-sonnet-4-6",
+    "claude-opus-4-5-20251101",
+    "claude-opus-4-5",
+    "claude-haiku-4-5",
+    "claude-fable-5-1[1m]",
+    "claude-opus-5[1m]",
+    "claude-opus-4-7[1m]",
+    "claude-opus-4-6[1m]",
+    "claude-sonnet-4-6[1m]"
+  ]);
+  PERSISTED_EFFORT_LEVELS = new Set(["low", "medium", "high", "xhigh"]);
+});
+
+// src/lib/sumi-settings-witness.ts
+function hashSumiSettingsReplacement(text, limits) {
+  const bytes = Buffer.byteLength(text);
+  if (bytes > CLAUDE_SETTINGS_WITNESS_LIMITS.bytes || !Number.isSafeInteger(limits.remaining) || limits.remaining < bytes)
+    throw new Error("Sumi settings witness exceeds its byte limit");
+  limits.remaining -= bytes;
+  return hashSumiNativeJsonControls(text);
+}
+function captureSumiSettings(path, limits = budget()) {
+  return { path, hashMode: "sumi-settings-v1", sha256: hashSumiNativeJsonControls(readNativeSettingsWitnessFile(path, limits, "sumi.json")) };
+}
+var SUMI_DISCOVERY_PROJECTION_FIELDS, budget = () => ({ remaining: 256 * 1024 * 1024 });
+var init_sumi_settings_witness = __esm(() => {
+  init_claude_settings_witness();
+  SUMI_DISCOVERY_PROJECTION_FIELDS = ["skills", "plugin", "plugins", "permissions"];
+});
+
 // src/lib/agent-policy-limits.ts
-import { basename as basename3, isAbsolute as isAbsolute3, resolve as resolve2 } from "path";
+import { basename as basename4, isAbsolute as isAbsolute4, join as join10, resolve as resolve3, sep as sep3 } from "path";
 function object4(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
@@ -38263,7 +38578,7 @@ function assertAgentPolicyCollections(policy) {
       text(control.pluginId, 1024);
       text(control.namespace, 64);
       text(control.pluginParent);
-      requireBound(isAbsolute3(control.pluginParent) && resolve2(control.pluginParent) === control.pluginParent && /^[a-f0-9]{64}$/.test(control.manifestSha256));
+      requireBound(isAbsolute4(control.pluginParent) && resolve3(control.pluginParent) === control.pluginParent && /^[a-f0-9]{64}$/.test(control.manifestSha256));
       if (control.remotePluginId !== undefined)
         requireBound(typeof control.remotePluginId === "string" && /^[A-Za-z0-9_~-]{1,1024}$/.test(control.remotePluginId));
       if (control.skillsOnly !== undefined)
@@ -38281,7 +38596,7 @@ function assertAgentPolicyCollections(policy) {
       text(control.pluginId, 1024);
       text(control.namespace, 64);
       text(control.pluginParent);
-      requireBound(!ids.has(control.pluginId) && isAbsolute3(control.pluginParent) && resolve2(control.pluginParent) === control.pluginParent && ["local", "git", "npm"].includes(control.sourceType) && typeof control.sourceSha256 === "string" && /^[a-f0-9]{64}$/.test(control.sourceSha256));
+      requireBound(!ids.has(control.pluginId) && isAbsolute4(control.pluginParent) && resolve3(control.pluginParent) === control.pluginParent && ["local", "git", "npm"].includes(control.sourceType) && typeof control.sourceSha256 === "string" && /^[a-f0-9]{64}$/.test(control.sourceSha256));
       ids.add(control.pluginId);
     }
   }
@@ -38306,15 +38621,15 @@ function assertAgentPolicyCollections(policy) {
     requireBound(object4(value));
     text(value.agent, 128);
     if (value.codexRetiredMaterializations !== undefined) {
-      const proof = record3(value.codexRetiredMaterializations, 3), roots = array3(proof.roots, AGENT_POLICY_LIMITS.discoveryRoots), parents = proof.parents === undefined ? [] : array3(proof.parents, AGENT_POLICY_LIMITS.discoveryRoots);
-      requireBound(agent === "codex" && value.agent === "codex" && value.method === "reviewed" && Object.keys(proof).every((key) => ["roots", "parents", "directories"].includes(key)) && roots.length + parents.length > 0 && new Set(roots).size === roots.length && new Set(parents).size === parents.length);
+      const proof = record3(value.codexRetiredMaterializations, 3), roots = array3(proof.roots, AGENT_POLICY_LIMITS.discoveryRoots), parents2 = proof.parents === undefined ? [] : array3(proof.parents, AGENT_POLICY_LIMITS.discoveryRoots);
+      requireBound(agent === "codex" && value.agent === "codex" && value.method === "reviewed" && Object.keys(proof).every((key) => ["roots", "parents", "directories"].includes(key)) && roots.length + parents2.length > 0 && new Set(roots).size === roots.length && new Set(parents2).size === parents2.length);
       for (const root of roots) {
         text(root);
-        requireBound(isAbsolute3(root) && resolve2(root) === root);
+        requireBound(isAbsolute4(root) && resolve3(root) === root);
       }
-      for (const parent of parents) {
+      for (const parent of parents2) {
         text(parent);
-        requireBound(isAbsolute3(parent) && resolve2(parent) === parent);
+        requireBound(isAbsolute4(parent) && resolve3(parent) === parent);
       }
       for (const directory of array3(proof.directories, AGENT_POLICY_LIMITS.discoveryDirectories)) {
         requireBound(object4(directory));
@@ -38334,7 +38649,7 @@ function assertAgentPolicyCollections(policy) {
         text(input2.namespace, 64);
         text(input2.pluginParent);
         text(input2.sourceRoot);
-        requireBound(!ids.has(input2.pluginId) && [input2.pluginParent, input2.sourceRoot].every((path) => isAbsolute3(path) && resolve2(path) === path) && typeof input2.sourceSha256 === "string" && /^[a-f0-9]{64}$/.test(input2.sourceSha256));
+        requireBound(!ids.has(input2.pluginId) && [input2.pluginParent, input2.sourceRoot].every((path) => isAbsolute4(path) && resolve3(path) === path) && typeof input2.sourceSha256 === "string" && /^[a-f0-9]{64}$/.test(input2.sourceSha256));
         ids.add(input2.pluginId);
       }
       if (proof.directories !== undefined)
@@ -38351,13 +38666,17 @@ function assertAgentPolicyCollections(policy) {
       text(source.path);
       requireBound(source.sha256 === null || typeof source.sha256 === "string" && /^[a-f0-9]{64}$/.test(source.sha256));
       if (source.hashMode !== undefined)
-        requireBound(["bytes", "path-bytes", "claude-plugin-registry", "claude-marketplace-registry", "claude-settings-v1", "claude-settings-v2", "claude-settings-v3", "claude-marketplace-registry-v2", "codex-settings-v1", "codex-settings-v2", "codex-settings-v3", "codex-settings-v4"].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-marketplace-registry-v2", "codex-settings-v1", "codex-settings-v2", "codex-settings-v3", "codex-settings-v4", "sumi-settings-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) && isAbsolute4(source.path) && resolve3(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) && isAbsolute4(source.path) && resolve3(source.path) === source.path && basename4(source.path) === "sumi.json");
       if (source.hashMode === "codex-settings-v1" || source.hashMode === "codex-settings-v2" || (source.hashMode === "codex-settings-v3" || source.hashMode === "codex-settings-v4"))
-        requireBound(agent === "codex" && value.agent === "codex" && value.method === "reviewed" && !/[\x00-\x1f\x7f]/.test(source.path) && isAbsolute3(source.path) && resolve2(source.path) === source.path && basename3(source.path) === "config.toml");
+        requireBound(agent === "codex" && value.agent === "codex" && value.method === "reviewed" && !/[\x00-\x1f\x7f]/.test(source.path) && isAbsolute4(source.path) && resolve3(source.path) === source.path && basename4(source.path) === "config.toml");
       if (source.hashMode === "claude-settings-v1" || source.hashMode === "claude-settings-v2" || source.hashMode === "claude-settings-v3")
-        requireBound(agent === "claude" && value.agent === "claude" && value.method === "reviewed" && !/[\x00-\x1f\x7f]/.test(source.path) && isAbsolute3(source.path) && resolve2(source.path) === source.path && basename3(source.path) === "settings.json");
+        requireBound(agent === "claude" && value.agent === "claude" && value.method === "reviewed" && !/[\x00-\x1f\x7f]/.test(source.path) && isAbsolute4(source.path) && resolve3(source.path) === source.path && basename4(source.path) === "settings.json");
       if (source.hashMode === "claude-marketplace-registry" || source.hashMode === "claude-marketplace-registry-v2")
-        requireBound(agent === "claude" && value.agent === "claude" && value.method === "reviewed" && !/[\x00-\x1f\x7f]/.test(source.path) && isAbsolute3(source.path) && resolve2(source.path) === source.path && basename3(source.path) === "known_marketplaces.json");
+        requireBound(agent === "claude" && value.agent === "claude" && value.method === "reviewed" && !/[\x00-\x1f\x7f]/.test(source.path) && isAbsolute4(source.path) && resolve3(source.path) === source.path && basename4(source.path) === "known_marketplaces.json");
       if (source.hashMode === "claude-plugin-registry") {
         requireBound(agent === "claude");
         const managed = array3(source.managedPlugins, 64);
@@ -42069,10 +42388,10 @@ var require_resolve_block_map = __commonJS((exports) => {
     let offset = bm.offset;
     let commentEnd = null;
     for (const collItem of bm.items) {
-      const { start, key, sep: sep3, value } = collItem;
+      const { start, key, sep: sep4, value } = collItem;
       const keyProps = resolveProps.resolveProps(start, {
         indicator: "explicit-key-ind",
-        next: key ?? sep3?.[0],
+        next: key ?? sep4?.[0],
         offset,
         onError,
         parentIndent: bm.indent,
@@ -42086,7 +42405,7 @@ var require_resolve_block_map = __commonJS((exports) => {
           else if ("indent" in key && key.indent !== bm.indent)
             onError(offset, "BAD_INDENT", startColMsg);
         }
-        if (!keyProps.anchor && !keyProps.tag && !sep3) {
+        if (!keyProps.anchor && !keyProps.tag && !sep4) {
           commentEnd = keyProps.end;
           if (keyProps.comment) {
             if (map3.comment)
@@ -42111,7 +42430,7 @@ var require_resolve_block_map = __commonJS((exports) => {
       ctx.atKey = false;
       if (utilMapIncludes.mapIncludes(ctx, map3.items, keyNode))
         onError(keyStart, "DUPLICATE_KEY", "Map keys must be unique");
-      const valueProps = resolveProps.resolveProps(sep3 ?? [], {
+      const valueProps = resolveProps.resolveProps(sep4 ?? [], {
         indicator: "map-value-ind",
         next: value,
         offset: keyNode.range[2],
@@ -42127,7 +42446,7 @@ var require_resolve_block_map = __commonJS((exports) => {
           if (ctx.options.strict && keyProps.start < valueProps.found.offset - 1024)
             onError(keyNode.range, "KEY_OVER_1024_CHARS", "The : indicator must be at most 1024 chars after the start of an implicit block mapping key");
         }
-        const valueNode = value ? composeNode(ctx, value, valueProps, onError) : composeEmptyNode(ctx, offset, sep3, null, valueProps, onError);
+        const valueNode = value ? composeNode(ctx, value, valueProps, onError) : composeEmptyNode(ctx, offset, sep4, null, valueProps, onError);
         if (ctx.schema.compat)
           utilFlowIndentCheck.flowIndentCheck(bm.indent, value, onError);
         offset = valueNode.range[2];
@@ -42213,7 +42532,7 @@ var require_resolve_end = __commonJS((exports) => {
     let comment = "";
     if (end) {
       let hasSpace = false;
-      let sep3 = "";
+      let sep4 = "";
       for (const token of end) {
         const { source, type } = token;
         switch (type) {
@@ -42227,13 +42546,13 @@ var require_resolve_end = __commonJS((exports) => {
             if (!comment)
               comment = cb;
             else
-              comment += sep3 + cb;
-            sep3 = "";
+              comment += sep4 + cb;
+            sep4 = "";
             break;
           }
           case "newline":
             if (comment)
-              sep3 += source;
+              sep4 += source;
             hasSpace = true;
             break;
           default:
@@ -42273,18 +42592,18 @@ var require_resolve_flow_collection = __commonJS((exports) => {
     let offset = fc.offset + fc.start.source.length;
     for (let i = 0;i < fc.items.length; ++i) {
       const collItem = fc.items[i];
-      const { start, key, sep: sep3, value } = collItem;
+      const { start, key, sep: sep4, value } = collItem;
       const props = resolveProps.resolveProps(start, {
         flow: fcName,
         indicator: "explicit-key-ind",
-        next: key ?? sep3?.[0],
+        next: key ?? sep4?.[0],
         offset,
         onError,
         parentIndent: fc.indent,
         startOnNewline: false
       });
       if (!props.found) {
-        if (!props.anchor && !props.tag && !sep3 && !value) {
+        if (!props.anchor && !props.tag && !sep4 && !value) {
           if (i === 0 && props.comma)
             onError(props.comma, "UNEXPECTED_TOKEN", `Unexpected , in ${fcName}`);
           else if (i < fc.items.length - 1)
@@ -42336,8 +42655,8 @@ var require_resolve_flow_collection = __commonJS((exports) => {
           }
         }
       }
-      if (!isMap && !sep3 && !props.found) {
-        const valueNode = value ? composeNode(ctx, value, props, onError) : composeEmptyNode(ctx, props.end, sep3, null, props, onError);
+      if (!isMap && !sep4 && !props.found) {
+        const valueNode = value ? composeNode(ctx, value, props, onError) : composeEmptyNode(ctx, props.end, sep4, null, props, onError);
         coll.items.push(valueNode);
         offset = valueNode.range[2];
         if (isBlock(value))
@@ -42349,7 +42668,7 @@ var require_resolve_flow_collection = __commonJS((exports) => {
         if (isBlock(key))
           onError(keyNode.range, "BLOCK_IN_FLOW", blockMsg);
         ctx.atKey = false;
-        const valueProps = resolveProps.resolveProps(sep3 ?? [], {
+        const valueProps = resolveProps.resolveProps(sep4 ?? [], {
           flow: fcName,
           indicator: "map-value-ind",
           next: value,
@@ -42360,8 +42679,8 @@ var require_resolve_flow_collection = __commonJS((exports) => {
         });
         if (valueProps.found) {
           if (!isMap && !props.found && ctx.options.strict) {
-            if (sep3)
-              for (const st of sep3) {
+            if (sep4)
+              for (const st of sep4) {
                 if (st === valueProps.found)
                   break;
                 if (st.type === "newline") {
@@ -42378,7 +42697,7 @@ var require_resolve_flow_collection = __commonJS((exports) => {
           else
             onError(valueProps.start, "MISSING_CHAR", `Missing , or : between ${fcName} items`);
         }
-        const valueNode = value ? composeNode(ctx, value, valueProps, onError) : valueProps.found ? composeEmptyNode(ctx, valueProps.end, sep3, null, valueProps, onError) : null;
+        const valueNode = value ? composeNode(ctx, value, valueProps, onError) : valueProps.found ? composeEmptyNode(ctx, valueProps.end, sep4, null, valueProps, onError) : null;
         if (valueNode) {
           if (isBlock(value))
             onError(valueNode.range, "BLOCK_IN_FLOW", blockMsg);
@@ -42555,7 +42874,7 @@ var require_resolve_block_scalar = __commonJS((exports) => {
         chompStart = i + 1;
     }
     let value = "";
-    let sep3 = "";
+    let sep4 = "";
     let prevMoreIndented = false;
     for (let i = 0;i < contentStart; ++i)
       value += lines[i][0].slice(trimIndent) + `
@@ -42573,33 +42892,33 @@ var require_resolve_block_scalar = __commonJS((exports) => {
         indent = "";
       }
       if (type === Scalar.Scalar.BLOCK_LITERAL) {
-        value += sep3 + indent.slice(trimIndent) + content;
-        sep3 = `
+        value += sep4 + indent.slice(trimIndent) + content;
+        sep4 = `
 `;
       } else if (indent.length > trimIndent || content[0] === "\t") {
-        if (sep3 === " ")
-          sep3 = `
+        if (sep4 === " ")
+          sep4 = `
 `;
-        else if (!prevMoreIndented && sep3 === `
+        else if (!prevMoreIndented && sep4 === `
 `)
-          sep3 = `
+          sep4 = `
 
 `;
-        value += sep3 + indent.slice(trimIndent) + content;
-        sep3 = `
+        value += sep4 + indent.slice(trimIndent) + content;
+        sep4 = `
 `;
         prevMoreIndented = true;
       } else if (content === "") {
-        if (sep3 === `
+        if (sep4 === `
 `)
           value += `
 `;
         else
-          sep3 = `
+          sep4 = `
 `;
       } else {
-        value += sep3 + content;
-        sep3 = " ";
+        value += sep4 + content;
+        sep4 = " ";
         prevMoreIndented = false;
       }
     }
@@ -42780,27 +43099,27 @@ var require_resolve_flow_scalar = __commonJS((exports) => {
     if (!match)
       return source;
     let res = match[1];
-    let sep3 = " ";
+    let sep4 = " ";
     let pos = first.lastIndex;
     line.lastIndex = pos;
     while (match = line.exec(source)) {
       if (match[1] === "") {
-        if (sep3 === `
+        if (sep4 === `
 `)
-          res += sep3;
+          res += sep4;
         else
-          sep3 = `
+          sep4 = `
 `;
       } else {
-        res += sep3 + match[1];
-        sep3 = " ";
+        res += sep4 + match[1];
+        sep4 = " ";
       }
       pos = line.lastIndex;
     }
     const last = /[ \t]*(.*)/sy;
     last.lastIndex = pos;
     match = last.exec(source);
-    return res + sep3 + (match?.[1] ?? "");
+    return res + sep4 + (match?.[1] ?? "");
   }
   function doubleQuotedValue(source, onError) {
     let res = "";
@@ -43581,14 +43900,14 @@ var require_cst_stringify = __commonJS((exports) => {
       }
     }
   }
-  function stringifyItem({ start, key, sep: sep3, value }) {
+  function stringifyItem({ start, key, sep: sep4, value }) {
     let res = "";
     for (const st of start)
       res += st.source;
     if (key)
       res += stringifyToken(key);
-    if (sep3)
-      for (const st of sep3)
+    if (sep4)
+      for (const st of sep4)
         res += st.source;
     if (value)
       res += stringifyToken(value);
@@ -44736,18 +45055,18 @@ var require_parser = __commonJS((exports) => {
       if (this.type === "map-value-ind") {
         const prev = getPrevProps(this.peek(2));
         const start = getFirstKeyStartProps(prev);
-        let sep3;
+        let sep4;
         if (scalar.end) {
-          sep3 = scalar.end;
-          sep3.push(this.sourceToken);
+          sep4 = scalar.end;
+          sep4.push(this.sourceToken);
           delete scalar.end;
         } else
-          sep3 = [this.sourceToken];
+          sep4 = [this.sourceToken];
         const map3 = {
           type: "block-map",
           offset: scalar.offset,
           indent: scalar.indent,
-          items: [{ start, key: scalar, sep: sep3 }]
+          items: [{ start, key: scalar, sep: sep4 }]
         };
         this.onKeyLine = true;
         this.stack[this.stack.length - 1] = map3;
@@ -44901,15 +45220,15 @@ var require_parser = __commonJS((exports) => {
               } else if (isFlowToken(it.key) && !includesToken(it.sep, "newline")) {
                 const start2 = getFirstKeyStartProps(it.start);
                 const key = it.key;
-                const sep3 = it.sep;
-                sep3.push(this.sourceToken);
+                const sep4 = it.sep;
+                sep4.push(this.sourceToken);
                 delete it.key;
                 delete it.sep;
                 this.stack.push({
                   type: "block-map",
                   offset: this.offset,
                   indent: this.indent,
-                  items: [{ start: start2, key, sep: sep3 }]
+                  items: [{ start: start2, key, sep: sep4 }]
                 });
               } else if (start.length > 0) {
                 it.sep = it.sep.concat(start, this.sourceToken);
@@ -45103,13 +45422,13 @@ var require_parser = __commonJS((exports) => {
           const prev = getPrevProps(parent);
           const start = getFirstKeyStartProps(prev);
           fixFlowSeqItems(fc);
-          const sep3 = fc.end.splice(1, fc.end.length);
-          sep3.push(this.sourceToken);
+          const sep4 = fc.end.splice(1, fc.end.length);
+          sep4.push(this.sourceToken);
           const map3 = {
             type: "block-map",
             offset: fc.offset,
             indent: fc.indent,
-            items: [{ start, key: fc, sep: sep3 }]
+            items: [{ start, key: fc, sep: sep4 }]
           };
           this.onKeyLine = true;
           this.stack[this.stack.length - 1] = map3;
@@ -45285,7 +45604,7 @@ var require_public_api = __commonJS((exports) => {
     }
     return doc2;
   }
-  function parse6(src, reviver, options) {
+  function parse7(src, reviver, options) {
     let _reviver = undefined;
     if (typeof reviver === "function") {
       _reviver = reviver;
@@ -45326,7 +45645,7 @@ var require_public_api = __commonJS((exports) => {
       return value.toString(options);
     return new Document.Document(value, _replacer, options).toString(options);
   }
-  exports.parse = parse6;
+  exports.parse = parse7;
   exports.parseAllDocuments = parseAllDocuments;
   exports.parseDocument = parseDocument;
   exports.stringify = stringify;
@@ -45382,7 +45701,7 @@ var init_dist = __esm(() => {
 });
 
 // src/lib/agent-hermes.ts
-import { dirname as dirname4, isAbsolute as isAbsolute4, join as join10, resolve as resolve3 } from "path";
+import { dirname as dirname5, isAbsolute as isAbsolute5, join as join11, resolve as resolve4 } from "path";
 function object5(value) {
   return Boolean(value && typeof value === "object" && (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null));
 }
@@ -45416,7 +45735,7 @@ function assertHermesEnvironment(home) {
       throw new Error(`NATIVE_SKILL_DRIFT: Hermes ${variable} requires a dedicated discovery adapter; unset it before using this adapter`);
   }
   const selected = process.env.HERMES_HOME?.trim();
-  if (selected && (!isAbsolute4(selected) || resolve3(selected) !== join10(resolve3(home), ".hermes")))
+  if (selected && (!isAbsolute5(selected) || resolve4(selected) !== join11(resolve4(home), ".hermes")))
     throw new Error("NATIVE_SKILL_DRIFT: custom Hermes homes/profiles require their own reviewed bridge");
   if (process.env.HERMES_ENABLE_PROJECT_PLUGINS?.trim() && !["0", "false", "no", "off"].includes(process.env.HERMES_ENABLE_PROJECT_PLUGINS.trim().toLowerCase()))
     throw new Error("NATIVE_SKILL_DRIFT: Hermes project plugins require a dedicated discovery review");
@@ -45426,189 +45745,189 @@ var init_agent_hermes = __esm(() => {
 });
 
 // src/lib/agent-discovery-directories.ts
-import { createHash as createHash2 } from "crypto";
-import { lstatSync as lstatSync5, opendirSync } from "fs";
-import { dirname as dirname5, isAbsolute as isAbsolute5, join as join11, resolve as resolve4 } from "path";
-function need(value, message) {
+import { createHash as createHash3 } from "crypto";
+import { lstatSync as lstatSync6, opendirSync } from "fs";
+import { dirname as dirname6, isAbsolute as isAbsolute6, join as join12, resolve as resolve5 } from "path";
+function need2(value, message) {
   if (!value)
     throw new Error(message);
 }
 function safe(path) {
-  need(typeof path === "string" && path.length <= AGENT_POLICY_LIMITS.pathCharacters && isAbsolute5(path) && resolve4(path) === path && !path.includes("\x00"), "Expected a canonical absolute discovery directory path");
-  for (let cursor = path;; cursor = dirname5(cursor)) {
-    need(!lstatSync5(cursor, { throwIfNoEntry: false })?.isSymbolicLink(), "Refusing symlink native discovery directory");
-    if (dirname5(cursor) === cursor)
+  need2(typeof path === "string" && path.length <= AGENT_POLICY_LIMITS.pathCharacters && isAbsolute6(path) && resolve5(path) === path && !path.includes("\x00"), "Expected a canonical absolute discovery directory path");
+  for (let cursor = path;; cursor = dirname6(cursor)) {
+    need2(!lstatSync6(cursor, { throwIfNoEntry: false })?.isSymbolicLink(), "Refusing symlink native discovery directory");
+    if (dirname6(cursor) === cursor)
       break;
   }
 }
 function same(before, after) {
   return Boolean(after && after.isDirectory() && before.dev === after.dev && before.ino === after.ino && before.mtimeMs === after.mtimeMs && before.ctimeMs === after.ctimeMs);
 }
-function capture(path, budget, excludedRoots, omittedRoots = [], rows) {
+function capture(path, budget2, excludedRoots, omittedRoots = [], rows) {
   safe(path);
   if (omittedRoots.some((root2) => path === root2 || path.startsWith(root2 + "/")))
     return { path, sha256: null };
-  const root = lstatSync5(path, { throwIfNoEntry: false });
+  const root = lstatSync6(path, { throwIfNoEntry: false });
   if (!root)
     return { path, sha256: null };
-  need(root.isDirectory(), "Unsupported native discovery directory input");
-  const hash2 = createHash2("sha256");
+  need2(root.isDirectory(), "Unsupported native discovery directory input");
+  const hash2 = createHash3("sha256");
   function walk(current, relative3, before, depth) {
-    need(depth <= 64, "Native discovery directory depth limit exceeded");
+    need2(depth <= 64, "Native discovery directory depth limit exceeded");
     const names = [], directory = opendirSync(current);
     try {
       for (let entry = directory.readSync();entry; entry = directory.readSync()) {
-        need(++budget.entries <= AGENT_POLICY_LIMITS.discoveryDirectoryEntries, "Native discovery directory entry limit exceeded");
+        need2(++budget2.entries <= AGENT_POLICY_LIMITS.discoveryDirectoryEntries, "Native discovery directory entry limit exceeded");
         names.push(entry.name);
       }
     } finally {
       directory.closeSync();
     }
-    need(new Set(names).size === names.length, "Ambiguous native discovery directory names");
+    need2(new Set(names).size === names.length, "Ambiguous native discovery directory names");
     for (const name of names.sort()) {
-      const child = join11(current, name), childRelative = relative3 ? `${relative3}/${name}` : name;
+      const child = join12(current, name), childRelative = relative3 ? `${relative3}/${name}` : name;
       if (omittedRoots.includes(child))
         continue;
-      need(child.length <= AGENT_POLICY_LIMITS.pathCharacters, "Native discovery directory path limit exceeded");
-      const stat = lstatSync5(child);
-      need(stat.isFile() || stat.isDirectory(), "Refusing symlink or special native discovery directory member");
+      need2(child.length <= AGENT_POLICY_LIMITS.pathCharacters, "Native discovery directory path limit exceeded");
+      const stat = lstatSync6(child);
+      need2(stat.isFile() || stat.isDirectory(), "Refusing symlink or special native discovery directory member");
       const row = JSON.stringify([childRelative, stat.isDirectory() ? "directory" : "file"]) + `
 `;
-      budget.bytes += Buffer.byteLength(row);
-      need(budget.bytes <= AGENT_POLICY_LIMITS.discoveryDirectoryBytes, "Native discovery directory metadata limit exceeded");
+      budget2.bytes += Buffer.byteLength(row);
+      need2(budget2.bytes <= AGENT_POLICY_LIMITS.discoveryDirectoryBytes, "Native discovery directory metadata limit exceeded");
       hash2.update(row);
       rows?.push(row);
       if (stat.isDirectory() && !excludedRoots.includes(child))
         walk(child, childRelative, stat, depth + 1);
     }
-    need(same(before, lstatSync5(current, { throwIfNoEntry: false })), "Native discovery directory changed while reading");
+    need2(same(before, lstatSync6(current, { throwIfNoEntry: false })), "Native discovery directory changed while reading");
   }
   walk(path, "", root, 0);
   safe(path);
   return { path, sha256: hash2.digest("hex") };
 }
 function captureDiscoveryDirectoryProjection(paths, omittedRoots) {
-  need(Array.isArray(paths) && paths.length <= AGENT_POLICY_LIMITS.discoveryDirectories && new Set(paths).size === paths.length, "Invalid projected discovery directory collection");
-  need(omittedRoots.length <= AGENT_POLICY_LIMITS.discoveryRoots && new Set(omittedRoots).size === omittedRoots.length, "Invalid inactive discovery roots");
+  need2(Array.isArray(paths) && paths.length <= AGENT_POLICY_LIMITS.discoveryDirectories && new Set(paths).size === paths.length, "Invalid projected discovery directory collection");
+  need2(omittedRoots.length <= AGENT_POLICY_LIMITS.discoveryRoots && new Set(omittedRoots).size === omittedRoots.length, "Invalid inactive discovery roots");
   for (const root of omittedRoots)
     safe(root);
-  const budget = { entries: 0, bytes: 0 };
+  const budget2 = { entries: 0, bytes: 0 };
   return paths.map((path) => {
     const entries = [];
-    return { ...capture(path, budget, [], omittedRoots, entries), entries };
+    return { ...capture(path, budget2, [], omittedRoots, entries), entries };
   });
 }
 function verifyDiscoveryDirectoryProjection(directories, omittedRoots) {
-  need(directories.length <= AGENT_POLICY_LIMITS.discoveryDirectories, "Invalid projected discovery directory collection");
+  need2(directories.length <= AGENT_POLICY_LIMITS.discoveryDirectories, "Invalid projected discovery directory collection");
   let count = 0, bytes = 0;
   const expected = directories.map((directory) => {
     safe(directory.path);
-    need(Array.isArray(directory.entries), "Missing reviewed directory membership inventory");
-    const hash2 = createHash2("sha256");
+    need2(Array.isArray(directory.entries), "Missing reviewed directory membership inventory");
+    const hash2 = createHash3("sha256");
     const kept = [];
     for (const row of directory.entries) {
-      need(typeof row === "string" && ++count <= AGENT_POLICY_LIMITS.discoveryDirectoryEntries, "Invalid reviewed directory membership rows");
+      need2(typeof row === "string" && ++count <= AGENT_POLICY_LIMITS.discoveryDirectoryEntries, "Invalid reviewed directory membership rows");
       bytes += Buffer.byteLength(row);
-      need(bytes <= AGENT_POLICY_LIMITS.discoveryDirectoryBytes, "Reviewed directory membership byte limit exceeded");
+      need2(bytes <= AGENT_POLICY_LIMITS.discoveryDirectoryBytes, "Reviewed directory membership byte limit exceeded");
       const value = JSON.parse(row);
-      need(Array.isArray(value) && value.length === 2 && typeof value[0] === "string" && value[0] && !isAbsolute5(value[0]) && !value[0].split("/").some((part) => !part || part === "." || part === "..") && ["file", "directory"].includes(value[1]) && row === JSON.stringify(value) + `
+      need2(Array.isArray(value) && value.length === 2 && typeof value[0] === "string" && value[0] && !isAbsolute6(value[0]) && !value[0].split("/").some((part) => !part || part === "." || part === "..") && ["file", "directory"].includes(value[1]) && row === JSON.stringify(value) + `
 `, "Invalid reviewed directory member");
       hash2.update(row);
-      const path = join11(directory.path, value[0]);
+      const path = join12(directory.path, value[0]);
       if (!omittedRoots.some((root) => path === root || path.startsWith(root + "/")))
         kept.push(row);
     }
-    need(directory.sha256 === null ? directory.entries.length === 0 : hash2.digest("hex") === directory.sha256, "Reviewed directory inventory does not match its fingerprint");
+    need2(directory.sha256 === null ? directory.entries.length === 0 : hash2.digest("hex") === directory.sha256, "Reviewed directory inventory does not match its fingerprint");
     const absent = omittedRoots.some((root) => directory.path === root || directory.path.startsWith(root + "/"));
-    return { path: directory.path, sha256: absent || directory.sha256 === null ? null : createHash2("sha256").update(kept.join("")).digest("hex") };
+    return { path: directory.path, sha256: absent || directory.sha256 === null ? null : createHash3("sha256").update(kept.join("")).digest("hex") };
   });
   const current = captureDiscoveryDirectoryProjection(directories.map((item) => item.path), omittedRoots);
-  need(current.every((item, index) => item.sha256 === expected[index].sha256), "Native discovery directory membership changed outside retired Codex roots");
+  need2(current.every((item, index) => item.sha256 === expected[index].sha256), "Native discovery directory membership changed outside retired Codex roots");
 }
 function captureDiscoveryDirectories(paths, excludedRoots = []) {
-  need(Array.isArray(paths) && paths.length <= AGENT_POLICY_LIMITS.discoveryDirectories && new Set(paths).size === paths.length, "Invalid native discovery directory collection");
-  const budget = { entries: 0, bytes: 0 };
+  need2(Array.isArray(paths) && paths.length <= AGENT_POLICY_LIMITS.discoveryDirectories && new Set(paths).size === paths.length, "Invalid native discovery directory collection");
+  const budget2 = { entries: 0, bytes: 0 };
   for (const root of excludedRoots)
     safe(root);
-  return paths.map((path) => capture(path, budget, excludedRoots));
+  return paths.map((path) => capture(path, budget2, excludedRoots));
 }
 function verifyDiscoveryDirectories(directories, excludedRoots = []) {
-  need(Array.isArray(directories) && directories.length <= AGENT_POLICY_LIMITS.discoveryDirectories, "Invalid native discovery directory collection");
+  need2(Array.isArray(directories) && directories.length <= AGENT_POLICY_LIMITS.discoveryDirectories, "Invalid native discovery directory collection");
   for (const directory of directories)
-    need(directory && typeof directory === "object" && (directory.sha256 === null || typeof directory.sha256 === "string" && /^[a-f0-9]{64}$/.test(directory.sha256)), "Invalid native discovery directory digest");
+    need2(directory && typeof directory === "object" && (directory.sha256 === null || typeof directory.sha256 === "string" && /^[a-f0-9]{64}$/.test(directory.sha256)), "Invalid native discovery directory digest");
   const current = captureDiscoveryDirectories(directories.map((directory) => directory.path), excludedRoots);
   for (let i = 0;i < directories.length; i++)
-    need(current[i].sha256 === directories[i].sha256, `Native discovery directory membership changed; run skills hook install with a fresh discovery review: ${directories[i].path}`);
+    need2(current[i].sha256 === directories[i].sha256, `Native discovery directory membership changed; run skills hook install with a fresh discovery review: ${directories[i].path}`);
 }
 var init_agent_discovery_directories = __esm(() => {
   init_agent_policy_limits();
 });
 
 // src/lib/agent-discovery-bytes.ts
-import { createHash as createHash3 } from "crypto";
-import { closeSync as closeSync5, constants as constants2, fstatSync as fstatSync5, lstatSync as lstatSync6, openSync as openSync5, readSync as readSync2 } from "fs";
-import { dirname as dirname6, isAbsolute as isAbsolute6, resolve as resolve5 } from "path";
+import { createHash as createHash4 } from "crypto";
+import { closeSync as closeSync6, constants as constants3, fstatSync as fstatSync6, lstatSync as lstatSync7, openSync as openSync6, readSync as readSync3 } from "fs";
+import { dirname as dirname7, isAbsolute as isAbsolute7, resolve as resolve6 } from "path";
 function discoveryByteBudget() {
   return { remaining: AGENT_POLICY_LIMITS.discoveryRawTotalBytes };
 }
 function safe2(path) {
-  if (typeof path !== "string" || !isAbsolute6(path) || path !== resolve5(path) || path.length > AGENT_POLICY_LIMITS.pathCharacters || path.includes("\x00"))
+  if (typeof path !== "string" || !isAbsolute7(path) || path !== resolve6(path) || path.length > AGENT_POLICY_LIMITS.pathCharacters || path.includes("\x00"))
     throw new Error("Expected a canonical absolute raw discovery path");
-  for (let cursor = path;; cursor = dirname6(cursor)) {
-    if (lstatSync6(cursor, { throwIfNoEntry: false })?.isSymbolicLink())
+  for (let cursor = path;; cursor = dirname7(cursor)) {
+    if (lstatSync7(cursor, { throwIfNoEntry: false })?.isSymbolicLink())
       throw new Error("Refusing symlink raw discovery input");
-    if (dirname6(cursor) === cursor)
+    if (dirname7(cursor) === cursor)
       break;
   }
 }
 function same2(left, right) {
   return left.dev === right.dev && left.ino === right.ino && left.size === right.size && left.mtimeMs === right.mtimeMs && left.ctimeMs === right.ctimeMs;
 }
-function consume(budget, bytes) {
-  if (bytes > budget.remaining)
+function consume(budget2, bytes) {
+  if (bytes > budget2.remaining)
     throw new Error("Raw discovery aggregate byte limit exceeded");
-  budget.remaining -= bytes;
+  budget2.remaining -= bytes;
 }
-function hashRawDiscoveryFile(path, budget, changes) {
+function hashRawDiscoveryFile(path, budget2, changes) {
   safe2(path);
   if (changes?.has(path)) {
     const text2 = changes.get(path), bytes = Buffer.byteLength(text2);
     if (bytes > AGENT_POLICY_LIMITS.discoveryRawSourceBytes)
       throw new Error("Raw discovery file byte limit exceeded");
-    consume(budget, bytes);
-    return createHash3("sha256").update(text2).digest("hex");
+    consume(budget2, bytes);
+    return createHash4("sha256").update(text2).digest("hex");
   }
-  const initial = lstatSync6(path, { throwIfNoEntry: false });
+  const initial = lstatSync7(path, { throwIfNoEntry: false });
   if (!initial)
     return null;
   if (!initial.isFile() || initial.size > AGENT_POLICY_LIMITS.discoveryRawSourceBytes)
     throw new Error("Unsupported or oversized raw discovery input");
-  if (initial.size > budget.remaining)
+  if (initial.size > budget2.remaining)
     throw new Error("Raw discovery aggregate byte limit exceeded");
-  const fd = openSync5(path, constants2.O_RDONLY | constants2.O_NOFOLLOW | constants2.O_NONBLOCK);
+  const fd = openSync6(path, constants3.O_RDONLY | constants3.O_NOFOLLOW | constants3.O_NONBLOCK);
   try {
-    const opened = fstatSync5(fd);
+    const opened = fstatSync6(fd);
     if (!opened.isFile() || !same2(initial, opened))
       throw new Error("Raw discovery input changed during open");
-    const hash2 = createHash3("sha256"), buffer = Buffer.alloc(64 * 1024);
+    const hash2 = createHash4("sha256"), buffer = Buffer.alloc(64 * 1024);
     let bytes = 0;
     while (true) {
-      const count = readSync2(fd, buffer, 0, Math.min(buffer.length, AGENT_POLICY_LIMITS.discoveryRawSourceBytes - bytes + 1), null);
+      const count = readSync3(fd, buffer, 0, Math.min(buffer.length, AGENT_POLICY_LIMITS.discoveryRawSourceBytes - bytes + 1), null);
       if (!count)
         break;
       bytes += count;
       if (bytes > AGENT_POLICY_LIMITS.discoveryRawSourceBytes)
         throw new Error("Raw discovery file byte limit exceeded");
-      consume(budget, count);
+      consume(budget2, count);
       hash2.update(buffer.subarray(0, count));
     }
-    const final = fstatSync5(fd), current = lstatSync6(path, { throwIfNoEntry: false });
+    const final = fstatSync6(fd), current = lstatSync7(path, { throwIfNoEntry: false });
     safe2(path);
     if (!current?.isFile() || !same2(opened, final) || !same2(final, current) || bytes !== final.size)
       throw new Error("Raw discovery input changed during read");
     return hash2.digest("hex");
   } finally {
-    closeSync5(fd);
+    closeSync6(fd);
   }
 }
 var init_agent_discovery_bytes = __esm(() => {
@@ -45616,9 +45935,9 @@ var init_agent_discovery_bytes = __esm(() => {
 });
 
 // src/lib/agent-discovery-path-bytes.ts
-import { createHash as createHash4 } from "crypto";
-import { lstatSync as lstatSync7, readlinkSync } from "fs";
-import { dirname as dirname7, isAbsolute as isAbsolute7, join as join12, parse as parse6, resolve as resolve6, sep as sep3 } from "path";
+import { createHash as createHash5 } from "crypto";
+import { lstatSync as lstatSync8, readlinkSync } from "fs";
+import { dirname as dirname8, isAbsolute as isAbsolute8, join as join13, parse as parse7, resolve as resolve7, sep as sep4 } from "path";
 function identity2(stat, mutable = false) {
   return {
     dev: String(stat.dev),
@@ -45629,14 +45948,14 @@ function identity2(stat, mutable = false) {
     ...mutable ? { size: String(stat.size), mtimeNs: String(stat.mtimeNs), ctimeNs: String(stat.ctimeNs) } : {}
   };
 }
-function canonical(path) {
-  if (typeof path !== "string" || !isAbsolute7(path) || path !== resolve6(path) || path.length > AGENT_POLICY_LIMITS.pathCharacters || path.includes("\x00") || Buffer.from(path).toString("utf8") !== path)
+function canonical2(path) {
+  if (typeof path !== "string" || !isAbsolute8(path) || path !== resolve7(path) || path.length > AGENT_POLICY_LIMITS.pathCharacters || path.includes("\x00") || Buffer.from(path).toString("utf8") !== path)
     throw new Error("Expected a canonical absolute discovery path");
 }
 function trace(path) {
-  canonical(path);
+  canonical2(path);
   const rows = [], paths = [];
-  let metadataBytes = 0, steps = 0, links = 0, cursor = parse6(path).root, pending = path.slice(cursor.length).split(sep3);
+  let metadataBytes = 0, steps = 0, links = 0, cursor = parse7(path).root, pending = path.slice(cursor.length).split(sep4);
   function record4(path2, row) {
     const value = { path: path2, ...row };
     metadataBytes += Buffer.byteLength(JSON.stringify(value));
@@ -45646,7 +45965,7 @@ function trace(path) {
     paths.push(path2);
   }
   function root() {
-    const stat = lstatSync7(cursor, { bigint: true });
+    const stat = lstatSync8(cursor, { bigint: true });
     if (!stat.isDirectory())
       throw new Error("Unsupported discovery path root");
     record4(cursor, { type: "directory", ...identity2(stat) });
@@ -45659,13 +45978,13 @@ function trace(path) {
     if (!component || component === ".")
       continue;
     if (component === "..") {
-      cursor = dirname7(cursor);
+      cursor = dirname8(cursor);
       continue;
     }
-    const candidate = join12(cursor, component);
+    const candidate = join13(cursor, component);
     if (candidate.length > AGENT_POLICY_LIMITS.pathCharacters)
       throw new Error("Discovery resolved path length limit exceeded");
-    const stat = lstatSync7(candidate, { bigint: true, throwIfNoEntry: false });
+    const stat = lstatSync8(candidate, { bigint: true, throwIfNoEntry: false });
     if (!stat) {
       record4(candidate, { type: "missing", remaining: pending });
       return { rows, paths, file: null, missing: candidate, metadataBytes };
@@ -45673,18 +45992,18 @@ function trace(path) {
     if (stat.isSymbolicLink()) {
       if (++links > AGENT_POLICY_LIMITS.discoveryPathLinks || stat.size > BigInt(AGENT_POLICY_LIMITS.pathCharacters))
         throw new Error("Discovery path link limit exceeded");
-      const rawTarget = readlinkSync(candidate, { encoding: "buffer" }), target = rawTarget.toString("utf8"), after = lstatSync7(candidate, { bigint: true });
+      const rawTarget = readlinkSync(candidate, { encoding: "buffer" }), target = rawTarget.toString("utf8"), after = lstatSync8(candidate, { bigint: true });
       if (!rawTarget.equals(Buffer.from(target, "utf8")))
         throw new Error("Unsupported non-UTF8 discovery link target");
       if (!target || target.includes("\x00") || Buffer.byteLength(target) > AGENT_POLICY_LIMITS.pathCharacters || !after.isSymbolicLink() || JSON.stringify(identity2(stat, true)) !== JSON.stringify(identity2(after, true)))
         throw new Error("Discovery link changed during read");
       record4(candidate, { type: "link", target, ...identity2(stat, true) });
-      if (isAbsolute7(target)) {
-        cursor = parse6(target).root;
+      if (isAbsolute8(target)) {
+        cursor = parse7(target).root;
         root();
       }
-      const remainder = isAbsolute7(target) ? target.slice(parse6(target).root.length) : target;
-      pending = [...remainder.split(sep3), ...pending];
+      const remainder = isAbsolute8(target) ? target.slice(parse7(target).root.length) : target;
+      pending = [...remainder.split(sep4), ...pending];
       if (pending.length + steps > AGENT_POLICY_LIMITS.discoveryPathSteps)
         throw new Error("Discovery path step limit exceeded");
       continue;
@@ -45703,12 +46022,12 @@ function trace(path) {
   }
   throw new Error("Unsupported directory discovery path input");
 }
-function hashDiscoveryPathFile(path, budget, changes) {
+function hashDiscoveryPathFile(path, budget2, changes) {
   const before = trace(path);
   let createsMissingPath = false;
   if (before.missing !== null && changes) {
     for (const target of changes.keys()) {
-      if (target === before.missing || target.startsWith(before.missing + sep3)) {
+      if (target === before.missing || target.startsWith(before.missing + sep4)) {
         createsMissingPath = true;
         break;
       }
@@ -45716,27 +46035,165 @@ function hashDiscoveryPathFile(path, budget, changes) {
   }
   if (createsMissingPath || changes?.has(path) || before.paths.some((path2) => changes?.has(path2)))
     throw new Error("Discovery path witness intersects a planned write; use bytes mode for owned configuration");
-  const remaining = budget.pathMetadataRemaining ?? AGENT_POLICY_LIMITS.discoveryPathTotalMetadataBytes;
+  const remaining = budget2.pathMetadataRemaining ?? AGENT_POLICY_LIMITS.discoveryPathTotalMetadataBytes;
   if (before.metadataBytes > remaining)
     throw new Error("Discovery path aggregate metadata limit exceeded");
-  budget.pathMetadataRemaining = remaining - before.metadataBytes;
-  const content = before.file === null ? null : hashRawDiscoveryFile(before.file, budget);
+  budget2.pathMetadataRemaining = remaining - before.metadataBytes;
+  const content = before.file === null ? null : hashRawDiscoveryFile(before.file, budget2);
   if (before.file !== null && content === null)
     throw new Error("Discovery path input changed during read");
   const after = trace(path);
   if (JSON.stringify(before.rows) !== JSON.stringify(after.rows) || before.file !== after.file)
     throw new Error("Discovery path input changed during read");
-  return createHash4("sha256").update(JSON.stringify({ version: 1, path, rows: before.rows, content })).digest("hex");
+  return createHash5("sha256").update(JSON.stringify({ version: 1, path, rows: before.rows, content })).digest("hex");
 }
 var init_agent_discovery_path_bytes = __esm(() => {
   init_agent_policy_limits();
   init_agent_discovery_bytes();
 });
 
+// src/lib/claude-plugin-manifest-witness.ts
+import { createHash as createHash6 } from "crypto";
+function requireValue(value, reason) {
+  if (!value)
+    throw new Error("Claude plugin manifest " + reason);
+}
+function parse8(text2) {
+  requireValue(Buffer.byteLength(text2, "utf8") <= CLAUDE_PLUGIN_MANIFEST_LIMITS.bytes, "exceeds its byte limit");
+  let at = 0, nodes = 0;
+  const numberPattern = /-?(?:0|[1-9][0-9]*)(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?/y;
+  const space = () => {
+    while (at < text2.length && /[\x20\t\r\n]/.test(text2[at]))
+      at++;
+  };
+  function string5() {
+    requireValue(text2[at] === '"', "contains invalid JSON");
+    const start = at++;
+    while (at < text2.length) {
+      const character = text2[at++];
+      if (character === '"') {
+        let value2;
+        try {
+          value2 = JSON.parse(text2.slice(start, at));
+        } catch {
+          throw new Error("Claude plugin manifest contains invalid JSON string");
+        }
+        requireValue(value2.length <= CLAUDE_PLUGIN_MANIFEST_LIMITS.stringCharacters, "exceeds its string limit");
+        return value2;
+      }
+      if (character === "\\")
+        at++;
+    }
+    throw new Error("Claude plugin manifest contains an unterminated JSON string");
+  }
+  function value(depth) {
+    requireValue(depth <= CLAUDE_PLUGIN_MANIFEST_LIMITS.depth && ++nodes <= CLAUDE_PLUGIN_MANIFEST_LIMITS.nodes, "exceeds its nesting or node limit");
+    space();
+    const character = text2[at];
+    if (character === '"')
+      return { kind: "string", value: string5() };
+    if (character === "{" || character === "[") {
+      at++;
+      space();
+      const object6 = character === "{", end = object6 ? "}" : "]", entries = [], items = [], keys = new Set;
+      if (text2[at] !== end)
+        while (true) {
+          if (object6) {
+            space();
+            const key = string5();
+            requireValue(!keys.has(key), "contains a duplicate JSON key");
+            keys.add(key);
+            space();
+            requireValue(text2[at++] === ":", "contains invalid JSON");
+            entries.push([key, value(depth + 1)]);
+          } else
+            items.push(value(depth + 1));
+          space();
+          if (text2[at] === end)
+            break;
+          requireValue(text2[at++] === ",", "contains invalid JSON");
+        }
+      at++;
+      return object6 ? { kind: "object", entries } : { kind: "array", items };
+    }
+    for (const literal3 of ["true", "false", "null"])
+      if (text2.startsWith(literal3, at)) {
+        at += literal3.length;
+        return { kind: "literal", value: literal3 };
+      }
+    numberPattern.lastIndex = at;
+    const number5 = numberPattern.exec(text2);
+    requireValue(number5, "contains invalid JSON");
+    at += number5[0].length;
+    return { kind: "number", value: number5[0] };
+  }
+  const root = value(0);
+  space();
+  requireValue(at === text2.length && root.kind === "object", "requires a JSON object without trailing content");
+  return root;
+}
+function canonical3(value) {
+  if (value.kind === "string")
+    return JSON.stringify(value.value);
+  if (value.kind === "number")
+    return value.value;
+  if (value.kind === "literal")
+    return value.value;
+  if (value.kind === "array")
+    return "[" + value.items.map(canonical3).join(",") + "]";
+  return "{" + value.entries.map(([key, item]) => JSON.stringify(key) + ":" + canonical3(item)).join(",") + "}";
+}
+function validateText(value, field) {
+  requireValue(value?.kind === "string" && value.value.length <= CLAUDE_PLUGIN_MANIFEST_LIMITS.stringCharacters, "has an invalid " + field + " field");
+}
+function validateDescriptiveFields(manifest) {
+  const values = new Map(manifest.entries);
+  for (const field of ["description", "version", "homepage", "license"]) {
+    const value = values.get(field);
+    if (value !== undefined)
+      validateText(value, field);
+  }
+  const author = values.get("author");
+  if (author !== undefined) {
+    if (author.kind === "string")
+      validateText(author, "author");
+    else {
+      requireValue(author.kind === "object" && author.entries.every(([key, value]) => ["name", "email", "url"].includes(key) && value.kind === "string" && value.value.length <= CLAUDE_PLUGIN_MANIFEST_LIMITS.stringCharacters), "has an invalid author field");
+    }
+  }
+  const repository = values.get("repository");
+  if (repository !== undefined) {
+    if (repository.kind === "string")
+      validateText(repository, "repository");
+    else
+      requireValue(repository.kind === "object" && repository.entries.every(([key, value]) => ["type", "url", "directory"].includes(key) && value.kind === "string" && value.value.length <= CLAUDE_PLUGIN_MANIFEST_LIMITS.stringCharacters), "has an invalid repository field");
+  }
+  const keywords = values.get("keywords");
+  if (keywords !== undefined)
+    requireValue(keywords.kind === "array" && keywords.items.every((value) => value.kind === "string" && value.value.length <= CLAUDE_PLUGIN_MANIFEST_LIMITS.stringCharacters), "has an invalid keywords field");
+}
+function hashClaudePluginManifest(text2) {
+  const manifest = parse8(text2);
+  validateDescriptiveFields(manifest);
+  const discovery = { kind: "object", entries: manifest.entries.filter(([key]) => !DESCRIPTIVE_FIELDS.has(key)) };
+  return createHash6("sha256").update(canonical3(discovery)).digest("hex");
+}
+function projectReviewedClaudePluginManifest(text2, reviewedSha256) {
+  if (!/^[a-f0-9]{64}$/.test(reviewedSha256) || createHash6("sha256").update(text2).digest("hex") !== reviewedSha256) {
+    throw new Error("Reviewed Claude plugin manifest changed before semantic projection");
+  }
+  return hashClaudePluginManifest(text2);
+}
+var CLAUDE_PLUGIN_MANIFEST_LIMITS, DESCRIPTIVE_FIELDS;
+var init_claude_plugin_manifest_witness = __esm(() => {
+  CLAUDE_PLUGIN_MANIFEST_LIMITS = Object.freeze({ bytes: 1024 * 1024, depth: 32, nodes: 65536, stringCharacters: 16384 });
+  DESCRIPTIVE_FIELDS = new Set(["description", "version", "author", "homepage", "repository", "license", "keywords"]);
+});
+
 // src/lib/skill-bundle.ts
-import { createHash as createHash5 } from "crypto";
+import { createHash as createHash7 } from "crypto";
 import { readFileSync as readFileSync9, readdirSync as readdirSync4, statSync as statSync6 } from "fs";
-import { join as join13, relative as relative3 } from "path";
+import { join as join14, relative as relative3 } from "path";
 import { createGunzip } from "zlib";
 function isDotenvFile(lower) {
   if (lower === ".env" || lower.startsWith(".env."))
@@ -45766,7 +46223,7 @@ function ownBytes(view) {
   return out;
 }
 function sha256Hex(bytes) {
-  return createHash5("sha256").update(bytes).digest("hex");
+  return createHash7("sha256").update(bytes).digest("hex");
 }
 function collectSkillBundleEntries(dir) {
   const entries = [];
@@ -45775,7 +46232,7 @@ function collectSkillBundleEntries(dir) {
 }
 function walk(root, current, out) {
   for (const entry of readdirSync4(current, { withFileTypes: true })) {
-    const absolute = join13(current, entry.name);
+    const absolute = join14(current, entry.name);
     const rel = relative3(root, absolute).split("\\").join("/");
     const isRootLevel = !rel.includes("/");
     if (ANY_SEGMENT_EXCLUDES.has(entry.name.toLowerCase()))
@@ -45944,7 +46401,7 @@ async function inspectSkillBundle(bundle, options = {}) {
       parser2.push(chunk);
       bytesSinceYield += chunk.byteLength;
       if (bytesSinceYield >= 256 * 1024) {
-        await new Promise((resolve7) => setTimeout(resolve7, 0));
+        await new Promise((resolve8) => setTimeout(resolve8, 0));
         bytesSinceYield = 0;
         check2();
       }
@@ -46301,24 +46758,24 @@ var init_profile_limits = __esm(() => {
 });
 
 // src/lib/selection-cache.ts
-import { createHash as createHash6, randomUUID } from "crypto";
+import { createHash as createHash8, randomUUID } from "crypto";
 import { spawnSync as spawnSync2 } from "child_process";
-import { closeSync as closeSync6, constants as constants3, fstatSync as fstatSync6, fsyncSync, linkSync, lstatSync as lstatSync8, mkdirSync as mkdirSync3, openSync as openSync6, readFileSync as readFileSync10, readlinkSync as readlinkSync2, readSync as readSync3, renameSync, unlinkSync, writeFileSync as writeFileSync3 } from "fs";
+import { closeSync as closeSync7, constants as constants4, fstatSync as fstatSync7, fsyncSync, linkSync, lstatSync as lstatSync9, mkdirSync as mkdirSync3, openSync as openSync7, readFileSync as readFileSync10, readlinkSync as readlinkSync2, readSync as readSync4, renameSync, unlinkSync, writeFileSync as writeFileSync3 } from "fs";
 import { hostname as hostname3 } from "os";
-import { dirname as dirname8, join as join14, parse as parse7, resolve as resolve7 } from "path";
+import { dirname as dirname9, join as join15, parse as parse9, resolve as resolve8 } from "path";
 import { isDeepStrictEqual } from "util";
 function selectionCacheRoot(options = {}) {
-  return resolve7(options.cacheDir ?? join14(getDataDirReadOnly(), "selection-cache"));
+  return resolve8(options.cacheDir ?? join15(getDataDirReadOnly(), "selection-cache"));
 }
 function selectionKey(selection) {
   validateSelection(selection);
   return hash2([selection.authority, selection.workspaceId, selection.slug, selection.version, selection.bundleDigest]);
 }
 function hash2(value) {
-  return createHash6("sha256").update(JSON.stringify(value)).digest("hex");
+  return createHash8("sha256").update(JSON.stringify(value)).digest("hex");
 }
 function validateSelection(selection) {
-  if (!selection || !/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(selection.slug) || !isValidSkillVersion(selection.version) || !/^sha256:[a-f0-9]{64}$/.test(selection.bundleDigest) || typeof selection.workspaceId !== "string" || !selection.workspaceId.trim() || typeof selection.profileRevision !== "string" || !selection.profileRevision.trim()) {
+  if (!selection || !/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(selection.slug) || !isValidSkillVersion(selection.version) || !/^sha256:[a-f0-9]{64}$/.test(selection.bundleDigest) || typeof selection.workspaceId !== "string" || !selection.workspaceId.trim() || selection.authorizationEpoch !== undefined && (typeof selection.authorizationEpoch !== "string" || !/^[a-f0-9]{32}$/.test(selection.authorizationEpoch)) || typeof selection.profileRevision !== "string" || !selection.profileRevision.trim()) {
     throw new SkillSelectionError("INVALID_SELECTION", "A skill selection must carry an exact version, digest, workspace and profile revision.");
   }
   const aliasError = selectionAliasError([selection]);
@@ -46352,17 +46809,17 @@ function validateResolvedProfile(profile, authority) {
 }
 function selectionBundlePath(selection, options = {}) {
   validateSelection(selection);
-  return join14(selectionCacheRoot(options), "objects", hash2(selection.authority), hash2(selection.workspaceId), `${selection.bundleDigest.slice(7)}.tar.gz`);
+  return join15(selectionCacheRoot(options), "objects", hash2(selection.authority), hash2(selection.workspaceId), `${selection.bundleDigest.slice(7)}.tar.gz`);
 }
 function assertRegularPath(path, createParents = false) {
-  const absolute = resolve7(path);
-  const root = parse7(absolute).root;
+  const absolute = resolve8(path);
+  const root = parse9(absolute).root;
   let cursor = root;
   const segments = absolute.slice(root.length).split("/");
   for (let index = 0;index < segments.length; index++) {
-    cursor = join14(cursor, segments[index]);
+    cursor = join15(cursor, segments[index]);
     try {
-      const stat = lstatSync8(cursor);
+      const stat = lstatSync9(cursor);
       if (stat.isSymbolicLink() || index < segments.length - 1 && !stat.isDirectory()) {
         throw new SkillSelectionError("UNSAFE_CACHE_PATH", "Skills cache paths must not traverse symlinks or non-directories.");
       }
@@ -46378,20 +46835,20 @@ function readRegularFile(path, limit) {
   assertRegularPath(path);
   let fd;
   try {
-    fd = openSync6(path, constants3.O_RDONLY | constants3.O_NOFOLLOW | constants3.O_NONBLOCK);
+    fd = openSync7(path, constants4.O_RDONLY | constants4.O_NOFOLLOW | constants4.O_NONBLOCK);
   } catch (error61) {
     if (error61.code === "ENOENT")
       return null;
     throw error61;
   }
   try {
-    const stat = fstatSync6(fd);
+    const stat = fstatSync7(fd);
     if (!stat.isFile() || stat.size > limit)
       throw new SkillSelectionError("INVALID_CACHE_FILE", "The Skills cache contains an invalid or oversized file.");
     const bytes = Buffer.alloc(stat.size + 1);
     let size = 0;
     while (size < bytes.length) {
-      const read = readSync3(fd, bytes, size, bytes.length - size, null);
+      const read = readSync4(fd, bytes, size, bytes.length - size, null);
       if (!read)
         break;
       size += read;
@@ -46400,7 +46857,7 @@ function readRegularFile(path, limit) {
       throw new SkillSelectionError("INVALID_CACHE_FILE", "The Skills cache file grew during its bounded read.");
     return bytes.subarray(0, size);
   } finally {
-    closeSync6(fd);
+    closeSync7(fd);
   }
 }
 function writeSelectionJson(path, value) {
@@ -46412,19 +46869,19 @@ function writeSelectionJson(path, value) {
 }
 function atomicWrite(path, bytes, mode, durable = false) {
   assertRegularPath(path, true);
-  const temporary = join14(dirname8(path), `.selection-${randomUUID()}.tmp`);
+  const temporary = join15(dirname9(path), `.selection-${randomUUID()}.tmp`);
   try {
-    const fd = openSync6(temporary, constants3.O_WRONLY | constants3.O_CREAT | constants3.O_EXCL | constants3.O_NOFOLLOW, mode);
+    const fd = openSync7(temporary, constants4.O_WRONLY | constants4.O_CREAT | constants4.O_EXCL | constants4.O_NOFOLLOW, mode);
     try {
       writeFileSync3(fd, bytes);
       if (durable)
         fsyncSync(fd);
     } finally {
-      closeSync6(fd);
+      closeSync7(fd);
     }
     renameSync(temporary, path);
     if (durable)
-      syncDirectory(dirname8(path));
+      syncDirectory(dirname9(path));
   } finally {
     try {
       unlinkSync(temporary);
@@ -46444,17 +46901,21 @@ function readSelectionJson(path) {
     throw new SkillSelectionError("INVALID_RECEIPT", "The Skills selection receipt is unreadable; sync the profile again.");
   }
 }
-async function verifiedEntries(selection, bytes) {
+async function verifiedEntries(selection, bytes, signal, deadline) {
   if (`sha256:${sha256Hex(bytes)}` !== selection.bundleDigest)
     throw new SkillSelectionError("BUNDLE_DIGEST_MISMATCH", "The skill bundle does not match its selected digest.");
-  const bundle = await inspectSkillBundle(bytes);
+  const remaining = deadline === undefined ? undefined : Math.floor(deadline - performance.now());
+  signal?.throwIfAborted();
+  if (remaining !== undefined && remaining <= 0)
+    throw new SkillSelectionError("SKILLS_API_UNAVAILABLE", "Skills session authorization deadline exceeded.");
+  const bundle = await inspectSkillBundle(bytes, { signal, ...remaining === undefined ? {} : { limits: { timeoutMs: remaining } } });
   return bundle.entries;
 }
 async function readCachedSelection(selection, options = {}) {
   const bytes = readRegularFile(selectionBundlePath(selection, options), SKILL_BUNDLE_INSPECTION_LIMITS.compressedBytes);
   return bytes ? verifiedEntries(selection, bytes) : null;
 }
-async function cacheSelectionBundle(selection, response, options = {}) {
+async function verifySelectionBundleResponse(selection, response, signal, deadline) {
   validateSelection(selection);
   if (!response?.ok)
     throw new SkillSelectionError("BUNDLE_UNAVAILABLE", `The selected skill bundle is unavailable${response ? ` (HTTP ${response.status})` : ""}.`);
@@ -46464,15 +46925,27 @@ async function cacheSelectionBundle(selection, response, options = {}) {
     await response.body?.cancel();
     throw new SkillSelectionError("BUNDLE_IDENTITY_MISMATCH", "The returned bundle does not match the selected version and digest.");
   }
+  const epoch = response.headers.get("X-Skill-Authorization-Epoch");
+  if (selection.authorizationEpoch !== undefined && epoch !== selection.authorizationEpoch) {
+    response.body?.cancel().catch(() => {});
+    throw new SkillSelectionError("SESSION_RECONCILIATION_REQUIRED", "The selected bundle lifecycle authorization changed or is unavailable.");
+  }
   const maximum = SKILL_BUNDLE_INSPECTION_LIMITS.compressedBytes;
   const reader = response.body?.getReader();
   if (!reader)
     throw new SkillSelectionError("BUNDLE_UNAVAILABLE", "The selected bundle response has no body.");
+  signal?.throwIfAborted();
+  const abort = () => {
+    reader.cancel().catch(() => {});
+  };
+  signal?.addEventListener("abort", abort, { once: true });
   const chunks = [];
   let length = 0;
   try {
     while (true) {
+      signal?.throwIfAborted();
       const next = await reader.read();
+      signal?.throwIfAborted();
       if (next.done)
         break;
       length += next.value.byteLength;
@@ -46481,9 +46954,10 @@ async function cacheSelectionBundle(selection, response, options = {}) {
       chunks.push(next.value);
     }
   } catch (error61) {
-    await reader.cancel().catch(() => {});
+    reader.cancel().catch(() => {});
     throw error61;
   } finally {
+    signal?.removeEventListener("abort", abort);
     reader.releaseLock();
   }
   const bytes = new Uint8Array(length);
@@ -46492,7 +46966,12 @@ async function cacheSelectionBundle(selection, response, options = {}) {
     bytes.set(chunk, offset);
     offset += chunk.byteLength;
   }
-  const entries = await verifiedEntries(selection, bytes);
+  const entries = await verifiedEntries(selection, bytes, signal, deadline);
+  return { bytes, entries };
+}
+async function cacheSelectionBundle(selection, response, options = {}) {
+  const { bytes, entries } = await verifySelectionBundleResponse(selection, response);
+  const maximum = SKILL_BUNDLE_INSPECTION_LIMITS.compressedBytes;
   const path = selectionBundlePath(selection, options);
   const existing = readRegularFile(path, maximum);
   if (existing)
@@ -46502,7 +46981,7 @@ async function cacheSelectionBundle(selection, response, options = {}) {
   return entries;
 }
 function profilePath(profileId, options) {
-  return join14(selectionCacheRoot(options), "profiles", `${hash2(profileId)}.json`);
+  return join15(selectionCacheRoot(options), "profiles", `${hash2(profileId)}.json`);
 }
 function readSelectionProfile(profileId, options = {}) {
   const receipt = readSelectionJson(profilePath(profileId, options));
@@ -46528,7 +47007,7 @@ function assertFreshCachedProfile(receipt, options = {}) {
   }
 }
 function projectSelectionLockPath(projectDir) {
-  return join14(resolve7(projectDir), ".skills", SELECTION_LOCK_FILE);
+  return join15(resolve8(projectDir), ".skills", SELECTION_LOCK_FILE);
 }
 function readProjectSelection(projectDir) {
   const receipt = readSelectionJson(projectSelectionLockPath(projectDir));
@@ -46539,7 +47018,7 @@ function readProjectSelection(projectDir) {
 function sessionReceiptPath(sessionId, options = {}) {
   if (!sessionId.trim() || sessionId.length > MAX_SKILL_SESSION_ID_CHARS)
     throw new SkillSelectionError("INVALID_SESSION", `A Skills session id must contain 1\u2013${MAX_SKILL_SESSION_ID_CHARS} characters.`);
-  return join14(selectionCacheRoot(options), "sessions", `${hash2(sessionId)}.json`);
+  return join15(selectionCacheRoot(options), "sessions", `${hash2(sessionId)}.json`);
 }
 function skillSessionGeneration(receipt) {
   return receipt.generation ?? 0;
@@ -46636,14 +47115,14 @@ function localLockIdentity() {
 }
 function readSessionLock(sessionId, options) {
   const path = `${sessionReceiptPath(sessionId, options)}.write-lock`;
-  const before = lstatSync8(path, { throwIfNoEntry: false });
+  const before = lstatSync9(path, { throwIfNoEntry: false });
   if (!before)
     return null;
   if (!before.isFile() || ![1, 2].includes(before.nlink) || (before.mode & 63) !== 0 || process.getuid && before.uid !== process.getuid()) {
     throw new SkillSelectionError("SESSION_WRITE_LOCKED", "The session lock is not a private regular file; recovery requires review.");
   }
   const bytes = readRegularFile(path, SESSION_LOCK_MAX_BYTES);
-  const after = lstatSync8(path, { throwIfNoEntry: false });
+  const after = lstatSync9(path, { throwIfNoEntry: false });
   if (!bytes || !after?.isFile() || before.dev !== after.dev || before.ino !== after.ino || before.mtimeMs !== after.mtimeMs || before.mode !== after.mode || before.uid !== after.uid || before.gid !== after.gid || before.nlink !== after.nlink) {
     throw new SkillSelectionError("SESSION_WRITE_LOCKED", "The session lock changed during inspection; recovery requires review.");
   }
@@ -46660,7 +47139,7 @@ function readSessionLock(sessionId, options) {
   if (after.nlink === 2) {
     stagingPath = `${path}.${marker.operationId}.prepared`;
     assertRegularPath(stagingPath);
-    const staged = lstatSync8(stagingPath, { throwIfNoEntry: false });
+    const staged = lstatSync9(stagingPath, { throwIfNoEntry: false });
     if (marker.publication !== "hard-link-v1" || !staged?.isFile() || staged.dev !== after.dev || staged.ino !== after.ino || staged.nlink !== 2 || staged.mode !== after.mode || staged.uid !== after.uid || staged.gid !== after.gid) {
       throw new SkillSelectionError("SESSION_WRITE_LOCKED", "The session lock has an unbound publication link; recovery requires review.");
     }
@@ -46671,33 +47150,33 @@ function publishSessionLock(path, marker) {
   const stagingPath = `${path}.${marker.operationId}.prepared`;
   const bytes = Buffer.from(`${JSON.stringify({ ...marker, publication: "hard-link-v1" })}
 `);
-  const fd = openSync6(stagingPath, constants3.O_WRONLY | constants3.O_CREAT | constants3.O_EXCL | constants3.O_NOFOLLOW, 384);
-  const stat = fstatSync6(fd);
+  const fd = openSync7(stagingPath, constants4.O_WRONLY | constants4.O_CREAT | constants4.O_EXCL | constants4.O_NOFOLLOW, 384);
+  const stat = fstatSync7(fd);
   let published = false, handedOff = false;
   try {
     writeFileSync3(fd, bytes);
     fsyncSync(fd);
     linkSync(stagingPath, path);
     published = true;
-    syncDirectory(dirname8(path));
-    const staged = lstatSync8(stagingPath);
+    syncDirectory(dirname9(path));
+    const staged = lstatSync9(stagingPath);
     if (!staged.isFile() || staged.dev !== stat.dev || staged.ino !== stat.ino) {
       throw new SkillSelectionError("SESSION_WRITE_LOCK_CHANGED", "The initialized lock staging inode changed before publication completed.");
     }
     unlinkSync(stagingPath);
-    syncDirectory(dirname8(path));
+    syncDirectory(dirname9(path));
     handedOff = true;
     return { path, stagingPath, fd, dev: stat.dev, ino: stat.ino };
   } finally {
     if (!handedOff) {
       try {
         for (const target of [...published ? [path] : [], stagingPath]) {
-          const current = lstatSync8(target, { throwIfNoEntry: false });
+          const current = lstatSync9(target, { throwIfNoEntry: false });
           if (current?.isFile() && current.dev === stat.dev && current.ino === stat.ino)
             unlinkSync(target);
         }
       } finally {
-        closeSync6(fd);
+        closeSync7(fd);
       }
     }
   }
@@ -46719,27 +47198,27 @@ function archiveSessionLock(lock, receipt, explicitLocalHost) {
   const guardPath = `${lock.path}.recovery-guard`;
   let guardFd;
   try {
-    guardFd = openSync6(guardPath, constants3.O_WRONLY | constants3.O_CREAT | constants3.O_EXCL | constants3.O_NOFOLLOW, 384);
+    guardFd = openSync7(guardPath, constants4.O_WRONLY | constants4.O_CREAT | constants4.O_EXCL | constants4.O_NOFOLLOW, 384);
   } catch (error61) {
     if (error61.code === "EEXIST")
       return null;
     throw error61;
   }
-  const guardStat = fstatSync6(guardFd);
+  const guardStat = fstatSync7(guardFd);
   try {
     writeFileSync3(guardFd, `${JSON.stringify({ schemaVersion: 1, pid: process.pid, operationId: randomUUID() })}
 `);
     fsyncSync(guardFd);
-    const cacheOptions = { cacheDir: dirname8(dirname8(lock.path)) };
+    const cacheOptions = { cacheDir: dirname9(dirname9(lock.path)) };
     const current = readSessionLock(lock.marker.sessionId, cacheOptions);
     if (!current || current.dev !== lock.dev || current.ino !== lock.ino || current.sha256 !== lock.sha256 || current.mtimeMs !== lock.mtimeMs || !writerIsGone(current, explicitLocalHost))
       return null;
     const currentReceipt = readSkillSessionSnapshotIfExists(lock.marker.sessionId, cacheOptions);
     if (currentReceipt?.sha256 !== receipt?.sha256 || currentReceipt?.generation !== receipt?.generation)
       return null;
-    const directory = join14(dirname8(dirname8(lock.path)), "session-lock-recoveries", randomUUID());
-    const archivePath = join14(directory, "original.write-lock");
-    const recordPath = join14(directory, "recovery.json");
+    const directory = join15(dirname9(dirname9(lock.path)), "session-lock-recoveries", randomUUID());
+    const archivePath = join15(directory, "original.write-lock");
+    const recordPath = join15(directory, "recovery.json");
     assertRegularPath(archivePath, true);
     archiveBytes(recordPath, Buffer.from(`${JSON.stringify({
       schemaVersion: 1,
@@ -46754,7 +47233,7 @@ function archiveSessionLock(lock, receipt, explicitLocalHost) {
     })}
 `));
     syncDirectory(directory);
-    syncDirectory(dirname8(directory));
+    syncDirectory(dirname9(directory));
     const finalLock = readSessionLock(lock.marker.sessionId, cacheOptions);
     if (!finalLock || finalLock.dev !== lock.dev || finalLock.ino !== lock.ino || finalLock.sha256 !== lock.sha256 || readSkillSessionSnapshotIfExists(lock.marker.sessionId, cacheOptions)?.sha256 !== receipt?.sha256)
       return null;
@@ -46764,16 +47243,16 @@ function archiveSessionLock(lock, receipt, explicitLocalHost) {
       moved = true;
       const archivedPaths = [archivePath];
       if (finalLock.stagingPath) {
-        const publicationPath = join14(directory, "publication.write-lock");
+        const publicationPath = join15(directory, "publication.write-lock");
         renameSync(finalLock.stagingPath, publicationPath);
         archivedPaths.push(publicationPath);
       }
       syncDirectory(directory);
-      syncDirectory(dirname8(lock.path));
+      syncDirectory(dirname9(lock.path));
       for (const path of archivedPaths) {
-        const before = lstatSync8(path, { throwIfNoEntry: false });
+        const before = lstatSync9(path, { throwIfNoEntry: false });
         const bytes = readRegularFile(path, SESSION_LOCK_MAX_BYTES);
-        const after = lstatSync8(path, { throwIfNoEntry: false });
+        const after = lstatSync9(path, { throwIfNoEntry: false });
         if (!before?.isFile() || before.dev !== lock.dev || before.ino !== lock.ino || before.nlink !== archivedPaths.length || before.mtimeMs !== lock.mtimeMs || (before.mode & 63) !== 0 || process.getuid && before.uid !== process.getuid() || !bytes || sha256Hex(bytes) !== lock.sha256 || !after?.isFile() || before.dev !== after.dev || before.ino !== after.ino || before.mtimeMs !== after.mtimeMs || before.mode !== after.mode || before.uid !== after.uid || before.gid !== after.gid || before.nlink !== after.nlink) {
           throw new Error("Archived lock ownership or bytes changed");
         }
@@ -46785,8 +47264,8 @@ function archiveSessionLock(lock, receipt, explicitLocalHost) {
     }
     return archivePath;
   } finally {
-    closeSync6(guardFd);
-    const current = lstatSync8(guardPath, { throwIfNoEntry: false });
+    closeSync7(guardFd);
+    const current = lstatSync9(guardPath, { throwIfNoEntry: false });
     if (current?.isFile() && current.dev === guardStat.dev && current.ino === guardStat.ino)
       unlinkSync(guardPath);
   }
@@ -46798,7 +47277,7 @@ function withSessionWriteLocks(sessionIds, options, action) {
   const owned = [];
   const assertOwned = () => {
     for (const lock of owned) {
-      const current = lstatSync8(lock.path, { throwIfNoEntry: false });
+      const current = lstatSync9(lock.path, { throwIfNoEntry: false });
       if (!current?.isFile() || current.dev !== lock.dev || current.ino !== lock.ino) {
         throw new SkillSelectionError("SESSION_WRITE_LOCK_CHANGED", "A session write lock changed during the operation; no replacement is permitted.");
       }
@@ -46842,12 +47321,12 @@ function withSessionWriteLocks(sessionIds, options, action) {
     for (const lock of owned.reverse()) {
       try {
         for (const path of [lock.path, lock.stagingPath]) {
-          const current = lstatSync8(path, { throwIfNoEntry: false });
+          const current = lstatSync9(path, { throwIfNoEntry: false });
           if (current?.isFile() && current.dev === lock.dev && current.ino === lock.ino)
             unlinkSync(path);
         }
       } finally {
-        closeSync6(lock.fd);
+        closeSync7(lock.fd);
       }
     }
   }
@@ -46895,21 +47374,21 @@ function writeSkillSession(receipt, expected, options = {}) {
 }
 function syncDirectory(path) {
   assertRegularPath(path);
-  const fd = openSync6(path, constants3.O_RDONLY | constants3.O_DIRECTORY | constants3.O_NOFOLLOW);
+  const fd = openSync7(path, constants4.O_RDONLY | constants4.O_DIRECTORY | constants4.O_NOFOLLOW);
   try {
     fsyncSync(fd);
   } finally {
-    closeSync6(fd);
+    closeSync7(fd);
   }
 }
 function archiveBytes(path, bytes) {
   assertRegularPath(path, true);
-  const fd = openSync6(path, constants3.O_WRONLY | constants3.O_CREAT | constants3.O_EXCL | constants3.O_NOFOLLOW, 384);
+  const fd = openSync7(path, constants4.O_WRONLY | constants4.O_CREAT | constants4.O_EXCL | constants4.O_NOFOLLOW, 384);
   try {
     writeFileSync3(fd, bytes);
     fsyncSync(fd);
   } finally {
-    closeSync6(fd);
+    closeSync7(fd);
   }
 }
 var SkillSelectionError, MAX_CACHED_PROFILE_AGE_MS, SELECTION_LOCK_FILE = "selection.lock.json", SESSION_LOCK_MAX_BYTES = 4096, SESSION_LOCK_MIN_AGE_MS = 30000;
@@ -46938,7 +47417,7 @@ __export(exports_remote_files, {
   decodeRemoteFiles: () => decodeRemoteFiles,
   MAX_REMOTE_FILE_BYTES: () => MAX_REMOTE_FILE_BYTES
 });
-import { createHash as createHash7 } from "crypto";
+import { createHash as createHash9 } from "crypto";
 function describeRemoteFiles(files) {
   if (files.length > 10)
     throw new Error("At most 10 input files are supported");
@@ -46955,9 +47434,9 @@ function describeRemoteFiles(files) {
   });
 }
 function sha256(bytes) {
-  return createHash7("sha256").update(bytes).digest("hex");
+  return createHash9("sha256").update(bytes).digest("hex");
 }
-async function readBoundedResponse(response, maximum) {
+async function readBoundedResponse(response, maximum, signal) {
   if (!Number.isSafeInteger(maximum) || maximum < 0 || maximum > MAX_REMOTE_FILE_BYTES)
     throw new Error("Invalid artifact size limit");
   const length = response.headers.get("content-length");
@@ -46968,11 +47447,18 @@ async function readBoundedResponse(response, maximum) {
   const reader = response.body?.getReader();
   if (!reader)
     return new Uint8Array;
+  signal?.throwIfAborted();
+  const abort = () => {
+    reader.cancel().catch(() => {});
+  };
+  signal?.addEventListener("abort", abort, { once: true });
   const chunks = [];
   let size = 0;
   try {
     while (true) {
+      signal?.throwIfAborted();
       const next = await reader.read();
+      signal?.throwIfAborted();
       if (next.done)
         break;
       size += next.value.byteLength;
@@ -46984,6 +47470,7 @@ async function readBoundedResponse(response, maximum) {
     await reader.cancel().catch(() => {});
     throw error61;
   } finally {
+    signal?.removeEventListener("abort", abort);
     reader.releaseLock();
   }
   const bytes = new Uint8Array(size);
@@ -47043,10 +47530,12 @@ function validateSelection2(value) {
 
 class HttpProfileClient {
   key;
+  signal;
   authority;
   origin;
-  constructor(key, origin) {
+  constructor(key, origin, signal) {
     this.key = key;
+    this.signal = signal;
     if (!key.trim())
       throw new Error("A Skills credential is required");
     this.origin = normalizeSkillsApiOrigin(origin);
@@ -47060,7 +47549,7 @@ class HttpProfileClient {
         ...init,
         redirect: "error",
         credentials: "omit",
-        signal: AbortSignal.timeout(15000),
+        signal: this.signal ? AbortSignal.any([this.signal, AbortSignal.timeout(15000)]) : AbortSignal.timeout(15000),
         headers: {
           "Content-Type": "application/json",
           "User-Agent": `hasna-skills/${package_default.version}`,
@@ -47085,22 +47574,28 @@ class HttpProfileClient {
   }
   async read(response, limit = MAX_PROFILE_DOCUMENT_BYTES) {
     try {
-      return JSON.parse(new TextDecoder().decode(await readBoundedResponse(response, limit)));
+      return JSON.parse(new TextDecoder().decode(await readBoundedResponse(response, limit, this.signal)));
     } catch {
       invalid();
     }
   }
+  async supportsPinRenewal() {
+    const result = await this.read(await this.request("/capabilities"));
+    if (!object6(result) || !Array.isArray(result.capabilities))
+      invalid();
+    return result.capabilities.includes("skills.session-pin-renewal");
+  }
   async resolveProfile(id) {
     if (!identifier(id))
       throw new Error("Invalid selection profile id");
-    const result = await this.read(await this.request(`/profiles/${encodeURIComponent(id)}/resolve`), MAX_RESOLVED_PROFILE_BYTES);
+    const result = await this.read(await this.request(`/profiles/${encodeURIComponent(id)}/resolve?pinAuthorization=epoch-v1`), MAX_RESOLVED_PROFILE_BYTES);
     if (!object6(result) || result.profileId !== id || result.authority !== this.authority || !identifier(result.workspaceId) || !identifier(result.profileRevision) || !Array.isArray(result.selections) || result.selections.length > MAX_PROFILE_SELECTIONS)
       invalid();
     const seen = new Set;
     for (const entry of result.selections) {
       validateSelection2(entry);
       const item = entry;
-      if (seen.has(item.slug) || item.authority !== this.authority || item.workspaceId !== result.workspaceId || item.profileRevision !== result.profileRevision)
+      if (item.authorizationEpoch !== undefined && (typeof item.authorizationEpoch !== "string" || !/^[a-f0-9]{32}$/.test(item.authorizationEpoch)) || seen.has(item.slug) || item.authority !== this.authority || item.workspaceId !== result.workspaceId || item.profileRevision !== result.profileRevision)
         invalid();
       seen.add(item.slug);
     }
@@ -47147,7 +47642,7 @@ class HttpProfileClient {
     return this.request(`/skills/${encodeURIComponent(slug)}/versions/${encodeURIComponent(version2)}/bundle`);
   }
 }
-async function createProfileClient() {
+async function createProfileClient(signal) {
   let connection;
   try {
     connection = await resolveSkillsConnection();
@@ -47159,7 +47654,7 @@ async function createProfileClient() {
   }
   if (!connection)
     throw new Error("Selection profiles require a configured Skills API");
-  return new HttpProfileClient(connection.apiKey, connection.apiOrigin);
+  return new HttpProfileClient(connection.apiKey, connection.apiOrigin, signal);
 }
 var init_profile_client = __esm(() => {
   init_selection_cache();
@@ -47210,19 +47705,19 @@ function capturePreparationProcess(child, platform = process.platform, signalGro
 }
 
 // src/lib/dependency-preparation.ts
-import { constants as constants4, closeSync as closeSync7, fstatSync as fstatSync7, lstatSync as lstatSync9, mkdirSync as mkdirSync4, openSync as openSync7, readFileSync as readFileSync11, readdirSync as readdirSync5, rmdirSync, unlinkSync as unlinkSync2, ftruncateSync, writeSync } from "fs";
-import { join as join15 } from "path";
+import { constants as constants5, closeSync as closeSync8, fstatSync as fstatSync8, lstatSync as lstatSync10, mkdirSync as mkdirSync4, openSync as openSync8, readFileSync as readFileSync11, readdirSync as readdirSync5, rmdirSync, unlinkSync as unlinkSync2, ftruncateSync, writeSync } from "fs";
+import { join as join16 } from "path";
 function hasDependencyPreparationMarker(skillPath) {
   try {
-    lstatSync9(join15(skillPath, DEPENDENCY_PREPARATION_MARKER));
+    lstatSync10(join16(skillPath, DEPENDENCY_PREPARATION_MARKER));
     return true;
   } catch (error61) {
     return error61.code !== "ENOENT";
   }
 }
 function claimPreparation(skillPath) {
-  const marker = join15(skillPath, DEPENDENCY_PREPARATION_MARKER);
-  const state = join15(marker, "state.json"), active = join15(marker, "active");
+  const marker = join16(skillPath, DEPENDENCY_PREPARATION_MARKER);
+  const state = join16(marker, "state.json"), active = join16(marker, "active");
   let created = false;
   try {
     mkdirSync4(marker, { mode: 448 });
@@ -47233,21 +47728,21 @@ function claimPreparation(skillPath) {
   }
   let fd;
   try {
-    if (!lstatSync9(marker).isDirectory() || lstatSync9(marker).isSymbolicLink())
+    if (!lstatSync10(marker).isDirectory() || lstatSync10(marker).isSymbolicLink())
       return;
     if (!created) {
       if (readdirSync5(marker).some((name) => name !== "state.json"))
         return;
-      if (!lstatSync9(state).isFile() || lstatSync9(state).isSymbolicLink() || lstatSync9(state).size > 1024)
+      if (!lstatSync10(state).isFile() || lstatSync10(state).isSymbolicLink() || lstatSync10(state).size > 1024)
         return;
       const previous = JSON.parse(readFileSync11(state, "utf8"));
       if (previous.version !== 1 || previous.status !== "failed" || Object.keys(previous).length !== 2)
         return;
     }
     mkdirSync4(active, { mode: 448 });
-    fd = openSync7(state, constants4.O_RDWR | constants4.O_NOFOLLOW | (created ? constants4.O_CREAT | constants4.O_EXCL : 0), 384);
-    if (!fstatSync7(fd).isFile()) {
-      closeSync7(fd);
+    fd = openSync8(state, constants5.O_RDWR | constants5.O_NOFOLLOW | (created ? constants5.O_CREAT | constants5.O_EXCL : 0), 384);
+    if (!fstatSync8(fd).isFile()) {
+      closeSync8(fd);
       return;
     }
     const descriptor = fd;
@@ -47259,7 +47754,7 @@ function claimPreparation(skillPath) {
     record4("pending");
     return { abandon() {
       try {
-        closeSync7(descriptor);
+        closeSync8(descriptor);
       } catch {}
     }, finish(success2) {
       try {
@@ -47267,7 +47762,7 @@ function claimPreparation(skillPath) {
           unlinkSync2(state);
         else
           record4("failed");
-        closeSync7(descriptor);
+        closeSync8(descriptor);
         fd = undefined;
         rmdirSync(active);
         if (success2)
@@ -47275,7 +47770,7 @@ function claimPreparation(skillPath) {
         return true;
       } catch {
         try {
-          closeSync7(descriptor);
+          closeSync8(descriptor);
         } catch {}
         return false;
       }
@@ -47283,7 +47778,7 @@ function claimPreparation(skillPath) {
   } catch {
     if (fd !== undefined)
       try {
-        closeSync7(fd);
+        closeSync8(fd);
       } catch {}
     return;
   }
@@ -47443,283 +47938,6 @@ function isCodexLocalStdioMcpServer(name, server) {
   }
 }
 
-// src/lib/claude-settings-witness.ts
-import { createHash as createHash8 } from "crypto";
-import { closeSync as closeSync8, constants as constants5, fstatSync as fstatSync8, lstatSync as lstatSync10, openSync as openSync8, readSync as readSync4 } from "fs";
-import { basename as basename4, dirname as dirname9, isAbsolute as isAbsolute8, resolve as resolve8 } from "path";
-function need2(value, reason) {
-  if (!value)
-    throw new Error(`Claude settings witness ${reason}`);
-}
-function absolutePath(value) {
-  need2(typeof value === "string" && value.length > 0 && value.length <= CLAUDE_SETTINGS_WITNESS_LIMITS.pathCharacters && !/[\x00-\x1f\x7f]/.test(value) && isAbsolute8(value) && resolve8(value) === value, "requires a normalized absolute path");
-}
-function parents(path) {
-  const result = [];
-  for (let at = dirname9(path);; at = dirname9(at)) {
-    const stat = lstatSync10(at, { bigint: true });
-    need2(stat.isDirectory() && !stat.isSymbolicLink(), "path traverses a symlink or non-directory");
-    result.push([at, stat]);
-    if (at === dirname9(at))
-      return result;
-  }
-}
-function readNativeSettingsWitnessFile(path, budget, filename = "settings.json") {
-  absolutePath(path);
-  need2(basename4(path) === filename, `requires ${filename}`);
-  need2(Number.isSafeInteger(budget.remaining) && budget.remaining >= 0, "has an invalid byte budget");
-  const ancestors = parents(path), initial = lstatSync10(path, { bigint: true });
-  need2(initial.isFile() && !initial.isSymbolicLink() && initial.size <= BigInt(CLAUDE_SETTINGS_WITNESS_LIMITS.bytes), "is not a bounded regular file");
-  need2(initial.size <= BigInt(budget.remaining), "exceeds its aggregate byte limit");
-  const fd = openSync8(path, constants5.O_RDONLY | constants5.O_NOFOLLOW | constants5.O_NONBLOCK);
-  try {
-    const opened = fstatSync8(fd, { bigint: true });
-    need2(opened.isFile() && sameFile(initial, opened), "changed during open");
-    const bytes = Buffer.alloc(Number(opened.size) + 1);
-    let length = 0;
-    while (length < bytes.length) {
-      const count = readSync4(fd, bytes, length, bytes.length - length, null);
-      if (!count)
-        break;
-      length += count;
-    }
-    const after = fstatSync8(fd, { bigint: true }), current = lstatSync10(path, { bigint: true });
-    need2(current.isFile() && sameFile(opened, after) && sameFile(after, current) && BigInt(length) === opened.size, "changed during read");
-    for (const [ancestor, before] of ancestors) {
-      const now = lstatSync10(ancestor, { bigint: true });
-      need2(now.isDirectory() && before.dev === now.dev && before.ino === now.ino && before.mode === now.mode, "parent changed during read");
-    }
-    budget.remaining -= length;
-    try {
-      return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes.subarray(0, length));
-    } catch {
-      throw new Error("Claude settings witness is not strict UTF-8");
-    }
-  } finally {
-    closeSync8(fd);
-  }
-}
-function parse8(text2) {
-  let at = 0, nodes = 0;
-  const numberPattern = /-?(?:0|[1-9][0-9]*)(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?/y;
-  const space = () => {
-    while (at < text2.length && /[\x20\t\r\n]/.test(text2[at]))
-      at++;
-  };
-  function string5() {
-    need2(text2[at] === '"', "contains invalid JSON");
-    const start = at++;
-    while (at < text2.length) {
-      const character = text2[at++];
-      if (character === '"') {
-        let value2;
-        try {
-          value2 = JSON.parse(text2.slice(start, at));
-        } catch {
-          throw new Error("Claude settings witness contains invalid JSON string");
-        }
-        need2(value2.length <= CLAUDE_SETTINGS_WITNESS_LIMITS.stringCharacters, "exceeds its string limit");
-        return value2;
-      }
-      if (character === "\\")
-        at++;
-    }
-    throw new Error("Claude settings witness contains an unterminated JSON string");
-  }
-  function value(depth) {
-    need2(depth <= CLAUDE_SETTINGS_WITNESS_LIMITS.depth && ++nodes <= CLAUDE_SETTINGS_WITNESS_LIMITS.nodes, "exceeds its nesting or node limit");
-    space();
-    const character = text2[at];
-    if (character === '"')
-      return { kind: "string", value: string5() };
-    if (character === "{" || character === "[") {
-      at++;
-      space();
-      const object7 = character === "{", end = object7 ? "}" : "]", entries = [], items = [], keys = new Set;
-      if (text2[at] !== end)
-        while (true) {
-          if (object7) {
-            space();
-            const key = string5();
-            need2(!keys.has(key), "contains a duplicate JSON key");
-            keys.add(key);
-            space();
-            need2(text2[at++] === ":", "contains invalid JSON");
-            entries.push([key, value(depth + 1)]);
-          } else
-            items.push(value(depth + 1));
-          space();
-          if (text2[at] === end)
-            break;
-          need2(text2[at++] === ",", "contains invalid JSON");
-        }
-      at++;
-      return object7 ? { kind: "object", entries } : { kind: "array", items };
-    }
-    for (const literal3 of ["true", "false", "null"])
-      if (text2.startsWith(literal3, at)) {
-        at += literal3.length;
-        return { kind: "literal", value: literal3 };
-      }
-    numberPattern.lastIndex = at;
-    const number5 = numberPattern.exec(text2);
-    need2(number5, "contains invalid JSON");
-    at += number5[0].length;
-    return { kind: "number", value: number5[0] };
-  }
-  const root = value(0);
-  space();
-  need2(at === text2.length && root.kind === "object", "requires a JSON object without trailing content");
-  need2(root.entries.length <= CLAUDE_SETTINGS_WITNESS_LIMITS.rows, "exceeds its settings field limit");
-  return root;
-}
-function canonical2(value) {
-  if (value.kind === "object")
-    return { kind: "object", entries: value.entries.map(([key, child]) => [key, canonical2(child)]).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0) };
-  if (value.kind === "array")
-    return { kind: "array", items: value.items.map(canonical2) };
-  return value;
-}
-function inferencePreference(key, child, version2) {
-  if (key === "skipDangerousModePermissionPrompt") {
-    need2(child.kind === "literal" && (child.value === "true" || child.value === "false"), "contains an invalid dialog acknowledgment");
-    return false;
-  }
-  if (key === "effortLevel") {
-    need2(child.kind === "string" && PERSISTED_EFFORT_LEVELS.has(child.value), "contains an invalid persisted effort level");
-    return true;
-  }
-  if (key !== "modelSettings")
-    return false;
-  need2(child.kind === "object", "requires an object of model preferences");
-  child.entries = child.entries.filter(([model, preferences]) => {
-    if (version2 === 2 && !BUILTIN_MODEL_SELECTIONS.has(model) || preferences.kind !== "object" || preferences.entries.length !== 1 || preferences.entries[0][0] !== "effortLevel")
-      return true;
-    const effort = preferences.entries[0][1];
-    need2(effort.kind === "string" && PERSISTED_EFFORT_LEVELS.has(effort.value), "contains an invalid persisted model effort level");
-    return false;
-  });
-  return child.entries.length === 0;
-}
-function settingsDigest(text2, version2 = 1) {
-  const value = parse8(text2);
-  value.entries = value.entries.filter(([key, child]) => {
-    if (version2 !== 1 && inferencePreference(key, child, version2))
-      return false;
-    if (key === "model") {
-      need2(child.kind === "string", "contains an invalid model selection");
-      return !BUILTIN_MODEL_SELECTIONS.has(child.value);
-    }
-    if (BOOLEAN_PREFERENCES.has(key)) {
-      need2(child.kind === "literal" && (child.value === "true" || child.value === "false"), "contains an invalid display preference");
-      return false;
-    }
-    if (Object.hasOwn(ENUM_PREFERENCES, key)) {
-      need2(child.kind === "string" && ENUM_PREFERENCES[key].includes(child.value), "contains an invalid display preference");
-      return false;
-    }
-    return true;
-  });
-  return createHash8("sha256").update(`hasna.skills.claude-settings.v${version2}\x00`).update(JSON.stringify(canonical2(value))).digest("hex");
-}
-function hashClaudeSettingsReplacement(text2, budget) {
-  need2(typeof text2 === "string", "requires settings text");
-  const bytes = Buffer.byteLength(text2);
-  need2(bytes <= CLAUDE_SETTINGS_WITNESS_LIMITS.bytes && Number.isSafeInteger(budget.remaining) && budget.remaining >= bytes, "exceeds its byte limit");
-  budget.remaining -= bytes;
-  return settingsDigest(text2);
-}
-function captureClaudeSettings(path, budget = { remaining: 256 * 1024 * 1024 }) {
-  return { path, hashMode: "claude-settings-v1", sha256: settingsDigest(readNativeSettingsWitnessFile(path, budget)) };
-}
-function captureClaudeSettingsV2(path, budget = { remaining: 256 * 1024 * 1024 }) {
-  return { path, hashMode: "claude-settings-v2", sha256: settingsDigest(readNativeSettingsWitnessFile(path, budget), 2) };
-}
-function hashClaudeSettingsReplacementV2(text2, budget) {
-  need2(typeof text2 === "string", "requires settings text");
-  const bytes = Buffer.byteLength(text2);
-  need2(bytes <= CLAUDE_SETTINGS_WITNESS_LIMITS.bytes && Number.isSafeInteger(budget.remaining) && budget.remaining >= bytes, "exceeds its byte limit");
-  budget.remaining -= bytes;
-  return settingsDigest(text2, 2);
-}
-function captureClaudeSettingsV3(path, budget = { remaining: 256 * 1024 * 1024 }) {
-  return { path, hashMode: "claude-settings-v3", sha256: settingsDigest(readNativeSettingsWitnessFile(path, budget), 3) };
-}
-function hashClaudeSettingsReplacementV3(text2, budget) {
-  need2(typeof text2 === "string", "requires settings text");
-  const bytes = Buffer.byteLength(text2);
-  need2(bytes <= CLAUDE_SETTINGS_WITNESS_LIMITS.bytes && Number.isSafeInteger(budget.remaining) && budget.remaining >= bytes, "exceeds its byte limit");
-  budget.remaining -= bytes;
-  return settingsDigest(text2, 3);
-}
-function hashNativeJsonControls(text2, excludedMetadata) {
-  need2(Buffer.byteLength(text2) <= CLAUDE_SETTINGS_WITNESS_LIMITS.bytes, "exceeds its byte limit");
-  const value = parse8(text2);
-  value.entries = value.entries.filter(([key, child]) => {
-    if (key !== excludedMetadata)
-      return true;
-    need2(child.kind === "string" && child.value.length <= 128, "has invalid version metadata");
-    return false;
-  });
-  return createHash8("sha256").update("hasna.skills.native-json-controls.v1\x00").update(JSON.stringify(canonical2(value))).digest("hex");
-}
-var CLAUDE_SETTINGS_WITNESS_LIMITS, sameFile = (a, b) => a.dev === b.dev && a.ino === b.ino && a.mode === b.mode && a.uid === b.uid && a.gid === b.gid && a.nlink === b.nlink && a.size === b.size && a.mtimeNs === b.mtimeNs && a.ctimeNs === b.ctimeNs, BOOLEAN_PREFERENCES, ENUM_PREFERENCES, BUILTIN_MODEL_SELECTIONS, PERSISTED_EFFORT_LEVELS;
-var init_claude_settings_witness = __esm(() => {
-  CLAUDE_SETTINGS_WITNESS_LIMITS = Object.freeze({ bytes: 1024 * 1024, rows: 1024, depth: 32, nodes: 65536, stringCharacters: 16384, pathCharacters: 4096 });
-  BOOLEAN_PREFERENCES = new Set([
-    "autoScrollEnabled",
-    "axScreenReader",
-    "emojiCompletionEnabled",
-    "prefersReducedMotion",
-    "showTurnDuration",
-    "spinnerTipsEnabled",
-    "syntaxHighlightingDisabled",
-    "terminalProgressBarEnabled",
-    "terminalTitleFromRename",
-    "verbose",
-    "wheelScrollAccelerationEnabled"
-  ]);
-  ENUM_PREFERENCES = Object.freeze({
-    editorMode: ["normal", "vim"],
-    tui: ["default", "fullscreen"],
-    viewMode: ["default", "verbose", "focus"]
-  });
-  BUILTIN_MODEL_SELECTIONS = new Set([
-    "default",
-    "best",
-    "fable",
-    "fable[1m]",
-    "sonnet",
-    "sonnet[1m]",
-    "opus",
-    "opus[1m]",
-    "haiku",
-    "opusplan",
-    "claude-fable-5-1",
-    "claude-fable-5",
-    "claude-fable-5[1m]",
-    "claude-opus-5",
-    "claude-sonnet-5",
-    "claude-haiku-4-5-20251001",
-    "claude-opus-4-6",
-    "claude-sonnet-4-5",
-    "claude-sonnet-4-5-20250929",
-    "claude-opus-4-8",
-    "claude-opus-4-8[1m]",
-    "claude-opus-4-7",
-    "claude-sonnet-4-6",
-    "claude-opus-4-5-20251101",
-    "claude-opus-4-5",
-    "claude-haiku-4-5",
-    "claude-fable-5-1[1m]",
-    "claude-opus-5[1m]",
-    "claude-opus-4-7[1m]",
-    "claude-opus-4-6[1m]",
-    "claude-sonnet-4-6[1m]"
-  ]);
-  PERSISTED_EFFORT_LEVELS = new Set(["low", "medium", "high", "xhigh"]);
-});
-
 // src/lib/codex-native-compatibility.ts
 function supportsCodexNativeCapability(version2, capability) {
   return typeof version2 === "string" && Object.hasOwn(MEASURED_CODEX_CAPABILITIES, version2) && MEASURED_CODEX_CAPABILITIES[version2].includes(capability);
@@ -47762,7 +47980,7 @@ var init_codex_native_skill_catalog = __esm(() => {
 });
 
 // src/lib/codex-plugin-skill-controls.ts
-import { basename as basename5, dirname as dirname10, join as join16, relative as relative4, resolve as resolve9, sep as sep4 } from "path";
+import { basename as basename5, dirname as dirname10, join as join17, relative as relative4, resolve as resolve9, sep as sep5 } from "path";
 import { lstatSync as lstatSync11, readdirSync as readdirSync6, readlinkSync as readlinkSync3, realpathSync as realpathSync3 } from "fs";
 function refuse() {
   throw new Error("CODEX_NATIVE_SKILL_IDENTITY_UNSUPPORTED: review native plugin names and hook controls");
@@ -47771,7 +47989,7 @@ function remoteInstallationMatches(parent, remotePluginId, read) {
   try {
     if (!remotePluginIdentifier(remotePluginId) || !lstatSync11(parent).isDirectory() || realpathSync3(parent) !== parent)
       return false;
-    const path = join16(parent, ".codex-remote-plugin-install.json"), stat = lstatSync11(path, { throwIfNoEntry: false });
+    const path = join17(parent, ".codex-remote-plugin-install.json"), stat = lstatSync11(path, { throwIfNoEntry: false });
     if (!stat?.isFile() || stat.isSymbolicLink() || stat.size > 16384)
       return false;
     const text2 = read(path);
@@ -47847,8 +48065,8 @@ function isBundledCleanupHooks(root, namespace, value) {
   return true;
 }
 function rootControls(root, read) {
-  const manifestPath = join16(root, ".codex-plugin/plugin.json"), manifestFile = lstatSync11(manifestPath, { throwIfNoEntry: false });
-  if (!lstatSync11(join16(root, ".codex-plugin"), { throwIfNoEntry: false })?.isDirectory() || !manifestFile?.isFile() || manifestFile.size > 1024 * 1024)
+  const manifestPath = join17(root, ".codex-plugin/plugin.json"), manifestFile = lstatSync11(manifestPath, { throwIfNoEntry: false });
+  if (!lstatSync11(join17(root, ".codex-plugin"), { throwIfNoEntry: false })?.isDirectory() || !manifestFile?.isFile() || manifestFile.size > 1024 * 1024)
     refuse();
   let manifest, manifestSha256;
   try {
@@ -47863,9 +48081,9 @@ function rootControls(root, read) {
   const cacheVersion = basename5(root), declaredVersion = manifest.version === undefined ? "" : typeof manifest.version === "string" ? manifest.version.trim() : null;
   if (declaredVersion === null || (declaredVersion ? declaredVersion !== cacheVersion : cacheVersion !== CODEX_DEFAULT_AGENT_PLUGIN_VERSION))
     refuse();
-  if (manifest.hooks !== undefined && !isBundledCleanupHooks(root, manifest.name, manifest.hooks) || manifest.commands !== undefined || manifest.mcpServers !== undefined && manifest.mcpServers !== "./.mcp.json" || manifest.apps !== undefined && manifest.apps !== "./.app.json" || lstatSync11(join16(root, "hooks"), { throwIfNoEntry: false }))
+  if (manifest.hooks !== undefined && !isBundledCleanupHooks(root, manifest.name, manifest.hooks) || manifest.commands !== undefined || manifest.mcpServers !== undefined && manifest.mcpServers !== "./.mcp.json" || manifest.apps !== undefined && manifest.apps !== "./.app.json" || lstatSync11(join17(root, "hooks"), { throwIfNoEntry: false }))
     refuse();
-  const mcp = join16(root, ".mcp.json"), mcpPresent = lstatSync11(mcp, { throwIfNoEntry: false });
+  const mcp = join17(root, ".mcp.json"), mcpPresent = lstatSync11(mcp, { throwIfNoEntry: false });
   if (manifest.hooks !== undefined && (manifest.mcpServers !== undefined || mcpPresent))
     refuse();
   if (mcpPresent && (!mcpPresent.isFile() || mcpPresent.isSymbolicLink() || mcpPresent.size > 1024 * 1024 || realpathSync3(mcp) !== mcp))
@@ -47873,7 +48091,7 @@ function rootControls(root, read) {
   if (Boolean(mcpPresent) !== (manifest.mcpServers !== undefined))
     refuse();
   const mcpSha256 = mcpPresent ? mcpControls(mcp, read) : undefined;
-  const app = join16(root, ".app.json"), present = lstatSync11(app, { throwIfNoEntry: false });
+  const app = join17(root, ".app.json"), present = lstatSync11(app, { throwIfNoEntry: false });
   if (present && (!present.isFile() || present.isSymbolicLink() || present.size > 1024 * 1024))
     refuse();
   if (manifest.apps !== undefined && !present)
@@ -47883,7 +48101,7 @@ function rootControls(root, read) {
 }
 function reviewedDisabledCodexPluginParent(cache, parent, controls, rules) {
   try {
-    const parts = relative4(cache, parent).split(sep4), enrolled = controls.filter((control) => control.pluginParent === parent);
+    const parts = relative4(cache, parent).split(sep5), enrolled = controls.filter((control) => control.pluginParent === parent);
     if (resolve9(parent) !== parent || parts.length !== 2 || parts.some((part) => !identifier2(part)) || !enrolled.length || !Array.isArray(rules))
       return false;
     for (let cursor = parent;; cursor = dirname10(cursor)) {
@@ -47893,7 +48111,7 @@ function reviewedDisabledCodexPluginParent(cache, parent, controls, rules) {
       if (dirname10(cursor) === cursor)
         break;
     }
-    return enrolled.every((control) => control.namespace === parts[1] && control.pluginId === `${parts[1]}@${parts[0]}` && remotePluginIdentifier(control.remotePluginId) && control.skillsOnly === true && !control.appSha256 && !control.mcpSha256 && control.name.startsWith(control.namespace + ":") && /^[a-f0-9]{64}$/.test(control.manifestSha256) && rules.some((rule) => typeof rule?.name === "string" && rule.name.trim() === control.name && rule.enabled === false) && !rules.some((rule) => (typeof rule?.name === "string" && rule.name.trim() === control.name || typeof rule?.path === "string" && (rule.path === parent || rule.path.startsWith(parent + sep4))) && rule.enabled !== false));
+    return enrolled.every((control) => control.namespace === parts[1] && control.pluginId === `${parts[1]}@${parts[0]}` && remotePluginIdentifier(control.remotePluginId) && control.skillsOnly === true && !control.appSha256 && !control.mcpSha256 && control.name.startsWith(control.namespace + ":") && /^[a-f0-9]{64}$/.test(control.manifestSha256) && rules.some((rule) => typeof rule?.name === "string" && rule.name.trim() === control.name && rule.enabled === false) && !rules.some((rule) => (typeof rule?.name === "string" && rule.name.trim() === control.name || typeof rule?.path === "string" && (rule.path === parent || rule.path.startsWith(parent + sep5))) && rule.enabled !== false));
   } catch {
     return false;
   }
@@ -47903,7 +48121,7 @@ function absentDisabledCodexPluginParent(cache, parent, controls, rules) {
 }
 function reviewedRetiredCodexRoot(cache, root, controls, rules, read, allowAbsent = false) {
   try {
-    const parent = dirname10(root), parts = relative4(cache, parent).split(sep4), enrolled = controls.filter((control) => control.pluginParent === parent);
+    const parent = dirname10(root), parts = relative4(cache, parent).split(sep5), enrolled = controls.filter((control) => control.pluginParent === parent);
     if (resolve9(root) !== root || parts.length !== 2 || parts.some((part) => !identifier2(part)) || !basename5(root) || basename5(root) === "latest" || !enrolled.length || !Array.isArray(rules))
       return false;
     for (let cursor = root;; cursor = dirname10(cursor)) {
@@ -47913,14 +48131,14 @@ function reviewedRetiredCodexRoot(cache, root, controls, rules, read, allowAbsen
       if (dirname10(cursor) === cursor)
         break;
     }
-    if (!enrolled.every((control) => control.namespace === parts[1] && control.pluginId === `${parts[1]}@${parts[0]}` && remotePluginIdentifier(control.remotePluginId) && control.skillsOnly === true && !control.appSha256 && !control.mcpSha256 && control.name.startsWith(control.namespace + ":") && /^[a-f0-9]{64}$/.test(control.manifestSha256) && rules.some((rule) => typeof rule?.name === "string" && rule.name.trim() === control.name && rule.enabled === false) && !rules.some((rule) => (typeof rule?.name === "string" && rule.name.trim() === control.name || typeof rule?.path === "string" && (rule.path === parent || rule.path === root || rule.path.startsWith(root + sep4))) && rule.enabled !== false)))
+    if (!enrolled.every((control) => control.namespace === parts[1] && control.pluginId === `${parts[1]}@${parts[0]}` && remotePluginIdentifier(control.remotePluginId) && control.skillsOnly === true && !control.appSha256 && !control.mcpSha256 && control.name.startsWith(control.namespace + ":") && /^[a-f0-9]{64}$/.test(control.manifestSha256) && rules.some((rule) => typeof rule?.name === "string" && rule.name.trim() === control.name && rule.enabled === false) && !rules.some((rule) => (typeof rule?.name === "string" && rule.name.trim() === control.name || typeof rule?.path === "string" && (rule.path === parent || rule.path === root || rule.path.startsWith(root + sep5))) && rule.enabled !== false)))
       return false;
     if (!lstatSync11(root, { throwIfNoEntry: false }))
       return allowAbsent && (lstatSync11(parent, { throwIfNoEntry: false }) ? enrolled.every((control) => remoteInstallationMatches(parent, control.remotePluginId, read)) : absentDisabledCodexPluginParent(cache, parent, controls, rules));
     if (!enrolled.every((control) => remoteInstallationMatches(parent, control.remotePluginId, read)))
       return false;
     const parsed = rootControls(root, read);
-    if (JSON.parse(read(join16(root, ".codex-plugin/plugin.json"))).hooks !== undefined)
+    if (JSON.parse(read(join17(root, ".codex-plugin/plugin.json"))).hooks !== undefined)
       return false;
     if (!enrolled.some((control) => control.namespace === parsed.namespace && control.manifestSha256 === parsed.manifestSha256 && !parsed.appSha256 && !parsed.mcpSha256))
       return false;
@@ -47928,7 +48146,7 @@ function reviewedRetiredCodexRoot(cache, root, controls, rules, read, allowAbsen
     const emptySkills = (directory, depth) => depth <= 64 && readdirSync6(directory).every((name) => {
       if (++entries > 4096 || name === "SKILL.md")
         return false;
-      const path = join16(directory, name), stat = lstatSync11(path);
+      const path = join17(directory, name), stat = lstatSync11(path);
       return !stat.isSymbolicLink() && (stat.isFile() || stat.isDirectory() && emptySkills(path, depth + 1));
     });
     return emptySkills(root, 0);
@@ -47944,7 +48162,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 + sep4) || !lstatSync11(parent, { throwIfNoEntry: false })?.isDirectory() || realpathSync3(parent) !== parent)
+      if (!parent.startsWith(cache + sep5) || !lstatSync11(parent, { throwIfNoEntry: false })?.isDirectory() || realpathSync3(parent) !== parent)
         return false;
       for (const control of controls.filter((control2) => control2.pluginParent === parent)) {
         if (control.remotePluginId !== undefined && !remoteInstallationMatches(parent, control.remotePluginId, read))
@@ -47955,7 +48173,7 @@ function reviewedCodexPluginCapabilitiesUnchanged(cache, controls, read, rules)
       if (entries > 4096)
         return false;
       for (const name of names) {
-        let root = join16(parent, name), stat = lstatSync11(root);
+        let root = join17(parent, name), stat = lstatSync11(root);
         if (stat.isSymbolicLink()) {
           const target = resolve9(parent, readlinkSync3(root));
           if (name !== "latest" || dirname10(target) !== parent || !lstatSync11(target).isDirectory() || realpathSync3(target) !== target)
@@ -47963,7 +48181,7 @@ function reviewedCodexPluginCapabilitiesUnchanged(cache, controls, read, rules)
           root = target;
           stat = lstatSync11(root);
         }
-        if (!stat.isDirectory() || ![".codex-plugin/plugin.json", ".app.json", "hooks", ".mcp.json"].some((path) => lstatSync11(join16(root, path), { throwIfNoEntry: false })))
+        if (!stat.isDirectory() || ![".codex-plugin/plugin.json", ".app.json", "hooks", ".mcp.json"].some((path) => lstatSync11(join17(root, path), { throwIfNoEntry: false })))
           continue;
         const parsed = rootControls(root, read);
         if (!controls.some((control) => control.pluginParent === parent && control.namespace === parsed.namespace && control.manifestSha256 === parsed.manifestSha256 && control.appSha256 === parsed.appSha256 && control.mcpSha256 === parsed.mcpSha256))
@@ -47977,10 +48195,10 @@ function reviewedCodexPluginCapabilitiesUnchanged(cache, controls, read, rules)
 }
 function sourceInputUnchanged(input2, cache, read) {
   try {
-    const parts = relative4(cache, input2.pluginParent).split(sep4);
-    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 })) || resolve9(input2.sourceRoot) !== input2.sourceRoot || !lstatSync11(input2.sourceRoot).isDirectory() || realpathSync3(input2.sourceRoot) !== input2.sourceRoot || input2.sourceRoot === cache || input2.sourceRoot.startsWith(cache + sep4) || cache.startsWith(input2.sourceRoot + sep4))
+    const parts = relative4(cache, input2.pluginParent).split(sep5);
+    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 })) || resolve9(input2.sourceRoot) !== input2.sourceRoot || !lstatSync11(input2.sourceRoot).isDirectory() || realpathSync3(input2.sourceRoot) !== input2.sourceRoot || input2.sourceRoot === cache || input2.sourceRoot.startsWith(cache + sep5) || cache.startsWith(input2.sourceRoot + sep5))
       return false;
-    const path = join16(input2.sourceRoot, ".codex-plugin/plugin.json"), stat = lstatSync11(path);
+    const path = join17(input2.sourceRoot, ".codex-plugin/plugin.json"), stat = lstatSync11(path);
     if (!stat.isFile() || stat.size > 1024 * 1024 || realpathSync3(path) !== path)
       return false;
     const text2 = read(path);
@@ -47995,7 +48213,7 @@ function reviewedCodexPluginSourceRoots(cache, inputs, read) {
   if (!Array.isArray(inputs) || inputs.length > 4096 || new Set(inputs.map((input2) => input2.pluginId)).size !== inputs.length || new Set(inputs.map((input2) => input2.sourceRoot)).size !== inputs.length || inputs.some((input2) => !sourceInputUnchanged(input2, cache, read)))
     refuse();
   const roots = inputs.map((input2) => input2.sourceRoot);
-  if (roots.some((root) => roots.some((other) => root !== other && root.startsWith(other + sep4))))
+  if (roots.some((root) => roots.some((other) => root !== other && root.startsWith(other + sep5))))
     refuse();
   return roots;
 }
@@ -48016,7 +48234,7 @@ var init_codex_native_skill_policy = __esm(() => {
 });
 
 // src/lib/codex-settings-witness-v1.ts
-import { createHash as createHash9 } from "crypto";
+import { createHash as createHash10 } from "crypto";
 function need3(value) {
   if (!value)
     throw new Error("Invalid Codex settings witness");
@@ -48060,8 +48278,8 @@ function numericTokens(text2) {
   }
   return result;
 }
-function canonical3(value, depth = 0, budget = { remaining: 65536 }) {
-  need3(depth <= 32 && --budget.remaining >= 0);
+function canonical4(value, depth = 0, budget2 = { remaining: 65536 }) {
+  need3(depth <= 32 && --budget2.remaining >= 0);
   if (value === null)
     return ["null"];
   if (typeof value === "string")
@@ -48077,13 +48295,13 @@ function canonical3(value, depth = 0, budget = { remaining: 65536 }) {
     return ["date", value.toISOString()];
   }
   if (Array.isArray(value))
-    return ["array", value.map((child) => canonical3(child, depth + 1, budget))];
+    return ["array", value.map((child) => canonical4(child, depth + 1, budget2))];
   need3(value && typeof value === "object");
-  return ["object", Object.entries(value).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, child]) => [key, canonical3(child, depth + 1, budget)])];
+  return ["object", Object.entries(value).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, child]) => [key, canonical4(child, depth + 1, budget2)])];
 }
-function hashCodexSettingsReplacement(text2, budget = { remaining: 256 * 1024 * 1024 }) {
-  need3(Buffer.byteLength(text2) <= 1024 * 1024 && budget.remaining >= Buffer.byteLength(text2));
-  budget.remaining -= Buffer.byteLength(text2);
+function hashCodexSettingsReplacement(text2, budget2 = { remaining: 256 * 1024 * 1024 }) {
+  need3(Buffer.byteLength(text2) <= 1024 * 1024 && budget2.remaining >= Buffer.byteLength(text2));
+  budget2.remaining -= Buffer.byteLength(text2);
   let config2;
   try {
     config2 = Bun.TOML.parse(text2);
@@ -48100,13 +48318,13 @@ function hashCodexSettingsReplacement(text2, budget = { remaining: 256 * 1024 *
       need3(typeof config2[key] === "string" && values.has(config2[key]));
       delete config2[key];
     }
-  return sha(`hasna.skills.codex-settings.v1\x00${JSON.stringify([canonical3(config2), numericTokens(text2)])}`);
+  return sha(`hasna.skills.codex-settings.v1\x00${JSON.stringify([canonical4(config2), numericTokens(text2)])}`);
 }
-function captureCodexSettings(path, budget = { remaining: 256 * 1024 * 1024 }) {
-  const text2 = readNativeSettingsWitnessFile(path, budget, "config.toml");
+function captureCodexSettings(path, budget2 = { remaining: 256 * 1024 * 1024 }) {
+  const text2 = readNativeSettingsWitnessFile(path, budget2, "config.toml");
   return { path, hashMode: "codex-settings-v1", sha256: hashCodexSettingsReplacement(text2) };
 }
-var sha = (text2) => createHash9("sha256").update(text2).digest("hex"), EFFORT, VERBOSITY;
+var sha = (text2) => createHash10("sha256").update(text2).digest("hex"), EFFORT, VERBOSITY;
 var init_codex_settings_witness_v1 = __esm(() => {
   init_claude_settings_witness();
   EFFORT = new Set(["none", "minimal", "low", "medium", "high", "xhigh"]);
@@ -48179,7 +48397,7 @@ function projectRegularCodexMcp(config2, source) {
 var init_codex_mcp_discovery_projection = () => {};
 
 // src/lib/codex-settings-witness.ts
-import { createHash as createHash10 } from "crypto";
+import { createHash as createHash11 } from "crypto";
 import { isDeepStrictEqual as isDeepStrictEqual3 } from "util";
 function need4(value) {
   if (!value)
@@ -48230,8 +48448,8 @@ function numericTokens2(text2) {
   }
   return result.sort();
 }
-function canonical4(value, depth = 0, budget = { remaining: 65536 }) {
-  need4(depth <= 32 && --budget.remaining >= 0);
+function canonical5(value, depth = 0, budget2 = { remaining: 65536 }) {
+  need4(depth <= 32 && --budget2.remaining >= 0);
   if (value === null)
     return ["null"];
   if (typeof value === "string")
@@ -48247,9 +48465,9 @@ function canonical4(value, depth = 0, budget = { remaining: 65536 }) {
     return ["date", value.toISOString()];
   }
   if (Array.isArray(value))
-    return ["array", value.map((child) => canonical4(child, depth + 1, budget))];
+    return ["array", value.map((child) => canonical5(child, depth + 1, budget2))];
   need4(isRecord3(value));
-  return ["object", Object.entries(value).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, child]) => [key, canonical4(child, depth + 1, budget)])];
+  return ["object", Object.entries(value).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, child]) => [key, canonical5(child, depth + 1, budget2)])];
 }
 function normalize2(config2, version2 = 2) {
   if (isRecord3(config2.hooks)) {
@@ -48423,34 +48641,34 @@ function settingsDigest2(text2, version2 = 2) {
   const mcp = version2 >= 3 ? projectRegularCodexMcp(config2, text2) : { config: config2, numericSource: text2 };
   const projected = version2 === 4 ? projectModelAvailabilityNux(mcp.config, mcp.numericSource) : mcp;
   normalize2(projected.config, version2);
-  return sha2(`hasna.skills.codex-settings.v${version2}\x00${JSON.stringify([canonical4(projected.config), numericTokens2(projected.numericSource)])}`);
+  return sha2(`hasna.skills.codex-settings.v${version2}\x00${JSON.stringify([canonical5(projected.config), numericTokens2(projected.numericSource)])}`);
 }
-function hashCodexSettingsReplacementV2(text2, budget = { remaining: 256 * 1024 * 1024 }) {
-  need4(Buffer.byteLength(text2) <= 1024 * 1024 && budget.remaining >= Buffer.byteLength(text2));
-  budget.remaining -= Buffer.byteLength(text2);
+function hashCodexSettingsReplacementV2(text2, budget2 = { remaining: 256 * 1024 * 1024 }) {
+  need4(Buffer.byteLength(text2) <= 1024 * 1024 && budget2.remaining >= Buffer.byteLength(text2));
+  budget2.remaining -= Buffer.byteLength(text2);
   return settingsDigest2(text2);
 }
-function captureCodexSettingsV2(path, budget = { remaining: 256 * 1024 * 1024 }) {
-  const text2 = readNativeSettingsWitnessFile(path, budget, "config.toml");
+function captureCodexSettingsV2(path, budget2 = { remaining: 256 * 1024 * 1024 }) {
+  const text2 = readNativeSettingsWitnessFile(path, budget2, "config.toml");
   return { path, hashMode: "codex-settings-v2", sha256: settingsDigest2(text2) };
 }
-function hashCodexSettingsReplacementV3(text2, budget = { remaining: 256 * 1024 * 1024 }) {
-  need4(Buffer.byteLength(text2) <= 1024 * 1024 && budget.remaining >= Buffer.byteLength(text2));
-  budget.remaining -= Buffer.byteLength(text2);
+function hashCodexSettingsReplacementV3(text2, budget2 = { remaining: 256 * 1024 * 1024 }) {
+  need4(Buffer.byteLength(text2) <= 1024 * 1024 && budget2.remaining >= Buffer.byteLength(text2));
+  budget2.remaining -= Buffer.byteLength(text2);
   return settingsDigest2(text2, 3);
 }
-function captureCodexSettingsV3(path, budget = { remaining: 256 * 1024 * 1024 }) {
-  return { path, hashMode: "codex-settings-v3", sha256: settingsDigest2(readNativeSettingsWitnessFile(path, budget, "config.toml"), 3) };
+function captureCodexSettingsV3(path, budget2 = { remaining: 256 * 1024 * 1024 }) {
+  return { path, hashMode: "codex-settings-v3", sha256: settingsDigest2(readNativeSettingsWitnessFile(path, budget2, "config.toml"), 3) };
 }
-function hashCodexSettingsReplacementV4(text2, budget = { remaining: 256 * 1024 * 1024 }) {
-  need4(Buffer.byteLength(text2) <= 1024 * 1024 && budget.remaining >= Buffer.byteLength(text2));
-  budget.remaining -= Buffer.byteLength(text2);
+function hashCodexSettingsReplacementV4(text2, budget2 = { remaining: 256 * 1024 * 1024 }) {
+  need4(Buffer.byteLength(text2) <= 1024 * 1024 && budget2.remaining >= Buffer.byteLength(text2));
+  budget2.remaining -= Buffer.byteLength(text2);
   return settingsDigest2(text2, 4);
 }
-function captureCodexSettingsV4(path, budget = { remaining: 256 * 1024 * 1024 }) {
-  return { path, hashMode: "codex-settings-v4", sha256: settingsDigest2(readNativeSettingsWitnessFile(path, budget, "config.toml"), 4) };
+function captureCodexSettingsV4(path, budget2 = { remaining: 256 * 1024 * 1024 }) {
+  return { path, hashMode: "codex-settings-v4", sha256: settingsDigest2(readNativeSettingsWitnessFile(path, budget2, "config.toml"), 4) };
 }
-var sha2 = (text2) => createHash10("sha256").update(text2).digest("hex"), EFFORT2, VERBOSITY2, MODEL, CODEX_DISCOVERY_PROJECTION_FIELDS, INFERENCE;
+var sha2 = (text2) => createHash11("sha256").update(text2).digest("hex"), EFFORT2, VERBOSITY2, MODEL, CODEX_DISCOVERY_PROJECTION_FIELDS, INFERENCE;
 var init_codex_settings_witness = __esm(() => {
   init_codex_settings_witness_v1();
   init_codex_settings_witness_v1();
@@ -48465,7 +48683,7 @@ var init_codex_settings_witness = __esm(() => {
 
 // src/lib/managed-policy.ts
 import { closeSync as closeSync9, constants as constants6, fstatSync as fstatSync9, lstatSync as lstatSync12, openSync as openSync9, readSync as readSync5 } from "fs";
-import { join as join17 } from "path";
+import { join as join18 } from "path";
 function refusal(reason = "is unreadable") {
   return new SkillSelectionError("INVALID_AGENT_POLICY", `The Skills agent loading policy ${reason}; refusing legacy fallback.`);
 }
@@ -48490,7 +48708,7 @@ function parseManagedSkillPolicy(text2) {
   return value;
 }
 function readManagedSkillPolicySnapshot(dataDir2 = getDataDirReadOnly()) {
-  const path = join17(dataDir2, "agent-policy.json");
+  const path = join18(dataDir2, "agent-policy.json");
   let descriptor, observed = false;
   try {
     const stat = lstatSync12(path);
@@ -48543,7 +48761,7 @@ var init_managed_policy = __esm(() => {
 });
 
 // src/lib/agent-bridge.ts
-import { createHash as createHash11 } from "crypto";
+import { createHash as createHash12 } 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.
@@ -48559,7 +48777,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 = createHash11("sha256").update(markdown).digest("hex");
+  CLI_BRIDGE_DIGEST = createHash12("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)}
@@ -48572,39 +48790,39 @@ var init_agent_codex = () => {};
 
 // src/lib/agent-sumi.ts
 import { existsSync as existsSync8, lstatSync as lstatSync13, realpathSync as realpathSync4 } from "fs";
-import { join as join18, resolve as resolve10 } from "path";
+import { join as join19, resolve as resolve10 } from "path";
 function sumiConfigDirectory(home, env = process.env) {
   for (const key of ["SUMI_CONFIG", "SUMI_CONFIG_CONTENT"])
     if (env[key] !== undefined)
       throw new Error(`Sumi ${key} requires a dedicated discovery adapter; unset it before Skills integration`);
   const selected = (key) => env[key]?.trim() ? env[key] : undefined;
-  const expand = (value) => resolve10(value === "~" ? home : value.startsWith("~/") ? join18(home, value.slice(2)) : value);
+  const expand = (value) => resolve10(value === "~" ? home : value.startsWith("~/") ? join19(home, value.slice(2)) : value);
   const explicit = selected("SUMI_CONFIG_DIR");
   const xdg = selected("XDG_CONFIG_HOME");
   const custom2 = selected("SUMI_HOME");
-  const canonical5 = explicit ? expand(explicit) : xdg ? join18(expand(xdg), "sumi") : join18(custom2 ? expand(custom2) : join18(home, ".hasna-internal/sumi"), "config");
+  const canonical6 = explicit ? expand(explicit) : xdg ? join19(expand(xdg), "sumi") : join19(custom2 ? expand(custom2) : join19(home, ".hasna-internal/sumi"), "config");
   if (explicit || xdg || custom2)
-    return canonical5;
-  const legacy = join18(home, ".config/sumi");
-  const a = lstatSync13(canonical5, { throwIfNoEntry: false }), b = lstatSync13(legacy, { throwIfNoEntry: false });
-  if (a && b && realpathSync4(canonical5) !== realpathSync4(legacy))
+    return canonical6;
+  const legacy = join19(home, ".config/sumi");
+  const a = lstatSync13(canonical6, { throwIfNoEntry: false }), b = lstatSync13(legacy, { throwIfNoEntry: false });
+  if (a && b && realpathSync4(canonical6) !== realpathSync4(legacy))
     throw new Error("Sumi config roots conflict; complete native home adoption before Skills integration");
-  const path = a ? canonical5 : b ? legacy : canonical5;
+  const path = a ? canonical6 : b ? legacy : canonical6;
   if (!existsSync8(path))
     return path;
   const physical = realpathSync4(path);
-  if ((a?.isSymbolicLink() || b?.isSymbolicLink()) && ![canonical5, legacy].includes(physical))
+  if ((a?.isSymbolicLink() || b?.isSymbolicLink()) && ![canonical6, legacy].includes(physical))
     throw new Error("Sumi config alias must resolve to its canonical or legacy root");
   return physical;
 }
 function sumiConfigPath(home) {
-  return join18(sumiConfigDirectory(home), "sumi.json");
+  return join19(sumiConfigDirectory(home), "sumi.json");
 }
 var init_agent_sumi = () => {};
 
 // src/lib/codex-hook-trust-files.ts
 import { closeSync as closeSync10, constants as constants7, fstatSync as fstatSync10, fsyncSync as fsyncSync2, lstatSync as lstatSync14, openSync as openSync10, readSync as readSync6, writeFileSync as writeFileSync4 } from "fs";
-import { createHash as createHash12 } from "crypto";
+import { createHash as createHash13 } from "crypto";
 import { dirname as dirname11 } from "path";
 function need5(value, code) {
   if (!value)
@@ -48639,7 +48857,7 @@ function snapshot(file2, privateFile = false, options = {}) {
     }
     need5(length === Number(before.size) && sameStat(before, fstatSync10(fd, { bigint: true })) && sameStat(before, lstatSync14(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: createHash12("sha256").update(content).digest("hex") };
+    return { file: file2, privateFile, readOnlyPackage, text: text2, bytes: content, stat: before, sha256: createHash13("sha256").update(content).digest("hex") };
   } finally {
     closeSync10(fd);
   }
@@ -48653,6 +48871,7 @@ var init_codex_hook_trust_files = () => {};
 
 // src/lib/agent-integration.ts
 var init_agent_integration = __esm(() => {
+  init_sumi_settings_witness();
   init_codex_corpus_write();
   init_codex_plugin_skill_controls();
   init_codex_native_skill_policy();
@@ -48707,12 +48926,12 @@ var init_skill_aliases = __esm(() => {
 
 // src/lib/project-state.ts
 import { existsSync as existsSync9, mkdirSync as mkdirSync5, readFileSync as readFileSync12, writeFileSync as writeFileSync5 } from "fs";
-import { join as join19 } from "path";
+import { join as join20 } from "path";
 function getProjectStateDir(targetDir = process.cwd()) {
-  return join19(targetDir, SKILLS_PROJECT_DIR);
+  return join20(targetDir, SKILLS_PROJECT_DIR);
 }
 function getProjectConfigPath(targetDir = process.cwd()) {
-  return join19(getProjectStateDir(targetDir), PROJECT_CONFIG_FILE);
+  return join20(getProjectStateDir(targetDir), PROJECT_CONFIG_FILE);
 }
 function loadProjectConfig(targetDir = process.cwd()) {
   const path = getProjectConfigPath(targetDir);
@@ -48828,7 +49047,7 @@ var init_project_state = __esm(() => {
 
 // src/lib/installer.ts
 import { existsSync as existsSync10, readFileSync as readFileSync13, rmSync } from "fs";
-import { join as join20 } from "path";
+import { join as join21 } from "path";
 import { homedir as homedir2 } from "os";
 function getSkillPath(name) {
   const skillName = normalizeSkillName(getCanonicalSkillName(name));
@@ -48838,7 +49057,7 @@ function getSkillPath(name) {
   const extensionPath = findExtensionSkillPath(skillName);
   if (extensionPath)
     return extensionPath;
-  return join20(getPortableSkillsRoot(), skillName);
+  return join21(getPortableSkillsRoot(), skillName);
 }
 function getCanonicalSkillName(name) {
   return getSkill(name)?.name ?? resolveSkillAlias(normalizeSkillSlug(name));
@@ -48892,11 +49111,11 @@ function getAgentSkillsDir(agent, scope = "global", projectDir) {
   const base = projectDir || process.cwd();
   switch (agent) {
     case "pi":
-      return scope === "project" ? join20(base, ".pi", "skills") : join20(homedir2(), ".pi", "agent", "skills");
+      return scope === "project" ? join21(base, ".pi", "skills") : join21(homedir2(), ".pi", "agent", "skills");
     case "opencode":
-      return scope === "project" ? join20(base, ".opencode", "skills") : join20(homedir2(), ".config", "opencode", "skills");
+      return scope === "project" ? join21(base, ".opencode", "skills") : join21(homedir2(), ".config", "opencode", "skills");
     default:
-      return scope === "project" ? join20(base, `.${agent}`, "skills") : join20(homedir2(), `.${agent}`, "skills");
+      return scope === "project" ? join21(base, `.${agent}`, "skills") : join21(homedir2(), `.${agent}`, "skills");
   }
 }
 function warnMissingDependencies(name, targetDir) {
@@ -48911,7 +49130,7 @@ function warnMissingDependencies(name, targetDir) {
   }
 }
 function readBundledSkillVersion(name) {
-  const pkgPath = join20(getSkillPath(name), "package.json");
+  const pkgPath = join21(getSkillPath(name), "package.json");
   if (!existsSync10(pkgPath))
     return "unknown";
   try {
@@ -48981,11 +49200,11 @@ var init_skill_doc_file = __esm(() => {
 
 // src/lib/skillinfo.ts
 import { existsSync as existsSync11, readFileSync as readFileSync14 } from "fs";
-import { join as join21 } from "path";
+import { join as join22 } from "path";
 function isInstructionSkillDir(skillPath, meta3) {
   if (meta3?.kind === "instruction")
     return true;
-  const skillMdPath = join21(skillPath, "SKILL.md");
+  const skillMdPath = join22(skillPath, "SKILL.md");
   if (!existsSync11(skillMdPath))
     return false;
   try {
@@ -48999,9 +49218,9 @@ function getSkillDocs(name) {
   if (!existsSync11(skillPath))
     return null;
   return {
-    skillMd: readIfExists(join21(skillPath, "SKILL.md")),
-    readme: readIfExists(join21(skillPath, "README.md")),
-    claudeMd: readIfExists(join21(skillPath, "CLAUDE.md"))
+    skillMd: readIfExists(join22(skillPath, "SKILL.md")),
+    readme: readIfExists(join22(skillPath, "README.md")),
+    claudeMd: readIfExists(join22(skillPath, "CLAUDE.md"))
   };
 }
 function getSkillBestDoc(name, file2) {
@@ -49017,14 +49236,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(join21(skillPath, file2));
+    const content = readIfExists(join22(skillPath, file2));
     if (content)
       texts.push(content);
   }
   const meta3 = getSkill(name);
   let dependencies = {};
   try {
-    dependencies = JSON.parse(readFileSync14(join21(skillPath, "package.json"), "utf8")).dependencies || {};
+    dependencies = JSON.parse(readFileSync14(join22(skillPath, "package.json"), "utf8")).dependencies || {};
   } catch {}
   return getSkillRequirementsFromContent(name, texts, dependencies, meta3);
 }
@@ -49086,7 +49305,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 = join21(skillPath, "package.json");
+  const pkgPath = join22(skillPath, "package.json");
   if (!existsSync11(pkgPath)) {
     return { exitCode: 1, error: `No package.json in skill '${name}'` };
   }
@@ -49106,12 +49325,12 @@ async function runSkill(name, args, options = {}) {
   } catch {
     return { exitCode: 1, error: `Failed to parse package.json for skill '${name}'` };
   }
-  const entryPath = join21(skillPath, entryPoint2);
+  const entryPath = join22(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(join21(skillPath, "node_modules")) || hasDependencyPreparationMarker(skillPath)) {
+  if (!existsSync11(join22(skillPath, "node_modules")) || hasDependencyPreparationMarker(skillPath)) {
     const failure = await prepareSkillDependencies(skillPath, env, options.preparationTimeoutMs);
     if (failure)
       return failure;
@@ -49137,7 +49356,7 @@ async function runSkill(name, args, options = {}) {
 function detectProjectSkills(cwd = process.cwd()) {
   let pkg;
   try {
-    pkg = JSON.parse(readFileSync14(join21(cwd, "package.json"), "utf8"));
+    pkg = JSON.parse(readFileSync14(join22(cwd, "package.json"), "utf8"));
   } catch {
     return { detected: [], recommended: [] };
   }
@@ -49342,7 +49561,7 @@ var init_selection_resolver = __esm(() => {
 });
 
 // src/lib/plugin-projection.ts
-import { createHash as createHash13 } from "crypto";
+import { createHash as createHash14 } from "crypto";
 function pluginRefusal(message) {
   throw new SkillSelectionError("PLUGIN_ADMISSION_REFUSED", message);
 }
@@ -49420,7 +49639,7 @@ function pluginFileWitnesses(entries) {
     return { path: item.path, mode: item.mode, size: item.bytes.byteLength, sha256: pluginHash(item.bytes) };
   });
 }
-var PLUGIN_PROJECTION_LIMITS, pluginHash = (bytes) => createHash13("sha256").update(bytes).digest("hex");
+var PLUGIN_PROJECTION_LIMITS, pluginHash = (bytes) => createHash14("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 });
@@ -49428,7 +49647,7 @@ var init_plugin_projection = __esm(() => {
 
 // src/lib/plugin-projection-store.ts
 import { constants as constants8, closeSync as closeSync11, fchmodSync, fstatSync as fstatSync11, fsyncSync as fsyncSync3, linkSync as linkSync2, lstatSync as lstatSync15, mkdirSync as mkdirSync6, openSync as openSync11, opendirSync as opendirSync2, readSync as readSync7, renameSync as renameSync2, rmdirSync as rmdirSync2, rmSync as rmSync2, unlinkSync as unlinkSync3, writeSync as writeSync2 } from "fs";
-import { dirname as dirname12, isAbsolute as isAbsolute9, join as join22, parse as parse9, resolve as resolve11 } from "path";
+import { dirname as dirname12, isAbsolute as isAbsolute9, join as join23, parse as parse10, resolve as resolve11 } from "path";
 function stat(path) {
   try {
     return lstatSync15(path, { bigint: true });
@@ -49438,7 +49657,7 @@ function stat(path) {
     return pluginRefusal("Cannot inspect plugin filesystem entry");
   }
 }
-function canonical5(path) {
+function canonical6(path) {
   pluginNeed(typeof path === "string" && path.length <= 8192 && isAbsolute9(path) && resolve11(path) === path && !/[\x00-\x1f\x7f]/.test(path), "Plugin storage paths must be canonical absolute paths");
 }
 function owner(stats, system = false) {
@@ -49449,12 +49668,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) {
-  canonical5(path);
-  const result = [], parent = dirname12(path), filesystemRoot = parse9(parent).root;
+  canonical6(path);
+  const result = [], parent = dirname12(path), filesystemRoot = parse10(parent).root;
   let current = filesystemRoot;
   for (const segment of ["", ...parent.slice(filesystemRoot.length).split("/").filter(Boolean)]) {
     if (segment)
-      current = join22(current, segment);
+      current = join23(current, segment);
     let currentStat = stat(current);
     if (!currentStat && create) {
       try {
@@ -49562,7 +49781,7 @@ function snapshotPluginTree(root, options = {}) {
       pluginNeed(++visited <= PLUGIN_PROJECTION_LIMITS.files * 50, "Plugin tree membership exceeds its limit");
       const path = relative5 ? `${relative5}/${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 = join22(directory, name), entryStat = stat(absolute);
+      const absolute = join23(directory, name), entryStat = stat(absolute);
       pluginNeed(entryStat, "Plugin tree member disappeared");
       if (relative5 === "" && name === ".orphaned_at" && (options.nativeRuntime === "claude-2.1.274" || options.nativeRuntime === "claude-2.1.276")) {
         const bytes2 = readBytes(absolute, 32, "native-pin");
@@ -49579,7 +49798,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 = join22(absolute, pin), pinStat = stat(pinPath);
+          const pinPath = join23(absolute, pin), pinStat = stat(pinPath);
           pluginNeed(pinStat, "Native plugin pin disappeared");
           const bytes2 = readBytes(pinPath, 4096, "native-pin");
           let value;
@@ -49676,7 +49895,7 @@ var init_selected_manifest = __esm(() => {
 });
 
 // src/lib/plugin-admission.ts
-import { isAbsolute as isAbsolute10, join as join23, resolve as resolve12 } from "path";
+import { isAbsolute as isAbsolute10, join as join24, resolve as resolve12 } from "path";
 function validatePluginTarget(value) {
   pluginKeys(value, ["schemaVersion", "pluginId", "registrations", "native", "resolver"]);
   pluginNeed(value.schemaVersion === 1, "Invalid plugin admission target");
@@ -49837,12 +50056,12 @@ function pluginResolverCommand(binding) {
 }
 function pluginBindingPath(storeRoot, id) {
   pluginNeed(/^[a-f0-9]{64}$/.test(id), "Invalid plugin binding identifier");
-  return join23(storeRoot, "bindings", `${id}.json`);
+  return join24(storeRoot, "bindings", `${id}.json`);
 }
 function pluginReceiptPath(storeRoot, id, digest) {
   pluginNeed(/^[a-f0-9]{64}$/.test(id), "Invalid plugin binding identifier");
   pluginDigest(digest);
-  return join23(storeRoot, "receipts", id, `${digest.slice(7)}.json`);
+  return join24(storeRoot, "receipts", id, `${digest.slice(7)}.json`);
 }
 function readPluginBinding(storeRoot, id) {
   const value = readPluginJson(pluginBindingPath(storeRoot, id));
@@ -49862,7 +50081,7 @@ function readPluginAdmissionReceipt(storeRoot, id, digest) {
   pluginNeed(receipt.plan.bindingId === id && receipt.plan.planDigest === digest, "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 === join23(storeRoot, "objects", id, digest.slice(7)), "Plugin receipt points outside its immutable materialization");
+  pluginNeed(receipt.materializedPath === join24(storeRoot, "objects", id, digest.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;
@@ -49880,7 +50099,7 @@ var init_plugin_admission = __esm(() => {
 
 // src/lib/plugin-discovery.ts
 import { closeSync as closeSync12, constants as constants9, fstatSync as fstatSync12, lstatSync as lstatSync16, openSync as openSync12, opendirSync as opendirSync3, readSync as readSync8 } from "fs";
-import { basename as basename6, dirname as dirname13, isAbsolute as isAbsolute11, join as join24, resolve as resolve13 } from "path";
+import { basename as basename6, dirname as dirname13, isAbsolute as isAbsolute11, join as join25, resolve as resolve13 } 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;
@@ -49947,7 +50166,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 = join24(dirname13(path), "cache", market, name);
+    const [name, market] = target.pluginId.split("@"), cacheRoot = join25(dirname13(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");
@@ -49960,7 +50179,7 @@ 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 === join24(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 === join25(cacheRoot, row.version), "Managed plugin cache path or version is outside its registration");
       const approval = (producer) => {
         pluginText(producer);
         const digest = `sha256:${basename6(producer)}`;
@@ -50003,11 +50222,11 @@ function hashManagedPluginRegistry(path, managed) {
       directory.closeSync();
     }
     for (const version2 of names.sort()) {
-      const files = pluginFileWitnesses(snapshotPluginTree(join24(cacheRoot, version2), { nativeRuntime: `claude-${target.native.version}` }));
+      const files = pluginFileWitnesses(snapshotPluginTree(join25(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(join24(cacheRoot, version2));
+      const expected = currentFiles.get(join25(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");
     }
@@ -50027,7 +50246,7 @@ var init_plugin_discovery = __esm(() => {
 });
 
 // src/lib/claude-marketplace-registry.ts
-import { createHash as createHash14 } from "crypto";
+import { createHash as createHash15 } from "crypto";
 import { closeSync as closeSync13, constants as constants10, fstatSync as fstatSync13, lstatSync as lstatSync17, openSync as openSync13, readSync as readSync9 } from "fs";
 import { basename as basename7, dirname as dirname14, isAbsolute as isAbsolute12, resolve as resolve14 } from "path";
 function need6(value, reason) {
@@ -50047,13 +50266,13 @@ function parents2(path) {
       return result;
   }
 }
-function readRegistry2(path, budget) {
+function readRegistry2(path, budget2) {
   absolutePath2(path);
   need6(basename7(path) === "known_marketplaces.json", "requires known_marketplaces.json");
-  need6(Number.isSafeInteger(budget.remaining) && budget.remaining >= 0, "has an invalid byte budget");
+  need6(Number.isSafeInteger(budget2.remaining) && budget2.remaining >= 0, "has an invalid byte budget");
   const ancestors2 = parents2(path), initial = lstatSync17(path, { bigint: true });
   need6(initial.isFile() && !initial.isSymbolicLink() && initial.size <= BigInt(CLAUDE_MARKETPLACE_REGISTRY_LIMITS.bytes), "is not a bounded regular file");
-  need6(initial.size <= BigInt(budget.remaining), "exceeds its aggregate byte limit");
+  need6(initial.size <= BigInt(budget2.remaining), "exceeds its aggregate byte limit");
   const fd = openSync13(path, constants10.O_RDONLY | constants10.O_NOFOLLOW | constants10.O_NONBLOCK);
   try {
     const opened = fstatSync13(fd, { bigint: true });
@@ -50072,7 +50291,7 @@ function readRegistry2(path, budget) {
       const now = lstatSync17(ancestor, { bigint: true });
       need6(now.isDirectory() && before.dev === now.dev && before.ino === now.ino && before.mode === now.mode, "parent changed during read");
     }
-    budget.remaining -= length;
+    budget2.remaining -= length;
     try {
       return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes.subarray(0, length));
     } catch {
@@ -50082,7 +50301,7 @@ function readRegistry2(path, budget) {
     closeSync13(fd);
   }
 }
-function parse10(text2) {
+function parse11(text2) {
   let at = 0, nodes = 0;
   const numberPattern = /-?(?:0|[1-9][0-9]*)(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?/y;
   const space = () => {
@@ -50189,18 +50408,18 @@ function normalizeRow(row, version2 = 1) {
   need6(Number.isFinite(millis) && new Date(millis).toISOString() === updated, "contains an invalid recognized update timestamp");
   row.entries = row.entries.map(([key, value]) => [key, key === "lastUpdated" ? { kind: "validated-update-time" } : value]);
 }
-function captureClaudeMarketplaceRegistry(path, budget = { remaining: 256 * 1024 * 1024 }) {
-  const value = parse10(readRegistry2(path, budget));
+function captureClaudeMarketplaceRegistry(path, budget2 = { remaining: 256 * 1024 * 1024 }) {
+  const value = parse11(readRegistry2(path, budget2));
   for (const [, row] of value.entries)
     normalizeRow(row);
-  const sha2562 = createHash14("sha256").update("hasna.skills.claude-marketplace-registry.v1\x00").update(JSON.stringify(value)).digest("hex");
+  const sha2562 = createHash15("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, budget = { remaining: 256 * 1024 * 1024 }) {
-  const value = parse10(readRegistry2(path, budget));
+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 = createHash14("sha256").update("hasna.skills.claude-marketplace-registry.v2\x00").update(JSON.stringify(value)).digest("hex");
+  const sha2562 = createHash15("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, field = (object7, key) => object7.entries.find(([name]) => name === key)?.[1];
@@ -50222,7 +50441,7 @@ var init_codex_hook_additions_review = __esm(() => {
 });
 
 // src/lib/codex-hook-discovery-recovery.ts
-import { createHash as createHash15 } from "crypto";
+import { createHash as createHash16 } from "crypto";
 function assertCodexHookDiscoveryRecovery(binding, witness) {
   const proof = proofs2.get(witness);
   need5(!!proof && binding.agent === "codex" && witness.discoverySha256 === sha3(JSON.stringify(binding)), "RECONCILE_DISCOVERY_RECOVERY_CHANGED");
@@ -50237,7 +50456,7 @@ function verifiesCodexHookDiscoverySource(binding, source, currentDigest, witnes
   need5(source.sha256 === witness.beforeSha256 && currentDigest === witness.currentSha256, "RECONCILE_DISCOVERY_RECOVERY_CHANGED");
   return true;
 }
-var sha3 = (text2) => createHash15("sha256").update(text2).digest("hex"), fields, proofs2;
+var sha3 = (text2) => createHash16("sha256").update(text2).digest("hex"), fields, proofs2;
 var init_codex_hook_discovery_recovery = __esm(() => {
   init_codex_hook_trust_files();
   init_codex_hook_trust_layout();
@@ -50248,9 +50467,9 @@ var init_codex_hook_discovery_recovery = __esm(() => {
 });
 
 // src/lib/agent-discovery.ts
-import { createHash as createHash16 } from "crypto";
+import { createHash as createHash17 } from "crypto";
 import { lstatSync as lstatSync18, readFileSync as readFileSync15, readdirSync as readdirSync7, realpathSync as realpathSync5 } from "fs";
-import { basename as basename8, dirname as dirname15, isAbsolute as isAbsolute13, join as join25, resolve as resolve15, sep as sep5 } from "path";
+import { basename as basename8, dirname as dirname15, isAbsolute as isAbsolute13, join as join26, resolve as resolve15, sep as sep6 } from "path";
 import { isDeepStrictEqual as isDeepStrictEqual4 } from "util";
 function parseConfig(text2, path, toml = false) {
   try {
@@ -50289,33 +50508,45 @@ function projectNativeDiscoveryFields(text2, format, fields2, path) {
     throw new Error("Expected native discovery configuration object");
   return digest(JSON.stringify(Object.fromEntries(fields2.map((field2) => [field2, object7[field2] ?? null]))));
 }
-function isSupersededCodexProjection(agent, configPath, source) {
+function isSupersededSettingsProjection(agent, configPath, source) {
+  if (agent === "sumi")
+    return source.path === configPath && source.format === "json" && isDeepStrictEqual4(source.fields, [...SUMI_DISCOVERY_PROJECTION_FIELDS]);
   return agent === "codex" && source.path === configPath && source.format === "toml" && isDeepStrictEqual4(source.fields, [...CODEX_DISCOVERY_PROJECTION_FIELDS]);
 }
-function supersedesCodexProjection(sources, configPath) {
-  return sources.some((source) => source.path === configPath && (source.hashMode === "codex-settings-v2" || (source.hashMode === "codex-settings-v3" || source.hashMode === "codex-settings-v4")));
+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")));
 }
-function projected(source, changes, budget = discoveryByteBudget()) {
+function projected(source, changes, budget2 = discoveryByteBudget()) {
+  if (source.hashMode === "sumi-settings-v1") {
+    if (source.format !== undefined || source.fields !== undefined || source.managedPlugins !== undefined || typeof source.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(source.sha256))
+      throw new Error("Sumi settings witnesses require exact typed metadata");
+    const current = captureSumiSettings(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) ? 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.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, budget).sha256;
+    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;
     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), budget) : current;
+    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;
   }
   if (source.hashMode === "claude-settings-v1" || source.hashMode === "claude-settings-v2" || source.hashMode === "claude-settings-v3") {
     if (source.format !== undefined || source.fields !== undefined || source.managedPlugins !== undefined || typeof source.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(source.sha256))
       throw new Error("Claude settings witnesses require exact typed metadata");
-    const current = (source.hashMode === "claude-settings-v3" ? captureClaudeSettingsV3 : source.hashMode === "claude-settings-v2" ? captureClaudeSettingsV2 : captureClaudeSettings)(source.path, budget).sha256;
+    const current = (source.hashMode === "claude-settings-v3" ? captureClaudeSettingsV3 : source.hashMode === "claude-settings-v2" ? captureClaudeSettingsV2 : captureClaudeSettings)(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 === "claude-settings-v3" ? hashClaudeSettingsReplacementV3 : source.hashMode === "claude-settings-v2" ? hashClaudeSettingsReplacementV2 : hashClaudeSettingsReplacement)(changes.get(source.path), budget) : current;
+    return changes?.has(source.path) ? (source.hashMode === "claude-settings-v3" ? hashClaudeSettingsReplacementV3 : source.hashMode === "claude-settings-v2" ? hashClaudeSettingsReplacementV2 : hashClaudeSettingsReplacement)(changes.get(source.path), budget2) : current;
   }
   if (source.hashMode === "claude-marketplace-registry" || source.hashMode === "claude-marketplace-registry-v2") {
     if (source.format !== undefined || source.fields !== undefined || source.managedPlugins !== undefined || typeof source.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(source.sha256) || changes?.has(source.path))
       throw new Error("Claude marketplace witnesses require an exact reviewed registry without synthetic changes");
-    const sha2562 = (source.hashMode === "claude-marketplace-registry-v2" ? captureClaudeMarketplaceRegistryV2 : captureClaudeMarketplaceRegistry)(source.path, budget).sha256;
+    const sha2562 = (source.hashMode === "claude-marketplace-registry-v2" ? captureClaudeMarketplaceRegistryV2 : captureClaudeMarketplaceRegistry)(source.path, budget2).sha256;
     if (sha2562 !== source.sha256)
       throw new Error(`Native discovery input changed; run skills hook install with a fresh discovery review: ${source.path}`);
     return sha2562;
@@ -50325,6 +50556,12 @@ function projected(source, changes, budget = discoveryByteBudget()) {
       throw new Error("Managed plugin registry witnesses require verified native registrations");
     return hashManagedPluginRegistry(source.path, source.managedPlugins);
   }
+  if (source.hashMode === "claude-plugin-manifest-v1") {
+    if (source.format !== undefined || source.fields !== undefined || source.managedPlugins !== undefined || changes?.has(source.path))
+      throw new Error("Claude plugin manifest witnesses require a native discovery source without synthetic changes");
+    const text3 = read(source.path);
+    return text3 === null ? null : hashClaudePluginManifest(text3);
+  }
   if (source.managedPlugins !== undefined)
     throw new Error("Managed plugin rules require a typed registry witness");
   if (source.hashMode !== undefined) {
@@ -50333,8 +50570,8 @@ function projected(source, changes, budget = discoveryByteBudget()) {
     if (source.format !== undefined || source.fields !== undefined)
       throw new Error("Raw discovery witnesses cannot project configuration fields");
     if (source.hashMode === "path-bytes")
-      return hashDiscoveryPathFile(source.path, budget, changes);
-    return hashRawDiscoveryFile(source.path, budget, changes);
+      return hashDiscoveryPathFile(source.path, budget2, changes);
+    return hashRawDiscoveryFile(source.path, budget2, changes);
   }
   const text2 = read(source.path, changes);
   if (text2 === null)
@@ -50351,7 +50588,7 @@ function absentCodexSkillRoots(binding) {
     throw new Error("Invalid disabled Codex discovery proof");
   if (binding.method !== "reviewed" || controls.every((control) => lstatSync18(control.pluginParent, { throwIfNoEntry: false })))
     return [];
-  const cache = dirname15(dirname15(controls[0].pluginParent)), config2 = join25(dirname15(dirname15(cache)), "config.toml");
+  const cache = dirname15(dirname15(controls[0].pluginParent)), config2 = join26(dirname15(dirname15(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");
@@ -50359,8 +50596,8 @@ function absentCodexSkillRoots(binding) {
   return [...new Set(controls.map((control) => control.pluginParent))].filter((parent) => !codexDirectHookSelects(cache, parent) && absentDisabledCodexPluginParent(cache, parent, controls, rules));
 }
 function codexDirectHookSelects(cache, root) {
-  const codex = dirname15(dirname15(cache)), config2 = Bun.TOML.parse(read(join25(codex, "config.toml")) ?? "");
-  const hooks = read(join25(codex, "hooks.json"));
+  const codex = dirname15(dirname15(cache)), config2 = Bun.TOML.parse(read(join26(codex, "config.toml")) ?? "");
+  const hooks = read(join26(codex, "hooks.json"));
   if (hooks !== null)
     hashNativeJsonControls(hooks);
   return JSON.stringify(config2.hooks ?? {}).includes(root) || hooks !== null && JSON.stringify(JSON.parse(hooks)).includes(root);
@@ -50372,7 +50609,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 = dirname15(dirname15(controls[0].pluginParent)), config2 = join25(dirname15(dirname15(cache)), "config.toml");
+  const cache = dirname15(dirname15(controls[0].pluginParent)), config2 = join26(dirname15(dirname15(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");
@@ -50380,7 +50617,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 === join25(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 === join26(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");
   }
@@ -50393,17 +50630,17 @@ function absentRetiredClaudeRoots(binding) {
   for (const source of binding.sources) {
     if (source.format !== undefined || source.fields !== undefined || source.managedPlugins !== undefined || ![undefined, "bytes"].includes(source.hashMode) || source.sha256 === null)
       continue;
-    const marker = sep5 + ".claude" + sep5 + "plugins" + sep5 + "cache" + sep5, at = source.path.indexOf(marker);
+    const marker = sep6 + ".claude" + sep6 + "plugins" + sep6 + "cache" + sep6, 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(sep5);
+    const cache = source.path.slice(0, at + marker.length - 1), parts = source.path.slice(at + marker.length).split(sep6);
     if (parts.length < 4 || parts.slice(0, 3).some((part) => !part || part === "." || part === ".."))
       continue;
-    const root = join25(cache, ...parts.slice(0, 3));
+    const root = join26(cache, ...parts.slice(0, 3));
     safe4(root);
     if (lstatSync18(root, { throwIfNoEntry: false }))
       continue;
-    const claude = dirname15(dirname15(cache)), settings = join25(claude, "settings.json"), registry2 = join25(claude, "plugins/installed_plugins.json");
+    const claude = dirname15(dirname15(cache)), settings = join26(claude, "settings.json"), registry2 = join26(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)
@@ -50422,10 +50659,10 @@ function absentRetiredClaudeRoots(binding) {
     const active = rows[0].installPath;
     if (rows[0].version !== basename8(active) || resolve15(active) !== active || dirname15(active) !== dirname15(root) || active === root || !lstatSync18(active, { throwIfNoEntry: false })?.isDirectory() || realpathSync5(active) !== active)
       continue;
-    const activeManifest = full(join25(active, ".claude-plugin/plugin.json"));
+    const activeManifest = full(join26(active, ".claude-plugin/plugin.json"));
     if (!activeManifest || projected(activeManifest) !== activeManifest.sha256)
       continue;
-    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 + sep5) || root.startsWith(row.installPath + sep5))))
+    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 + sep6) || root.startsWith(row.installPath + sep6))))
       continue;
     result.add(root);
   }
@@ -50440,10 +50677,10 @@ function verifyAgentDiscovery(binding, codexRecovery) {
     throw new Error("Hermes discovery requires directory membership coverage; run skills hook install with a fresh discovery review");
   const installationRoots = codexInstallationRoots(binding);
   const retiredRoots = retiredCodexRoots(binding);
-  const installationInput = (path) => installationRoots.some((root) => path === root || path.startsWith(root + sep5));
+  const installationInput = (path) => installationRoots.some((root) => path === root || path.startsWith(root + sep6));
   if (binding.directories !== undefined) {
     const projected2 = binding.codexInstallationInputs?.directories ?? [];
-    const ancestors2 = binding.directories.filter((directory) => installationRoots.some((root) => root.startsWith(directory.path + sep5)));
+    const ancestors2 = binding.directories.filter((directory) => installationRoots.some((root) => root.startsWith(directory.path + sep6)));
     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));
@@ -50466,7 +50703,7 @@ function verifyAgentDiscovery(binding, codexRecovery) {
     verifyDiscoveryDirectories(projected2, installationRoots);
   }
   const absentRoots = [...absentCodexSkillRoots(binding), ...absentRetiredClaudeRoots(binding), ...retiredRoots.filter((root) => !lstatSync18(root, { throwIfNoEntry: false }))];
-  const budget = discoveryByteBudget();
+  const budget2 = discoveryByteBudget();
   for (const source of binding.sources) {
     assertMarketplaceBinding(binding, source);
     if (source.hashMode === "claude-plugin-registry" && binding.agent !== "claude")
@@ -50479,11 +50716,11 @@ function verifyAgentDiscovery(binding, codexRecovery) {
       safe4(source.path);
       continue;
     }
-    if (absentRoots.some((root) => source.path.startsWith(root + sep5)) && source.format === undefined && source.fields === undefined && source.managedPlugins === undefined && [undefined, "bytes"].includes(source.hashMode)) {
+    if (absentRoots.some((root) => source.path.startsWith(root + sep6)) && source.format === undefined && source.fields === undefined && source.managedPlugins === undefined && [undefined, "bytes"].includes(source.hashMode)) {
       safe4(source.path);
       continue;
     }
-    const current = projected(source, undefined, budget);
+    const current = projected(source, undefined, budget2);
     if (current !== source.sha256 && !verifiesCodexHookDiscoverySource(binding, source, current, codexRecovery))
       throw new Error(`Native discovery input changed; run skills hook install with a fresh discovery review: ${source.path}`);
   }
@@ -50502,12 +50739,12 @@ function codexInstallationRoots(binding) {
   if (binding.agent !== "codex" || binding.method !== "reviewed" || proof.version !== "codex-cli 0.160.0" || !/^[a-f0-9]{64}$/.test(proof.catalogSha256) || !Array.isArray(proof.plugins) || !proof.plugins.length)
     throw new Error("Invalid native installation input proof");
   const cache = dirname15(dirname15(proof.plugins[0].pluginParent));
-  const config2 = join25(dirname15(dirname15(cache)), "config.toml"), home = dirname15(dirname15(dirname15(cache)));
+  const config2 = join26(dirname15(dirname15(cache)), "config.toml"), home = dirname15(dirname15(dirname15(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]) => join25(home, path));
-  if (!configSource || proof.plugins.some((input2) => nativeRoots.some((root) => root === input2.sourceRoot || root.startsWith(input2.sourceRoot + sep5) || input2.sourceRoot.startsWith(root + sep5)) || binding.sources.some((source) => basename8(source.path) === "config.toml" && (source.path === input2.sourceRoot || source.path.startsWith(input2.sourceRoot + sep5)))))
+  const nativeRoots = NATIVE_SKILL_ROOTS.filter(([agent]) => agent === "codex").map(([, path]) => join26(home, path));
+  if (!configSource || proof.plugins.some((input2) => nativeRoots.some((root) => root === input2.sourceRoot || root.startsWith(input2.sourceRoot + sep6) || input2.sourceRoot.startsWith(root + sep6)) || binding.sources.some((source) => basename8(source.path) === "config.toml" && (source.path === input2.sourceRoot || source.path.startsWith(input2.sourceRoot + sep6)))))
     throw new Error("Native installation input overlaps configuration or loading roots");
-  if (proof.plugins.some((input2) => dirname15(dirname15(input2.pluginParent)) !== cache || !binding.sources.some((source) => source.path === join25(input2.sourceRoot, ".codex-plugin/plugin.json") && source.sha256 !== null && source.format === undefined && source.fields === undefined)))
+  if (proof.plugins.some((input2) => dirname15(dirname15(input2.pluginParent)) !== cache || !binding.sources.some((source) => source.path === join26(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);
@@ -50517,6 +50754,10 @@ function codexInstallationRoots(binding) {
   });
 }
 function assertMarketplaceBinding(binding, source) {
+  if (source.hashMode === "claude-plugin-manifest-v1" && (binding.agent !== "claude" || basename8(source.path) !== "plugin.json" || !source.path.endsWith(join26(sep6, ".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" || basename8(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" || basename8(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") && (binding.agent !== "claude" || binding.method !== "reviewed" || basename8(source.path) !== "settings.json"))
@@ -50527,13 +50768,13 @@ function assertMarketplaceBinding(binding, source) {
 function agentDiscoveryConfigPath(home, agent) {
   if (agent === "sumi")
     return sumiConfigPath(home);
-  return join25(home, agent === "hermes" ? ".hermes/config.yaml" : agent === "opencode" ? ".config/opencode/opencode.json" : `.${agent}/${agent === "codex" ? "config.toml" : agent === "cursor" ? "hooks.json" : "settings.json"}`);
+  return join26(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 canonical6 = options.canonical ?? resolve15, home = resolve15(options.home), agent = options.agent;
+  const canonical7 = options.canonical ?? resolve15, home = resolve15(options.home), agent = options.agent;
   const sources = [], roots = new Set, builtinNames = [];
-  const witness = (path, format, fields2) => {
-    const source = { path: canonical6(path), sha256: null, ...format ? { format, fields: fields2 } : {} };
+  const witness = (path, format, fields2, hashMode) => {
+    const source = { path: canonical7(path), sha256: null, ...format ? { format, fields: fields2 } : {}, ...hashMode ? { hashMode } : {} };
     source.sha256 = projected(source);
     sources.push(source);
     return read(source.path);
@@ -50541,36 +50782,39 @@ function resolveAgentDiscovery(options) {
   if (agent === "hermes")
     assertHermesEnvironment(home);
   const configPath = agentDiscoveryConfigPath(home, agent);
-  const configText = witness(configPath, agent === "hermes" ? "yaml" : agent === "codex" ? "toml" : "json", agent === "hermes" ? ["skills", "plugins", "hooks"] : agent === "claude" ? ["enabledPlugins", "extraKnownMarketplaces"] : agent === "codex" ? [...CODEX_DISCOVERY_PROJECTION_FIELDS] : agent === "gemini" ? ["skills", "extensions", "security"] : agent === "opencode" ? ["plugin", "skills"] : agent === "sumi" ? ["skills", "plugin", "plugins", "permissions"] : ["version"]);
+  const configText = witness(configPath, agent === "hermes" ? "yaml" : agent === "codex" ? "toml" : "json", agent === "hermes" ? ["skills", "plugins", "hooks"] : agent === "claude" ? ["enabledPlugins", "extraKnownMarketplaces"] : agent === "codex" ? [...CODEX_DISCOVERY_PROJECTION_FIELDS] : agent === "gemini" ? ["skills", "extensions", "security"] : agent === "opencode" ? ["plugin", "skills"] : agent === "sumi" ? [...SUMI_DISCOVERY_PROJECTION_FIELDS] : ["version"]);
   const config2 = configText === null ? {} : agent === "hermes" ? parseHermesConfig(configText) : parseConfig(configText, configPath, agent === "codex");
   const unresolved = (detail) => {
     throw new Error(`Native discovery is unresolved (${agent}: ${detail}); provide a reviewed --discovery-inputs file`);
   };
+  if (options.reviewed && (options.reviewed.version !== 1 || !Array.isArray(options.reviewed.agents) || options.reviewed.agents.some((item) => !item || typeof item !== "object") || new Set(options.reviewed.agents.map((item) => item.agent)).size !== options.reviewed.agents.length))
+    throw new Error("Invalid --discovery-inputs version or agents");
+  const review = options.reviewed?.agents.find((item) => item.agent === agent);
   if (agent === "sumi") {
     const directory = sumiConfigDirectory(home);
-    if (witness(join25(directory, "sumi.jsonc")) !== null)
+    if (witness(join26(directory, "sumi.jsonc")) !== null)
       unresolved("JSONC configuration requires a supported format adapter");
-    for (const root of [directory, join25(home, ".claude"), join25(home, ".agents")])
+    for (const root of [directory, join26(home, ".claude"), join26(home, ".agents")])
       for (const name of ["skill", "skills"])
-        roots.add(canonical6(join25(root, name)));
+        roots.add(canonical7(join26(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 || !(isAbsolute13(value) || value.startsWith("~/")))
         unresolved("remote or relative skill sources need a dedicated discovery adapter");
-      roots.add(canonical6(value.startsWith("~/") ? join25(home, value.slice(2)) : value));
+      roots.add(canonical7(value.startsWith("~/") ? join26(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 = [join25(directory, "plugin"), join25(directory, "plugins")];
+    const plugins = [join26(directory, "plugin"), join26(directory, "plugins")];
     for (const path of plugins) {
       safe4(path);
       if (lstatSync18(path, { throwIfNoEntry: false })?.isDirectory())
         for (const name of readdirSync7(path).sort()) {
           if (name === "skills-cli.js" && path === plugins[1])
             continue;
-          const target = join25(path, name);
+          const target = join26(path, name);
           if (!lstatSync18(target).isFile())
             unresolved("local plugin packages need a dedicated discovery adapter");
           witness(target);
@@ -50583,7 +50827,7 @@ function resolveAgentDiscovery(options) {
     }
   }
   if (agent === "hermes") {
-    const profile = witness(join25(home, ".hermes/active_profile"));
+    const profile = witness(join26(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;
@@ -50597,7 +50841,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("~/") ? join25(home, normalized.slice(2)) : resolve15(home, ".hermes", normalized);
+      const path = normalized === "~" ? home : normalized.startsWith("~/") ? join26(home, normalized.slice(2)) : resolve15(home, ".hermes", normalized);
       safe4(path);
       roots.add(path);
     }
@@ -50607,7 +50851,7 @@ function resolveAgentDiscovery(options) {
     if (executable) {
       let packageRoot;
       for (let directory = dirname15(realpathSync5(executable)), depth = 0;depth < 8; directory = dirname15(directory), depth++) {
-        const path = join25(directory, "package.json"), raw = read(path);
+        const path = join26(directory, "package.json"), raw = read(path);
         if (raw !== null && parseConfig(raw, path).name === "@google/gemini-cli") {
           packageRoot = directory;
           witness(path);
@@ -50618,12 +50862,12 @@ function resolveAgentDiscovery(options) {
       }
       if (!packageRoot)
         unresolved("installed Gemini package layout is not recognized");
-      const builtinRoot = join25(packageRoot, "bundle/builtin");
+      const builtinRoot = join26(packageRoot, "bundle/builtin");
       safe4(builtinRoot);
       if (!lstatSync18(builtinRoot, { throwIfNoEntry: false })?.isDirectory())
         unresolved("installed Gemini builtin root is missing");
       for (const name of readdirSync7(builtinRoot).sort()) {
-        const text2 = witness(join25(builtinRoot, name, "SKILL.md"));
+        const text2 = witness(join26(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");
@@ -50636,18 +50880,15 @@ function resolveAgentDiscovery(options) {
     if (retained.agent !== agent || retained.method !== "reviewed")
       unresolved("invalid retained review");
     verifyAgentDiscovery(retained);
-    if (!retained.sources.some((source) => source.path === canonical6(configPath) && source.format === undefined && source.fields === undefined))
+    if (!retained.sources.some((source) => source.path === canonical7(configPath) && source.format === undefined && source.fields === undefined))
       unresolved("retained review is missing the full agent configuration source");
-    if (retained.sources.some((source) => (source.hashMode === "claude-settings-v1" || source.hashMode === "claude-settings-v2" || (source.hashMode === "claude-settings-v3" || (source.hashMode === "codex-settings-v1" || source.hashMode === "codex-settings-v2" || (source.hashMode === "codex-settings-v3" || source.hashMode === "codex-settings-v4")))) && source.path !== canonical6(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 === "codex-settings-v1" || source.hashMode === "codex-settings-v2" || (source.hashMode === "codex-settings-v3" || source.hashMode === "codex-settings-v4")))) && source.path !== canonical7(configPath)))
       unresolved("retained settings witness names another configuration source");
-    const covered = supersedesCodexProjection(retained.sources, canonical6(configPath)) ? sources.filter((source) => !isSupersededCodexProjection(agent, canonical6(configPath), source)) : sources;
+    const covered = supersedesSettingsProjection(agent, retained.sources, canonical7(configPath)) ? sources.filter((source) => !isSupersededSettingsProjection(agent, canonical7(configPath), source)) : sources;
     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;
   }
-  if (options.reviewed && (options.reviewed.version !== 1 || !Array.isArray(options.reviewed.agents) || options.reviewed.agents.some((item) => !item || typeof item !== "object") || new Set(options.reviewed.agents.map((item) => item.agent)).size !== options.reviewed.agents.length))
-    throw new Error("Invalid --discovery-inputs version or agents");
-  const review = options.reviewed?.agents.find((item) => item.agent === agent);
   if (review) {
     if (review.pluginHooks !== "reviewed-no-skill-injection" || !Array.isArray(review.sources) || !review.sources.length || !Array.isArray(review.roots))
       throw new Error("Discovery review must bind sources and confirm plugin hooks do not inject retired skills");
@@ -50655,47 +50896,77 @@ 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 === "claude-settings-v1" || source.hashMode === "claude-settings-v2" || (source.hashMode === "claude-settings-v3" || (source.hashMode === "codex-settings-v1" || source.hashMode === "codex-settings-v2" || (source.hashMode === "codex-settings-v3" || source.hashMode === "codex-settings-v4")))) && source.path !== canonical6(configPath)))
-      throw new Error("Semantic settings witnesses must name the configured Claude configuration source");
-    if (!review.sources.some((source) => source.path === canonical6(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 === "codex-settings-v1" || source.hashMode === "codex-settings-v2" || (source.hashMode === "codex-settings-v3" || source.hashMode === "codex-settings-v4")))) && source.path !== canonical7(configPath)))
+      throw new Error("Semantic settings witnesses must name the configured agent configuration source");
+    if (!review.sources.some((source) => source.path === canonical7(configPath)))
       throw new Error("Discovery review must include the agent configuration source");
-    const reviewedSources = supersedesCodexProjection(review.sources, canonical6(configPath)) ? sources.filter((source) => !isSupersededCodexProjection(agent, canonical6(configPath), source)) : sources;
-    return { ...supplied, roots: [...new Set([...roots, ...supplied.roots])].sort(), sources: [...reviewedSources, ...review.sources], ...agent === "gemini" ? { builtinNames } : {} };
+    const reviewedSources = supersedesSettingsProjection(agent, review.sources, canonical7(configPath)) ? sources.filter((source) => !isSupersededSettingsProjection(agent, canonical7(configPath), source)) : sources;
+    const reviewedSourcesWithManifestProjection = review.sources.map((source) => {
+      if (agent !== "claude" || source.format !== undefined || source.fields !== undefined || source.managedPlugins !== undefined || source.hashMode !== undefined && source.hashMode !== "bytes" || basename8(source.path) !== "plugin.json" || !source.path.endsWith(join26(sep6, ".claude-plugin", "plugin.json")))
+        return source;
+      const pluginRoot = dirname15(dirname15(source.path)), hooksPath = join26(pluginRoot, "hooks/hooks.json");
+      const hookStat = lstatSync18(hooksPath, { throwIfNoEntry: false });
+      const text2 = read(source.path);
+      if (text2 === null)
+        throw new Error("Reviewed Claude plugin manifest is missing");
+      const manifestSha256 = projectReviewedClaudePluginManifest(text2, source.sha256 ?? "");
+      const manifest = JSON.parse(text2);
+      if (!manifest || typeof manifest !== "object" || Array.isArray(manifest))
+        throw new Error("Reviewed Claude plugin manifest must be an object");
+      const reviewedHookPaths = new Set;
+      if (hookStat)
+        reviewedHookPaths.add(hooksPath);
+      if (manifest.hooks !== undefined) {
+        if (typeof manifest.hooks !== "string")
+          throw new Error("Reviewed Claude plugin manifest has an unsupported hooks target");
+        const declaredHookPath = resolve15(pluginRoot, manifest.hooks);
+        if (!declaredHookPath.startsWith(pluginRoot + sep6))
+          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 === canonical7(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" };
+    });
+    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 = canonical6(root);
+    root = canonical7(root);
     safe4(root);
-    const manifestPath = join25(root, agent === "claude" ? ".claude-plugin/plugin.json" : ".codex-plugin/plugin.json");
-    const raw = witness(manifestPath);
+    const manifestPath = join26(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(join25(root, "hooks/hooks.json"));
+    const hooks = witness(join26(root, "hooks/hooks.json"));
     if (manifest.hooks !== undefined || hooks !== null)
       unresolved("plugin hooks require a separate no-skill-injection review");
-    const commands = join25(root, "commands");
+    const commands = join26(root, "commands");
     safe4(commands);
     if (agent === "claude" && (manifest.commands !== undefined || lstatSync18(commands, { throwIfNoEntry: false })?.isDirectory() && readdirSync7(commands).length))
       unresolved("legacy command discovery requires retirement or a dedicated format adapter");
-    const rootSkill = witness(join25(root, "SKILL.md"));
+    const rootSkill = witness(join26(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(join25(root, "skills"));
+      roots.add(join26(root, "skills"));
     for (const value of declared) {
       const path = resolve15(root, value);
-      if (path !== root && !path.startsWith(root + sep5))
+      if (path !== root && !path.startsWith(root + sep6))
         unresolved("plugin skill path escapes its root");
-      roots.add(path.endsWith(`${sep5}SKILL.md`) ? dirname15(path) : path);
+      roots.add(path.endsWith(`${sep6}SKILL.md`) ? dirname15(path) : path);
     }
   }
   if (agent === "claude") {
-    const registrations = witness(join25(home, ".claude/plugins/installed_plugins.json"));
-    const installed = registrations === null ? {} : parseConfig(registrations, join25(home, ".claude/plugins/installed_plugins.json")).plugins;
-    const commands = canonical6(join25(home, ".claude/commands"));
+    const registrations = witness(join26(home, ".claude/plugins/installed_plugins.json"));
+    const installed = registrations === null ? {} : parseConfig(registrations, join26(home, ".claude/plugins/installed_plugins.json")).plugins;
+    const commands = canonical7(join26(home, ".claude/commands"));
     safe4(commands);
     if (lstatSync18(commands, { throwIfNoEntry: false })?.isDirectory() && readdirSync7(commands).length)
       unresolved("legacy home command discovery requires a dedicated format adapter");
@@ -50719,16 +50990,16 @@ function resolveAgentDiscovery(options) {
       const market = config2.marketplaces?.[marketplace] ?? (marketplace === "personal" ? { source_type: "local", source: home } : undefined);
       if (split < 1 || market?.source_type !== "local" || typeof market.source !== "string" || !isAbsolute13(market.source))
         unresolved("enabled plugin marketplace is not an explicit local source");
-      const catalogText = witness(join25(market.source, ".agents/plugins/marketplace.json"));
+      const catalogText = witness(join26(market.source, ".agents/plugins/marketplace.json"));
       if (catalogText === null)
         unresolved("marketplace catalog missing");
-      const catalog = parseConfig(catalogText, join25(market.source, ".agents/plugins/marketplace.json")), matches = Array.isArray(catalog.plugins) ? catalog.plugins.filter((item) => item.name === name) : [];
+      const catalog = parseConfig(catalogText, join26(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(resolve15(market.source, matches[0].source.path));
     }
   } else if (agent === "opencode") {
-    if (witness(join25(home, ".config/opencode/opencode.jsonc")) !== null || witness(join25(home, ".config/opencode/config.json")) !== null)
+    if (witness(join26(home, ".config/opencode/opencode.jsonc")) !== null || witness(join26(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");
@@ -50737,15 +51008,15 @@ function resolveAgentDiscovery(options) {
         unresolved("relative or malformed added skill root");
       roots.add(path);
     }
-    const localPlugins = join25(home, ".config/opencode/plugins");
+    const localPlugins = join26(home, ".config/opencode/plugins");
     safe4(localPlugins);
     if (lstatSync18(localPlugins, { throwIfNoEntry: false }) && readdirSync7(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 !== canonical6(configPath) && source.path !== canonical6(join25(sumiConfigDirectory(home), "sumi.jsonc")) && source.sha256 !== null))
+    if ((config2.plugin?.length ?? 0) > 0 || (config2.plugins?.length ?? 0) > 0 || sources.some((source) => source.path !== canonical7(configPath) && source.path !== canonical7(join26(sumiConfigDirectory(home), "sumi.jsonc")) && source.sha256 !== null))
       unresolved("external or foreign local plugins require review");
   } else if (agent === "hermes") {
-    for (const directory of [join25(home, ".hermes/plugins"), join25(home, ".hermes/hermes-agent")]) {
+    for (const directory of [join26(home, ".hermes/plugins"), join26(home, ".hermes/hermes-agent")]) {
       safe4(directory);
       if (lstatSync18(directory, { throwIfNoEntry: false }))
         unresolved("installed runtime/plugin discovery requires reviewed source bindings");
@@ -50755,32 +51026,34 @@ 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 = join25(home, ".gemini/extensions");
+    const directory = join26(home, ".gemini/extensions");
     safe4(directory);
     if (lstatSync18(directory, { throwIfNoEntry: false }))
       for (const name of readdirSync7(directory)) {
-        const root = join25(directory, name);
+        const root = join26(directory, name);
         safe4(root);
         if (!lstatSync18(root)?.isDirectory())
           continue;
-        const raw = witness(join25(root, "gemini-extension.json"));
+        const raw = witness(join26(root, "gemini-extension.json"));
         if (raw === null)
           unresolved("extension registration missing");
-        const manifest = parseConfig(raw, join25(root, "gemini-extension.json"));
-        if (manifest.hooks !== undefined || witness(join25(root, "hooks/hooks.json")) !== null || witness(join25(root, ".gemini-extension-install.json")) !== null)
+        const manifest = parseConfig(raw, join26(root, "gemini-extension.json"));
+        if (manifest.hooks !== undefined || witness(join26(root, "hooks/hooks.json")) !== null || witness(join26(root, ".gemini-extension-install.json")) !== null)
           unresolved("extension hooks or linked registration require review");
-        roots.add(join25(root, "skills"));
+        roots.add(join26(root, "skills"));
       }
   }
-  return { agent, roots: [...roots].sort(), sources, method: "automatic", ...agent === "gemini" ? { builtinNames } : {}, ...agent === "hermes" ? { directories: captureDiscoveryDirectories([join25(home, ".hermes/plugins"), join25(home, ".hermes/hermes-agent")].map((path) => canonical6(path))) } : {} };
+  return { agent, roots: [...roots].sort(), sources, method: "automatic", ...agent === "gemini" ? { builtinNames } : {}, ...agent === "hermes" ? { directories: captureDiscoveryDirectories([join26(home, ".hermes/plugins"), join26(home, ".hermes/hermes-agent")].map((path) => canonical7(path))) } : {} };
 }
-var digest = (text2) => createHash16("sha256").update(text2).digest("hex");
+var digest = (text2) => createHash17("sha256").update(text2).digest("hex");
 var init_agent_discovery = __esm(() => {
+  init_sumi_settings_witness();
   init_agent_policy_limits();
   init_agent_hermes();
   init_agent_discovery_directories();
   init_agent_discovery_bytes();
   init_agent_discovery_path_bytes();
+  init_claude_plugin_manifest_witness();
   init_plugin_discovery();
   init_plugin_admission();
   init_claude_marketplace_registry();
@@ -50796,9 +51069,9 @@ var init_agent_discovery = __esm(() => {
 // src/lib/authoring-path.ts
 import { lstatSync as lstatSync19, realpathSync as realpathSync6 } from "fs";
 import { homedir as homedir3 } from "os";
-import { basename as basename9, dirname as dirname16, join as join26, resolve as resolve16, sep as sep6 } from "path";
+import { basename as basename9, dirname as dirname16, join as join27, resolve as resolve16, sep as sep7 } from "path";
 function pathParts(path) {
-  return resolve16(path).split(sep6).filter(Boolean);
+  return resolve16(path).split(sep7).filter(Boolean);
 }
 function nativeRootMatch(path) {
   const parts = pathParts(path);
@@ -50824,10 +51097,10 @@ function physicalPath(path) {
   return resolve16(realpathSync6(cursor), ...suffix);
 }
 function contains(root, path) {
-  return path === root || path.startsWith(root + sep6);
+  return path === root || path.startsWith(root + sep7);
 }
 function configuredRoots(home, explicitHome) {
-  const homeData = join26(home, ".hasna", "skills");
+  const homeData = join27(home, ".hasna", "skills");
   const homePolicy = readManagedSkillPolicySnapshot(homeData);
   const configuredPolicy = !explicitHome && resolve16(getDataDirReadOnly()) !== resolve16(homeData) ? readManagedSkillPolicySnapshot(getDataDirReadOnly()) : null;
   const policy = homePolicy ?? configuredPolicy;
@@ -50858,7 +51131,7 @@ function configuredRoots(home, explicitHome) {
       admitBinding(binding);
       continue;
     }
-    const nativeHome = join26(home, agent === "opencode" ? ".config/opencode" : `.${agent}`);
+    const nativeHome = join27(home, agent === "opencode" ? ".config/opencode" : `.${agent}`);
     if (!lstatSync19(nativeHome, { throwIfNoEntry: false }))
       continue;
     roots.push(...resolveAgentDiscovery({ home, agent, canonical: physicalPath }).roots);
@@ -50873,8 +51146,8 @@ function assertPortableAuthoringPath(path, options = {}) {
   const candidates = [lexical, physical];
   let native = candidates.map(nativeRootMatch).find(Boolean);
   const home = resolve16(options.homeDir ?? homedir3());
-  const defaults = NATIVE_DISCOVERY_ROOTS.map((parts) => join26(home, ...parts));
-  defaults.push(join26(home, ".codex/plugins/cache"), join26(home, ".claude/plugins/cache"), join26(home, ".claude/plugins/synced"), join26(home, ".gemini/extensions"));
+  const defaults = NATIVE_DISCOVERY_ROOTS.map((parts) => join27(home, ...parts));
+  defaults.push(join27(home, ".codex/plugins/cache"), join27(home, ".claude/plugins/cache"), join27(home, ".claude/plugins/synced"), join27(home, ".gemini/extensions"));
   for (const root of defaults) {
     if (candidates.some((candidate) => contains(resolve16(root), candidate) || contains(physicalPath(root), candidate)))
       native ??= root;
@@ -50910,22 +51183,22 @@ import {
   statSync as statSync7,
   writeFileSync as writeFileSync6
 } from "fs";
-import { basename as basename10, dirname as dirname17, isAbsolute as isAbsolute14, join as join27, normalize as normalize3, relative as relative5, resolve as resolve17, sep as sep7 } from "path";
+import { basename as basename10, dirname as dirname17, isAbsolute as isAbsolute14, join as join28, normalize as normalize3, relative as relative5, resolve as resolve17, sep as sep8 } from "path";
 function getPortableSkillsRoot(options = {}) {
   return resolvePortableSkillsRoot(options, true);
 }
 function resolvePortableSkillsRoot(options, migrate) {
   if (options.rootDir)
     return options.rootDir;
-  const appDir = options.homeDir ? join27(options.homeDir, ".hasna", "skills") : migrate ? getDataDir() : getDataDirReadOnly();
-  const cache = join27(appDir, SKILLS_CACHE_DIRNAME);
+  const appDir = options.homeDir ? join28(options.homeDir, ".hasna", "skills") : migrate ? getDataDir() : getDataDirReadOnly();
+  const cache = join28(appDir, SKILLS_CACHE_DIRNAME);
   if (isOwnerLayoutMigrated(appDir) && safeIsDirectory(cache))
     return cache;
-  const installed = join27(appDir, INSTALLED_SKILLS_DIRNAME);
+  const installed = join28(appDir, INSTALLED_SKILLS_DIRNAME);
   return installed;
 }
 function getPortableSkillPath(name, options = {}) {
-  return join27(getPortableSkillsRoot(options), normalizePortableSkillName(name));
+  return join28(getPortableSkillsRoot(options), normalizePortableSkillName(name));
 }
 function findPortableSkill(name, options = {}) {
   let normalized;
@@ -50951,7 +51224,7 @@ function listPortableSkills(options = {}) {
   for (const entry of readdirSync8(root).sort()) {
     if (entry.startsWith("."))
       continue;
-    const path = join27(root, entry);
+    const path = join28(root, entry);
     if (!safeIsDirectory(path))
       continue;
     try {
@@ -50984,9 +51257,9 @@ function isOfficialSkillName(name) {
 function scaffoldPortableSkill(name, options = {}) {
   const skillName = normalizeNewPortableSkillName(name);
   const readOnlyRoot = resolvePortableSkillsRoot(options, false);
-  assertPortableAuthoringPath(join27(readOnlyRoot, skillName), options);
+  assertPortableAuthoringPath(join28(readOnlyRoot, skillName), options);
   const root = getPortableSkillsRoot(options);
-  const skillPath = join27(root, skillName);
+  const skillPath = join28(root, skillName);
   assertPortableAuthoringPath(skillPath, options);
   if (existsSync12(skillPath)) {
     if (!options.overwrite)
@@ -51011,14 +51284,14 @@ function physicalImportPath(path) {
     suffix.unshift(basename10(ancestor));
     ancestor = dirname17(ancestor);
   }
-  return join27(realpathSync7(ancestor), ...suffix);
+  return join28(realpathSync7(ancestor), ...suffix);
 }
 function assertDisjointImportPaths(source, destination) {
   const sourcePath = realpathSync7(source);
   const destinationPath = physicalImportPath(destination);
   const contains2 = (parent, child) => {
     const path = relative5(parent, child);
-    return path === "" || !isAbsolute14(path) && path !== ".." && !path.startsWith(`..${sep7}`);
+    return path === "" || !isAbsolute14(path) && path !== ".." && !path.startsWith(`..${sep8}`);
   };
   if (contains2(sourcePath, destinationPath) || contains2(destinationPath, sourcePath)) {
     throw new Error("Source and destination skill directories must not overlap");
@@ -51037,11 +51310,11 @@ function portPortableSkill(sourcePath, options = {}) {
     const via = explicitName ? `Name '${skillName}' matches a bundled official skill.` : `Inferred name '${skillName}'${sourceSlug && sourceSlug !== skillName ? ` (from source folder '${basename10(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 = join27(resolvePortableSkillsRoot(options, false), skillName);
+  const readOnlyDestination = join28(resolvePortableSkillsRoot(options, false), skillName);
   assertPortableAuthoringPath(readOnlyDestination, options);
   assertDisjointImportPaths(absoluteSource, readOnlyDestination);
   const root = getPortableSkillsRoot(options);
-  const destination = join27(root, skillName);
+  const destination = join28(root, skillName);
   assertPortableAuthoringPath(destination, options);
   assertDisjointImportPaths(absoluteSource, destination);
   if (existsSync12(destination)) {
@@ -51073,8 +51346,8 @@ function validatePortableSkillDirectory(name, skillPath) {
   const warnings = [...base.warnings];
   let manifest;
   if (existsSync12(skillPath)) {
-    const skillJsonPath = join27(skillPath, "skill.json");
-    const skillMdPath = join27(skillPath, "SKILL.md");
+    const skillJsonPath = join28(skillPath, "skill.json");
+    const skillMdPath = join28(skillPath, "SKILL.md");
     if (!existsSync12(skillJsonPath) && !existsSync12(skillMdPath)) {
       add3(issues, "portable.manifest_missing", "Missing portable manifest: expected SKILL.md frontmatter and/or skill.json");
     }
@@ -51094,7 +51367,7 @@ function validatePortableSkillDirectory(name, skillPath) {
         add3(issues, "portable.version_missing", "Portable manifest missing version");
       }
       const contractIssues = validatePortableManifestContract(manifest, {
-        strict: existsSync12(join27(skillPath, "skill.json")),
+        strict: existsSync12(join28(skillPath, "skill.json")),
         skillPath
       });
       for (const issue2 of contractIssues)
@@ -51134,7 +51407,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 = join27(skillPath, command.entry);
+            const entryPath = join28(skillPath, command.entry);
             if (!existsSync12(entryPath))
               add3(issues, "portable.command_entry_missing", `Command '${command.name}' entry '${command.entry}' is missing`);
             else if (statSync7(entryPath).isDirectory())
@@ -51145,7 +51418,7 @@ function validatePortableSkillDirectory(name, skillPath) {
     } catch (error61) {
       add3(issues, "portable.manifest_invalid", error61.message);
     }
-    if (manifest?.kind !== "instruction" && !existsSync12(join27(skillPath, "AGENTS.md"))) {
+    if (manifest?.kind !== "instruction" && !existsSync12(join28(skillPath, "AGENTS.md"))) {
       add3(issues, "portable.agents_missing", "Missing AGENTS.md with build-out instructions for coding agents");
     }
   }
@@ -51373,7 +51646,7 @@ var init_search = __esm(() => {
 
 // src/lib/registry.ts
 import { existsSync as existsSync13, readFileSync as readFileSync16, readdirSync as readdirSync9 } from "fs";
-import { join as join28 } from "path";
+import { join as join29 } from "path";
 function parseSkillMdFrontmatter(content) {
   const match = content.match(/^---\n([\s\S]*?)\n---/);
   if (!match)
@@ -51414,7 +51687,7 @@ function discoverSkillsInDir(dir, source = "custom") {
     for (const entry of entries) {
       if (!entry.isDirectory())
         continue;
-      const skillMdPath = join28(dir, entry.name, "SKILL.md");
+      const skillMdPath = join29(dir, entry.name, "SKILL.md");
       if (!existsSync13(skillMdPath))
         continue;
       let content;
@@ -51434,7 +51707,7 @@ function discoverSkillsInDir(dir, source = "custom") {
         category: fm.category || "Development Tools",
         tags: fm.tags || [],
         ...fm.kind ? { kind: fm.kind } : {},
-        ...isHostedMetadataSkillDir(join28(dir, entry.name)) ? { serverOwned: true } : {},
+        ...isHostedMetadataSkillDir(join29(dir, entry.name)) ? { serverOwned: true } : {},
         source
       });
     }
@@ -51450,8 +51723,8 @@ function findExtensionSkillPath(name) {
     for (const entry of entries) {
       if (!entry.isDirectory())
         continue;
-      const skillDir = join28(config2.extensionsDir, entry.name);
-      const skillMdPath = join28(skillDir, "SKILL.md");
+      const skillDir = join29(config2.extensionsDir, entry.name);
+      const skillMdPath = join29(skillDir, "SKILL.md");
       if (!existsSync13(skillMdPath))
         continue;
       let content;
@@ -51854,7 +52127,7 @@ var init_remote_customer_operations = __esm(() => {
 });
 
 // src/lib/canonical-json.ts
-import { createHash as createHash17 } from "crypto";
+import { createHash as createHash18 } from "crypto";
 function canonicalJson2(value, maximumBytes = 2 * 1024 * 1024) {
   return canonicalJsonAtDepth(value, maximumBytes, 64);
 }
@@ -51898,7 +52171,7 @@ function canonicalJsonAtDepth(value, maximumBytes, maximumDepth) {
   return visit3(value, 0);
 }
 function canonicalJsonSha256(value, maximumBytes) {
-  return createHash17("sha256").update(canonicalJson2(value, maximumBytes)).digest("hex");
+  return createHash18("sha256").update(canonicalJson2(value, maximumBytes)).digest("hex");
 }
 var init_canonical_json = () => {};
 
@@ -52077,7 +52350,7 @@ function parseRecurringResult(action, value, input2, identity3) {
   }
   return result;
 }
-var RecurringInputError, RemoteRecurringUnavailableError, RemoteRecurringReadError, RemoteRecurringUnconfirmedError, failures, RemoteRecurringError, uuid3, instant2, integer2, digest2, list, inputs, capabilityNames, budget, 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, 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 init_remote_recurring = __esm(() => {
   init_v4();
   init_canonical_json();
@@ -52163,7 +52436,7 @@ var init_remote_recurring = __esm(() => {
     occurrences: "recurring.occurrences",
     revoke: "recurring.revoke"
   };
-  budget = exports_external.object({ reservedCredits: integer2, settledCredits: integer2, admittedOccurrences: integer2 });
+  budget2 = exports_external.object({ reservedCredits: integer2, settledCredits: integer2, admittedOccurrences: integer2 });
   period = exports_external.object({ startsAt: instant2, endsAt: instant2 });
   preview = exports_external.object({
     contractVersion: exports_external.literal(1),
@@ -52185,8 +52458,8 @@ var init_remote_recurring = __esm(() => {
     state: exports_external.enum(["active", "revoked", "expired"]),
     activatedAt: instant2,
     revokedAt: instant2.nullable(),
-    total: budget,
-    currentPeriod: budget.extend(period.shape).nullable(),
+    total: budget2,
+    currentPeriod: budget2.extend(period.shape).nullable(),
     nextDueAt: instant2.nullable()
   });
   refusal2 = exports_external.enum([
@@ -52649,13 +52922,13 @@ var init_remote_workspace_leave = __esm(() => {
 
 // src/lib/auth-store.ts
 import { chmodSync, existsSync as existsSync14, mkdirSync as mkdirSync8, readFileSync as readFileSync17, renameSync as renameSync4, statSync as statSync8, unlinkSync as unlinkSync4, writeFileSync as writeFileSync7 } from "fs";
-import { basename as basename11, dirname as dirname18, join as join29 } from "path";
+import { basename as basename11, dirname as dirname18, join as join30 } from "path";
 function getAuthFilePath(env = process.env) {
   return skillsCredentialFilePath(env);
 }
 function getIdentityFilePath(env = process.env) {
   const file2 = skillsCredentialFilePath(env);
-  return join29(dirname18(file2), basename11(file2).replace(/^credentials/, "identity") + ".json");
+  return join30(dirname18(file2), basename11(file2).replace(/^credentials/, "identity") + ".json");
 }
 function getApiUrl(action, env = process.env, options = {}) {
   return requireSkillsApiOrigin(action, env, options);
@@ -54124,7 +54397,7 @@ var init_remote_invitation_recovery = __esm(() => {
 });
 
 // src/lib/remote-private-publications.ts
-import { createHash as createHash18 } from "crypto";
+import { createHash as createHash19 } 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)
     return bad();
@@ -54144,7 +54417,7 @@ function checkedPublicationView(value, skillId, intentId, declaration) {
     return invalid4();
   return Object.freeze({ ...value });
 }
-async function boundedJson(url2, init, token, mutation, budget2 = 15000, signal) {
+async function boundedJson(url2, init, token, mutation, budget3 = 15000, signal) {
   const controller = new AbortController;
   let reader;
   let response;
@@ -54199,7 +54472,7 @@ async function boundedJson(url2, init, token, mutation, budget2 = 15000, signal)
         controller.abort();
         reject(timeout);
       };
-      timer = setTimeout(abort, Math.max(1, Math.min(15000, budget2)));
+      timer = setTimeout(abort, Math.max(1, Math.min(15000, budget3)));
       signal?.addEventListener("abort", abort, { once: true });
     })]);
   } catch (error61) {
@@ -54385,7 +54658,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), record10 = (v) => !!v && typeof v === "object" && !Array.isArray(v), exact = (v, keys) => record10(v) && Object.keys(v).sort().join(",") === keys.sort().join(","), date6 = (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) => createHash18("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), hash3 = (v) => typeof v === "string" && /^[a-f0-9]{64}$/.test(v), record10 = (v) => !!v && typeof v === "object" && !Array.isArray(v), exact = (v, keys) => record10(v) && Object.keys(v).sort().join(",") === keys.sort().join(","), date6 = (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) => createHash19("sha256").update(bytes).digest("hex");
 var init_remote_private_publications = __esm(() => {
   init_fleet_credentials();
   init_remote_workspace_selection();
@@ -54895,7 +55168,7 @@ var init_recurring_customer = __esm(() => {
 
 // src/lib/recurring-recovery.ts
 import { constants as constants12, closeSync as closeSync15, fsyncSync as fsyncSync4, fstatSync as fstatSync15, lstatSync as lstatSync21, mkdirSync as mkdirSync10, openSync as openSync15, readSync as readSync10, realpathSync as realpathSync8, renameSync as renameSync6, unlinkSync as unlinkSync5, writeFileSync as writeFileSync9 } from "fs";
-import { dirname as dirname19, isAbsolute as isAbsolute15, join as join30, resolve as resolve18 } from "path";
+import { dirname as dirname19, isAbsolute as isAbsolute15, join as join31, resolve as resolve18 } from "path";
 import { randomUUID as randomUUID2 } from "crypto";
 
 class RecoveryOwner {
@@ -54929,7 +55202,7 @@ class RecoveryOwner {
   }
   read(name) {
     this.assert();
-    const fd = openSync15(join30(this.directory, name), constants12.O_RDONLY | constants12.O_NOFOLLOW | constants12.O_NONBLOCK);
+    const fd = openSync15(join31(this.directory, name), constants12.O_RDONLY | constants12.O_NOFOLLOW | constants12.O_NONBLOCK);
     try {
       const before = fstatSync15(fd);
       if (!before.isFile() || before.nlink !== 1 || (before.mode & 4095) !== 384 || before.size < 1 || before.size > 8192 || process.getuid && before.uid !== process.getuid())
@@ -54942,7 +55215,7 @@ class RecoveryOwner {
           break;
         size += n2;
       }
-      const after = fstatSync15(fd), path = lstatSync21(join30(this.directory, name));
+      const after = fstatSync15(fd), path = lstatSync21(join31(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();
@@ -54955,7 +55228,7 @@ class RecoveryOwner {
     this.assert();
     const bytes = canonicalJson2(value, 8192) + `
 `;
-    const fd = openSync15(join30(this.directory, name), constants12.O_WRONLY | constants12.O_CREAT | constants12.O_EXCL | constants12.O_NOFOLLOW, 384);
+    const fd = openSync15(join31(this.directory, name), constants12.O_WRONLY | constants12.O_CREAT | constants12.O_EXCL | constants12.O_NOFOLLOW, 384);
     try {
       writeFileSync9(fd, bytes);
       fsyncSync4(fd);
@@ -54982,14 +55255,14 @@ class RecoveryOwner {
     if (this.read("state.json") !== expected)
       invalid5();
     this.assert();
-    renameSync6(join30(this.directory, name), join30(this.directory, "state.json"));
+    renameSync6(join31(this.directory, name), join31(this.directory, "state.json"));
     this.sync();
   }
   async locked(action) {
     this.assert();
     let fd;
     try {
-      fd = openSync15(join30(this.directory, "operation.lock"), constants12.O_WRONLY | constants12.O_CREAT | constants12.O_EXCL | constants12.O_NOFOLLOW, 384);
+      fd = openSync15(join31(this.directory, "operation.lock"), constants12.O_WRONLY | constants12.O_CREAT | constants12.O_EXCL | constants12.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.");
     }
@@ -55002,10 +55275,10 @@ class RecoveryOwner {
     } finally {
       closeSync15(fd);
       this.assert();
-      const now = lstatSync21(join30(this.directory, "operation.lock"));
+      const now = lstatSync21(join31(this.directory, "operation.lock"));
       if (owner2.dev !== now.dev || owner2.ino !== now.ino || !now.isFile() || now.isSymbolicLink())
         invalid5();
-      unlinkSync5(join30(this.directory, "operation.lock"));
+      unlinkSync5(join31(this.directory, "operation.lock"));
       this.sync();
     }
   }
@@ -57135,21 +57408,21 @@ var init_credential_state = __esm(() => {
 });
 
 // src/lib/run-state.ts
-import { createHash as createHash19, randomBytes } from "crypto";
+import { createHash as createHash20, randomBytes } from "crypto";
 import { existsSync as existsSync15, mkdirSync as mkdirSync11, readFileSync as readFileSync19, readdirSync as readdirSync10, statSync as statSync9, writeFileSync as writeFileSync10 } from "fs";
-import { extname, join as join31, relative as relative6 } from "path";
+import { extname, join as join32, relative as relative6 } 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 = join31(root, "runs", day, id);
-  const logsDir = join31(runDir, "logs");
-  const exportDir = join31(root, "exports", skillName, id);
+  const runDir = join32(root, "runs", day, id);
+  const logsDir = join32(runDir, "logs");
+  const exportDir = join32(root, "exports", skillName, id);
   mkdirSync11(logsDir, { recursive: true });
   mkdirSync11(exportDir, { recursive: true });
-  mkdirSync11(join31(root, "tmp"), { recursive: true });
+  mkdirSync11(join32(root, "tmp"), { recursive: true });
   const record11 = {
     id,
     skill: skillName,
@@ -57201,22 +57474,22 @@ function updateSkillRun(context2, patch) {
   return context2.record;
 }
 function writeRunLogs(context2, stdout = "", stderr = "") {
-  writeFileSync10(join31(context2.logsDir, "stdout.log"), stdout);
-  writeFileSync10(join31(context2.logsDir, "stderr.log"), stderr);
+  writeFileSync10(join32(context2.logsDir, "stdout.log"), stdout);
+  writeFileSync10(join32(context2.logsDir, "stderr.log"), stderr);
 }
 function appendRunEvent(context2, event, data = {}) {
   const line = JSON.stringify({ ts: new Date().toISOString(), event, ...data }) + `
 `;
-  const path = join31(context2.runDir, "events.ndjson");
+  const path = join32(context2.runDir, "events.ndjson");
   const previous = existsSync15(path) ? readFileSync19(path, "utf-8") : "";
   writeFileSync10(path, previous + line);
 }
 function findSkillRun(runId, targetDir = process.cwd()) {
-  const runsRoot = join31(getProjectStateDir(targetDir), "runs");
+  const runsRoot = join32(getProjectStateDir(targetDir), "runs");
   if (!existsSync15(runsRoot))
     return null;
   for (const day of readdirSync10(runsRoot)) {
-    const record11 = readRunRecord(join31(runsRoot, day, runId));
+    const record11 = readRunRecord(join32(runsRoot, day, runId));
     if (record11)
       return record11;
   }
@@ -57233,11 +57506,11 @@ function skillRunEnv(context2) {
   };
 }
 function writeRunRecord(context2) {
-  writeFileSync10(join31(context2.runDir, "run.json"), JSON.stringify(context2.record, null, 2) + `
+  writeFileSync10(join32(context2.runDir, "run.json"), JSON.stringify(context2.record, null, 2) + `
 `);
 }
 function writeArtifactsManifest(context2, artifacts) {
-  writeFileSync10(join31(context2.runDir, "artifacts.json"), JSON.stringify({ runId: context2.record.id, artifacts }, null, 2) + `
+  writeFileSync10(join32(context2.runDir, "artifacts.json"), JSON.stringify({ runId: context2.record.id, artifacts }, null, 2) + `
 `);
 }
 function collectRunArtifacts(context2) {
@@ -57250,14 +57523,14 @@ function collectRunArtifacts(context2) {
     artifacts.push({
       path: toProjectRelative(context2.targetDir, path),
       mime: mimeForPath(path),
-      sha256: createHash19("sha256").update(bytes).digest("hex"),
+      sha256: createHash20("sha256").update(bytes).digest("hex"),
       sizeBytes: stat3.size
     });
   }
   return artifacts.sort((a, b) => a.path.localeCompare(b.path));
 }
 function readRunRecord(runDir) {
-  const path = join31(runDir, "run.json");
+  const path = join32(runDir, "run.json");
   if (!existsSync15(path))
     return null;
   try {
@@ -57269,7 +57542,7 @@ function readRunRecord(runDir) {
 function walkFiles(dir) {
   const files = [];
   for (const entry of readdirSync10(dir)) {
-    const full = join31(dir, entry);
+    const full = join32(dir, entry);
     if (statSync9(full).isDirectory())
       files.push(...walkFiles(full));
     else
@@ -57526,7 +57799,7 @@ import { closeSync as closeSync16, fstatSync as fstatSync16, openSync as openSyn
 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 isAbsolute17, join as join32 } from "path";
+import { isAbsolute as isAbsolute17, join as join33 } from "path";
 import { createRequire as createRequire22 } from "module";
 function envToken2(name) {
   return name.toUpperCase().replace(/-/g, "_");
@@ -57557,14 +57830,14 @@ function hasnaHomeDir2(env) {
   if (override)
     return override;
   const home = homeDir2(env);
-  return home ? join32(home, HASNA_HOME_DIR2) : null;
+  return home ? join33(home, HASNA_HOME_DIR2) : null;
 }
 function appConfigDir2(name, env) {
   const configRoot = absoluteOverride2(env, HASNA_CONFIG_HOME_ENV_KEY2);
   if (configRoot)
-    return join32(configRoot, name);
+    return join33(configRoot, name);
   const root = hasnaHomeDir2(env);
-  return root ? join32(root, name, CONFIG_SUBDIR2) : null;
+  return root ? join33(root, name, CONFIG_SUBDIR2) : null;
 }
 function credentialDiskSourceList2(name, env, profile = null) {
   if (!SAFE_APP_SLUG2.test(name))
@@ -57573,7 +57846,7 @@ function credentialDiskSourceList2(name, env, profile = null) {
   if (!directory2)
     return [];
   const file2 = profile ? `${CREDENTIALS_FILE2}-${profile}` : CREDENTIALS_FILE2;
-  return [{ path: join32(directory2, file2), tier: "disk" }];
+  return [{ path: join33(directory2, file2), tier: "disk" }];
 }
 function credentialDiskSources2(name, env) {
   return credentialDiskSourceList2(name, env, null).map((s) => s.path);
@@ -59064,10 +59337,10 @@ __export(exports_selected_run, {
   prepareSelectedSecretBindings: () => prepareSelectedSecretBindings,
   executeSelectedLocal: () => executeSelectedLocal
 });
-import { createHash as createHash20 } from "crypto";
+import { createHash as createHash21 } from "crypto";
 import { spawn } from "child_process";
 import { mkdirSync as mkdirSync12, mkdtempSync as mkdtempSync3, writeFileSync as writeFileSync11, realpathSync as realpathSync10 } from "fs";
-import { dirname as dirname20, join as join33, resolve as resolve19 } from "path";
+import { dirname as dirname20, join as join34, resolve as resolve19 } from "path";
 import { tmpdir, hostname as stationHostname2 } from "os";
 async function resolveSelectedRun(spec, profileId, options = {}) {
   const context2 = await resolveSelectionContext(profileId, options);
@@ -59147,7 +59420,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(join33(tmpdir(), "skills-execution-"));
+  const runDirectory = mkdtempSync3(join34(tmpdir(), "skills-execution-"));
   const paths = new SkillEntryPaths;
   for (const entry of entries) {
     paths.add(entry.path, 100, () => {
@@ -59155,7 +59428,7 @@ async function executeSelectedLocal(selected, options = {}) {
     }, () => {
       throw new SkillSelectionError("INVALID_BUNDLE_PATH", "The execution bundle path exceeds its limit.");
     });
-    const destination = join33(runDirectory, entry.path);
+    const destination = join34(runDirectory, entry.path);
     mkdirSync12(dirname20(destination), { recursive: true, mode: 448 });
     writeFileSync11(destination, entry.bytes, { flag: "wx", mode: entry.mode & 511 });
   }
@@ -59183,20 +59456,20 @@ async function executeSelectedLocal(selected, options = {}) {
   }
   if (bindings)
     secretEnv = await resolveSelectedSecrets(bindings, options.createSecretsClient);
-  const result = await subprocess([executable, ...runtimeName === "bun" ? ["--no-env-file"] : [], join33(runDirectory, declaredEntry), ...args], runDirectory, { ...env, ...secretEnv }, input2, timeoutMs);
+  const result = await subprocess([executable, ...runtimeName === "bun" ? ["--no-env-file"] : [], join34(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:${createHash20("sha256").update(input2).digest("hex")}`,
+    inputDigest: `sha256:${createHash21("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(join33(runDirectory, ".execution-receipt.json"), JSON.stringify({ ...receipt, stdout: undefined, stderr: undefined }), { mode: 384 });
+  writeFileSync11(join34(runDirectory, ".execution-receipt.json"), JSON.stringify({ ...receipt, stdout: undefined, stderr: undefined }), { mode: 384 });
   return receipt;
 }
 async function subprocess(command, cwd, env, input2, timeoutMs) {
@@ -59386,7 +59659,7 @@ var init_blog_article = __esm(() => {
 
 // src/mcp/operation-tools.ts
 import { existsSync as existsSync16, readdirSync as readdirSync11, statSync as statSync10 } from "fs";
-import { join as join34 } from "path";
+import { join as join35 } from "path";
 function registerOperationTools(server) {
   server.registerTool("cloud_skill_eligibility", {
     title: "Cloud Skill Eligibility",
@@ -59863,7 +60136,7 @@ function registerOperationTools(server) {
       if (exists) {
         try {
           skillCount = readdirSync11(agentSkillsPath).filter((f) => {
-            const full = join34(agentSkillsPath, f);
+            const full = join35(agentSkillsPath, f);
             return !f.startsWith(".") && statSync10(full).isDirectory();
           }).length;
         } catch {}
@@ -59931,10 +60204,10 @@ var init_operation_tools = __esm(() => {
 
 // src/lib/feedback.ts
 import { appendFileSync, existsSync as existsSync17, mkdirSync as mkdirSync13 } from "fs";
-import { dirname as dirname21, join as join35 } from "path";
+import { dirname as dirname21, join as join36 } from "path";
 import { Database } from "bun:sqlite";
 function getFeedbackDbPath() {
-  return join35(getDataDir(), "skills.db");
+  return join36(getDataDir(), "skills.db");
 }
 function getFeedbackDb() {
   const dbPath = getFeedbackDbPath();
@@ -59966,7 +60239,7 @@ function saveFeedback(input2) {
     throw new Error("Feedback message is required");
   const category = input2.category ?? "general";
   if (isApiMode()) {
-    const path = join35(getDataDir(), "feedback.jsonl");
+    const path = join36(getDataDir(), "feedback.jsonl");
     const dir = dirname21(path);
     if (!existsSync17(dir))
       mkdirSync13(dir, { recursive: true });
@@ -60131,9 +60404,9 @@ var init_resource_meta_tools = __esm(() => {
 
 // src/lib/scheduler.ts
 import { existsSync as existsSync18, readFileSync as readFileSync21, writeFileSync as writeFileSync12, mkdirSync as mkdirSync14 } from "fs";
-import { join as join36 } from "path";
+import { join as join37 } from "path";
 function getSchedulesPath(targetDir = process.cwd()) {
-  return join36(targetDir, ".skills", "schedules.json");
+  return join37(targetDir, ".skills", "schedules.json");
 }
 function loadSchedules(targetDir = process.cwd()) {
   const path = getSchedulesPath(targetDir);
@@ -60146,7 +60419,7 @@ function loadSchedules(targetDir = process.cwd()) {
 }
 function saveSchedules(data, targetDir = process.cwd()) {
   const path = getSchedulesPath(targetDir);
-  const dir = join36(targetDir, ".skills");
+  const dir = join37(targetDir, ".skills");
   if (!existsSync18(dir))
     mkdirSync14(dir, { recursive: true });
   writeFileSync12(path, JSON.stringify(data, null, 2));
@@ -60418,7 +60691,7 @@ var init_schedule_tools = __esm(() => {
 });
 
 // src/lib/native-storage.ts
-import { createHash as createHash21, createHmac } from "crypto";
+import { createHash as createHash22, createHmac } from "crypto";
 import {
   existsSync as existsSync19,
   mkdirSync as mkdirSync15,
@@ -60427,7 +60700,7 @@ import {
   statSync as statSync11,
   writeFileSync as writeFileSync13
 } from "fs";
-import { dirname as dirname22, join as join37, normalize as normalize4, relative as relative7, sep as sep8 } from "path";
+import { dirname as dirname22, join as join38, normalize as normalize4, relative as relative7, sep as sep9 } from "path";
 function resolveSkillsNativeStorageConfig(env = process.env) {
   assertNoRetiredModeEnvVars(env, {
     app: SKILLS_ENV_NAMESPACE,
@@ -60468,7 +60741,7 @@ function getSkillsNativeStorageStatus(options = {}) {
     local: {
       dataDir: getDataDir(),
       projectStateDir: getProjectStateDir(targetDir),
-      feedbackDbPath: join37(getDataDir(), "skills.db")
+      feedbackDbPath: join38(getDataDir(), "skills.db")
     },
     remote: {
       databaseConfigured: Boolean(config2.databaseUrl),
@@ -60495,7 +60768,7 @@ function exportSkillsLocalSnapshot(targetDir = process.cwd(), options = {}) {
       files.push({
         path: relativePath,
         sizeBytes: bytes.byteLength,
-        sha256: createHash21("sha256").update(bytes).digest("hex"),
+        sha256: createHash22("sha256").update(bytes).digest("hex"),
         ...options.includeFileContents ? { contentBase64: Buffer.from(bytes).toString("base64") } : {}
       });
     }
@@ -60549,7 +60822,7 @@ function parsePositiveInteger(value) {
 function walkFiles2(dir) {
   const files = [];
   for (const entry of readdirSync12(dir)) {
-    const full = join37(dir, entry);
+    const full = join38(dir, entry);
     const stats = statSync11(full);
     if (stats.isDirectory())
       files.push(...walkFiles2(full));
@@ -60788,7 +61061,7 @@ var init_private_publication_customer = __esm(() => {
 
 // src/lib/private-publication-recovery.ts
 import { constants as constants14, closeSync as closeSync18, fsyncSync as fsyncSync5, fstatSync as fstatSync18, lstatSync as lstatSync22, mkdirSync as mkdirSync16, openSync as openSync18, readSync as readSync12, realpathSync as realpathSync11, renameSync as renameSync7, unlinkSync as unlinkSync6, writeFileSync as writeFileSync14 } from "fs";
-import { dirname as dirname23, isAbsolute as isAbsolute18, join as join38, resolve as resolve20 } from "path";
+import { dirname as dirname23, isAbsolute as isAbsolute18, join as join39, resolve as resolve20 } from "path";
 import { randomUUID as randomUUID3 } from "crypto";
 function safeDirectory(directory2) {
   if (!isAbsolute18(directory2) || directory2 !== resolve20(directory2) || realpathSync11(directory2) !== directory2)
@@ -60811,7 +61084,7 @@ function unchangedDirectory(directory2, identity3) {
     return fail2();
 }
 function readOwned(directory2, name, max) {
-  const identity3 = safeDirectory(directory2), file2 = join38(directory2, name);
+  const identity3 = safeDirectory(directory2), file2 = join39(directory2, name);
   const fd = openSync18(file2, constants14.O_RDONLY | constants14.O_NOFOLLOW);
   try {
     const stat3 = fstatSync18(fd);
@@ -60835,7 +61108,7 @@ function readOwned(directory2, name, max) {
   }
 }
 function writeOwned(directory2, name, bytes) {
-  const fd = openSync18(join38(directory2, name), constants14.O_WRONLY | constants14.O_CREAT | constants14.O_EXCL | constants14.O_NOFOLLOW, 384);
+  const fd = openSync18(join39(directory2, name), constants14.O_WRONLY | constants14.O_CREAT | constants14.O_EXCL | constants14.O_NOFOLLOW, 384);
   try {
     writeFileSync14(fd, bytes);
     fsyncSync5(fd);
@@ -60848,7 +61121,7 @@ function save(directory2, value) {
   writeOwned(directory2, temporary, JSON.stringify(value) + `
 `);
   unchangedDirectory(directory2, identity3);
-  renameSync7(join38(directory2, temporary), join38(directory2, "receipt.json"));
+  renameSync7(join39(directory2, temporary), join39(directory2, "receipt.json"));
   const fd = openSync18(directory2, constants14.O_RDONLY | constants14.O_NOFOLLOW);
   try {
     fsyncSync5(fd);
@@ -60861,7 +61134,7 @@ 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 = join38(directory2, "operation.lock");
+  const identity3 = safeDirectory(directory2), file2 = join39(directory2, "operation.lock");
   let fd;
   try {
     fd = openSync18(file2, constants14.O_WRONLY | constants14.O_CREAT | constants14.O_EXCL | constants14.O_NOFOLLOW, 384);
@@ -62752,7 +63025,7 @@ var require_content_type = __commonJS((exports) => {
   var QUOTE_REGEXP = /([\\"])/g;
   var TYPE_REGEXP = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+\/[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
   exports.format = format;
-  exports.parse = parse11;
+  exports.parse = parse12;
   function format(obj) {
     if (!obj || typeof obj !== "object") {
       throw new TypeError("argument obj is required");
@@ -62776,7 +63049,7 @@ var require_content_type = __commonJS((exports) => {
     }
     return string6;
   }
-  function parse11(string6) {
+  function parse12(string6) {
     if (!string6) {
       throw new TypeError("argument string is required");
     }