@hasna/skills 0.10.44 → 0.10.46

package/bin/mcp.js

@@ -20019,7 +20019,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@hasna/skills",
-    version: "0.10.44",
+    version: "0.10.46",
     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, resolve as resolve3 } 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,15 @@ 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-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 === "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);
@@ -45285,7 +45602,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 +45643,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 +45699,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 join10, 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 +45733,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) !== join10(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 +45743,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 join11, 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;
       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]);
       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 +45933,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 join12, parse as parse7, resolve as resolve7, sep as sep3 } from "path";
 function identity2(stat, mutable = false) {
   return {
     dev: String(stat.dev),
@@ -45629,14 +45946,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(sep3);
   function record4(path2, row) {
     const value = { path: path2, ...row };
     metadataBytes += Buffer.byteLength(JSON.stringify(value));
@@ -45646,7 +45963,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 +45976,13 @@ function trace(path) {
     if (!component || component === ".")
       continue;
     if (component === "..") {
-      cursor = dirname7(cursor);
+      cursor = dirname8(cursor);
       continue;
     }
     const candidate = join12(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,17 +45990,17 @@ 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;
+      const remainder = isAbsolute8(target) ? target.slice(parse7(target).root.length) : target;
       pending = [...remainder.split(sep3), ...pending];
       if (pending.length + steps > AGENT_POLICY_LIMITS.discoveryPathSteps)
         throw new Error("Discovery path step limit exceeded");
@@ -45703,7 +46020,7 @@ 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) {
@@ -45716,17 +46033,17 @@ 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();
@@ -45734,7 +46051,7 @@ var init_agent_discovery_path_bytes = __esm(() => {
 });
 
 // src/lib/skill-bundle.ts
-import { createHash as createHash5 } from "crypto";
+import { createHash as createHash6 } from "crypto";
 import { readFileSync as readFileSync9, readdirSync as readdirSync4, statSync as statSync6 } from "fs";
 import { join as join13, relative as relative3 } from "path";
 import { createGunzip } from "zlib";
@@ -45766,7 +46083,7 @@ function ownBytes(view) {
   return out;
 }
 function sha256Hex(bytes) {
-  return createHash5("sha256").update(bytes).digest("hex");
+  return createHash6("sha256").update(bytes).digest("hex");
 }
 function collectSkillBundleEntries(dir) {
   const entries = [];
@@ -45944,7 +46261,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,21 +46618,21 @@ var init_profile_limits = __esm(() => {
 });
 
 // src/lib/selection-cache.ts
-import { createHash as createHash6, randomUUID } from "crypto";
+import { createHash as createHash7, 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 join14, parse as parse8, resolve as resolve8 } from "path";
 import { isDeepStrictEqual } from "util";
 function selectionCacheRoot(options = {}) {
-  return resolve7(options.cacheDir ?? join14(getDataDirReadOnly(), "selection-cache"));
+  return resolve8(options.cacheDir ?? join14(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 createHash7("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()) {
@@ -46355,14 +46672,14 @@ function selectionBundlePath(selection, options = {}) {
   return join14(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 = parse8(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]);
     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 +46695,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 +46717,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 +46729,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 = join14(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);
@@ -46528,7 +46845,7 @@ function assertFreshCachedProfile(receipt, options = {}) {
   }
 }
 function projectSelectionLockPath(projectDir) {
-  return join14(resolve7(projectDir), ".skills", SELECTION_LOCK_FILE);
+  return join14(resolve8(projectDir), ".skills", SELECTION_LOCK_FILE);
 }
 function readProjectSelection(projectDir) {
   const receipt = readSelectionJson(projectSelectionLockPath(projectDir));
@@ -46636,14 +46953,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 +46977,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 +46988,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,25 +47036,25 @@ 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 directory = join14(dirname9(dirname9(lock.path)), "session-lock-recoveries", randomUUID());
     const archivePath = join14(directory, "original.write-lock");
     const recordPath = join14(directory, "recovery.json");
     assertRegularPath(archivePath, true);
@@ -46754,7 +47071,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;
@@ -46769,11 +47086,11 @@ function archiveSessionLock(lock, receipt, explicitLocalHost) {
         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 +47102,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 +47115,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 +47159,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 +47212,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 +47255,7 @@ __export(exports_remote_files, {
   decodeRemoteFiles: () => decodeRemoteFiles,
   MAX_REMOTE_FILE_BYTES: () => MAX_REMOTE_FILE_BYTES
 });
-import { createHash as createHash7 } from "crypto";
+import { createHash as createHash8 } from "crypto";
 function describeRemoteFiles(files) {
   if (files.length > 10)
     throw new Error("At most 10 input files are supported");
@@ -46955,7 +47272,7 @@ function describeRemoteFiles(files) {
   });
 }
 function sha256(bytes) {
-  return createHash7("sha256").update(bytes).digest("hex");
+  return createHash8("sha256").update(bytes).digest("hex");
 }
 async function readBoundedResponse(response, maximum) {
   if (!Number.isSafeInteger(maximum) || maximum < 0 || maximum > MAX_REMOTE_FILE_BYTES)
@@ -47210,11 +47527,11 @@ 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 { 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 join15 } from "path";
 function hasDependencyPreparationMarker(skillPath) {
   try {
-    lstatSync9(join15(skillPath, DEPENDENCY_PREPARATION_MARKER));
+    lstatSync10(join15(skillPath, DEPENDENCY_PREPARATION_MARKER));
     return true;
   } catch (error61) {
     return error61.code !== "ENOENT";
@@ -47233,21 +47550,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 +47576,7 @@ function claimPreparation(skillPath) {
     record4("pending");
     return { abandon() {
       try {
-        closeSync7(descriptor);
+        closeSync8(descriptor);
       } catch {}
     }, finish(success2) {
       try {
@@ -47267,7 +47584,7 @@ function claimPreparation(skillPath) {
           unlinkSync2(state);
         else
           record4("failed");
-        closeSync7(descriptor);
+        closeSync8(descriptor);
         fd = undefined;
         rmdirSync(active);
         if (success2)
@@ -47275,7 +47592,7 @@ function claimPreparation(skillPath) {
         return true;
       } catch {
         try {
-          closeSync7(descriptor);
+          closeSync8(descriptor);
         } catch {}
         return false;
       }
@@ -47283,7 +47600,7 @@ function claimPreparation(skillPath) {
   } catch {
     if (fd !== undefined)
       try {
-        closeSync7(fd);
+        closeSync8(fd);
       } catch {}
     return;
   }
@@ -47443,283 +47760,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);
@@ -48060,8 +48100,8 @@ function numericTokens(text2) {
   }
   return result;
 }
-function canonical3(value, depth = 0, budget = { remaining: 65536 }) {
-  need3(depth <= 32 && --budget.remaining >= 0);
+function canonical3(value, depth = 0, budget2 = { remaining: 65536 }) {
+  need3(depth <= 32 && --budget2.remaining >= 0);
   if (value === null)
     return ["null"];
   if (typeof value === "string")
@@ -48077,13 +48117,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) => canonical3(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, canonical3(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);
@@ -48102,8 +48142,8 @@ function hashCodexSettingsReplacement(text2, budget = { remaining: 256 * 1024 *
     }
   return sha(`hasna.skills.codex-settings.v1\x00${JSON.stringify([canonical3(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;
@@ -48230,8 +48270,8 @@ function numericTokens2(text2) {
   }
   return result.sort();
 }
-function canonical4(value, depth = 0, budget = { remaining: 65536 }) {
-  need4(depth <= 32 && --budget.remaining >= 0);
+function canonical4(value, depth = 0, budget2 = { remaining: 65536 }) {
+  need4(depth <= 32 && --budget2.remaining >= 0);
   if (value === null)
     return ["null"];
   if (typeof value === "string")
@@ -48247,9 +48287,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) => canonical4(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, canonical4(child, depth + 1, budget2)])];
 }
 function normalize2(config2, version2 = 2) {
   if (isRecord3(config2.hooks)) {
@@ -48425,30 +48465,30 @@ function settingsDigest2(text2, version2 = 2) {
   normalize2(projected.config, version2);
   return sha2(`hasna.skills.codex-settings.v${version2}\x00${JSON.stringify([canonical4(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 init_codex_settings_witness = __esm(() => {
@@ -48653,6 +48693,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();
@@ -50047,13 +50088,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 +50113,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 {
@@ -50189,15 +50230,15 @@ 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 = parse10(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");
   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 = parse10(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");
@@ -50289,33 +50330,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;
@@ -50333,8 +50386,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)
@@ -50466,7 +50519,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")
@@ -50483,7 +50536,7 @@ function verifyAgentDiscovery(binding, codexRecovery) {
       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}`);
   }
@@ -50517,6 +50570,8 @@ function codexInstallationRoots(binding) {
   });
 }
 function assertMarketplaceBinding(binding, source) {
+  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"))
@@ -50541,7 +50596,7 @@ 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`);
@@ -50638,9 +50693,9 @@ function resolveAgentDiscovery(options) {
     verifyAgentDiscovery(retained);
     if (!retained.sources.some((source) => source.path === canonical6(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 !== canonical6(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, canonical6(configPath)) ? sources.filter((source) => !isSupersededSettingsProjection(agent, canonical6(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;
@@ -50655,11 +50710,11 @@ 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.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 !== canonical6(configPath)))
+      throw new Error("Semantic settings witnesses must name the configured agent configuration source");
     if (!review.sources.some((source) => source.path === canonical6(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;
+    const reviewedSources = supersedesSettingsProjection(agent, review.sources, canonical6(configPath)) ? sources.filter((source) => !isSupersededSettingsProjection(agent, canonical6(configPath), source)) : sources;
     return { ...supplied, roots: [...new Set([...roots, ...supplied.roots])].sort(), sources: [...reviewedSources, ...review.sources], ...agent === "gemini" ? { builtinNames } : {} };
   }
   function plugin(root) {
@@ -50776,6 +50831,7 @@ function resolveAgentDiscovery(options) {
 }
 var digest = (text2) => createHash16("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();
@@ -52077,7 +52133,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 +52219,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 +52241,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([
@@ -54144,7 +54200,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 +54255,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) {