@hasna/skills 0.10.60 → 0.10.62

package/dist/runtime-prerequisites.js

@@ -0,0 +1,3089 @@
+// @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// src/runtime-prerequisites.ts
+import { isAbsolute as isAbsolute5 } from "path";
+// package.json
+var version = "0.10.62";
+var package_default = {
+  name: "@hasna/skills",
+  version,
+  description: "Skills library for AI coding agents",
+  type: "module",
+  bin: {
+    skills: "bin/index.js",
+    "skills-mcp": "bin/mcp.js",
+    "skills-serve": "bin/server.js",
+    "skills-server": "bin/server.js",
+    "skills-worker": "bin/worker.js",
+    "skills-maintenance": "bin/maintenance.js",
+    "skills-migrate": "bin/migrate.js"
+  },
+  exports: {
+    ".": {
+      import: "./dist/index.js",
+      types: "./dist/index.d.ts"
+    },
+    "./storage": {
+      import: "./dist/storage.js",
+      types: "./dist/storage.d.ts"
+    },
+    "./sdk": {
+      import: "./dist/sdk/index.js",
+      types: "./dist/sdk/index.d.ts"
+    },
+    "./admin-contract": {
+      import: "./dist/admin-contract.js",
+      types: "./dist/admin-contract.d.ts"
+    }
+  },
+  files: [
+    "dist/",
+    "!dist/**/*.test.d.ts",
+    "!dist/**/*.fixture.d.ts",
+    "!dist/test-preload.d.ts",
+    "!dist/platform",
+    "bin/",
+    "native/kernel-lock-acl-darwin",
+    "migrations/",
+    "docs/skill-standard.md",
+    "docs/plugin-admission.md",
+    "docs/runtime-activation.md",
+    "schemas/",
+    "LICENSE",
+    "README.md",
+    "!dist/**/*test-utils.d.ts",
+    "!dist/**/*fixtures.d.ts"
+  ],
+  main: "./dist/index.js",
+  types: "./dist/index.d.ts",
+  scripts: {
+    clean: "rm -rf bin/ dist/",
+    build: "bun run clean && bun build --external @hasna/contracts/kernel-lock ./src/cli/index.tsx --outdir ./bin --target bun && bun build --external @modelcontextprotocol/sdk ./src/mcp/index.ts --outfile ./bin/mcp.js --target bun && bun build --external @hasna/contracts/kernel-lock ./src/server/index.ts --outfile ./bin/server.js --target bun && bun build --external @hasna/contracts/kernel-lock ./src/server/worker.ts --outfile ./bin/worker.js --target bun && bun build --external @hasna/contracts/kernel-lock ./src/server/migrate.ts --outfile ./bin/migrate.js --target bun && bun build --external @hasna/contracts/kernel-lock ./src/server/maintenance.ts --outfile ./bin/maintenance.js --target bun && bun build ./src/index.ts ./src/storage.ts ./src/sdk/index.ts ./src/admin-contract.ts ./src/runtime-prerequisites.ts --outdir ./dist --target bun && tsc --emitDeclarationOnly --declaration --outDir dist && bun scripts/stage-kernel-lock-assets.ts",
+    "build:js": "rm -rf dist && bun build ./src/index.ts ./src/storage.ts ./src/sdk/index.ts ./src/admin-contract.ts ./src/runtime-prerequisites.ts --outdir ./dist --target bun && tsc --emitDeclarationOnly --declaration --outDir dist && bun scripts/stage-kernel-lock-assets.ts",
+    test: "bun test --timeout 30000",
+    dev: "bun run ./src/cli/index.tsx",
+    "dev:watch": "bun --watch run ./src/cli/index.tsx",
+    "dev:mcp": "bun --watch run ./src/mcp/index.ts",
+    "dev:server": "bun --watch run ./src/server/index.ts",
+    "dev:worker": "bun --watch run ./src/server/worker.ts",
+    "docker:check": "bash scripts/docker-build-check.sh",
+    migrate: "bun run ./src/server/migrate.ts",
+    typecheck: "tsc --noEmit",
+    "verify:release": "bun run scripts/release-guard.ts",
+    "verify:release-review": "bun run scripts/verify-release-review.ts",
+    "verify:consumer-types": "bun run scripts/consumer-types.ts",
+    prepack: "bun run verify:generated && bun run verify:release && bun run verify:consumer-types",
+    prepublishOnly: "bun run verify:producer && bun run typecheck && bun run test",
+    "verify:producer": "bun run scripts/release-dependencies.ts",
+    "verify:generated": "HASNA_SKILLS_RELEASE_ARTIFACT_TEST=1 bun test src/lib/release-artifacts.test.ts",
+    "verify:consumer-credentials": "bun run scripts/consumer-credentials.ts"
+  },
+  keywords: [
+    "skills",
+    "ai",
+    "agent",
+    "cli",
+    "typescript",
+    "bun",
+    "claude",
+    "codex",
+    "gemini",
+    "mcp",
+    "model-context-protocol",
+    "open-source",
+    "skills-library",
+    "automation"
+  ],
+  author: "Hasna",
+  license: "Apache-2.0",
+  devDependencies: {
+    "@types/bun": "1.3.14",
+    "@types/node": "25.2.3",
+    "@types/react": "^18.2.0",
+    "bun-types": "1.3.14",
+    "react-devtools-core": "^7.0.1",
+    typescript: "^5",
+    yaml: "^2.9.0"
+  },
+  dependencies: {
+    "@aws-sdk/client-ecs": "^3.1079.0",
+    "@aws-sdk/client-s3": "^3.1079.0",
+    "@hasna/events": "0.1.18",
+    "@hasna/secrets": "0.4.2",
+    "@modelcontextprotocol/sdk": "^1.26.0",
+    chalk: "^5.3.0",
+    commander: "^12.1.0",
+    ink: "^5.0.1",
+    "ink-select-input": "^6.0.0",
+    "ink-spinner": "^5.0.0",
+    "ink-text-input": "^6.0.0",
+    react: "^18.2.0",
+    zod: "^4.3.6",
+    "@hasna/contracts": "1.3.5"
+  },
+  engines: {
+    bun: ">=1.0.0"
+  },
+  publishConfig: {
+    registry: "https://registry.npmjs.org",
+    access: "public"
+  },
+  repository: {
+    type: "git",
+    url: "https://github.com/hasna/skills.git",
+    directory: "apps/skills"
+  },
+  homepage: "https://github.com/hasna/skills/tree/main/apps/skills",
+  bugs: {
+    url: "https://github.com/hasna/skills/issues"
+  },
+  skillsRuntimePrerequisites: {
+    version: 1,
+    entry: "dist/runtime-prerequisites.js"
+  }
+};
+
+// src/lib/agent-install-selection.ts
+import { lstatSync as lstatSync4 } from "fs";
+import { dirname as dirname5, join as join7, resolve as resolve6 } from "path";
+import { homedir as homedir2 } from "os";
+
+// src/lib/agent-adapters.ts
+var INTEGRATION_AGENTS = ["claude", "codex", "gemini", "opencode", "cursor", "hermes", "sumi"];
+function renderAgentHookCommand(command, agent, profileId, event) {
+  if (typeof profileId !== "string" || !/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/.test(profileId) || profileId.includes(".."))
+    throw new Error("Invalid selection profile id");
+  return `'${command.replace(/'/g, `'\\''`)}' hook user-prompt --agent ${agent} --selection-profile ${profileId} --event ${event}`;
+}
+var AGENT_ADAPTERS = {
+  claude: { root: ".claude/skills", config: ".claude/settings.json", events: ["UserPromptSubmit", "SessionStart", "SubagentStart"], promptContext: true },
+  codex: { root: ".codex/skills", config: ".codex/hooks.json", events: ["UserPromptSubmit", "SessionStart", "SubagentStart"], promptContext: true },
+  gemini: { root: ".gemini/skills", config: ".gemini/settings.json", events: ["BeforeAgent", "SessionStart"], promptContext: true },
+  opencode: { root: ".config/opencode/skills", config: ".config/opencode/opencode.json", events: ["chat.message"], promptContext: true },
+  sumi: { root: null, config: null, events: ["prompt", "context"], promptContext: true },
+  hermes: { root: ".hermes/skills", config: ".hermes/config.yaml", events: ["pre_llm_call", "pre_tool_call"], promptContext: true, promptFailureMode: "open", toolFailureMode: "supervised-child-errors-block", requiresNativeTrust: true },
+  cursor: { root: ".cursor/skills", config: ".cursor/hooks.json", events: ["beforeSubmitPrompt", "sessionStart"], promptContext: false }
+};
+function renderOpenCodePlugin(command, profileId) {
+  return `// Managed by @hasna/skills. Regenerate with skills hook install --agent opencode.
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+const command = ${JSON.stringify(command)};
+const profile = ${JSON.stringify(profileId)};
+function context(input) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, ["hook", "user-prompt", "--agent", "opencode", "--selection-profile", profile], { cwd: input.cwd, stdio: ["pipe", "pipe", "pipe"] });
+    const chunks = []; let bytes = 0, failure;
+    const timer = setTimeout(() => { failure = new Error("Skills prompt hook timed out"); child.kill("SIGKILL"); }, 15000);
+    child.stdout.on("data", chunk => { bytes += chunk.length; if (bytes > 1048576) { failure = new Error("Skills prompt hook output exceeded its limit"); child.kill("SIGKILL"); } else chunks.push(chunk); });
+    child.stderr.on("data", () => {});
+    child.stdin.on("error", () => {});
+    child.on("error", error => { clearTimeout(timer); reject(error); });
+    child.on("close", code => {
+      clearTimeout(timer);
+      if (failure || code !== 0) return reject(failure ?? new Error("Skills prompt hook failed"));
+      try {
+        const result = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+        if (!result || typeof result !== "object" || Array.isArray(result)) throw new Error("Invalid Skills hook response");
+        if (result.decision === "block" || result.continue === false) throw new Error(result.reason ?? result.stopReason ?? "Skills prompt hook refused");
+        if (Object.keys(result).length && (!result.hookSpecificOutput || result.hookSpecificOutput.hookEventName !== input.hook_event_name)) throw new Error("Invalid Skills hook response");
+        const text = result.hookSpecificOutput?.additionalContext ?? "";
+        if (typeof text !== "string") throw new Error("Invalid Skills prompt context");
+        resolve(text);
+      } catch (error) { reject(error); }
+    });
+    child.stdin.end(JSON.stringify(input));
+  });
+}
+export default async ({ directory }) => {
+  const sessions = new Set();
+  return {
+    "chat.message": async (input, output) => {
+      const parts = output.parts.filter(part => part.type === "text" && typeof part.text === "string");
+      const first = !sessions.has(input.sessionID);
+      const text = await context({ hook_event_name: first ? "SessionStart" : "UserPromptSubmit", cwd: directory, session_id: input.sessionID, prompt: parts.map(part => part.text).join("\\n") });
+      if (text && parts.length) parts[0].text += "\\n\\n" + text;
+      else if (text) output.parts.push({ id: "prt_" + randomUUID().replaceAll("-", ""), sessionID: input.sessionID, messageID: output.message.id, type: "text", text, synthetic: true });
+      if (sessions.size >= 1000) sessions.clear();
+      sessions.add(input.sessionID);
+    },
+    "tool.execute.before": async (input, output) => {
+      if (input.tool === "skill" && output.args?.name !== "skills-cli") throw new Error("Load instructions through the Skills CLI bridge");
+    },
+  };
+};
+`;
+}
+
+// src/lib/native-discovery-roots.ts
+var NATIVE_SKILL_ROOTS = [
+  ["claude", ".claude/skills"],
+  ["codex", ".codex/skills"],
+  ["codex", ".agents/skills"],
+  ["gemini", ".gemini/skills"],
+  ["sumi", ".sumi/skills"],
+  ["sumi", ".sumi/skill"],
+  ["codewith", ".codewith/skills"],
+  ["opencode", ".config/opencode/skills"],
+  ["opencode", ".opencode/skills"],
+  ["cursor", ".cursor/skills"],
+  ["hermes", ".hermes/skills"],
+  ["windsurf", ".windsurf/skills"],
+  ["pi", ".pi/agent/skills"],
+  ["amp", ".amp/skills"],
+  ["cline", ".cline/skills"],
+  ["roo", ".roo/skills"],
+  ["copilot", ".github/skills"]
+];
+
+// src/lib/managed-policy.ts
+import { closeSync as closeSync3, constants as constants3, fstatSync as fstatSync3, lstatSync as lstatSync3, openSync as openSync3, readSync as readSync3 } from "fs";
+import { join as join6 } from "path";
+
+// src/lib/config.ts
+import { existsSync as existsSync2, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { join as join2, dirname } from "path";
+
+// src/lib/retired-settings.ts
+var RETIRED_ENV_SUFFIXES = ["_STORAGE_MODE", "_DEPLOYMENT_MODE", "_CLOUD_MODE"];
+var RETIRED_CONFIG_KEYS = {
+  mode: "a configured API origin",
+  apiUrl: "skills setup --api-url <origin>"
+};
+var RETIRED_CONFIG_KEY_REASONS = {
+  mode: "Deployment modes were removed: a Skills client either resolves a credential " + "or it does not, and that is the whole of it.",
+  apiUrl: "The service address is no longer kept in this app's config file: it is read from " + "HASNA_SKILLS_API_URL, then the macOS Keychain item hasna.credentials.skills.api-url, " + "then ~/.hasna/skills/config/credentials, then the fleet gateway."
+};
+
+class RetiredSettingError extends Error {
+  code = "RETIRED_SETTING";
+  setting;
+  constructor(setting, message) {
+    super(message);
+    this.name = "RetiredSettingError";
+    this.setting = setting;
+  }
+}
+function isRetiredModeEnvVar(name, app) {
+  const upper = name.toUpperCase();
+  if (!upper.includes(app.toUpperCase()))
+    return false;
+  return RETIRED_ENV_SUFFIXES.some((suffix) => upper.endsWith(suffix));
+}
+function findRetiredModeEnvVars(env, app) {
+  const found = [];
+  for (const [name, value] of Object.entries(env)) {
+    if (value === undefined || value === "")
+      continue;
+    if (isRetiredModeEnvVar(name, app))
+      found.push({ name, value });
+  }
+  return found.sort((a, b) => a.name.localeCompare(b.name));
+}
+function assertNoRetiredModeEnvVars(env, options) {
+  const found = findRetiredModeEnvVars(env, options.app);
+  if (found.length === 0)
+    return;
+  const names = found.map((entry) => entry.name);
+  throw new RetiredSettingError(names[0], `${names.join(", ")} ${names.length === 1 ? "is" : "are"} no longer read. ` + "Deployment modes were removed: where a server keeps its data is decided by the " + `database it is given, not by a declared label. Set ${options.replacement} to a ` + "postgres:// URL to use PostgreSQL, or leave it unset for the on-box SQLite database. " + `Then unset ${names.join(" and ")}. ` + "Refused rather than ignored, because a discarded setting looks exactly like a " + "working one until something needs the data.");
+}
+function assertNoRetiredConfigKeys(config, source) {
+  for (const [key, replacement] of Object.entries(RETIRED_CONFIG_KEYS)) {
+    if (!(key in config))
+      continue;
+    throw new RetiredSettingError(key, `${source}: "${key}" is no longer a configuration key. ` + `${RETIRED_CONFIG_KEY_REASONS[key] ?? ""} ` + `Use ${replacement} instead, and remove the old key with: skills config unset ${key}. ` + "Refused rather than ignored, because silently dropping it would leave an " + "operator believing they had pointed this install at a server.");
+  }
+}
+
+// src/lib/app-home.ts
+import { existsSync } from "fs";
+import { homedir } from "os";
+import { join, resolve } from "path";
+import { homedir as pathsResolverHomedir } from "os";
+import { join as pathsResolverJoin } from "path";
+var PATHS_RESOLVER_DATA_ENV = "HASNA_DATA_HOME";
+var PATHS_RESOLVER_APP_SLUG_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+function pathsResolverAssertApp(app) {
+  if (typeof app !== "string" || app.length === 0) {
+    throw new TypeError("paths: app must be a non-empty string");
+  }
+  if (!PATHS_RESOLVER_APP_SLUG_RE.test(app)) {
+    throw new TypeError(`paths: invalid app slug "${app}" \u2014 expected lowercase kebab-case ([a-z0-9]+(-[a-z0-9]+)*)`);
+  }
+}
+function pathsResolverDataBaseDir(options) {
+  const env = options.env ?? process.env;
+  const override = env[PATHS_RESOLVER_DATA_ENV];
+  if (typeof override === "string" && override.length > 0)
+    return override;
+  const home = options.home ?? pathsResolverHomedir();
+  const platform = options.platform ?? process.platform;
+  return platform === "darwin" ? pathsResolverJoin(home, "Library", "Application Support", "Hasna") : pathsResolverJoin(home, ".local", "share", "hasna");
+}
+function dataDir(options) {
+  pathsResolverAssertApp(options.app);
+  const appSegment = options.internal === true ? pathsResolverJoin("internal", options.app) : options.app;
+  return pathsResolverJoin(pathsResolverDataBaseDir(options), appSegment);
+}
+var DATA_DIR_ENV = "HASNA_SKILLS_DIR";
+var HASNA_SKILLS_HOME_ENV = "HASNA_SKILLS_HOME";
+var SKILLS_HOME_ENV = "SKILLS_HOME";
+var DEFAULT_SQLITE_FILENAME = "server.db";
+var GLOBAL_CONFIG_FILENAME = "config.json";
+function effectiveHome() {
+  return process.env["HOME"] || process.env["USERPROFILE"] || homedir() || "/tmp";
+}
+function legacyDataRoot() {
+  return join(effectiveHome(), ".hasna", "skills");
+}
+function resolverDataRoot(home = effectiveHome(), env) {
+  return dataDir({ app: "skills", home, env });
+}
+function adoptResolverDataRoot(resolved, env = process.env) {
+  const dataOverride = env.HASNA_DATA_HOME;
+  if (typeof dataOverride === "string" && dataOverride.trim().length > 0)
+    return true;
+  return existsSync(join(resolved, DEFAULT_SQLITE_FILENAME)) || existsSync(join(resolved, GLOBAL_CONFIG_FILENAME));
+}
+function exactDataRoot() {
+  for (const key of [DATA_DIR_ENV, HASNA_SKILLS_HOME_ENV, SKILLS_HOME_ENV]) {
+    const dir = process.env[key]?.trim();
+    if (dir)
+      return resolve(dir);
+  }
+  return;
+}
+function getDataRoot() {
+  const exact = exactDataRoot();
+  if (exact)
+    return exact;
+  const resolved = resolverDataRoot();
+  return adoptResolverDataRoot(resolved) ? resolve(resolved) : resolve(legacyDataRoot());
+}
+function skillsDataRootForHome(home) {
+  const isOwnHome = resolve(home) === resolve(effectiveHome()) || resolve(home) === resolve(homedir());
+  if (isOwnHome) {
+    const exact = exactDataRoot();
+    if (exact)
+      return exact;
+    const resolved2 = resolverDataRoot(home);
+    return adoptResolverDataRoot(resolved2) ? resolve(resolved2) : resolve(join(home, ".hasna", "skills"));
+  }
+  const resolved = resolverDataRoot(home, {});
+  return adoptResolverDataRoot(resolved, {}) ? resolve(resolved) : resolve(join(home, ".hasna", "skills"));
+}
+
+// src/lib/config.ts
+var ENUM_KEYS = {
+  defaultAgent: ["claude", "codex", "gemini", "pi", "opencode", "all"],
+  defaultScope: ["global", "project"],
+  format: ["compact", "json", "csv"]
+};
+var STRING_KEYS = ["extensionsDir"];
+function validKeys() {
+  return [...Object.keys(ENUM_KEYS), ...STRING_KEYS];
+}
+function allowedValues(key) {
+  return ENUM_KEYS[key];
+}
+function normalizeConfigValue(key, value) {
+  if (typeof value !== "string")
+    return;
+  const allowed = allowedValues(key);
+  if (allowed)
+    return allowed.includes(value) ? value : undefined;
+  if (key === "extensionsDir")
+    return value.trim() ? value : undefined;
+  return;
+}
+var INSTALLED_SKILLS_DIRNAME = "installed";
+var SKILLS_CACHE_DIRNAME = "skills";
+var LAYOUT_MIGRATION_RECORD = ".layout-migration.json";
+function isOwnerLayoutMigrated(appDir) {
+  return existsSync2(join2(appDir, SKILLS_CACHE_DIRNAME, LAYOUT_MIGRATION_RECORD));
+}
+function getDataDir() {
+  const root = getDataRoot();
+  try {
+    mkdirSync(root, { recursive: true });
+  } catch {}
+  return root;
+}
+function getDataDirReadOnly() {
+  return getDataRoot();
+}
+function getConfigPath(scope) {
+  if (scope === "global") {
+    return join2(getDataDir(), "config.json");
+  }
+  return join2(process.cwd(), "skills.config.json");
+}
+function readConfigFile(path) {
+  if (!existsSync2(path))
+    return {};
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return {};
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
+    return {};
+  assertNoRetiredConfigKeys(parsed, path);
+  const config = {};
+  for (const key of validKeys()) {
+    const value = normalizeConfigValue(key, parsed[key]);
+    if (value !== undefined)
+      config[key] = value;
+  }
+  return config;
+}
+function loadConfig() {
+  const globalConfig = readConfigFile(getConfigPath("global"));
+  const projectConfig = readConfigFile(getConfigPath("project"));
+  return { ...globalConfig, ...projectConfig };
+}
+function saveConfig(key, value, scope = "project") {
+  assertNoRetiredConfigKeys({ [key]: value }, `config set ${key}`);
+  if (!validKeys().includes(key)) {
+    throw new Error(`Unknown config key: ${key}. Valid keys: ${validKeys().join(", ")}`);
+  }
+  const normalized = normalizeConfigValue(key, value);
+  if (normalized === undefined) {
+    const allowed = allowedValues(key);
+    throw new Error(allowed ? `Invalid value '${value}' for ${key}. Allowed: ${allowed.join(", ")}` : `Invalid value '${value}' for ${key}. Expected a non-empty path`);
+  }
+  const filePath = getConfigPath(scope);
+  let existing = {};
+  if (existsSync2(filePath)) {
+    try {
+      existing = JSON.parse(readFileSync(filePath, "utf-8"));
+      if (typeof existing !== "object" || existing === null || Array.isArray(existing)) {
+        existing = {};
+      }
+    } catch {
+      existing = {};
+    }
+  } else {
+    const dir = dirname(filePath);
+    if (!existsSync2(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+  }
+  assertNoRetiredConfigKeys(existing, filePath);
+  existing[key] = normalized;
+  writeFileSync(filePath, JSON.stringify(existing, null, 2) + `
+`);
+}
+function unsetConfig(key, scope = "project") {
+  if (!validKeys().includes(key) && !(key in RETIRED_CONFIG_KEYS)) {
+    throw new Error(`Unknown config key: ${key}. Valid keys: ${validKeys().join(", ")}`);
+  }
+  const filePath = getConfigPath(scope);
+  if (!existsSync2(filePath))
+    return false;
+  let existing;
+  try {
+    const parsed = JSON.parse(readFileSync(filePath, "utf-8"));
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
+      return false;
+    existing = parsed;
+  } catch {
+    return false;
+  }
+  if (!(key in existing))
+    return false;
+  delete existing[key];
+  writeFileSync(filePath, JSON.stringify(existing, null, 2) + `
+`);
+  return true;
+}
+
+// src/lib/selection-cache.ts
+import { createHash as createHash2, randomUUID } from "crypto";
+import { spawnSync } from "child_process";
+import { closeSync, constants, fstatSync, fsyncSync, linkSync, lstatSync, mkdirSync as mkdirSync2, openSync, readFileSync as readFileSync3, readlinkSync, readSync, renameSync, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
+import { hostname } from "os";
+import { dirname as dirname2, join as join4, parse, resolve as resolve2 } from "path";
+import { isDeepStrictEqual } from "util";
+
+// src/lib/skill-bundle.ts
+import { createHash } from "crypto";
+import { readFileSync as readFileSync2, readdirSync, statSync } from "fs";
+import { join as join3, relative } from "path";
+import { createGunzip } from "zlib";
+
+// src/lib/skill-entry-path.ts
+class SkillEntryPaths {
+  files = new Set;
+  directories = new Set;
+  add(path, maxBytes, invalid, limit) {
+    if (path.length > maxBytes)
+      limit();
+    const encoded = new TextEncoder().encode(path);
+    if (encoded.byteLength > maxBytes)
+      limit();
+    if (new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(encoded) !== path)
+      invalid("Invalid UTF-8 entry path");
+    if (!path || /[\\:\x00-\x1f\x7f]/u.test(path))
+      invalid("Unsafe entry path");
+    if (path.split("/").some((segment) => !segment || segment === "." || segment === ".."))
+      invalid("Unsafe entry path segment");
+    const key = path.normalize("NFC").toLowerCase().normalize("NFC");
+    if (this.files.has(key) || this.directories.has(key))
+      invalid("Duplicate or conflicting entry path");
+    const parents = key.split("/");
+    parents.pop();
+    while (parents.length) {
+      const parent = parents.join("/");
+      if (this.files.has(parent))
+        invalid("Conflicting entry file ancestor");
+      this.directories.add(parent);
+      parents.pop();
+    }
+    this.files.add(key);
+  }
+}
+
+// src/lib/skill-bundle.ts
+var BLOCK = 512;
+var ANY_SEGMENT_EXCLUDES = new Set([
+  ".git",
+  ".ds_store",
+  ".system",
+  "node_modules",
+  ".aws",
+  ".ssh",
+  ".gnupg",
+  ".docker"
+]);
+var ROOT_EXCLUDES = new Set(["dist", "build", ".turbo"]);
+var TOOL_SIDECAR_FILENAMES = new Set([".hasna-skills.json", ".skills-dependency-preparation"]);
+var CREDENTIAL_FILENAMES = new Set([
+  ".npmrc",
+  ".pypirc",
+  ".netrc",
+  ".envrc",
+  ".pgpass",
+  ".git-credentials",
+  "credentials",
+  "id_rsa",
+  "id_dsa",
+  "id_ecdsa",
+  "id_ed25519"
+]);
+var CREDENTIAL_EXTENSIONS = [".pem", ".key", ".p12", ".pfx", ".keystore", ".jks"];
+var ENV_TEMPLATE_NAMES = new Set([".env.example", ".env.sample", ".env.template", ".env.dist"]);
+var NON_DOTENV_EXTENSIONS = new Set([
+  "ts",
+  "tsx",
+  "mts",
+  "cts",
+  "js",
+  "jsx",
+  "mjs",
+  "cjs",
+  "json",
+  "jsonc",
+  "json5",
+  "py",
+  "rb",
+  "go",
+  "rs",
+  "java",
+  "kt",
+  "kts",
+  "swift",
+  "c",
+  "h",
+  "cc",
+  "cpp",
+  "hpp",
+  "cs",
+  "php",
+  "sh",
+  "bash",
+  "zsh",
+  "fish",
+  "ps1",
+  "bat",
+  "cmd",
+  "lua",
+  "pl",
+  "pm",
+  "r",
+  "jl",
+  "dart",
+  "ex",
+  "exs",
+  "scala",
+  "clj",
+  "cljs",
+  "groovy",
+  "gradle",
+  "vb",
+  "fs",
+  "yaml",
+  "yml",
+  "toml",
+  "ini",
+  "xml",
+  "csv",
+  "tsv",
+  "html",
+  "htm",
+  "css",
+  "scss",
+  "sass",
+  "less",
+  "md",
+  "mdx",
+  "txt",
+  "rst",
+  "adoc",
+  "sql",
+  "graphql",
+  "gql",
+  "proto",
+  "d",
+  "png",
+  "jpg",
+  "jpeg",
+  "gif",
+  "svg",
+  "webp",
+  "ico",
+  "bmp",
+  "pdf",
+  "woff",
+  "woff2",
+  "ttf",
+  "otf",
+  "eot",
+  "mp3",
+  "mp4",
+  "wav",
+  "webm",
+  "zip",
+  "gz",
+  "tar",
+  "wasm"
+]);
+function isDotenvFile(lower) {
+  if (lower === ".env" || lower.startsWith(".env."))
+    return true;
+  if (lower === "env")
+    return true;
+  if (lower.startsWith("env.")) {
+    const extension = lower.slice(lower.lastIndexOf(".") + 1);
+    return !NON_DOTENV_EXTENSIONS.has(extension);
+  }
+  return false;
+}
+function isCredentialFile(name) {
+  const lower = name.toLowerCase();
+  if (ENV_TEMPLATE_NAMES.has(lower))
+    return false;
+  if (isDotenvFile(lower))
+    return true;
+  if (CREDENTIAL_FILENAMES.has(lower))
+    return true;
+  return CREDENTIAL_EXTENSIONS.some((extension) => lower.endsWith(extension));
+}
+function ownBytes(view) {
+  const source = view instanceof ArrayBuffer ? new Uint8Array(view) : view;
+  const out = new Uint8Array(new ArrayBuffer(source.byteLength));
+  out.set(source);
+  return out;
+}
+function sha256Hex(bytes) {
+  return createHash("sha256").update(bytes).digest("hex");
+}
+function collectSkillBundleEntries(dir) {
+  const entries = [];
+  walk(dir, dir, entries);
+  return entries.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
+}
+function walk(root, current, out) {
+  for (const entry of readdirSync(current, { withFileTypes: true })) {
+    const absolute = join3(current, entry.name);
+    const rel = relative(root, absolute).split("\\").join("/");
+    const isRootLevel = !rel.includes("/");
+    if (ANY_SEGMENT_EXCLUDES.has(entry.name.toLowerCase()))
+      continue;
+    if (isRootLevel && ROOT_EXCLUDES.has(entry.name.toLowerCase()))
+      continue;
+    if (isRootLevel && TOOL_SIDECAR_FILENAMES.has(entry.name.toLowerCase()))
+      continue;
+    if (entry.name.startsWith("._"))
+      continue;
+    if (entry.isSymbolicLink())
+      continue;
+    if (entry.isDirectory()) {
+      walk(root, absolute, out);
+      continue;
+    }
+    if (!entry.isFile())
+      continue;
+    if (isCredentialFile(entry.name))
+      continue;
+    const stats = statSync(absolute);
+    out.push({
+      path: rel,
+      bytes: ownBytes(readFileSync2(absolute)),
+      mode: stats.mode & 64 ? 493 : 420
+    });
+  }
+}
+function packSkillBundle(dir, options = {}) {
+  const entries = collectSkillBundleEntries(dir);
+  if (entries.length === 0) {
+    throw new Error(`Nothing to pack: ${dir} contains no files after exclusions (.git, node_modules, dist, .env)`);
+  }
+  const unpackedByteSize = entries.reduce((sum, entry) => sum + entry.bytes.byteLength, 0);
+  const max = options.maxUnpackedBytes ?? 0;
+  if (max > 0 && unpackedByteSize > max) {
+    throw new Error(`Skill sources are ${unpackedByteSize} bytes, over the ${max} byte limit. Remove build output or large fixtures.`);
+  }
+  const tar = writeTar(entries);
+  const bytes = canonicalGzip(tar);
+  return {
+    bytes,
+    sha256: sha256Hex(bytes),
+    fileCount: entries.length,
+    unpackedByteSize,
+    paths: entries.map((entry) => entry.path)
+  };
+}
+function canonicalGzip(tar) {
+  const bytes = ownBytes(Bun.gzipSync(tar, { level: 6 }));
+  if (bytes.byteLength >= 10) {
+    bytes[4] = 0;
+    bytes[5] = 0;
+    bytes[6] = 0;
+    bytes[7] = 0;
+    bytes[9] = 255;
+  }
+  return bytes;
+}
+function unpackSkillBundle(bundle) {
+  return readTar(ownBytes(Bun.gunzipSync(ownBytes(bundle))));
+}
+function writeTar(entries) {
+  const blocks = [];
+  for (const entry of entries) {
+    blocks.push(ustarHeader(entry));
+    blocks.push(entry.bytes);
+    const remainder = entry.bytes.byteLength % BLOCK;
+    if (remainder !== 0)
+      blocks.push(new Uint8Array(new ArrayBuffer(BLOCK - remainder)));
+  }
+  blocks.push(new Uint8Array(new ArrayBuffer(BLOCK * 2)));
+  return concat(blocks);
+}
+function ustarHeader(entry) {
+  const header = new Uint8Array(new ArrayBuffer(BLOCK));
+  const encoder = new TextEncoder;
+  const put = (offset, length, value) => {
+    const encoded = encoder.encode(value);
+    if (encoded.byteLength > length) {
+      throw new Error(`Cannot pack '${entry.path}': field does not fit in a ustar header (${encoded.byteLength} > ${length})`);
+    }
+    header.set(encoded, offset);
+  };
+  if (encoder.encode(entry.path).byteLength > 100) {
+    throw new Error(`Cannot pack '${entry.path}': path is longer than the 100 bytes a ustar header holds`);
+  }
+  put(0, 100, entry.path);
+  put(100, 8, `${entry.mode.toString(8).padStart(7, "0")}\x00`);
+  put(108, 8, "0000000\x00");
+  put(116, 8, "0000000\x00");
+  put(124, 12, `${entry.bytes.byteLength.toString(8).padStart(11, "0")}\x00`);
+  put(136, 12, `${0 .toString(8).padStart(11, "0")}\x00`);
+  put(148, 8, "        ");
+  put(156, 1, "0");
+  put(257, 6, "ustar\x00");
+  put(263, 2, "00");
+  let checksum = 0;
+  for (const byte of header)
+    checksum += byte;
+  put(148, 8, `${checksum.toString(8).padStart(6, "0")}\x00 `);
+  return header;
+}
+function readTar(tar) {
+  const decoder = new TextDecoder;
+  const entries = [];
+  let offset = 0;
+  let terminated = false;
+  while (offset + BLOCK <= tar.byteLength) {
+    const header = tar.subarray(offset, offset + BLOCK);
+    if (header.every((byte) => byte === 0)) {
+      terminated = true;
+      break;
+    }
+    const path = trimNul(decoder.decode(header.subarray(0, 100)));
+    assertSafeEntryPath(path);
+    const typeflag = String.fromCharCode(header[156]);
+    if (typeflag !== "0" && typeflag !== "\x00") {
+      throw new Error(`unsafe bundle entry '${path}': only regular files are allowed, found tar type '${typeflag}'`);
+    }
+    const mode = Number.parseInt(trimNul(decoder.decode(header.subarray(100, 108))).trim() || "0", 8);
+    const size = Number.parseInt(trimNul(decoder.decode(header.subarray(124, 136))).trim() || "0", 8);
+    if (!Number.isSafeInteger(size) || size < 0)
+      throw new Error(`corrupt bundle: unreadable size for '${path}'`);
+    offset += BLOCK;
+    if (offset + size > tar.byteLength)
+      throw new Error(`corrupt bundle: '${path}' claims ${size} bytes past the end of the archive`);
+    entries.push({ path, mode, bytes: ownBytes(tar.subarray(offset, offset + size)) });
+    offset += Math.ceil(size / BLOCK) * BLOCK;
+  }
+  if (!terminated) {
+    throw new Error("corrupt bundle: the archive ends without its terminating blocks, so it is truncated");
+  }
+  return entries;
+}
+function assertSafeEntryPath(path) {
+  if (!path)
+    throw new Error("corrupt bundle: an entry has an empty path");
+  const normalized = path.split("\\").join("/");
+  if (normalized.startsWith("/"))
+    throw new Error(`unsafe bundle entry '${path}': absolute paths are not allowed`);
+  if (/^[A-Za-z]:/.test(normalized))
+    throw new Error(`unsafe bundle entry '${path}': drive-qualified paths are not allowed`);
+  const segments = normalized.split("/");
+  if (segments.includes(".."))
+    throw new Error(`unsafe bundle entry '${path}': '..' is not allowed`);
+}
+function trimNul(value) {
+  const end = value.indexOf("\x00");
+  return end === -1 ? value : value.slice(0, end);
+}
+function concat(chunks) {
+  const total = chunks.reduce((sum, chunk) => sum + chunk.byteLength, 0);
+  const merged = new Uint8Array(new ArrayBuffer(total));
+  let offset = 0;
+  for (const chunk of chunks) {
+    merged.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return merged;
+}
+var SKILL_BUNDLE_INSPECTION_LIMITS = Object.freeze({
+  compressedBytes: 16 * 1024 * 1024,
+  decompressedBytes: 64 * 1024 * 1024,
+  entries: 1024,
+  fileBytes: 16 * 1024 * 1024,
+  pathBytes: 100,
+  timeoutMs: 5000
+});
+
+class SkillBundleInspectionError extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "SkillBundleInspectionError";
+  }
+}
+function invalidBundle(message) {
+  throw new SkillBundleInspectionError("BUNDLE_INVALID", message);
+}
+function inspectionLimits(options) {
+  const limits = { ...SKILL_BUNDLE_INSPECTION_LIMITS };
+  for (const key of Object.keys(options.limits ?? {})) {
+    if (!Object.hasOwn(limits, key))
+      throw new SkillBundleInspectionError("BUNDLE_LIMIT", "Unknown bundle limit");
+    const field = key;
+    const value = options.limits[field];
+    if (!Number.isSafeInteger(value) || value <= 0 || value > limits[field]) {
+      throw new SkillBundleInspectionError("BUNDLE_LIMIT", "Bundle limits must be positive integers within the hard ceilings");
+    }
+    limits[field] = value;
+  }
+  return limits;
+}
+async function inspectSkillBundle(bundle, options = {}) {
+  const signal = options.signal;
+  const limits = inspectionLimits(options);
+  const deadline = performance.now() + limits.timeoutMs;
+  const check = () => {
+    if (signal?.aborted)
+      throw new SkillBundleInspectionError("BUNDLE_ABORTED", "Bundle inspection aborted");
+    if (performance.now() >= deadline)
+      throw new SkillBundleInspectionError("BUNDLE_TIMEOUT", "Bundle inspection deadline exceeded");
+  };
+  check();
+  if (bundle.byteLength > limits.compressedBytes)
+    throw new SkillBundleInspectionError("BUNDLE_LIMIT", "Compressed bundle exceeds byte limit");
+  const snapshot = ownBytes(bundle);
+  check();
+  const sha256 = sha256Hex(snapshot);
+  check();
+  const parser = new BoundedTarReader(limits, check);
+  const streamOptions = { chunkSize: 16 * 1024, highWaterMark: 16 * 1024 };
+  const decoder = createGunzip(streamOptions);
+  let terminalError;
+  const stop = (code) => {
+    terminalError ??= new SkillBundleInspectionError(code, code === "BUNDLE_ABORTED" ? "Bundle inspection aborted" : "Bundle inspection deadline exceeded");
+    decoder.destroy(terminalError);
+  };
+  const onAbort = () => stop("BUNDLE_ABORTED");
+  const expire = () => {
+    const remaining = deadline - performance.now();
+    if (remaining > 0)
+      timer = setTimeout(expire, Math.max(1, Math.ceil(remaining)));
+    else
+      stop("BUNDLE_TIMEOUT");
+  };
+  let timer = setTimeout(expire, Math.max(1, Math.ceil(deadline - performance.now())));
+  signal?.addEventListener("abort", onAbort, { once: true });
+  let decompressedByteSize = 0;
+  let bytesSinceYield = 0;
+  try {
+    check();
+    decoder.end(snapshot);
+    for await (const chunk of decoder) {
+      check();
+      decompressedByteSize += chunk.byteLength;
+      if (decompressedByteSize > limits.decompressedBytes)
+        throw new SkillBundleInspectionError("BUNDLE_LIMIT", "Decompressed bundle exceeds byte limit");
+      parser.push(chunk);
+      bytesSinceYield += chunk.byteLength;
+      if (bytesSinceYield >= 256 * 1024) {
+        await new Promise((resolve2) => setTimeout(resolve2, 0));
+        bytesSinceYield = 0;
+        check();
+      }
+    }
+    check();
+    const entries = parser.finish();
+    return {
+      entries,
+      sha256,
+      compressedByteSize: snapshot.byteLength,
+      decompressedByteSize,
+      unpackedByteSize: parser.fileBytes,
+      fileCount: entries.length
+    };
+  } catch (error) {
+    if (terminalError)
+      throw terminalError;
+    if (error instanceof SkillBundleInspectionError)
+      throw error;
+    throw new SkillBundleInspectionError("BUNDLE_INVALID", "Invalid or truncated gzip bundle");
+  } finally {
+    clearTimeout(timer);
+    signal?.removeEventListener("abort", onAbort);
+    decoder.destroy();
+  }
+}
+
+class BoundedTarReader {
+  limits;
+  check;
+  header = new Uint8Array(BLOCK);
+  headerOffset = 0;
+  pending;
+  bodyOffset = 0;
+  padding = 0;
+  zeroBlocks = 0;
+  entries = [];
+  paths = new SkillEntryPaths;
+  fileBytes = 0;
+  constructor(limits, check) {
+    this.limits = limits;
+    this.check = check;
+  }
+  push(chunk) {
+    let offset = 0;
+    while (offset < chunk.byteLength) {
+      this.check();
+      if (this.pending) {
+        const count = Math.min(this.pending.bytes.byteLength - this.bodyOffset, chunk.byteLength - offset);
+        this.pending.bytes.set(chunk.subarray(offset, offset + count), this.bodyOffset);
+        offset += count;
+        this.bodyOffset += count;
+        if (this.bodyOffset === this.pending.bytes.byteLength) {
+          this.entries.push(this.pending);
+          this.pending = undefined;
+        }
+      } else if (this.padding) {
+        const count = Math.min(this.padding, chunk.byteLength - offset);
+        if (chunk.subarray(offset, offset + count).some((byte) => byte !== 0))
+          invalidBundle("Nonzero tar body padding");
+        offset += count;
+        this.padding -= count;
+      } else {
+        const count = Math.min(BLOCK - this.headerOffset, chunk.byteLength - offset);
+        this.header.set(chunk.subarray(offset, offset + count), this.headerOffset);
+        offset += count;
+        this.headerOffset += count;
+        if (this.headerOffset === BLOCK) {
+          this.readHeader();
+          this.headerOffset = 0;
+        }
+      }
+    }
+  }
+  finish() {
+    this.check();
+    if (this.pending || this.padding || this.headerOffset || this.zeroBlocks < 2)
+      invalidBundle("Truncated tar bundle");
+    return this.entries;
+  }
+  readHeader() {
+    this.check();
+    const h = this.header;
+    if (h.every((byte) => byte === 0)) {
+      this.zeroBlocks++;
+      return;
+    }
+    if (this.zeroBlocks)
+      invalidBundle("Nonzero tar data after terminator");
+    if (this.entries.length >= this.limits.entries)
+      throw new SkillBundleInspectionError("BUNDLE_LIMIT", "Bundle entry limit exceeded");
+    let checksum = 0;
+    for (let i = 0;i < BLOCK; i++)
+      checksum += i >= 148 && i < 156 ? 32 : h[i];
+    if (tarOctal(h.subarray(148, 156)) !== checksum)
+      invalidBundle("Invalid tar header checksum");
+    if (new TextDecoder().decode(h.subarray(257, 265)) !== "ustar\x00" + "00")
+      invalidBundle("Unsupported tar format");
+    if (h[156] !== 48 && h[156] !== 0 || h.subarray(157, 257).some((b) => b !== 0) || h.subarray(345).some((b) => b !== 0))
+      invalidBundle("Unsupported tar entry or path prefix");
+    const mode = tarOctal(h.subarray(100, 108));
+    if (mode > 511)
+      invalidBundle("Unsupported tar permission bits");
+    tarOctal(h.subarray(108, 116));
+    tarOctal(h.subarray(116, 124));
+    tarOctal(h.subarray(136, 148));
+    const size = tarOctal(h.subarray(124, 136));
+    if (size > this.limits.fileBytes || this.fileBytes + size > this.limits.decompressedBytes) {
+      throw new SkillBundleInspectionError("BUNDLE_LIMIT", "Bundle file byte limit exceeded");
+    }
+    const name = h.subarray(0, 100);
+    const end = name.indexOf(0);
+    if (end !== -1 && name.subarray(end).some((b) => b !== 0))
+      invalidBundle("Invalid tar path padding");
+    const raw = end === -1 ? name : name.subarray(0, end);
+    if (raw.byteLength > this.limits.pathBytes)
+      throw new SkillBundleInspectionError("BUNDLE_LIMIT", "Bundle path byte limit exceeded");
+    let path;
+    try {
+      path = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(raw);
+    } catch {
+      return invalidBundle("Invalid UTF-8 bundle path");
+    }
+    this.paths.add(path, this.limits.pathBytes, invalidBundle, () => {
+      throw new SkillBundleInspectionError("BUNDLE_LIMIT", "Bundle path byte limit exceeded");
+    });
+    this.fileBytes += size;
+    this.pending = { path, mode, bytes: new Uint8Array(new ArrayBuffer(size)) };
+    this.bodyOffset = 0;
+    this.padding = (BLOCK - size % BLOCK) % BLOCK;
+    if (!size) {
+      this.entries.push(this.pending);
+      this.pending = undefined;
+    }
+  }
+}
+function tarOctal(field) {
+  const text = new TextDecoder().decode(field);
+  if (!/^[0-7]+[\0 ]*$/.test(text))
+    invalidBundle("Invalid tar octal field");
+  const value = Number.parseInt(text, 8);
+  if (!Number.isSafeInteger(value))
+    invalidBundle("Tar integer is out of range");
+  return value;
+}
+
+// src/lib/skill-version.ts
+var SKILL_VERSION_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._+-]{0,127}$/;
+function isValidSkillVersion(value) {
+  return typeof value === "string" && SKILL_VERSION_PATTERN.test(value) && !/^\.+$/.test(value) && !value.includes("..");
+}
+var SKILL_VERSION_RULE = "1-128 characters: letters, digits, '.', '_', '+', '-'; must start with a letter or digit; no '..'";
+
+// src/lib/selection-aliases.ts
+function selectionAliasError(selections) {
+  const names = new Set(selections.map((selection) => selection.slug));
+  for (const selection of selections) {
+    if (selection.aliases === undefined)
+      continue;
+    if (!Array.isArray(selection.aliases) || selection.aliases.length > 32)
+      return "Selection aliases must be an array of at most 32 names.";
+    for (const alias of selection.aliases) {
+      if (typeof alias !== "string" || alias.length > 128 || !/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(alias))
+        return "Selection aliases must be bounded kebab-case names.";
+      if (names.has(alias))
+        return "Selection aliases must be unique and cannot shadow a selected canonical name.";
+      names.add(alias);
+    }
+  }
+}
+function selectionMatchesName(selection, name) {
+  return selection.slug === name || Boolean(selection.aliases?.includes(name));
+}
+function selectionSnapshotsEqual(left, right) {
+  const snapshot = (selections) => selections.map((selection) => [
+    selection.slug,
+    selection.version,
+    selection.bundleDigest,
+    selection.aliases ?? [],
+    selection.triggers?.keywords ?? [],
+    selection.triggers?.paths ?? [],
+    selection.triggers?.always ?? null
+  ]).sort((a, b) => String(a[0]).localeCompare(String(b[0])));
+  return JSON.stringify(snapshot(left)) === JSON.stringify(snapshot(right));
+}
+
+// src/lib/profile-limits.ts
+var MAX_PROFILE_SELECTIONS = 4096;
+var MAX_PROFILE_DOCUMENT_BYTES = 8 * 1024 * 1024;
+var MAX_SKILL_SESSION_ID_CHARS = 256;
+var PROFILE_SESSION_ENVELOPE_BYTES = MAX_PROFILE_SELECTIONS * 67 + MAX_SKILL_SESSION_ID_CHARS * 12 + 512;
+var MAX_RESOLVED_PROFILE_BYTES = MAX_PROFILE_DOCUMENT_BYTES - PROFILE_SESSION_ENVELOPE_BYTES;
+var LEGACY_PROFILE_SELECTIONS = 256;
+var LEGACY_PROFILE_DOCUMENT_BYTES = 1e6;
+function profileDocumentBytes(value) {
+  return new TextEncoder().encode(JSON.stringify(value)).byteLength;
+}
+function requiresProfileCapacity(selections, bodyBytes) {
+  return selections.length > LEGACY_PROFILE_SELECTIONS || bodyBytes > LEGACY_PROFILE_DOCUMENT_BYTES;
+}
+function assertAdvertisedProfileCapacity(value, count, bodyBytes) {
+  const limits = value?.profileLimits;
+  if (!limits || !Number.isSafeInteger(limits.maxSelections) || Number(limits.maxSelections) < count || !Number.isSafeInteger(limits.maxDocumentBytes) || Number(limits.maxDocumentBytes) < bodyBytes || !Number.isSafeInteger(limits.requestBodyLimitBytes) || Number(limits.requestBodyLimitBytes) < bodyBytes || !Number.isSafeInteger(limits.maxResolvedProfileBytes) || Number(limits.maxResolvedProfileBytes) <= 0) {
+    throw new Error("The Skills API does not advertise enough profile capacity. Review the API version and its configured request-body limit before saving this profile.");
+  }
+}
+function resolvedProfileSnapshot(profile, authority) {
+  return {
+    profileId: profile.id,
+    workspaceId: profile.workspaceId,
+    profileRevision: profile.revision,
+    authority,
+    selections: profile.selections.map((selection) => ({ ...selection, authority, workspaceId: profile.workspaceId, profileRevision: profile.revision }))
+  };
+}
+function profileSelectionSnapshot(selections) {
+  return selections.map(({ slug, version: version2, bundleDigest, aliases, triggers }) => ({
+    slug,
+    version: version2,
+    bundleDigest,
+    ...aliases !== undefined ? { aliases } : {},
+    ...triggers !== undefined ? { triggers } : {}
+  }));
+}
+
+// src/lib/selection-cache.ts
+class SkillSelectionError extends Error {
+  code;
+  constructor(code, message, options) {
+    super(message, options);
+    this.code = code;
+    this.name = "SkillSelectionError";
+  }
+}
+var MAX_CACHED_PROFILE_AGE_MS = 24 * 60 * 60 * 1000;
+var SELECTION_LOCK_FILE = "selection.lock.json";
+function selectionCacheRoot(options = {}) {
+  return resolve2(options.cacheDir ?? join4(getDataDirReadOnly(), "selection-cache"));
+}
+function selectionKey(selection) {
+  validateSelection(selection);
+  return hash([selection.authority, selection.workspaceId, selection.slug, selection.version, selection.bundleDigest]);
+}
+function hash(value) {
+  return createHash2("sha256").update(JSON.stringify(value)).digest("hex");
+}
+function validateSelection(selection) {
+  if (!selection || !/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(selection.slug) || !isValidSkillVersion(selection.version) || !/^sha256:[a-f0-9]{64}$/.test(selection.bundleDigest) || typeof selection.workspaceId !== "string" || !selection.workspaceId.trim() || selection.authorizationEpoch !== undefined && (typeof selection.authorizationEpoch !== "string" || !/^[a-f0-9]{32}$/.test(selection.authorizationEpoch)) || typeof selection.profileRevision !== "string" || !selection.profileRevision.trim()) {
+    throw new SkillSelectionError("INVALID_SELECTION", "A skill selection must carry an exact version, digest, workspace and profile revision.");
+  }
+  const aliasError = selectionAliasError([selection]);
+  if (aliasError)
+    throw new SkillSelectionError("INVALID_SELECTION_ALIASES", aliasError);
+  try {
+    const url = new URL(selection.authority);
+    if (url.username || url.password || url.search || url.hash || !["https:", "http:"].includes(url.protocol) || url.protocol === "http:" && !["localhost", "127.0.0.1", "[::1]"].includes(url.hostname))
+      throw new Error;
+  } catch {
+    throw new SkillSelectionError("INVALID_SELECTION", "The skill selection authority is invalid.");
+  }
+}
+function validateResolvedProfile(profile, authority) {
+  if (!profile || typeof profile.profileId !== "string" || !profile.profileId.trim() || !Array.isArray(profile.selections) || profile.selections.length > MAX_PROFILE_SELECTIONS || typeof profile.workspaceId !== "string" || !profile.workspaceId.trim() || typeof profile.profileRevision !== "string" || !profile.profileRevision.trim() || typeof profile.authority !== "string" || authority !== undefined && profile.authority !== authority) {
+    throw new SkillSelectionError("PROFILE_IDENTITY_MISMATCH", "The resolved profile does not match the configured Skills authority.");
+  }
+  if (profileDocumentBytes(profile) > MAX_RESOLVED_PROFILE_BYTES)
+    throw new SkillSelectionError("RECEIPT_TOO_LARGE", "The resolved Skills profile exceeds its size limit.");
+  const slugs = new Set;
+  for (const selection of profile.selections) {
+    validateSelection(selection);
+    if (selection.authority !== profile.authority || selection.workspaceId !== profile.workspaceId || selection.profileRevision !== profile.profileRevision || slugs.has(selection.slug)) {
+      throw new SkillSelectionError("PROFILE_IDENTITY_MISMATCH", "The resolved profile contains conflicting selection identities.");
+    }
+    slugs.add(selection.slug);
+  }
+  const aliasError = selectionAliasError(profile.selections);
+  if (aliasError)
+    throw new SkillSelectionError("INVALID_SELECTION_ALIASES", aliasError);
+}
+function selectionBundlePath(selection, options = {}) {
+  validateSelection(selection);
+  return join4(selectionCacheRoot(options), "objects", hash(selection.authority), hash(selection.workspaceId), `${selection.bundleDigest.slice(7)}.tar.gz`);
+}
+function assertRegularPath(path, createParents = false) {
+  const absolute = resolve2(path);
+  const root = parse(absolute).root;
+  let cursor = root;
+  const segments = absolute.slice(root.length).split("/");
+  for (let index = 0;index < segments.length; index++) {
+    cursor = join4(cursor, segments[index]);
+    try {
+      const stat = lstatSync(cursor);
+      if (stat.isSymbolicLink() || index < segments.length - 1 && !stat.isDirectory()) {
+        throw new SkillSelectionError("UNSAFE_CACHE_PATH", "Skills cache paths must not traverse symlinks or non-directories.");
+      }
+    } catch (error) {
+      if (error.code !== "ENOENT")
+        throw error;
+      if (createParents && index < segments.length - 1)
+        mkdirSync2(cursor, { mode: 448 });
+    }
+  }
+}
+function readRegularFile(path, limit) {
+  assertRegularPath(path);
+  let fd;
+  try {
+    fd = openSync(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return null;
+    throw error;
+  }
+  try {
+    const stat = fstatSync(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 = readSync(fd, bytes, size, bytes.length - size, null);
+      if (!read)
+        break;
+      size += read;
+    }
+    if (size > stat.size)
+      throw new SkillSelectionError("INVALID_CACHE_FILE", "The Skills cache file grew during its bounded read.");
+    return bytes.subarray(0, size);
+  } finally {
+    closeSync(fd);
+  }
+}
+function writeSelectionJson(path, value) {
+  const bytes = Buffer.from(`${JSON.stringify(value)}
+`);
+  if (bytes.length > MAX_PROFILE_DOCUMENT_BYTES)
+    throw new SkillSelectionError("RECEIPT_TOO_LARGE", "The Skills selection receipt exceeds its size limit.");
+  atomicWrite(path, bytes, 384);
+}
+function atomicWrite(path, bytes, mode, durable = false) {
+  assertRegularPath(path, true);
+  const temporary = join4(dirname2(path), `.selection-${randomUUID()}.tmp`);
+  try {
+    const fd = openSync(temporary, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, mode);
+    try {
+      writeFileSync2(fd, bytes);
+      if (durable)
+        fsyncSync(fd);
+    } finally {
+      closeSync(fd);
+    }
+    renameSync(temporary, path);
+    if (durable)
+      syncDirectory(dirname2(path));
+  } finally {
+    try {
+      unlinkSync(temporary);
+    } catch (error) {
+      if (error.code !== "ENOENT")
+        throw error;
+    }
+  }
+}
+function readSelectionJson(path, maximumBytes = MAX_PROFILE_DOCUMENT_BYTES) {
+  const bytes = readRegularFile(path, Math.min(maximumBytes, MAX_PROFILE_DOCUMENT_BYTES));
+  if (!bytes)
+    return null;
+  try {
+    return JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+  } catch {
+    throw new SkillSelectionError("INVALID_RECEIPT", "The Skills selection receipt is unreadable; sync the profile again.");
+  }
+}
+async function verifiedEntries(selection, bytes, signal, deadline) {
+  if (`sha256:${sha256Hex(bytes)}` !== selection.bundleDigest)
+    throw new SkillSelectionError("BUNDLE_DIGEST_MISMATCH", "The skill bundle does not match its selected digest.");
+  const remaining = deadline === undefined ? undefined : Math.ceil(deadline - performance.now());
+  signal?.throwIfAborted();
+  if (remaining !== undefined && remaining <= 0)
+    throw new SkillBundleInspectionError("BUNDLE_TIMEOUT", "Bundle inspection deadline exceeded");
+  const bundle = await inspectSkillBundle(bytes, { signal, ...remaining === undefined ? {} : { limits: { timeoutMs: remaining } } });
+  return bundle.entries;
+}
+async function readCachedSelection(selection, options = {}) {
+  const bytes = readRegularFile(selectionBundlePath(selection, options), SKILL_BUNDLE_INSPECTION_LIMITS.compressedBytes);
+  return bytes ? verifiedEntries(selection, bytes) : null;
+}
+async function verifySelectionBundleResponse(selection, response, signal, deadline) {
+  validateSelection(selection);
+  if (!response?.ok)
+    throw new SkillSelectionError("BUNDLE_UNAVAILABLE", `The selected skill bundle is unavailable${response ? ` (HTTP ${response.status})` : ""}.`);
+  const declared = response.headers.get("X-Skill-Bundle-Sha256");
+  const version2 = response.headers.get("X-Skill-Version");
+  if (declared && `sha256:${declared}` !== selection.bundleDigest || version2 && version2 !== selection.version) {
+    await response.body?.cancel();
+    throw new SkillSelectionError("BUNDLE_IDENTITY_MISMATCH", "The returned bundle does not match the selected version and digest.");
+  }
+  const epoch = response.headers.get("X-Skill-Authorization-Epoch");
+  if (selection.authorizationEpoch !== undefined && epoch !== selection.authorizationEpoch) {
+    response.body?.cancel().catch(() => {});
+    throw new SkillSelectionError("SESSION_RECONCILIATION_REQUIRED", "The selected bundle lifecycle authorization changed or is unavailable.");
+  }
+  const maximum = SKILL_BUNDLE_INSPECTION_LIMITS.compressedBytes;
+  const reader = response.body?.getReader();
+  if (!reader)
+    throw new SkillSelectionError("BUNDLE_UNAVAILABLE", "The selected bundle response has no body.");
+  signal?.throwIfAborted();
+  const abort = () => {
+    reader.cancel().catch(() => {});
+  };
+  signal?.addEventListener("abort", abort, { once: true });
+  const chunks = [];
+  let length = 0;
+  try {
+    while (true) {
+      signal?.throwIfAborted();
+      const next = await reader.read();
+      signal?.throwIfAborted();
+      if (next.done)
+        break;
+      length += next.value.byteLength;
+      if (length > maximum)
+        throw new SkillSelectionError("BUNDLE_TOO_LARGE", "The selected bundle exceeds the cache size limit.");
+      chunks.push(next.value);
+    }
+  } catch (error) {
+    reader.cancel().catch(() => {});
+    throw error;
+  } finally {
+    signal?.removeEventListener("abort", abort);
+    reader.releaseLock();
+  }
+  const bytes = new Uint8Array(length);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  const entries = await verifiedEntries(selection, bytes, signal, deadline);
+  return { bytes, entries };
+}
+async function cacheSelectionBundle(selection, response, options = {}) {
+  const { bytes, entries } = await verifySelectionBundleResponse(selection, response);
+  const maximum = SKILL_BUNDLE_INSPECTION_LIMITS.compressedBytes;
+  const path = selectionBundlePath(selection, options);
+  const existing = readRegularFile(path, maximum);
+  if (existing)
+    await verifiedEntries(selection, existing);
+  else
+    atomicWrite(path, bytes, 256);
+  return entries;
+}
+function profilePath(profileId, options) {
+  return join4(selectionCacheRoot(options), "profiles", `${hash(profileId)}.json`);
+}
+function activateSelectionProfile(profile, options = {}) {
+  validateResolvedProfile(profile);
+  const receipt = { schemaVersion: 1, verifiedAt: new Date((options.now ?? Date.now)()).toISOString(), profile };
+  writeSelectionJson(profilePath(profile.profileId, options), receipt);
+  return receipt;
+}
+function readSelectionProfile(profileId, options = {}) {
+  const receipt = readSelectionJson(profilePath(profileId, options));
+  if (receipt)
+    validateSelectionReceipt(receipt);
+  return receipt;
+}
+function validateSelectionReceipt(receipt) {
+  if (!receipt || receipt.schemaVersion !== 1 || !Number.isFinite(Date.parse(receipt.verifiedAt)))
+    throw new SkillSelectionError("INVALID_RECEIPT", "The Skills selection receipt is invalid.");
+  validateResolvedProfile(receipt.profile);
+}
+function assertFreshCachedProfile(receipt, options = {}) {
+  validateSelectionReceipt(receipt);
+  const age = (options.now ?? Date.now)() - Date.parse(receipt.verifiedAt);
+  const maximum = options.maxAgeMs ?? MAX_CACHED_PROFILE_AGE_MS;
+  if (!Number.isFinite(maximum) || maximum <= 0 || maximum > MAX_CACHED_PROFILE_AGE_MS)
+    throw new SkillSelectionError("INVALID_CONTEXT_BUDGET", "The cached profile maximum age must be positive and within the supported bound.");
+  if (!Number.isFinite(age) || age < 0)
+    throw new SkillSelectionError("INVALID_RECEIPT", "The cached profile verification timestamp is invalid or in the future.");
+  if (age > maximum) {
+    throw new SkillSelectionError("CACHED_PROFILE_EXPIRED", "The cached Skills profile has expired; authenticate and sync it again.");
+  }
+}
+function projectSelectionLockPath(projectDir) {
+  return join4(resolve2(projectDir), ".skills", SELECTION_LOCK_FILE);
+}
+function readProjectSelection(projectDir) {
+  const receipt = readSelectionJson(projectSelectionLockPath(projectDir));
+  if (receipt)
+    validateSelectionReceipt(receipt);
+  return receipt;
+}
+function sessionReceiptPath(sessionId, options = {}) {
+  if (!sessionId.trim() || sessionId.length > MAX_SKILL_SESSION_ID_CHARS)
+    throw new SkillSelectionError("INVALID_SESSION", `A Skills session id must contain 1\u2013${MAX_SKILL_SESSION_ID_CHARS} characters.`);
+  return join4(selectionCacheRoot(options), "sessions", `${hash(sessionId)}.json`);
+}
+function skillSessionGeneration(receipt) {
+  return receipt.generation ?? 0;
+}
+function validateSkillSessionBinding(binding) {
+  if (!binding || typeof binding.sessionId !== "string" || !binding.sessionId.trim() || binding.sessionId.length > MAX_SKILL_SESSION_ID_CHARS || !Number.isSafeInteger(binding.generation) || binding.generation < 0 || !/^[a-f0-9]{64}$/.test(binding.receiptSha256)) {
+    throw new SkillSelectionError("INVALID_RECEIPT", "The Skills session receipt contains an invalid parent snapshot binding.");
+  }
+}
+function validateSkillSessionReceipt(receipt, sessionId) {
+  validateSelectionReceipt(receipt);
+  const keys = new Set(receipt.profile.selections.map(selectionKey));
+  if (receipt.sessionId !== sessionId || !Array.isArray(receipt.loaded) || receipt.loaded.length > keys.size || new Set(receipt.loaded).size !== receipt.loaded.length || !receipt.loaded.every((key) => keys.has(key)) || receipt.generation !== undefined && (!Number.isSafeInteger(receipt.generation) || receipt.generation < 1)) {
+    throw new SkillSelectionError("INVALID_RECEIPT", "The Skills session receipt is invalid.");
+  }
+  if (receipt.parent) {
+    validateSkillSessionBinding(receipt.parent);
+    if (receipt.parent.sessionId === sessionId)
+      throw new SkillSelectionError("INVALID_RECEIPT", "A Skills child session cannot name itself as its parent.");
+  }
+}
+function readSkillSessionSnapshotIfExists(sessionId, options = {}) {
+  const path = sessionReceiptPath(sessionId, options), bytes = readRegularFile(path, MAX_PROFILE_DOCUMENT_BYTES);
+  if (!bytes)
+    return null;
+  let receipt;
+  try {
+    receipt = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+  } catch {
+    throw new SkillSelectionError("INVALID_RECEIPT", "The Skills session receipt is unreadable.");
+  }
+  validateSkillSessionReceipt(receipt, sessionId);
+  const sha256 = sha256Hex(bytes);
+  return { path, bytes, receipt, sha256, sessionId, generation: skillSessionGeneration(receipt), receiptSha256: sha256 };
+}
+function readSkillSessionSnapshot(sessionId, options = {}) {
+  const snapshot = readSkillSessionSnapshotIfExists(sessionId, options);
+  if (!snapshot)
+    throw new SkillSelectionError("SESSION_NOT_FOUND", "The requested Skills session receipt does not exist.");
+  return snapshot;
+}
+function skillSessionSnapshotBinding(snapshot) {
+  return { sessionId: snapshot.sessionId, generation: snapshot.generation, receiptSha256: snapshot.receiptSha256 };
+}
+var SESSION_LOCK_MAX_BYTES = 4096;
+var SESSION_LOCK_MIN_AGE_MS = 30000;
+function localBootId() {
+  try {
+    if (process.platform === "linux") {
+      const value = readFileSync3("/proc/sys/kernel/random/boot_id", "utf8").trim();
+      return /^[a-f0-9-]{36}$/i.test(value) ? value : null;
+    }
+    if (process.platform === "darwin") {
+      const result = spawnSync("/usr/sbin/sysctl", ["-n", "kern.boottime"], { encoding: "utf8", timeout: 3000, env: { LC_ALL: "C" } });
+      if (result.status !== 0 || result.error)
+        return null;
+      const seconds = /\bsec\s*=\s*(\d+)\b/.exec(result.stdout)?.[1];
+      return seconds ? `darwin:${seconds}` : null;
+    }
+  } catch {}
+  return null;
+}
+function processStart(pid) {
+  if (!Number.isSafeInteger(pid) || pid <= 0)
+    return { state: "unknown" };
+  if (process.platform === "linux") {
+    try {
+      const stat = readFileSync3(`/proc/${pid}/stat`, "utf8");
+      const close = stat.lastIndexOf(")");
+      const start = close < 0 ? undefined : stat.slice(close + 2).trim().split(/\s+/)[19];
+      return start && /^\d+$/.test(start) ? { state: "alive", start: `linux:${start}` } : { state: "unknown" };
+    } catch (error) {
+      return { state: error.code === "ENOENT" ? "absent" : "unknown" };
+    }
+  }
+  if (process.platform === "darwin") {
+    const result = spawnSync("/bin/ps", ["-p", String(pid), "-o", "lstart="], { encoding: "utf8", timeout: 3000, env: { LC_ALL: "C" } });
+    if (result.error || result.signal)
+      return { state: "unknown" };
+    const start = result.stdout.trim();
+    if (result.status === 1 && !start && !result.stderr.trim())
+      return { state: "absent" };
+    return result.status === 0 && start ? { state: "alive", start: `darwin:${start}` } : { state: "unknown" };
+  }
+  return { state: "unknown" };
+}
+function localLockIdentity() {
+  const bootId = localBootId(), owner = processStart(process.pid);
+  if (!bootId || owner.state !== "alive")
+    return null;
+  let pidNamespace;
+  if (process.platform === "linux") {
+    try {
+      pidNamespace = readlinkSync("/proc/self/ns/pid");
+    } catch {
+      return null;
+    }
+    if (!/^pid:\[\d+\]$/.test(pidNamespace))
+      return null;
+  }
+  return { host: hostname(), bootId, pidNamespace, processStart: owner.start };
+}
+function readSessionLock(sessionId, options) {
+  const path = `${sessionReceiptPath(sessionId, options)}.write-lock`;
+  const before = lstatSync(path, { throwIfNoEntry: false });
+  if (!before)
+    return null;
+  if (!before.isFile() || ![1, 2].includes(before.nlink) || (before.mode & 63) !== 0 || process.getuid && before.uid !== process.getuid()) {
+    throw new SkillSelectionError("SESSION_WRITE_LOCKED", "The session lock is not a private regular file; recovery requires review.");
+  }
+  const bytes = readRegularFile(path, SESSION_LOCK_MAX_BYTES);
+  const after = lstatSync(path, { throwIfNoEntry: false });
+  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.");
+  }
+  let marker;
+  try {
+    marker = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+  } catch {
+    throw new SkillSelectionError("SESSION_WRITE_LOCKED", "The session lock is unreadable; recovery requires review.");
+  }
+  if (!marker || ![1, 2].includes(marker.schemaVersion) || marker.sessionId !== sessionId || !/^[a-f0-9-]{36}$/i.test(marker.operationId) || !Number.isSafeInteger(marker.pid) || marker.pid <= 0 || marker.publication !== undefined && marker.publication !== "hard-link-v1" || marker.schemaVersion === 2 && (!marker.host || !marker.bootId || !marker.processStart || process.platform === "linux" && !marker.pidNamespace)) {
+    throw new SkillSelectionError("SESSION_WRITE_LOCKED", "The session lock has invalid ownership metadata; recovery requires review.");
+  }
+  let stagingPath;
+  if (after.nlink === 2) {
+    stagingPath = `${path}.${marker.operationId}.prepared`;
+    assertRegularPath(stagingPath);
+    const staged = lstatSync(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.");
+    }
+  }
+  return { path, bytes, marker, sha256: sha256Hex(bytes), dev: after.dev, ino: after.ino, mtimeMs: after.mtimeMs, stagingPath };
+}
+function publishSessionLock(path, marker) {
+  const stagingPath = `${path}.${marker.operationId}.prepared`;
+  const bytes = Buffer.from(`${JSON.stringify({ ...marker, publication: "hard-link-v1" })}
+`);
+  const fd = openSync(stagingPath, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 384);
+  const stat = fstatSync(fd);
+  let published = false, handedOff = false;
+  try {
+    writeFileSync2(fd, bytes);
+    fsyncSync(fd);
+    linkSync(stagingPath, path);
+    published = true;
+    syncDirectory(dirname2(path));
+    const staged = lstatSync(stagingPath);
+    if (!staged.isFile() || staged.dev !== stat.dev || staged.ino !== stat.ino) {
+      throw new SkillSelectionError("SESSION_WRITE_LOCK_CHANGED", "The initialized lock staging inode changed before publication completed.");
+    }
+    unlinkSync(stagingPath);
+    syncDirectory(dirname2(path));
+    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 = lstatSync(target, { throwIfNoEntry: false });
+          if (current?.isFile() && current.dev === stat.dev && current.ino === stat.ino)
+            unlinkSync(target);
+        }
+      } finally {
+        closeSync(fd);
+      }
+    }
+  }
+}
+function writerIsGone(lock, explicitLocalHost) {
+  if (Date.now() - lock.mtimeMs < SESSION_LOCK_MIN_AGE_MS)
+    return false;
+  const owner = processStart(lock.marker.pid);
+  if (owner.state === "unknown")
+    return false;
+  if (lock.marker.schemaVersion === 1)
+    return explicitLocalHost && owner.state === "absent";
+  const local = localLockIdentity();
+  if (!local || lock.marker.host !== local.host || lock.marker.bootId !== local.bootId || lock.marker.pidNamespace !== local.pidNamespace)
+    return false;
+  return owner.state === "absent" || owner.state === "alive" && owner.start !== lock.marker.processStart;
+}
+function archiveSessionLock(lock, receipt, explicitLocalHost) {
+  const guardPath = `${lock.path}.recovery-guard`;
+  let guardFd;
+  try {
+    guardFd = openSync(guardPath, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 384);
+  } catch (error) {
+    if (error.code === "EEXIST")
+      return null;
+    throw error;
+  }
+  const guardStat = fstatSync(guardFd);
+  try {
+    writeFileSync2(guardFd, `${JSON.stringify({ schemaVersion: 1, pid: process.pid, operationId: randomUUID() })}
+`);
+    fsyncSync(guardFd);
+    const cacheOptions = { cacheDir: dirname2(dirname2(lock.path)) };
+    const current = readSessionLock(lock.marker.sessionId, cacheOptions);
+    if (!current || current.dev !== lock.dev || current.ino !== lock.ino || current.sha256 !== lock.sha256 || current.mtimeMs !== lock.mtimeMs || !writerIsGone(current, explicitLocalHost))
+      return null;
+    const currentReceipt = readSkillSessionSnapshotIfExists(lock.marker.sessionId, cacheOptions);
+    if (currentReceipt?.sha256 !== receipt?.sha256 || currentReceipt?.generation !== receipt?.generation)
+      return null;
+    const directory = join4(dirname2(dirname2(lock.path)), "session-lock-recoveries", randomUUID());
+    const archivePath = join4(directory, "original.write-lock");
+    const recordPath = join4(directory, "recovery.json");
+    assertRegularPath(archivePath, true);
+    archiveBytes(recordPath, Buffer.from(`${JSON.stringify({
+      schemaVersion: 1,
+      sessionId: lock.marker.sessionId,
+      originalPath: lock.path,
+      lockSha256: lock.sha256,
+      lockMtime: new Date(lock.mtimeMs).toISOString(),
+      lockPid: lock.marker.pid,
+      receiptSha256: receipt?.sha256 ?? null,
+      receiptGeneration: receipt?.generation ?? null,
+      status: "prepared"
+    })}
+`));
+    syncDirectory(directory);
+    syncDirectory(dirname2(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;
+    let moved = false;
+    try {
+      renameSync(lock.path, archivePath);
+      moved = true;
+      const archivedPaths = [archivePath];
+      if (finalLock.stagingPath) {
+        const publicationPath = join4(directory, "publication.write-lock");
+        renameSync(finalLock.stagingPath, publicationPath);
+        archivedPaths.push(publicationPath);
+      }
+      syncDirectory(directory);
+      syncDirectory(dirname2(lock.path));
+      for (const path of archivedPaths) {
+        const before = lstatSync(path, { throwIfNoEntry: false });
+        const bytes = readRegularFile(path, SESSION_LOCK_MAX_BYTES);
+        const after = lstatSync(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");
+        }
+      }
+    } catch (error) {
+      if (moved)
+        throw new SkillSelectionError("SESSION_LOCK_RECOVERY_INCOMPLETE", "The lock moved, but durable recovery could not be confirmed; inspect the preserved recovery directory and session receipt.");
+      throw error;
+    }
+    return archivePath;
+  } finally {
+    closeSync(guardFd);
+    const current = lstatSync(guardPath, { throwIfNoEntry: false });
+    if (current?.isFile() && current.dev === guardStat.dev && current.ino === guardStat.ino)
+      unlinkSync(guardPath);
+  }
+}
+function withSessionWriteLocks(sessionIds, options, action) {
+  const operationId = randomUUID();
+  const identity = localLockIdentity();
+  const locks = [...new Set(sessionIds)].map((sessionId) => ({ sessionId, path: `${sessionReceiptPath(sessionId, options)}.write-lock` })).sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
+  const owned = [];
+  const assertOwned = () => {
+    for (const lock of owned) {
+      const current = lstatSync(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.");
+      }
+    }
+  };
+  try {
+    for (const lock of locks) {
+      assertRegularPath(lock.path, true);
+      const marker = { schemaVersion: identity ? 2 : 1, operationId, sessionId: lock.sessionId, pid: process.pid, ...identity };
+      let acquired;
+      try {
+        acquired = publishSessionLock(lock.path, marker);
+      } catch (error) {
+        if (error.code !== "EEXIST")
+          throw error;
+        try {
+          const stale = readSessionLock(lock.sessionId, options);
+          const receipt = stale && readSkillSessionSnapshotIfExists(lock.sessionId, options);
+          if (stale?.marker.schemaVersion === 2 && writerIsGone(stale, false)) {
+            archiveSessionLock(stale, receipt, false);
+          }
+        } catch (recoveryError) {
+          if (recoveryError instanceof SkillSelectionError && recoveryError.code === "SESSION_LOCK_RECOVERY_INCOMPLETE")
+            throw recoveryError;
+        }
+        try {
+          acquired = publishSessionLock(lock.path, marker);
+        } catch (retryError) {
+          if (retryError.code === "EEXIST") {
+            if (!readSessionLock(lock.sessionId, options))
+              throw new SkillSelectionError("SESSION_WRITE_LOCK_CHANGED", "The session lock changed during acquisition.");
+            throw new SkillSelectionError("SESSION_WRITE_BUSY", "Another Skills process owns a required session write lock; retry after it completes. A surviving legacy lock requires explicit recovery review.");
+          }
+          throw retryError;
+        }
+      }
+      owned.push(acquired);
+    }
+    return action(assertOwned);
+  } finally {
+    for (const lock of owned.reverse()) {
+      try {
+        for (const path of [lock.path, lock.stagingPath]) {
+          const current = lstatSync(path, { throwIfNoEntry: false });
+          if (current?.isFile() && current.dev === lock.dev && current.ino === lock.ino)
+            unlinkSync(path);
+        }
+      } finally {
+        closeSync(lock.fd);
+      }
+    }
+  }
+}
+function withSessionWriteLock(sessionId, options, action) {
+  return withSessionWriteLocks([sessionId], options, action);
+}
+function sameSnapshot(actual, expected) {
+  return actual === null ? expected === null : expected !== null && actual.sessionId === expected.sessionId && actual.generation === expected.generation && actual.receiptSha256 === expected.receiptSha256;
+}
+function nextSkillSessionGeneration(generation) {
+  if (!Number.isSafeInteger(generation) || generation < 0 || generation >= Number.MAX_SAFE_INTEGER) {
+    throw new SkillSelectionError("SESSION_GENERATION_EXHAUSTED", "The Skills session generation cannot advance safely; preserve the receipt and review recovery before continuing.");
+  }
+  return generation + 1;
+}
+function parentChanged() {
+  throw new SkillSelectionError("SESSION_PARENT_CHANGED", "The parent Skills session changed while the child was resolving; resolve the child again from the current parent pin.");
+}
+function writeSkillSession(receipt, expected, options = {}) {
+  validateSkillSessionReceipt(receipt, receipt.sessionId);
+  if (expected.parent)
+    validateSkillSessionBinding(expected.parent);
+  if (expected.parent?.sessionId === receipt.sessionId)
+    throw new SkillSelectionError("INVALID_RECEIPT", "A Skills child session cannot name itself as its parent.");
+  const lockIds = expected.parent ? [receipt.sessionId, expected.parent.sessionId] : [receipt.sessionId];
+  withSessionWriteLocks(lockIds, options, (assertOwned) => {
+    const current = readSkillSessionSnapshotIfExists(receipt.sessionId, options);
+    if (!sameSnapshot(current, expected.current) || current && !isDeepStrictEqual(current.receipt.profile, receipt.profile)) {
+      throw new SkillSelectionError("SESSION_CONTEXT_CONFLICT", "The Skills session receipt changed while context was loading; resolve context again without replacing the current pin.");
+    }
+    let parent = null;
+    if (expected.parent) {
+      parent = readSkillSessionSnapshotIfExists(expected.parent.sessionId, options);
+      if (!sameSnapshot(parent, expected.parent) || !parent || !isDeepStrictEqual(parent.receipt.profile, receipt.profile))
+        parentChanged();
+    }
+    const generation = nextSkillSessionGeneration(current?.generation ?? 0);
+    const next = current ? { ...current.receipt, generation, loaded: [...new Set([...current.receipt.loaded, ...receipt.loaded])] } : { ...receipt, generation, ...expected.parent ? { parent: expected.parent } : {} };
+    assertOwned();
+    if (expected.parent) {
+      parent = readSkillSessionSnapshotIfExists(expected.parent.sessionId, options);
+      if (!sameSnapshot(parent, expected.parent))
+        parentChanged();
+    }
+    writeSelectionJson(sessionReceiptPath(receipt.sessionId, options), next);
+  });
+}
+function syncDirectory(path) {
+  assertRegularPath(path);
+  const fd = openSync(path, constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW);
+  try {
+    fsyncSync(fd);
+  } finally {
+    closeSync(fd);
+  }
+}
+function archiveBytes(path, bytes) {
+  assertRegularPath(path, true);
+  const fd = openSync(path, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 384);
+  try {
+    writeFileSync2(fd, bytes);
+    fsyncSync(fd);
+  } finally {
+    closeSync(fd);
+  }
+}
+function replaceSkillSession(expected, replacement, plan, options = {}, beforeCommit = () => {}) {
+  validateSkillSessionReceipt(replacement, replacement.sessionId);
+  const bytes = Buffer.from(`${JSON.stringify(replacement)}
+`);
+  if (bytes.length > MAX_PROFILE_DOCUMENT_BYTES)
+    throw new SkillSelectionError("RECEIPT_TOO_LARGE", "The Skills selection receipt exceeds its size limit.");
+  return withSessionWriteLock(replacement.sessionId, options, (assertOwned) => {
+    const before = readSkillSessionSnapshot(replacement.sessionId, options);
+    if (!sameSnapshot(before, expected))
+      throw new SkillSelectionError("SESSION_RECEIPT_CHANGED", "The Skills session receipt generation or bytes changed after review; inspect it and prepare a new plan.");
+    if (replacement.generation !== nextSkillSessionGeneration(before.generation))
+      throw new SkillSelectionError("SESSION_GENERATION_CHANGED", "The replacement Skills session must advance exactly one generation.");
+    if (before.receipt.profile.authority !== replacement.profile.authority || before.receipt.profile.workspaceId !== replacement.profile.workspaceId) {
+      throw new SkillSelectionError("PROFILE_IDENTITY_MISMATCH", "A session reconciliation cannot change its Skills authority or workspace.");
+    }
+    const directory = join4(selectionCacheRoot(options), "session-reconciliations", randomUUID());
+    const archivePath = join4(directory, "original.json"), replacementPath = join4(directory, "replacement.json"), receiptPath = join4(directory, "receipt.json");
+    const afterSha256 = sha256Hex(bytes);
+    archiveBytes(archivePath, before.bytes);
+    archiveBytes(replacementPath, bytes);
+    const receipt = { schemaVersion: 1, status: "prepared", sessionId: replacement.sessionId, beforeGeneration: before.generation, afterGeneration: replacement.generation, beforeSha256: before.sha256, afterSha256, archivePath, replacementPath, plan };
+    archiveBytes(receiptPath, Buffer.from(`${JSON.stringify(receipt)}
+`));
+    syncDirectory(directory);
+    syncDirectory(dirname2(directory));
+    syncDirectory(selectionCacheRoot(options));
+    if (sha256Hex(readRegularFile(archivePath, MAX_PROFILE_DOCUMENT_BYTES)) !== before.sha256 || !sameSnapshot(readSkillSessionSnapshot(replacement.sessionId, options), expected)) {
+      throw new SkillSelectionError("SESSION_RECEIPT_CHANGED", "The session or its preservation archive changed before replacement; retained evidence must be reviewed.");
+    }
+    beforeCommit();
+    assertOwned();
+    try {
+      atomicWrite(before.path, bytes, 384, true);
+      atomicWrite(receiptPath, Buffer.from(`${JSON.stringify({ ...receipt, status: "applied" })}
+`), 384, true);
+    } catch {
+      throw new SkillSelectionError("SESSION_RECONCILIATION_INCOMPLETE", `Inspect sessions show and the preserved operation receipt at ${receiptPath} before any retry; replacement may already have committed.`);
+    }
+    return { archivePath, receiptPath, beforeSha256: before.sha256, afterSha256 };
+  });
+}
+
+// src/lib/agent-policy-limits.ts
+import { basename as basename3, isAbsolute as isAbsolute3, join as join5, resolve as resolve5, sep } from "path";
+
+// src/lib/codex-native-compatibility.ts
+var MEASURED_CODEX_CAPABILITIES = {
+  "codex-cli 0.153.0": ["hooks"],
+  "codex-cli 0.154.0": ["hooks"],
+  "codex-cli 0.155.0": ["hooks"],
+  "codex-cli 0.155.1": ["hooks"],
+  "codex-cli 0.156.1": ["hooks"],
+  "codex-cli 0.157.0": ["hooks"],
+  "codex-cli 0.157.1": ["hooks"],
+  "codex-cli 0.158.0": ["hooks"],
+  "codex-cli 0.159.0": ["hooks"],
+  "codex-cli 0.159.2": ["hooks", "qualified-skill-catalog"],
+  "codex-cli 0.160.0": ["hooks", "qualified-skill-catalog", "installed-plugin-review"],
+  "codex-cli 0.160.1": ["hooks", "qualified-skill-catalog", "installed-plugin-review"],
+  "codex-cli 0.161.0": ["hooks", "qualified-skill-catalog", "installed-plugin-review"],
+  "codex-cli 0.162.0": ["hooks", "qualified-skill-catalog", "installed-plugin-review"]
+};
+function supportsCodexNativeCapability(version2, capability) {
+  return typeof version2 === "string" && Object.hasOwn(MEASURED_CODEX_CAPABILITIES, version2) && MEASURED_CODEX_CAPABILITIES[version2].includes(capability);
+}
+var SUPPORTED_CODEX_HOOK_VERSIONS = Object.freeze(Object.keys(MEASURED_CODEX_CAPABILITIES).filter((version2) => supportsCodexNativeCapability(version2, "hooks")));
+
+// src/lib/claude-marketplace-entry-witness.ts
+import { createHash as createHash4 } from "crypto";
+import { basename as basename2, dirname as dirname4, isAbsolute as isAbsolute2, resolve as resolve4 } from "path";
+
+// src/lib/claude-settings-witness.ts
+import { createHash as createHash3 } from "crypto";
+import { closeSync as closeSync2, constants as constants2, fstatSync as fstatSync2, lstatSync as lstatSync2, openSync as openSync2, readSync as readSync2 } from "fs";
+import { basename, dirname as dirname3, isAbsolute, resolve as resolve3 } from "path";
+var CLAUDE_SETTINGS_WITNESS_LIMITS = Object.freeze({ bytes: 1024 * 1024, rows: 1024, depth: 32, nodes: 65536, stringCharacters: 16384, pathCharacters: 4096 });
+function need(value, reason) {
+  if (!value)
+    throw new Error(`Claude settings witness ${reason}`);
+}
+function absolutePath(value) {
+  need(typeof value === "string" && value.length > 0 && value.length <= CLAUDE_SETTINGS_WITNESS_LIMITS.pathCharacters && !/[\x00-\x1f\x7f]/.test(value) && isAbsolute(value) && resolve3(value) === value, "requires a normalized absolute path");
+}
+var sameFile = (a, b) => a.dev === b.dev && a.ino === b.ino && a.mode === b.mode && a.uid === b.uid && a.gid === b.gid && a.nlink === b.nlink && a.size === b.size && a.mtimeNs === b.mtimeNs && a.ctimeNs === b.ctimeNs;
+function parents(path) {
+  const result = [];
+  for (let at = dirname3(path);; at = dirname3(at)) {
+    const stat = lstatSync2(at, { bigint: true });
+    need(stat.isDirectory() && !stat.isSymbolicLink(), "path traverses a symlink or non-directory");
+    result.push([at, stat]);
+    if (at === dirname3(at))
+      return result;
+  }
+}
+function readNativeSettingsWitnessFile(path, budget, filename = "settings.json") {
+  absolutePath(path);
+  need(basename(path) === filename, `requires ${filename}`);
+  need(Number.isSafeInteger(budget.remaining) && budget.remaining >= 0, "has an invalid byte budget");
+  const ancestors = parents(path), initial = lstatSync2(path, { bigint: true });
+  need(initial.isFile() && !initial.isSymbolicLink() && initial.size <= BigInt(CLAUDE_SETTINGS_WITNESS_LIMITS.bytes), "is not a bounded regular file");
+  need(initial.size <= BigInt(budget.remaining), "exceeds its aggregate byte limit");
+  const fd = openSync2(path, constants2.O_RDONLY | constants2.O_NOFOLLOW | constants2.O_NONBLOCK);
+  try {
+    const opened = fstatSync2(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 = fstatSync2(fd, { bigint: true }), current = lstatSync2(path, { bigint: true });
+    need(current.isFile() && sameFile(opened, after) && sameFile(after, current) && BigInt(length) === opened.size, "changed during read");
+    for (const [ancestor, before] of ancestors) {
+      const now = lstatSync2(ancestor, { bigint: true });
+      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 {
+    closeSync2(fd);
+  }
+}
+function parse2(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 string() {
+    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: string() };
+    if (character === "{" || character === "[") {
+      at++;
+      space();
+      const object = character === "{", end = object ? "}" : "]", entries = [], items = [], keys = new Set;
+      if (text[at] !== end)
+        while (true) {
+          if (object) {
+            space();
+            const key = string();
+            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 object ? { kind: "object", entries } : { kind: "array", items };
+    }
+    for (const literal of ["true", "false", "null"])
+      if (text.startsWith(literal, at)) {
+        at += literal.length;
+        return { kind: "literal", value: literal };
+      }
+    numberPattern.lastIndex = at;
+    const number = numberPattern.exec(text);
+    need(number, "contains invalid JSON");
+    at += number[0].length;
+    return { kind: "number", value: number[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 parseNativeJsonObject(text) {
+  need(typeof text === "string" && Buffer.byteLength(text) <= CLAUDE_SETTINGS_WITNESS_LIMITS.bytes, "exceeds its byte limit");
+  return parse2(text);
+}
+var BOOLEAN_PREFERENCES = new Set([
+  "autoScrollEnabled",
+  "axScreenReader",
+  "emojiCompletionEnabled",
+  "prefersReducedMotion",
+  "showTurnDuration",
+  "spinnerTipsEnabled",
+  "syntaxHighlightingDisabled",
+  "terminalProgressBarEnabled",
+  "terminalTitleFromRename",
+  "verbose",
+  "wheelScrollAccelerationEnabled"
+]);
+var ENUM_PREFERENCES = Object.freeze({
+  editorMode: ["normal", "vim"],
+  tui: ["default", "fullscreen"],
+  viewMode: ["default", "verbose", "focus"]
+});
+var 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]"
+]);
+var CLAUDE_BUILTIN_THEMES = Object.freeze(["auto", "dark", "light", "dark-daltonized", "light-daltonized", "dark-ansi", "light-ansi"]);
+var BUILTIN_THEMES = new Set(CLAUDE_BUILTIN_THEMES);
+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;
+}
+var CLAUDE_COORDINATED_HOOK_EVENTS = ["PreToolUse", "PostToolUse", "Stop", "Notification", "SessionStart", "SessionEnd", "UserPromptSubmit", "SubagentStart"];
+function assertClaudeHookEventsReplacement(before, replacement, events) {
+  need(Array.isArray(events) && events.length > 0 && events.length <= CLAUDE_COORDINATED_HOOK_EVENTS.length && new Set(events).size === events.length && events.every((event) => CLAUDE_COORDINATED_HOOK_EVENTS.includes(event)), "requires explicit supported hook events");
+  const label = events.join(",");
+  function bounded(text) {
+    need(typeof text === "string" && Buffer.byteLength(text) <= CLAUDE_SETTINGS_WITNESS_LIMITS.bytes, `${label} update exceeds its byte limit`);
+    return parse2(text);
+  }
+  const original = bounded(before ?? "{}"), next = bounded(replacement);
+  const hadHooks = original.entries.some(([key]) => key === "hooks");
+  function withoutOwnedEvents(value) {
+    const hooks = value.entries.find(([key]) => key === "hooks")?.[1];
+    if (hooks !== undefined) {
+      need(hooks.kind === "object", `${label} update requires an object of hooks`);
+      for (const event of events) {
+        const selected = hooks.entries.find(([key]) => key === event)?.[1];
+        need(selected === undefined || selected.kind === "array", `${event} update requires a ${event} array`);
+      }
+      hooks.entries = hooks.entries.filter(([key]) => !events.includes(key));
+      if (!hadHooks && hooks.entries.length === 0)
+        value.entries = value.entries.filter(([key]) => key !== "hooks");
+    }
+    return canonical(value);
+  }
+  need(JSON.stringify(withoutOwnedEvents(original)) === JSON.stringify(withoutOwnedEvents(next)), `${label} update changed settings outside hooks.${label}`);
+}
+var PERSISTED_EFFORT_LEVELS = new Set(["low", "medium", "high", "xhigh"]);
+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 = parse2(text);
+  value.entries = value.entries.filter(([key, child]) => {
+    if (version2 === 4 && key === "theme" && child.kind === "string" && BUILTIN_THEMES.has(child.value))
+      return false;
+    if (version2 !== 1 && inferencePreference(key, child, version2 === 4 ? 3 : 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 createHash3("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 upgradeClaudeSettingsWitness(previous, reviewedSettingsPath) {
+  need(previous && Object.keys(previous).every((key) => ["path", "hashMode", "sha256"].includes(key)) && (previous.hashMode === undefined || previous.hashMode === "bytes" || previous.hashMode === "claude-settings-v1" || previous.hashMode === "claude-settings-v2") && typeof previous.sha256 === "string" && /^[a-f0-9]{64}$/.test(previous.sha256), "requires an exact legacy settings witness");
+  const budget = { remaining: 2 * CLAUDE_SETTINGS_WITNESS_LIMITS.bytes };
+  const before = readNativeSettingsWitnessFile(reviewedSettingsPath, budget), current = readNativeSettingsWitnessFile(previous.path, budget);
+  const beforeDigest = previous.hashMode === undefined || previous.hashMode === "bytes" ? createHash3("sha256").update(before).digest("hex") : settingsDigest(before, previous.hashMode === "claude-settings-v1" ? 1 : 2);
+  need(beforeDigest === previous.sha256, "reviewed preimage does not match the legacy witness");
+  const sha256 = settingsDigest(current, 3);
+  need(settingsDigest(before, 3) === sha256, "non-preference settings changed; explicit discovery review required");
+  return { path: previous.path, hashMode: "claude-settings-v3", sha256 };
+}
+function captureClaudeSettingsV4(path, budget = { remaining: 256 * 1024 * 1024 }) {
+  return { path, hashMode: "claude-settings-v4", sha256: settingsDigest(readNativeSettingsWitnessFile(path, budget), 4) };
+}
+function hashClaudeSettingsReplacementV4(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, 4);
+}
+function upgradeClaudeSettingsWitnessV4(previous, reviewedSettingsPath) {
+  need(previous && Object.keys(previous).every((key) => ["path", "hashMode", "sha256"].includes(key)) && (previous.hashMode === undefined || previous.hashMode === "bytes" || previous.hashMode === "claude-settings-v1" || previous.hashMode === "claude-settings-v2" || previous.hashMode === "claude-settings-v3") && typeof previous.sha256 === "string" && /^[a-f0-9]{64}$/.test(previous.sha256), "requires an exact prior settings witness");
+  const budget = { remaining: 2 * CLAUDE_SETTINGS_WITNESS_LIMITS.bytes };
+  const before = readNativeSettingsWitnessFile(reviewedSettingsPath, budget), current = readNativeSettingsWitnessFile(previous.path, budget);
+  const beforeDigest = previous.hashMode === undefined || previous.hashMode === "bytes" ? createHash3("sha256").update(before).digest("hex") : settingsDigest(before, previous.hashMode === "claude-settings-v1" ? 1 : previous.hashMode === "claude-settings-v2" ? 2 : 3);
+  need(beforeDigest === previous.sha256, "reviewed preimage does not match the prior witness");
+  const sha256 = settingsDigest(current, 4);
+  need(settingsDigest(before, 4) === sha256, "non-preference settings changed; explicit discovery review required");
+  return { path: previous.path, hashMode: "claude-settings-v4", sha256 };
+}
+function hashNativeJsonControls(text, excludedMetadata) {
+  need(Buffer.byteLength(text) <= CLAUDE_SETTINGS_WITNESS_LIMITS.bytes, "exceeds its byte limit");
+  const value = parse2(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 createHash3("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 = parse2(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 createHash3("sha256").update("hasna.skills.sumi-settings.v1\x00").update(JSON.stringify(value)).digest("hex");
+}
+
+// src/lib/claude-marketplace-entry-witness.ts
+var CLAUDE_MARKETPLACE_ENTRY_HASH_MODE = "claude-marketplace-entry-v1";
+var DOMAIN = "hasna.skills.claude-marketplace-entry.v1\x00";
+var PATH_CHARACTERS = 4096;
+var NAME = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+function need2(value, reason) {
+  if (!value)
+    throw new Error(`Claude marketplace entry witness ${reason}`);
+}
+var bounded = (key) => key.length > 64 ? `${key.slice(0, 64)}...` : key;
+var quote = (text) => JSON.stringify(text).replace(/[^\x20-\x7e]/g, (character) => `\\u${character.charCodeAt(0).toString(16).padStart(4, "0")}`);
+var child = (path, key) => path + (/^[A-Za-z0-9_$-]{1,64}$/.test(key) ? `.${key}` : `[${JSON.stringify(bounded(key))}]`);
+function unknownKey(selector, path, key) {
+  throw new Error(path === null ? `${CLAUDE_MARKETPLACE_ENTRY_HASH_MODE}: unknown top-level key ${quote(bounded(key))} in ${selector.marketplace}` : `${CLAUDE_MARKETPLACE_ENTRY_HASH_MODE}: unknown key ${quote(child(path, key))} in ${selector.marketplace}`);
+}
+function knownKeys(object, allowed, selector, path) {
+  for (const [key] of object.entries)
+    if (!allowed.has(key))
+      unknownKey(selector, path, key);
+}
+var reason = (error) => String(error?.message ?? error).replace(/^Claude settings witness /, "");
+var MARKETPLACE_KEYS = new Set(["$schema", "name", "owner", "plugins", "description", "version", "metadata", "forceRemoveDeletedPlugins", "allowCrossMarketplaceDependenciesOn", "renames"]);
+var MARKETPLACE_METADATA_KEYS = new Set(["description", "version", "pluginRoot"]);
+var ENTRY_BOUND_KEYS = new Set([
+  "name",
+  "source",
+  "strict",
+  "defaultEnabled",
+  "dependencies",
+  "relevance",
+  "headers",
+  "headersHelper",
+  "settings",
+  "userConfig",
+  "types",
+  "channels",
+  "skills",
+  "commands",
+  "agents",
+  "hooks",
+  "mcpServers",
+  "lspServers",
+  "outputStyles",
+  "workflows",
+  "experimental",
+  "themes",
+  "monitors"
+]);
+var ENTRY_OMITTED_KEYS = new Set(["$schema", "description", "version", "author", "homepage", "repository", "license", "keywords", "category", "tags", "displayName", "metadata"]);
+var EXPERIMENTAL_KEYS = new Set(["themes", "monitors", "evals"]);
+var SOURCE_KEYS = Object.freeze({
+  github: ["source", "repo", "ref", "sha"],
+  url: ["source", "url", "ref", "sha", "path"],
+  "git-subdir": ["source", "url", "path", "ref", "sha"],
+  npm: ["source", "package", "version", "registry"],
+  archive: ["source", "url", "sha256"],
+  command: ["source", "command", "timeout", "mode"]
+});
+var field = (object, key) => object.entries.find(([name]) => name === key)?.[1];
+var isString = (value) => value?.kind === "string";
+var isBoolean = (value) => value?.kind === "literal" && (value.value === "true" || value.value === "false");
+var stringArray = (value) => value?.kind === "array" && value.items.every(isString);
+var stringObject = (value) => value?.kind === "object" && value.entries.every(([, item]) => isString(item));
+function claudeMarketplaceEntrySourceValid(source) {
+  const path = source?.path;
+  return typeof path === "string" && path.length > 0 && path.length <= PATH_CHARACTERS && !/[\x00-\x1f\x7f]/.test(path) && isAbsolute2(path) && resolve4(path) === path && basename2(path) === "marketplace.json" && basename2(dirname4(path)) === ".claude-plugin" && typeof source.marketplace === "string" && NAME.test(source.marketplace) && !source.marketplace.includes("..") && typeof source.plugin === "string" && NAME.test(source.plugin);
+}
+function canonical2(value) {
+  if (value.kind === "string")
+    return JSON.stringify(value.value);
+  if (value.kind === "number" || value.kind === "literal")
+    return value.value;
+  if (value.kind === "array")
+    return "[" + value.items.map(canonical2).join(",") + "]";
+  return "{" + [...value.entries].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, item]) => JSON.stringify(key) + ":" + canonical2(item)).join(",") + "}";
+}
+function validateMarketplace(root, selector) {
+  knownKeys(root, MARKETPLACE_KEYS, selector, null);
+  const name = field(root, "name");
+  need2(isString(name) && name.value === selector.marketplace, "marketplace name does not match the reviewed binding");
+  for (const key of ["$schema", "description", "version"]) {
+    const value = field(root, key);
+    need2(value === undefined || isString(value), `has an invalid marketplace ${key}`);
+  }
+  const owner = field(root, "owner");
+  need2(owner === undefined || owner.kind === "object", "has an invalid marketplace owner");
+  const metadata = field(root, "metadata");
+  if (metadata !== undefined) {
+    need2(metadata.kind === "object", "has an invalid marketplace metadata object");
+    knownKeys(metadata, MARKETPLACE_METADATA_KEYS, selector, "metadata");
+    for (const [key, value] of metadata.entries)
+      need2(isString(value), `has an invalid marketplace metadata.${key}`);
+  }
+  const remove = field(root, "forceRemoveDeletedPlugins");
+  need2(remove === undefined || isBoolean(remove), "has an invalid forceRemoveDeletedPlugins value");
+  const cross = field(root, "allowCrossMarketplaceDependenciesOn");
+  need2(cross === undefined || stringArray(cross), "has an invalid allowCrossMarketplaceDependenciesOn value");
+  const renames = field(root, "renames");
+  if (renames !== undefined) {
+    need2(renames.kind === "object" && renames.entries.every(([, target]) => isString(target) || target.kind === "literal" && target.value === "null"), "has an invalid renames map");
+    need2(!renames.entries.some(([from]) => from.toLowerCase() === selector.plugin.toLowerCase()), "plugin id is redirected by the marketplace renames map");
+  }
+}
+function validateSource(source, selector, path) {
+  if (isString(source)) {
+    need2(source.value.length > 0, "has an empty plugin source");
+    return;
+  }
+  need2(source?.kind === "object", "has an invalid plugin source");
+  const type = field(source, "source");
+  need2(isString(type) && Object.hasOwn(SOURCE_KEYS, type.value), "has an unreviewed plugin source type");
+  knownKeys(source, new Set(SOURCE_KEYS[type.value]), selector, path);
+}
+function projectEntry(entry, selector) {
+  const path = `plugins[${selector.plugin}]`;
+  knownKeys(entry, { has: (key) => ENTRY_BOUND_KEYS.has(key) || ENTRY_OMITTED_KEYS.has(key) }, selector, path);
+  const name = field(entry, "name");
+  need2(isString(name) && name.value === selector.plugin, "selected entry name does not match");
+  validateSource(field(entry, "source"), selector, `${path}.source`);
+  for (const key of ["strict", "defaultEnabled"]) {
+    const value = field(entry, key);
+    need2(value === undefined || isBoolean(value), `has an invalid entry ${key}`);
+  }
+  const headersHelper = field(entry, "headersHelper");
+  need2(headersHelper === undefined || isString(headersHelper), "has an invalid entry headersHelper");
+  const experimental = field(entry, "experimental");
+  if (experimental !== undefined) {
+    need2(experimental.kind === "object", "has an invalid entry experimental object");
+    knownKeys(experimental, EXPERIMENTAL_KEYS, selector, `${path}.experimental`);
+  }
+  for (const key of ["$schema", "description", "version", "homepage", "license", "category", "displayName"]) {
+    const value = field(entry, key);
+    need2(value === undefined || isString(value), `has an invalid entry ${key}`);
+  }
+  for (const [key, keys] of [["author", new Set(["name", "email", "url"])], ["repository", new Set(["type", "url", "directory"])]]) {
+    const value = field(entry, key);
+    if (value?.kind === "object")
+      knownKeys(value, keys, selector, `${path}.${key}`);
+    need2(value === undefined || isString(value) || stringObject(value), `has an invalid entry ${key}`);
+  }
+  for (const key of ["keywords", "tags"]) {
+    const value = field(entry, key);
+    need2(value === undefined || stringArray(value), `has an invalid entry ${key}`);
+  }
+  const metadata = field(entry, "metadata");
+  need2(metadata === undefined || metadata.kind === "object", "has an invalid entry metadata object");
+  return { kind: "object", entries: entry.entries.filter(([key]) => ENTRY_BOUND_KEYS.has(key)) };
+}
+function hashClaudeMarketplaceEntry(text, selector) {
+  need2(selector && typeof selector.marketplace === "string" && NAME.test(selector.marketplace) && !selector.marketplace.includes("..") && typeof selector.plugin === "string" && NAME.test(selector.plugin), "requires an exact marketplace and plugin name");
+  let root;
+  try {
+    root = parseNativeJsonObject(text);
+  } catch (error) {
+    throw new Error(`Claude marketplace entry witness cannot parse marketplace.json: ${reason(error)}`);
+  }
+  validateMarketplace(root, selector);
+  const plugins = field(root, "plugins");
+  need2(plugins?.kind === "array", "requires a plugins array");
+  const entryName = (item) => {
+    if (item.kind !== "object")
+      return;
+    const name = field(item, "name");
+    return isString(name) ? name.value : undefined;
+  };
+  const exact = plugins.items.filter((item) => entryName(item) === selector.plugin);
+  const folded = plugins.items.filter((item) => entryName(item)?.toLowerCase() === selector.plugin.toLowerCase());
+  need2(exact.length > 0, "selected plugin entry is missing");
+  need2(exact.length === 1 && folded.length === 1, "selected plugin entry is duplicated or ambiguous");
+  const entry = projectEntry(exact[0], selector);
+  const metadata = field(root, "metadata"), pluginRoot = metadata?.kind === "object" ? field(metadata, "pluginRoot") : undefined;
+  const nullValue = { kind: "literal", value: "null" };
+  const marketplace = { kind: "object", entries: [
+    ["name", field(root, "name")],
+    ["pluginRoot", pluginRoot ?? nullValue],
+    ["allowCrossMarketplaceDependenciesOn", field(root, "allowCrossMarketplaceDependenciesOn") ?? nullValue]
+  ] };
+  const projection = { kind: "object", entries: [["marketplace", marketplace], ["plugin", entry]] };
+  return createHash4("sha256").update(DOMAIN).update(canonical2(projection)).digest("hex");
+}
+function captureClaudeMarketplaceEntry(path, marketplace, plugin, budget = { remaining: 256 * 1024 * 1024 }) {
+  need2(claudeMarketplaceEntrySourceValid({ path, marketplace, plugin }), "requires a normalized absolute .claude-plugin/marketplace.json path and exact names");
+  let text;
+  try {
+    text = readNativeSettingsWitnessFile(path, budget, "marketplace.json");
+  } catch (error) {
+    throw new Error(`Claude marketplace entry witness cannot read marketplace.json: ${reason(error)}`);
+  }
+  return { path, hashMode: CLAUDE_MARKETPLACE_ENTRY_HASH_MODE, marketplace, plugin, sha256: hashClaudeMarketplaceEntry(text, { marketplace, plugin }) };
+}
+
+// src/lib/agent-policy-limits.ts
+var AGENT_POLICY_LIMITS = Object.freeze({ bytes: 1024 * 1024, agents: 16, discoverySources: 2048, discoveryRawSourceBytes: 64 * 1024 * 1024, discoveryRawTotalBytes: 256 * 1024 * 1024, discoveryPathLinks: 40, discoveryPathSteps: 256, discoveryPathSourceMetadataBytes: 64 * 1024, discoveryPathTotalMetadataBytes: 8 * 1024 * 1024, discoveryRoots: 512, discoveryDirectories: 64, discoveryDirectoryEntries: 20000, discoveryDirectoryBytes: 8 * 1024 * 1024, builtinNames: 2048, rootAliases: 2, fields: 64, pathCharacters: 4096 });
+function object(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function requireBound(value) {
+  if (!value)
+    throw new Error("Agent policy collection bounds are invalid");
+}
+function array(value, maximum) {
+  requireBound(Array.isArray(value) && value.length <= maximum);
+  return value;
+}
+function record(value, maximum) {
+  requireBound(object(value) && Object.keys(value).length <= maximum);
+  return value;
+}
+function text(value, maximum = AGENT_POLICY_LIMITS.pathCharacters) {
+  requireBound(typeof value === "string" && value.length > 0 && value.length <= maximum && !value.includes("\x00"));
+}
+function assertAgentPolicyCollections(policy) {
+  if (policy.bridge === undefined)
+    return;
+  const bridge = record(policy.bridge, 64);
+  if (bridge.agents !== undefined)
+    for (const agent of array(bridge.agents, AGENT_POLICY_LIMITS.agents))
+      text(agent, 128);
+  for (const key of ["commands", "profiles", "supervisors"])
+    if (bridge[key] !== undefined) {
+      const entries = record(bridge[key], AGENT_POLICY_LIMITS.agents);
+      for (const [agent, value] of Object.entries(entries)) {
+        text(agent, 128);
+        if (key === "supervisors") {
+          requireBound(object(value));
+          text(value.path);
+          text(value.runtime);
+          text(value.sha256, 64);
+        } else
+          text(value, key === "profiles" ? 128 : AGENT_POLICY_LIMITS.pathCharacters);
+      }
+    }
+  if (bridge.rootAliases !== undefined)
+    for (const alias of array(bridge.rootAliases, AGENT_POLICY_LIMITS.rootAliases)) {
+      requireBound(object(alias));
+      for (const key of ["agent", "home", "alias", "target", "link", "aliasIdentity", "targetIdentity"])
+        text(alias[key]);
+    }
+  if (bridge.codexPluginSkills !== undefined)
+    for (const control of array(bridge.codexPluginSkills, 4096)) {
+      requireBound(object(control) && Object.keys(control).every((key) => ["name", "pluginId", "namespace", "pluginParent", "manifestSha256", "appSha256", "mcpSha256", "remotePluginId", "skillsOnly"].includes(key)));
+      text(control.name, 129);
+      text(control.pluginId, 1024);
+      text(control.namespace, 64);
+      text(control.pluginParent);
+      requireBound(isAbsolute3(control.pluginParent) && resolve5(control.pluginParent) === control.pluginParent && /^[a-f0-9]{64}$/.test(control.manifestSha256));
+      if (control.remotePluginId !== undefined)
+        requireBound(typeof control.remotePluginId === "string" && /^[A-Za-z0-9_~-]{1,1024}$/.test(control.remotePluginId));
+      if (control.skillsOnly !== undefined)
+        requireBound(control.skillsOnly === true && control.appSha256 === undefined && control.mcpSha256 === undefined);
+      if (control.mcpSha256 !== undefined)
+        requireBound(typeof control.mcpSha256 === "string" && /^[a-f0-9]{64}$/.test(control.mcpSha256));
+      if (control.appSha256 !== undefined)
+        requireBound(typeof control.appSha256 === "string" && /^[a-f0-9]{64}$/.test(control.appSha256));
+    }
+  if (bridge.codexInactivePlugins !== undefined) {
+    const controls = array(bridge.codexInactivePlugins, 4096), ids = new Set;
+    requireBound(controls.length === 0 || object(bridge.codexPluginSkillReview) && supportsCodexNativeCapability(bridge.codexPluginSkillReview.version, "installed-plugin-review") && typeof bridge.codexPluginSkillReview.catalogSha256 === "string" && /^[a-f0-9]{64}$/.test(bridge.codexPluginSkillReview.catalogSha256));
+    for (const control of controls) {
+      requireBound(object(control) && Object.keys(control).every((key) => ["pluginId", "namespace", "pluginParent", "sourceType", "sourceSha256"].includes(key)));
+      text(control.pluginId, 1024);
+      text(control.namespace, 64);
+      text(control.pluginParent);
+      requireBound(!ids.has(control.pluginId) && isAbsolute3(control.pluginParent) && resolve5(control.pluginParent) === control.pluginParent && ["local", "git", "npm"].includes(control.sourceType) && typeof control.sourceSha256 === "string" && /^[a-f0-9]{64}$/.test(control.sourceSha256));
+      ids.add(control.pluginId);
+    }
+  }
+  if (bridge.discoveryExecutables !== undefined)
+    for (const [agent, executable] of Object.entries(record(bridge.discoveryExecutables, AGENT_POLICY_LIMITS.agents))) {
+      requireBound(agent === "gemini" && object(executable) && Object.keys(executable).length === 3 && executable.command === "gemini");
+      for (const path of [executable.path, executable.target]) {
+        text(path);
+        requireBound(!/[\x00-\x1f\x7f-\x9f\u200e\u200f\u202a-\u202e\u2066-\u2069]/.test(path) && isAbsolute3(path) && resolve5(path) === path);
+      }
+    }
+  if (bridge.disabledBuiltins !== undefined)
+    for (const builtin of array(bridge.disabledBuiltins, AGENT_POLICY_LIMITS.builtinNames)) {
+      requireBound(object(builtin));
+      text(builtin.path);
+      text(builtin.hash, 64);
+    }
+  if (bridge.codexNativePolicy !== undefined) {
+    const trust = record(bridge.codexNativePolicy, 1);
+    for (const [platform, digests] of Object.entries(record(trust.executableDigests, 8))) {
+      text(platform, 32);
+      for (const digest of array(digests, 16))
+        text(digest, 64);
+    }
+  }
+  if (bridge.discovery === undefined)
+    return;
+  for (const [agent, value] of Object.entries(record(bridge.discovery, AGENT_POLICY_LIMITS.agents))) {
+    text(agent, 128);
+    requireBound(object(value));
+    text(value.agent, 128);
+    if (value.codexRetiredMaterializations !== undefined) {
+      const proof = record(value.codexRetiredMaterializations, 3), roots = array(proof.roots, AGENT_POLICY_LIMITS.discoveryRoots), parents2 = proof.parents === undefined ? [] : array(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) && resolve5(root) === root);
+      }
+      for (const parent of parents2) {
+        text(parent);
+        requireBound(isAbsolute3(parent) && resolve5(parent) === parent);
+      }
+      for (const directory of array(proof.directories, AGENT_POLICY_LIMITS.discoveryDirectories)) {
+        requireBound(object(directory));
+        text(directory.path);
+        requireBound(directory.sha256 === null || typeof directory.sha256 === "string" && /^[a-f0-9]{64}$/.test(directory.sha256));
+        if (directory.entries !== undefined)
+          for (const entry of array(directory.entries, AGENT_POLICY_LIMITS.discoveryDirectoryEntries))
+            text(entry, AGENT_POLICY_LIMITS.pathCharacters * 6 + 100);
+      }
+    }
+    if (value.codexInstallationInputs !== undefined) {
+      const proof = record(value.codexInstallationInputs, 4), inputs = array(proof.plugins, 4096), ids = new Set;
+      requireBound(agent === "codex" && value.agent === "codex" && value.method === "reviewed" && supportsCodexNativeCapability(proof.version, "installed-plugin-review") && typeof proof.catalogSha256 === "string" && /^[a-f0-9]{64}$/.test(proof.catalogSha256) && inputs.length > 0 && object(bridge.codexPluginSkillReview) && bridge.codexPluginSkillReview.version === proof.version && bridge.codexPluginSkillReview.catalogSha256 === proof.catalogSha256);
+      for (const input of inputs) {
+        requireBound(object(input) && Object.keys(input).every((key) => ["pluginId", "namespace", "pluginParent", "sourceRoot", "sourceSha256"].includes(key)));
+        text(input.pluginId, 1024);
+        text(input.namespace, 64);
+        text(input.pluginParent);
+        text(input.sourceRoot);
+        requireBound(!ids.has(input.pluginId) && [input.pluginParent, input.sourceRoot].every((path) => isAbsolute3(path) && resolve5(path) === path) && typeof input.sourceSha256 === "string" && /^[a-f0-9]{64}$/.test(input.sourceSha256));
+        ids.add(input.pluginId);
+      }
+      if (proof.directories !== undefined)
+        for (const directory of array(proof.directories, AGENT_POLICY_LIMITS.discoveryDirectories)) {
+          requireBound(object(directory));
+          text(directory.path);
+          requireBound(directory.sha256 === null || typeof directory.sha256 === "string" && /^[a-f0-9]{64}$/.test(directory.sha256));
+        }
+    }
+    for (const root of array(value.roots, AGENT_POLICY_LIMITS.discoveryRoots))
+      text(root);
+    for (const source of array(value.sources, AGENT_POLICY_LIMITS.discoverySources)) {
+      requireBound(object(source));
+      text(source.path);
+      requireBound(source.sha256 === null || typeof source.sha256 === "string" && /^[a-f0-9]{64}$/.test(source.sha256));
+      if (source.hashMode !== undefined)
+        requireBound(["bytes", "path-bytes", "claude-plugin-manifest-v1", "claude-plugin-registry", "claude-marketplace-registry", "claude-settings-v1", "claude-settings-v2", "claude-settings-v3", "claude-settings-v4", "claude-marketplace-registry-v2", "codex-settings-v1", "codex-settings-v2", "codex-settings-v3", "codex-settings-v4", "sumi-settings-v1", "claude-marketplace-entry-v1"].includes(source.hashMode) && source.format === undefined && source.fields === undefined && (source.hashMode === "bytes" || source.sha256 !== null));
+      if (source.hashMode === "claude-plugin-manifest-v1")
+        requireBound(agent === "claude" && value.agent === "claude" && ["automatic", "reviewed"].includes(value.method) && !/[\x00-\x1f\x7f]/.test(source.path) && isAbsolute3(source.path) && resolve5(source.path) === source.path && source.path.endsWith(join5(sep, ".claude-plugin", "plugin.json")) && source.managedPlugins === undefined);
+      if (source.hashMode === "sumi-settings-v1")
+        requireBound(agent === "sumi" && value.agent === "sumi" && value.method === "reviewed" && !/[\x00-\x1f\x7f]/.test(source.path) && isAbsolute3(source.path) && resolve5(source.path) === source.path && basename3(source.path) === "sumi.json");
+      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) && resolve5(source.path) === source.path && basename3(source.path) === "config.toml");
+      if (source.hashMode === "claude-settings-v1" || source.hashMode === "claude-settings-v2" || (source.hashMode === "claude-settings-v3" || source.hashMode === "claude-settings-v4"))
+        requireBound(agent === "claude" && value.agent === "claude" && value.method === "reviewed" && !/[\x00-\x1f\x7f]/.test(source.path) && isAbsolute3(source.path) && resolve5(source.path) === source.path && basename3(source.path) === "settings.json");
+      if (source.hashMode === "claude-marketplace-registry" || source.hashMode === "claude-marketplace-registry-v2")
+        requireBound(agent === "claude" && value.agent === "claude" && value.method === "reviewed" && !/[\x00-\x1f\x7f]/.test(source.path) && isAbsolute3(source.path) && resolve5(source.path) === source.path && basename3(source.path) === "known_marketplaces.json");
+      if (source.hashMode === "claude-marketplace-entry-v1")
+        requireBound(agent === "claude" && value.agent === "claude" && value.method === "reviewed" && claudeMarketplaceEntrySourceValid(source));
+      if (source.hashMode === "claude-plugin-registry") {
+        requireBound(agent === "claude");
+        const managed = array(source.managedPlugins, 64);
+        requireBound(managed.length > 0);
+        for (const entry of managed) {
+          requireBound(object(entry) && Object.keys(entry).every((key) => ["bindingId", "storeRoot"].includes(key)));
+          text(entry.storeRoot);
+          requireBound(typeof entry.bindingId === "string" && /^[a-f0-9]{64}$/.test(entry.bindingId));
+        }
+      } else
+        requireBound(source.managedPlugins === undefined);
+      if (source.format !== undefined)
+        requireBound(["json", "toml", "yaml"].includes(source.format));
+      if (source.fields !== undefined)
+        for (const field2 of array(source.fields, AGENT_POLICY_LIMITS.fields))
+          text(field2, 256);
+    }
+    if (value.directories !== undefined)
+      for (const directory of array(value.directories, AGENT_POLICY_LIMITS.discoveryDirectories)) {
+        requireBound(object(directory));
+        text(directory.path);
+        requireBound(directory.sha256 === null || typeof directory.sha256 === "string" && /^[a-f0-9]{64}$/.test(directory.sha256));
+      }
+    if (value.builtinNames !== undefined)
+      for (const name of array(value.builtinNames, AGENT_POLICY_LIMITS.builtinNames))
+        text(name, 128);
+  }
+}
+
+// src/lib/managed-policy.ts
+function refusal(reason2 = "is unreadable") {
+  return new SkillSelectionError("INVALID_AGENT_POLICY", `The Skills agent loading policy ${reason2}; refusing legacy fallback.`);
+}
+function parseManagedSkillPolicy(text2) {
+  if (Buffer.byteLength(text2) > AGENT_POLICY_LIMITS.bytes)
+    throw refusal("exceeds its size limit");
+  let value;
+  try {
+    value = JSON.parse(text2);
+  } catch {
+    throw refusal();
+  }
+  if (!value || typeof value !== "object" || Array.isArray(value) || value.loading !== "cli" || value.version !== undefined && value.version !== 1)
+    throw refusal();
+  if (value.profileId !== undefined && (typeof value.profileId !== "string" || !/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/.test(value.profileId) || value.profileId.includes("..")))
+    throw refusal();
+  try {
+    assertAgentPolicyCollections(value);
+  } catch {
+    throw refusal("has invalid collection bounds");
+  }
+  return value;
+}
+function serializeManagedSkillPolicy(value) {
+  const text2 = `${JSON.stringify(value, null, 2)}
+`;
+  parseManagedSkillPolicy(text2);
+  return text2;
+}
+function readManagedSkillPolicySnapshot(dataDir2 = getDataDirReadOnly()) {
+  const path = join6(dataDir2, "agent-policy.json");
+  let descriptor, observed = false;
+  try {
+    const stat = lstatSync3(path);
+    observed = true;
+    if (!stat.isFile() || stat.isSymbolicLink())
+      throw refusal();
+    if (stat.size > AGENT_POLICY_LIMITS.bytes)
+      throw refusal("exceeds its size limit");
+    descriptor = openSync3(path, constants3.O_RDONLY | (constants3.O_NOFOLLOW ?? 0) | constants3.O_NONBLOCK);
+    const opened = fstatSync3(descriptor);
+    if (!opened.isFile())
+      throw refusal();
+    if (opened.size > AGENT_POLICY_LIMITS.bytes)
+      throw refusal("exceeds its size limit");
+    const bytes = Buffer.allocUnsafe(AGENT_POLICY_LIMITS.bytes + 1);
+    let length = 0;
+    while (length < bytes.length) {
+      const count = readSync3(descriptor, bytes, length, bytes.length - length, null);
+      if (count === 0)
+        break;
+      length += count;
+    }
+    if (length > AGENT_POLICY_LIMITS.bytes)
+      throw refusal("exceeds its size limit");
+    const text2 = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes.subarray(0, length));
+    return { text: text2, value: parseManagedSkillPolicy(text2) };
+  } catch (error) {
+    if (error.code === "ENOENT" && !observed) {
+      if (lstatSync3(path, { throwIfNoEntry: false }) === undefined)
+        return null;
+    }
+    if (error instanceof SkillSelectionError)
+      throw error;
+    throw refusal();
+  } finally {
+    if (descriptor !== undefined)
+      closeSync3(descriptor);
+  }
+}
+function readManagedSkillPolicy(dataDir2 = getDataDirReadOnly()) {
+  return readManagedSkillPolicySnapshot(dataDir2)?.value ?? null;
+}
+function requiresCliSkillLoading(dataDir2 = getDataDirReadOnly()) {
+  return readManagedSkillPolicy(dataDir2)?.loading === "cli";
+}
+
+// src/lib/agent-install-selection.ts
+function detectedIntegrationAgents(options = {}) {
+  const home = options.home ?? homedir2(), env = options.env ?? process.env;
+  const policy = readManagedSkillPolicySnapshot(options.dataDir ?? getDataDirReadOnly())?.value;
+  const bridge = policy?.bridge;
+  if (bridge !== undefined && (!bridge || typeof bridge !== "object" || Array.isArray(bridge)))
+    throw new Error("Invalid existing Skills bridge policy");
+  const configured = bridge === undefined ? [] : bridge.agents;
+  if (!Array.isArray(configured) || configured.some((agent) => !INTEGRATION_AGENTS.includes(agent)))
+    throw new Error("Invalid existing bridge agent inventory");
+  const present = (path) => {
+    try {
+      return lstatSync4(path, { throwIfNoEntry: false }) !== undefined;
+    } catch {
+      throw new Error("Agent presence cannot be inspected; review native configuration before hook installation");
+    }
+  };
+  const selected = INTEGRATION_AGENTS.filter((agent) => {
+    if (configured.includes(agent) || Bun.which(agent, { PATH: env.PATH ?? "" }))
+      return true;
+    if (agent === "sumi") {
+      const xdg = env.XDG_CONFIG_HOME;
+      const xdgSumi = xdg?.trim() ? resolve6(options.cwd ?? process.cwd(), xdg === "~" ? home : xdg.startsWith("~/") || xdg.startsWith("~\\") ? resolve6(home, xdg.slice(2)) : xdg, "sumi") : null;
+      return ["SUMI_HOME", "SUMI_CONFIG_DIR", "SUMI_CONFIG", "SUMI_CONFIG_CONTENT"].some((key) => env[key] !== undefined) || Bun.which("sumi-paths", { PATH: env.PATH ?? "" }) !== null || NATIVE_SKILL_ROOTS.some(([provider, root]) => provider === "sumi" && present(join7(home, dirname5(root)))) || present(join7(home, ".config", "sumi")) || xdgSumi !== null && present(xdgSumi);
+    }
+    if (agent === "hermes" && env.HERMES_HOME !== undefined)
+      return true;
+    const adapter = AGENT_ADAPTERS[agent];
+    return present(join7(home, dirname5(adapter.config))) || NATIVE_SKILL_ROOTS.some(([provider, root]) => provider === agent && dirname5(root) === `.${agent}` && present(join7(home, dirname5(root))));
+  });
+  if (!selected.length && !options.allowEmpty)
+    throw new Error(`No configured or detected agents; select --agent <agent> explicitly (${INTEGRATION_AGENTS.join(", ")}).`);
+  return selected;
+}
+
+// src/lib/agent-sumi.ts
+import { spawnSync as spawnSync2 } from "child_process";
+import { accessSync, constants as constants4, existsSync as existsSync4, lstatSync as lstatSync5, realpathSync, statSync as statSync2 } from "fs";
+import { delimiter, isAbsolute as isAbsolute4, join as join8, resolve as resolve7 } from "path";
+var SUMI_PATH_SELECTORS = ["SUMI_HOME", "SUMI_CONFIG_DIR", "XDG_DATA_HOME", "XDG_CACHE_HOME", "XDG_CONFIG_HOME", "XDG_STATE_HOME"];
+var SUMI_PATH_KEYS = ["data", "cache", "config", "state"];
+var SUMI_PATH_OUTPUT_LIMIT = 128 * 1024;
+
+class SumiPathResolverError extends Error {
+  code;
+  constructor(code) {
+    super(`Sumi path discovery refused (${code})`);
+    this.code = code;
+    this.name = "SumiPathResolverError";
+  }
+}
+function recordWithKeys(value, keys) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) && Object.keys(value).length === keys.length && keys.every((key) => Object.hasOwn(value, key));
+}
+function absolutePath2(value) {
+  return typeof value === "string" && value.length > 0 && value.length <= 32768 && !/[\x00-\x1f\x7f]/.test(value) && isAbsolute4(value) && resolve7(value) === value;
+}
+function absoluteInput(value) {
+  return value.length > 0 && value.length <= 32768 && !/[\x00-\x1f\x7f]/.test(value) && isAbsolute4(value);
+}
+function resolveSumiPathsCommand(pathValue) {
+  if (!pathValue)
+    return null;
+  for (const directory of pathValue.split(delimiter)) {
+    if (!directory || /[\x00-\x1f\x7f]/.test(directory))
+      continue;
+    const candidate = resolve7(directory, "sumi-paths");
+    try {
+      accessSync(candidate, constants4.X_OK);
+      if (statSync2(candidate).isFile())
+        return candidate;
+    } catch {}
+  }
+  return null;
+}
+function validPathPlan(value, home, cwd) {
+  if (!recordWithKeys(value, ["schemaVersion", "kind", "home", "cwd", "roots", "legacyRoots", "configFiles", "skillRoots"]))
+    return false;
+  if (value.schemaVersion !== 1 || value.kind !== "sumi-paths" || value.home !== resolve7(home) || value.cwd !== resolve7(cwd))
+    return false;
+  if (!recordWithKeys(value.roots, SUMI_PATH_KEYS) || !recordWithKeys(value.legacyRoots, SUMI_PATH_KEYS))
+    return false;
+  for (const key of SUMI_PATH_KEYS) {
+    if (!absolutePath2(value.roots[key]))
+      return false;
+    if (value.legacyRoots[key] !== null && !absolutePath2(value.legacyRoots[key]))
+      return false;
+  }
+  if (!recordWithKeys(value.configFiles, ["canonical", "legacy"]) || !recordWithKeys(value.skillRoots, ["canonical", "legacy"]))
+    return false;
+  if (!absolutePath2(value.configFiles.canonical) || !absolutePath2(value.skillRoots.canonical))
+    return false;
+  if (value.configFiles.legacy !== null && !absolutePath2(value.configFiles.legacy))
+    return false;
+  if (value.skillRoots.legacy !== null && !absolutePath2(value.skillRoots.legacy))
+    return false;
+  const configRoot = value.roots.config;
+  const legacyConfigRoot = value.legacyRoots.config;
+  if (typeof configRoot !== "string" || legacyConfigRoot !== null && typeof legacyConfigRoot !== "string")
+    return false;
+  if (value.configFiles.canonical !== join8(configRoot, "sumi.json") || value.skillRoots.canonical !== join8(configRoot, "skills"))
+    return false;
+  if (legacyConfigRoot === null)
+    return value.configFiles.legacy === null && value.skillRoots.legacy === null;
+  return value.configFiles.legacy === join8(legacyConfigRoot, "sumi.json") && value.skillRoots.legacy === join8(legacyConfigRoot, "skills");
+}
+function sumiPathPlan(home, cwd = process.cwd(), env = process.env) {
+  for (const key of ["SUMI_CONFIG", "SUMI_CONFIG_CONTENT"])
+    if (env[key] !== undefined)
+      throw new SumiPathResolverError("SUMI_PATH_CONFIG_UNSUPPORTED");
+  if (!absoluteInput(home) || !absoluteInput(cwd))
+    throw new SumiPathResolverError("SUMI_PATH_INPUT_REFUSED");
+  const runtimePath = process.env.PATH ?? "";
+  const executable = resolveSumiPathsCommand(runtimePath);
+  if (!executable || !isAbsolute4(executable))
+    throw new SumiPathResolverError("SUMI_PATH_RESOLVER_UNAVAILABLE");
+  const childEnv = { PATH: runtimePath };
+  for (const key of SUMI_PATH_SELECTORS)
+    if (env[key] !== undefined)
+      childEnv[key] = env[key];
+  let child2;
+  try {
+    child2 = spawnSync2(executable, ["--json", "--home", resolve7(home), "--cwd", resolve7(cwd)], {
+      cwd: resolve7(cwd),
+      env: childEnv,
+      encoding: "buffer",
+      timeout: 3000,
+      maxBuffer: SUMI_PATH_OUTPUT_LIMIT,
+      shell: false
+    });
+  } catch {
+    throw new SumiPathResolverError("SUMI_PATH_RESOLVER_UNAVAILABLE");
+  }
+  const stdoutBytes = child2.stdout === null ? 0 : Buffer.byteLength(child2.stdout);
+  const stderrBytes = child2.stderr === null ? 0 : Buffer.byteLength(child2.stderr);
+  if (child2.error || child2.signal || !child2.stdout || stdoutBytes > SUMI_PATH_OUTPUT_LIMIT || stderrBytes > 0) {
+    throw new SumiPathResolverError("SUMI_PATH_RESOLVER_UNAVAILABLE");
+  }
+  let result;
+  try {
+    result = JSON.parse(child2.stdout.toString("utf8"));
+  } catch {
+    throw new SumiPathResolverError("SUMI_PATH_RESOLVER_INVALID_RESPONSE");
+  }
+  if (recordWithKeys(result, ["schemaVersion", "kind", "code"]) && result.schemaVersion === 1 && result.kind === "sumi-paths-error" && (result.code === "SUMI_PATH_INPUT_REFUSED" || result.code === "SUMI_PATH_CONFIG_UNSUPPORTED") && child2.status === 2) {
+    throw new SumiPathResolverError(result.code);
+  }
+  if (child2.status !== 0 || !validPathPlan(result, home, cwd))
+    throw new SumiPathResolverError("SUMI_PATH_RESOLVER_INVALID_RESPONSE");
+  return result;
+}
+function selectedConfigDirectory(plan) {
+  const canonical3 = plan.roots.config, legacy = plan.legacyRoots.config;
+  if (legacy === null)
+    return existsSync4(canonical3) ? realpathSync(canonical3) : canonical3;
+  const canonicalStat = lstatSync5(canonical3, { throwIfNoEntry: false }), legacyStat = lstatSync5(legacy, { throwIfNoEntry: false });
+  if (canonicalStat && legacyStat && realpathSync(canonical3) !== realpathSync(legacy))
+    throw new Error("Sumi config roots conflict; complete native home adoption before Skills integration");
+  const selected = canonicalStat ? canonical3 : legacyStat ? legacy : canonical3;
+  if (!existsSync4(selected))
+    return selected;
+  const physical = realpathSync(selected);
+  if ((canonicalStat?.isSymbolicLink() || legacyStat?.isSymbolicLink()) && ![canonical3, legacy].includes(physical))
+    throw new Error("Sumi config alias must resolve to its canonical or legacy root");
+  return physical;
+}
+function sumiConfigDirectory(home, env = process.env, cwd = process.cwd()) {
+  return selectedConfigDirectory(sumiPathPlan(home, cwd, env));
+}
+function sumiSkillRoots(home, cwd = process.cwd(), env = process.env) {
+  const plan = sumiPathPlan(home, cwd, env);
+  return [join8(selectedConfigDirectory(plan), "skills")];
+}
+function sumiBridgeRoot(home, cwd = process.cwd(), env = process.env) {
+  return sumiSkillRoots(home, cwd, env)[0];
+}
+function sumiConfigPath(home, cwd = process.cwd(), env = process.env) {
+  return join8(sumiConfigDirectory(home, env, cwd), "sumi.json");
+}
+function renderSumiPlugin(command, profile) {
+  return renderSumiPluginVersion(command, profile, false);
+}
+function isManagedSumiPlugin(text2, command, profile) {
+  return text2 === renderSumiPlugin(command, profile) || text2 === renderSumiPluginVersion(command, profile, true);
+}
+function renderSumiPluginVersion(command, profile, legacy) {
+  const failure = (message) => legacy ? `new Error(${JSON.stringify(message)})` : "refusal()";
+  return `// Managed by @hasna/skills. Regenerate with skills hook install --agent sumi.
+import { spawn } from "node:child_process";
+const command = ${JSON.stringify(command)};
+const profile = ${JSON.stringify(profile)};
+${legacy ? "" : `function refusal() {
+  const error = new Error("Skills verification blocked this request. Review the Sumi Skills hook configuration, then retry.");
+  error.name = "SkillsHookRefusal";
+  error.skillsHookRefusal = { version: 1, code: "SKILLS_HOOK_REFUSED" };
+  return error;
+}
+`}function context(input) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, ["hook", "user-prompt", "--agent", "sumi", "--selection-profile", profile], { cwd: input.cwd, stdio: ["pipe", "pipe", "pipe"] });
+    const chunks = []; let bytes = 0, failure;
+    const timer = setTimeout(() => { failure = ${failure("Skills prompt hook timed out")}; child.kill("SIGKILL"); }, 15000);
+    child.stdout.on("data", chunk => { bytes += chunk.length; if (bytes > 1048576) { failure = ${failure("Skills prompt hook output exceeded its limit")}; child.kill("SIGKILL"); } else chunks.push(chunk); });
+    child.stderr.on("data", () => {});
+    child.stdin.on("error", () => {});
+    child.on("error", error => { clearTimeout(timer); reject(${legacy ? "error" : "refusal()"}); });
+    child.on("close", code => {
+      clearTimeout(timer);
+      if (failure || code !== 0) return reject(failure ?? ${failure("Skills prompt hook failed")});
+      try {
+        const result = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+        if (!result || typeof result !== "object" || Array.isArray(result)) throw ${failure("Invalid Skills hook response")};
+        if (result.decision === "block" || result.continue === false) throw ${failure("Skills prompt hook refused")};
+        if (Object.keys(result).length && (!result.hookSpecificOutput || result.hookSpecificOutput.hookEventName !== input.hook_event_name)) throw ${failure("Invalid Skills hook response")};
+        const text = result.hookSpecificOutput?.additionalContext ?? "";
+        if (typeof text !== "string") throw ${failure("Invalid Skills prompt context")};
+        resolve(text);
+      } catch (error) { reject(${legacy ? "error" : "refusal()"}); }
+    });
+    child.stdin.end(JSON.stringify(input));
+  });
+}
+export default {
+  id: "local.hasna-skills-cli",
+  async setup(ctx) {
+    if (!ctx?.session?.hook || !ctx?.session?.get || !ctx?.skill?.transform || !ctx?.tool?.hook) throw ${failure("Unsupported Sumi native Skills contract")};
+    const registrations = [];
+    const sessions = new Set();
+    async function input(sessionID, prompt, first) {
+      // The Promise adapter unwraps single-data endpoint responses.
+      ${legacy ? "const session = await ctx.session.get({ sessionID });" : `let session;
+      try { session = await ctx.session.get({ sessionID }); } catch { throw refusal(); }`}
+      if (!session || session.id !== sessionID || typeof session.location?.directory !== "string" || (session.parentID !== undefined && typeof session.parentID !== "string") || session.parentID === sessionID) throw ${failure("Invalid Sumi session custody")};
+      return { hook_event_name: first ? session.parentID ? "SubagentStart" : "SessionStart" : "UserPromptSubmit", cwd: session.location.directory, session_id: sessionID, parent_session_id: session.parentID ?? null, prompt, restore: true };
+    }
+    registrations.push(await ctx.skill.transform(editor => {
+      for (const skill of editor.list()) if (skill.id !== "skills-cli" || skill.name !== "skills-cli") editor.remove(skill.id);
+    }));
+    // Native config transforms may add skills after this transform. Guard
+    // both direct tool calls and prompt attachments at the consumption edge.
+    registrations.push(await ctx.tool.hook("execute.before", event => {
+      if (event.tool === "skill" && event.input?.id !== "skills-cli") throw ${failure("Native Sumi skill payload refused; use Skills CLI")};
+    }));
+    registrations.push(await ctx.session.hook("prompt", async event => {
+      if (typeof event.prompt?.text !== "string") throw ${failure("Invalid Sumi prompt")};
+      if (event.prompt.skills !== undefined && (!Array.isArray(event.prompt.skills) || event.prompt.skills.some(skill => skill?.id !== "skills-cli"))) throw ${failure("Native Sumi skill attachment refused; use Skills CLI")};
+      await context(await input(event.sessionID, event.prompt.text, !sessions.has(event.sessionID)));
+      sessions.add(event.sessionID);
+    }));
+    registrations.push(await ctx.session.hook("context", async event => {
+      const last = event.messages.findLast(message => message.role === "user");
+      const prompt = (last?.content ?? []).filter(part => part.type === "text").map(part => part.text).join("\\n");
+      // Recheck on every primary request, including resumed and synthetic
+      // sessions. The CLI owns optional failures versus explicit refusals.
+      const text = await context(await input(event.sessionID, prompt, !sessions.has(event.sessionID)));
+      if (text) event.system.push({ type: "text", text });
+      sessions.add(event.sessionID);
+    }));
+    return async () => { for (const registration of registrations) await registration.dispose(); };
+  },
+};
+`;
+}
+var SUMI_SKILL_PERMISSIONS = [
+  { action: "skill", resource: "*", effect: "deny" },
+  { action: "skill", resource: "skills-cli", effect: "allow" }
+];
+
+// src/runtime-prerequisites.ts
+var RUNTIME_PREREQUISITES_SCHEMA = "skills.runtime-prerequisites.v1";
+var RUNTIME_PREREQUISITE_CODES = [
+  "RUNTIME_CONSUMER_DISCOVERY_REFUSED",
+  "RUNTIME_PREREQUISITE_INPUT_REFUSED",
+  "SUMI_PATH_INPUT_REFUSED",
+  "SUMI_PATH_CONFIG_UNSUPPORTED",
+  "SUMI_PATH_RESOLVER_UNAVAILABLE",
+  "SUMI_PATH_RESOLVER_INVALID_RESPONSE",
+  "SUMI_PATH_DISCOVERY_REFUSED"
+];
+function runtimePrerequisites(home, cwd) {
+  const result = {
+    schema: RUNTIME_PREREQUISITES_SCHEMA,
+    targetVersion: version,
+    ok: false,
+    checked: [],
+    code: null
+  };
+  if (!isAbsolute5(home) || !isAbsolute5(cwd))
+    return { ...result, code: "RUNTIME_PREREQUISITE_INPUT_REFUSED" };
+  let agents;
+  try {
+    agents = detectedIntegrationAgents({ home, cwd, allowEmpty: true });
+  } catch {
+    return { ...result, code: "RUNTIME_CONSUMER_DISCOVERY_REFUSED" };
+  }
+  if (agents.includes("sumi")) {
+    try {
+      sumiConfigDirectory(home, process.env, cwd);
+      result.checked.push("sumi-paths");
+    } catch (error) {
+      const code = error instanceof SumiPathResolverError && RUNTIME_PREREQUISITE_CODES.includes(error.code) ? error.code : "SUMI_PATH_DISCOVERY_REFUSED";
+      return { ...result, code };
+    }
+  }
+  return { ...result, ok: true };
+}
+if (import.meta.main) {
+  const [home, cwd, ...extra] = process.argv.slice(2);
+  const result = !home || !cwd || extra.length ? { schema: RUNTIME_PREREQUISITES_SCHEMA, targetVersion: version, ok: false, checked: [], code: "RUNTIME_PREREQUISITE_INPUT_REFUSED" } : runtimePrerequisites(home, cwd);
+  process.stdout.write(`${JSON.stringify(result)}
+`);
+  process.exitCode = result.ok ? 0 : 2;
+}
+export {
+  runtimePrerequisites,
+  RUNTIME_PREREQUISITE_CODES,
+  RUNTIME_PREREQUISITES_SCHEMA
+};