@hasna/skills 0.8.10 → 0.8.11

package/bin/index.js

@@ -36868,7 +36868,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@hasna/skills",
-    version: "0.8.10",
+    version: "0.8.11",
     description: "Skills library for AI coding agents",
     type: "module",
     bin: {
@@ -36930,10 +36930,11 @@ var init_package = __esm(() => {
       typecheck: "tsc --noEmit",
       "verify:release": "bun run scripts/release-guard.ts",
       "verify:consumer-types": "bun run scripts/consumer-types.ts",
-      prepare: "bun run build:js",
-      prepack: "bun run build && bun run verify:release && bun run verify:consumer-types",
+      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: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",
@@ -36955,7 +36956,6 @@ var init_package = __esm(() => {
     license: "Apache-2.0",
     devDependencies: {
       "@hasna/contracts": "1.1.0",
-      "@hasna/secrets": "0.4.2",
       "@types/bun": "1.3.14",
       "@types/node": "25.2.3",
       "@types/react": "^18.2.0",
@@ -36968,6 +36968,7 @@ var init_package = __esm(() => {
       "@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",
@@ -42784,14 +42785,15 @@ function profileSelectionSnapshot(selections) {
 var MAX_PROFILE_SELECTIONS = 4096, MAX_PROFILE_DOCUMENT_BYTES, MAX_SKILL_SESSION_ID_CHARS = 256, PROFILE_SESSION_ENVELOPE_BYTES, MAX_RESOLVED_PROFILE_BYTES, LEGACY_PROFILE_SELECTIONS = 256, LEGACY_PROFILE_DOCUMENT_BYTES = 1e6;
 var init_profile_limits = __esm(() => {
   MAX_PROFILE_DOCUMENT_BYTES = 8 * 1024 * 1024;
-  PROFILE_SESSION_ENVELOPE_BYTES = MAX_PROFILE_SELECTIONS * 67 + MAX_SKILL_SESSION_ID_CHARS * 6 + 256;
+  PROFILE_SESSION_ENVELOPE_BYTES = MAX_PROFILE_SELECTIONS * 67 + MAX_SKILL_SESSION_ID_CHARS * 12 + 512;
   MAX_RESOLVED_PROFILE_BYTES = MAX_PROFILE_DOCUMENT_BYTES - PROFILE_SESSION_ENVELOPE_BYTES;
 });
 
 // src/lib/selection-cache.ts
 import { createHash as createHash3, randomUUID as randomUUID3 } from "crypto";
-import { closeSync, constants as constants2, fstatSync, lstatSync as lstatSync3, mkdirSync as mkdirSync4, openSync, readSync, renameSync as renameSync2, unlinkSync, writeFileSync as writeFileSync4 } from "fs";
+import { closeSync, constants as constants2, fstatSync, fsyncSync, lstatSync as lstatSync3, mkdirSync as mkdirSync4, openSync, readSync, renameSync as renameSync2, unlinkSync, writeFileSync as writeFileSync4 } from "fs";
 import { dirname as dirname4, join as join14, parse, resolve as resolve4 } from "path";
+import { isDeepStrictEqual as isDeepStrictEqual2 } from "util";
 function selectionCacheRoot(options = {}) {
   return resolve4(options.cacheDir ?? join14(getDataDirReadOnly(), "selection-cache"));
 }
@@ -42895,12 +42897,21 @@ function writeSelectionJson(path, value) {
     throw new SkillSelectionError("RECEIPT_TOO_LARGE", "The Skills selection receipt exceeds its size limit.");
   atomicWrite(path, bytes, 384);
 }
-function atomicWrite(path, bytes, mode) {
+function atomicWrite(path, bytes, mode, durable = false) {
   assertRegularPath(path, true);
   const temporary = join14(dirname4(path), `.selection-${randomUUID3()}.tmp`);
   try {
-    writeFileSync4(temporary, bytes, { flag: "wx", mode });
+    const fd = openSync(temporary, constants2.O_WRONLY | constants2.O_CREAT | constants2.O_EXCL | constants2.O_NOFOLLOW, mode);
+    try {
+      writeFileSync4(fd, bytes);
+      if (durable)
+        fsyncSync(fd);
+    } finally {
+      closeSync(fd);
+    }
     renameSync2(temporary, path);
+    if (durable)
+      syncDirectory(dirname4(path));
   } finally {
     try {
       unlinkSync(temporary);
@@ -43019,16 +43030,190 @@ function sessionReceiptPath(sessionId, options = {}) {
     throw new SkillSelectionError("INVALID_SESSION", `A Skills session id must contain 1\u2013${MAX_SKILL_SESSION_ID_CHARS} characters.`);
   return join14(selectionCacheRoot(options), "sessions", `${hash(sessionId)}.json`);
 }
-function readSkillSession(sessionId, options = {}) {
-  const receipt = readSelectionJson(sessionReceiptPath(sessionId, options));
-  if (receipt) {
-    validateSelectionReceipt(receipt);
-    const keys2 = new Set(receipt.profile.selections.map(selectionKey));
-    if (receipt.sessionId !== sessionId || !Array.isArray(receipt.loaded) || receipt.loaded.length > keys2.size || new Set(receipt.loaded).size !== receipt.loaded.length || !receipt.loaded.every((key) => keys2.has(key))) {
-      throw new SkillSelectionError("INVALID_RECEIPT", "The Skills session receipt is invalid.");
+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 keys2 = new Set(receipt.profile.selections.map(selectionKey));
+  if (receipt.sessionId !== sessionId || !Array.isArray(receipt.loaded) || receipt.loaded.length > keys2.size || new Set(receipt.loaded).size !== receipt.loaded.length || !receipt.loaded.every((key) => keys2.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 };
+}
+function withSessionWriteLocks(sessionIds, options, action) {
+  const operationId = randomUUID3();
+  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 = lstatSync3(lock.path, { throwIfNoEntry: false });
+      if (!current?.isFile() || current.dev !== lock.dev || current.ino !== lock.ino) {
+        throw new SkillSelectionError("SESSION_WRITE_LOCK_CHANGED", "A session write lock changed during the operation; no replacement is permitted.");
+      }
+    }
+  };
+  try {
+    for (const lock of locks) {
+      assertRegularPath(lock.path, true);
+      let fd;
+      try {
+        fd = openSync(lock.path, constants2.O_WRONLY | constants2.O_CREAT | constants2.O_EXCL | constants2.O_NOFOLLOW, 384);
+      } catch (error) {
+        if (error.code === "EEXIST")
+          throw new SkillSelectionError("SESSION_WRITE_LOCKED", "Another Skills process owns a required session write lock; retry after it completes. A surviving lock requires explicit recovery review.");
+        throw error;
+      }
+      const stat = fstatSync(fd);
+      owned.push({ path: lock.path, fd, dev: stat.dev, ino: stat.ino });
+      writeFileSync4(fd, `${JSON.stringify({ schemaVersion: 1, operationId, sessionId: lock.sessionId, pid: process.pid })}
+`);
+    }
+    return action(assertOwned);
+  } finally {
+    for (const lock of owned.reverse()) {
+      closeSync(lock.fd);
+      const current = lstatSync3(lock.path, { throwIfNoEntry: false });
+      if (current?.isFile() && current.dev === lock.dev && current.ino === lock.ino)
+        unlinkSync(lock.path);
     }
   }
-  return receipt;
+}
+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 && !isDeepStrictEqual2(current.receipt.profile, receipt.profile)) {
+      throw new SkillSelectionError("SESSION_RECEIPT_CHANGED", "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 || !isDeepStrictEqual2(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, constants2.O_RDONLY | constants2.O_DIRECTORY | constants2.O_NOFOLLOW);
+  try {
+    fsyncSync(fd);
+  } finally {
+    closeSync(fd);
+  }
+}
+function archiveBytes(path, bytes) {
+  assertRegularPath(path, true);
+  const fd = openSync(path, constants2.O_WRONLY | constants2.O_CREAT | constants2.O_EXCL | constants2.O_NOFOLLOW, 384);
+  try {
+    writeFileSync4(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 before2 = readSkillSessionSnapshot(replacement.sessionId, options);
+    if (!sameSnapshot(before2, 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(before2.generation))
+      throw new SkillSelectionError("SESSION_GENERATION_CHANGED", "The replacement Skills session must advance exactly one generation.");
+    if (before2.receipt.profile.authority !== replacement.profile.authority || before2.receipt.profile.workspaceId !== replacement.profile.workspaceId) {
+      throw new SkillSelectionError("PROFILE_IDENTITY_MISMATCH", "A session reconciliation cannot change its Skills authority or workspace.");
+    }
+    const directory = join14(selectionCacheRoot(options), "session-reconciliations", randomUUID3());
+    const archivePath = join14(directory, "original.json"), replacementPath = join14(directory, "replacement.json"), receiptPath = join14(directory, "receipt.json");
+    const afterSha256 = sha256Hex(bytes);
+    archiveBytes(archivePath, before2.bytes);
+    archiveBytes(replacementPath, bytes);
+    const receipt = { schemaVersion: 1, status: "prepared", sessionId: replacement.sessionId, beforeGeneration: before2.generation, afterGeneration: replacement.generation, beforeSha256: before2.sha256, afterSha256, archivePath, replacementPath, plan };
+    archiveBytes(receiptPath, Buffer.from(`${JSON.stringify(receipt)}
+`));
+    syncDirectory(directory);
+    syncDirectory(dirname4(directory));
+    syncDirectory(selectionCacheRoot(options));
+    if (sha256Hex(readRegularFile(archivePath, MAX_PROFILE_DOCUMENT_BYTES)) !== before2.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(before2.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: before2.sha256, afterSha256 };
+  });
 }
 var SkillSelectionError, MAX_CACHED_PROFILE_AGE_MS, SELECTION_LOCK_FILE = "selection.lock.json";
 var init_selection_cache = __esm(() => {
@@ -43048,6 +43233,7 @@ var init_selection_cache = __esm(() => {
 });
 
 // src/lib/agent-policy-limits.ts
+import { basename as basename3, isAbsolute as isAbsolute3, resolve as resolve5 } from "path";
 function object(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
@@ -43112,7 +43298,9 @@ function assertAgentPolicyCollections(policy) {
       text(source.path);
       requireBound(source.sha256 === null || typeof source.sha256 === "string" && /^[a-f0-9]{64}$/.test(source.sha256));
       if (source.hashMode !== undefined)
-        requireBound(["bytes", "path-bytes", "claude-plugin-registry"].includes(source.hashMode) && source.format === undefined && source.fields === undefined && (source.hashMode === "bytes" || source.sha256 !== null));
+        requireBound(["bytes", "path-bytes", "claude-plugin-registry", "claude-marketplace-registry"].includes(source.hashMode) && source.format === undefined && source.fields === undefined && (source.hashMode === "bytes" || source.sha256 !== null));
+      if (source.hashMode === "claude-marketplace-registry")
+        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-plugin-registry") {
         requireBound(agent === "claude");
         const managed = array(source.managedPlugins, 64);
@@ -50265,7 +50453,7 @@ var init_dist = __esm(() => {
 });
 
 // src/lib/agent-hermes.ts
-import { dirname as dirname5, isAbsolute as isAbsolute3, join as join17, resolve as resolve5 } from "path";
+import { dirname as dirname5, isAbsolute as isAbsolute4, join as join17, resolve as resolve6 } from "path";
 import { lstatSync as lstatSync6, readFileSync as readFileSync10, opendirSync } from "fs";
 function object2(value) {
   return Boolean(value && typeof value === "object" && (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null));
@@ -50301,7 +50489,7 @@ function quoted(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
 }
 function hermesHookDefinitions(supervisor) {
-  if (!isAbsolute3(supervisor.runtime) || !isAbsolute3(supervisor.path))
+  if (!isAbsolute4(supervisor.runtime) || !isAbsolute4(supervisor.path))
     throw new Error("Expected absolute Hermes supervisor paths");
   const entry = (event) => ({ command: `${quoted(supervisor.runtime)} ${quoted(supervisor.path)} --event ${event}`, timeout: 15, ...event === "pre_tool_call" ? { fail_closed: true } : {} });
   return { pre_llm_call: entry("pre_llm_call"), pre_tool_call: entry("pre_tool_call") };
@@ -50337,7 +50525,7 @@ function assertHermesEnvironment(home) {
       throw new Error(`NATIVE_SKILL_DRIFT: Hermes ${variable} requires a dedicated discovery adapter; unset it before using this adapter`);
   }
   const selected = process.env.HERMES_HOME?.trim();
-  if (selected && (!isAbsolute3(selected) || resolve5(selected) !== join17(resolve5(home), ".hermes")))
+  if (selected && (!isAbsolute4(selected) || resolve6(selected) !== join17(resolve6(home), ".hermes")))
     throw new Error("NATIVE_SKILL_DRIFT: custom Hermes homes/profiles require their own reviewed bridge");
   if (process.env.HERMES_ENABLE_PROJECT_PLUGINS?.trim() && !["0", "false", "no", "off"].includes(process.env.HERMES_ENABLE_PROJECT_PLUGINS.trim().toLowerCase()))
     throw new Error("NATIVE_SKILL_DRIFT: Hermes project plugins require a dedicated discovery review");
@@ -50360,7 +50548,7 @@ function assertHermesProtection(home, config, command, profile, supervisor) {
   assertHermesEnvironment(home);
   if (read(join17(home, ".hermes", HERMES_OPT_OUT)) === null)
     throw new Error("NATIVE_SKILL_DRIFT: Hermes bundled skill reseeding is not disabled; run skills hook install");
-  if (!supervisor || !isAbsolute3(supervisor.path) || supervisor.runtime !== process.execPath || read(supervisor.path) !== renderHermesSupervisor(command, profile))
+  if (!supervisor || !isAbsolute4(supervisor.path) || supervisor.runtime !== process.execPath || read(supervisor.path) !== renderHermesSupervisor(command, profile))
     throw new Error("NATIVE_SKILL_DRIFT: Hermes owned supervisor changed; run skills hook install");
   const raw = read(join17(home, ".hermes/shell-hooks-allowlist.json"));
   let trust;
@@ -50386,7 +50574,7 @@ function assertHermesProtection(home, config, command, profile, supervisor) {
 }
 function assertNoHermesLegacyShadow(root) {
   let entries = 0;
-  for (let cursor = resolve5(root);; cursor = dirname5(cursor)) {
+  for (let cursor = resolve6(root);; cursor = dirname5(cursor)) {
     if (lstatSync6(cursor, { throwIfNoEntry: false })?.isSymbolicLink())
       throw new Error("NATIVE_SKILL_DRIFT: symlink Hermes legacy discovery root");
     if (dirname5(cursor) === cursor)
@@ -50490,13 +50678,13 @@ var init_agent_hermes = __esm(() => {
 // src/lib/agent-discovery-directories.ts
 import { createHash as createHash5 } from "crypto";
 import { lstatSync as lstatSync7, opendirSync as opendirSync2 } from "fs";
-import { dirname as dirname6, isAbsolute as isAbsolute4, join as join18, resolve as resolve6 } from "path";
+import { dirname as dirname6, isAbsolute as isAbsolute5, join as join18, resolve as resolve7 } from "path";
 function need(value, message) {
   if (!value)
     throw new Error(message);
 }
 function safe(path) {
-  need(typeof path === "string" && path.length <= AGENT_POLICY_LIMITS.pathCharacters && isAbsolute4(path) && resolve6(path) === path && !path.includes("\x00"), "Expected a canonical absolute discovery directory path");
+  need(typeof path === "string" && path.length <= AGENT_POLICY_LIMITS.pathCharacters && isAbsolute5(path) && resolve7(path) === path && !path.includes("\x00"), "Expected a canonical absolute discovery directory path");
   for (let cursor = path;; cursor = dirname6(cursor)) {
     need(!lstatSync7(cursor, { throwIfNoEntry: false })?.isSymbolicLink(), "Refusing symlink native discovery directory");
     if (dirname6(cursor) === cursor)
@@ -50564,12 +50752,12 @@ var init_agent_discovery_directories = __esm(() => {
 // src/lib/agent-discovery-bytes.ts
 import { createHash as createHash6 } from "crypto";
 import { closeSync as closeSync3, constants as constants4, fstatSync as fstatSync3, lstatSync as lstatSync8, openSync as openSync3, readSync as readSync3 } from "fs";
-import { dirname as dirname7, isAbsolute as isAbsolute5, resolve as resolve7 } from "path";
+import { dirname as dirname7, isAbsolute as isAbsolute6, resolve as resolve8 } from "path";
 function discoveryByteBudget() {
   return { remaining: AGENT_POLICY_LIMITS.discoveryRawTotalBytes };
 }
 function safe2(path) {
-  if (typeof path !== "string" || !isAbsolute5(path) || path !== resolve7(path) || path.length > AGENT_POLICY_LIMITS.pathCharacters || path.includes("\x00"))
+  if (typeof path !== "string" || !isAbsolute6(path) || path !== resolve8(path) || path.length > AGENT_POLICY_LIMITS.pathCharacters || path.includes("\x00"))
     throw new Error("Expected a canonical absolute raw discovery path");
   for (let cursor = path;; cursor = dirname7(cursor)) {
     if (lstatSync8(cursor, { throwIfNoEntry: false })?.isSymbolicLink())
@@ -50635,7 +50823,7 @@ var init_agent_discovery_bytes = __esm(() => {
 // src/lib/agent-discovery-path-bytes.ts
 import { createHash as createHash7 } from "crypto";
 import { lstatSync as lstatSync9, readlinkSync } from "fs";
-import { dirname as dirname8, isAbsolute as isAbsolute6, join as join19, parse as parse2, resolve as resolve8, sep as sep3 } from "path";
+import { dirname as dirname8, isAbsolute as isAbsolute7, join as join19, parse as parse2, resolve as resolve9, sep as sep3 } from "path";
 function identity3(stat, mutable = false) {
   return {
     dev: String(stat.dev),
@@ -50647,7 +50835,7 @@ function identity3(stat, mutable = false) {
   };
 }
 function canonical(path) {
-  if (typeof path !== "string" || !isAbsolute6(path) || path !== resolve8(path) || path.length > AGENT_POLICY_LIMITS.pathCharacters || path.includes("\x00") || Buffer.from(path).toString("utf8") !== path)
+  if (typeof path !== "string" || !isAbsolute7(path) || path !== resolve9(path) || path.length > AGENT_POLICY_LIMITS.pathCharacters || path.includes("\x00") || Buffer.from(path).toString("utf8") !== path)
     throw new Error("Expected a canonical absolute discovery path");
 }
 function trace(path) {
@@ -50696,11 +50884,11 @@ function trace(path) {
       if (!target || target.includes("\x00") || Buffer.byteLength(target) > AGENT_POLICY_LIMITS.pathCharacters || !after2.isSymbolicLink() || JSON.stringify(identity3(stat, true)) !== JSON.stringify(identity3(after2, true)))
         throw new Error("Discovery link changed during read");
       record2(candidate, { type: "link", target, ...identity3(stat, true) });
-      if (isAbsolute6(target)) {
+      if (isAbsolute7(target)) {
         cursor = parse2(target).root;
         root();
       }
-      const remainder = isAbsolute6(target) ? target.slice(parse2(target).root.length) : target;
+      const remainder = isAbsolute7(target) ? target.slice(parse2(target).root.length) : target;
       pending = [...remainder.split(sep3), ...pending];
       if (pending.length + steps > AGENT_POLICY_LIMITS.discoveryPathSteps)
         throw new Error("Discovery path step limit exceeded");
@@ -50756,12 +50944,12 @@ import { spawnSync } from "child_process";
 import { closeSync as closeSync22, fstatSync as fstatSync22, openSync as openSync22, readFileSync as readFileSync22 } from "fs";
 import { O_NOFOLLOW as O_NOFOLLOW2, O_NONBLOCK as O_NONBLOCK2, O_RDONLY as O_RDONLY2 } from "constants";
 import { hostname as osHostname } from "os";
-import { isAbsolute as isAbsolute7, join as join22 } from "path";
+import { isAbsolute as isAbsolute8, join as join22 } from "path";
 import { createRequire } from "module";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { closeSync as closeSync4, fstatSync as fstatSync4, lstatSync as lstatSync10, openSync as openSync4, readFileSync as readFileSync11, realpathSync as realpathSync3, statSync as statSync7 } from "fs";
 import { O_NOFOLLOW, O_NONBLOCK, O_RDONLY } from "constants";
-import { basename as basename3, dirname as dirname9, join as join20, relative as relative4, sep as sep4 } from "path";
+import { basename as basename4, dirname as dirname9, join as join20, relative as relative4, sep as sep4 } from "path";
 import { fileURLToPath, pathToFileURL } from "url";
 function envToken(name) {
   return name.toUpperCase().replace(/-/g, "_");
@@ -50866,7 +51054,7 @@ function entryPoint(directory) {
 function resolveInstalledSecrets(parentUrl) {
   let directory = dirname9(fileURLToPath(parentUrl));
   for (;; ) {
-    if (basename3(directory) !== "node_modules") {
+    if (basename4(directory) !== "node_modules") {
       const candidate = join20(directory, "node_modules", PACKAGE);
       let absent = false;
       try {
@@ -50891,7 +51079,7 @@ function homeDir(env3) {
 }
 function absoluteOverride(env3, key) {
   const value = env3[key]?.trim();
-  return value && isAbsolute7(value) ? value : null;
+  return value && isAbsolute8(value) ? value : null;
 }
 function hasnaHomeDir(env3) {
   const override = absoluteOverride(env3, HASNA_HOME_ENV_KEY);
@@ -51709,6 +51897,7 @@ __export(exports_fleet_credentials, {
   SKILLS_API_URL_ENV: () => SKILLS_API_URL_ENV,
   SKILLS_API_KEY_ENV_KEYS: () => SKILLS_API_KEY_ENV_KEYS,
   SKILLS_API_KEY_ENV: () => SKILLS_API_KEY_ENV,
+  REDACTED_VAULT_REFERENCE: () => REDACTED_VAULT_REFERENCE,
   MissingSkillsFleetError: () => MissingSkillsFleetError
 });
 function isCredentialResolutionError(error) {
@@ -51717,10 +51906,15 @@ function isCredentialResolutionError(error) {
 function isSkillsFleetCredentialError(error) {
   return error instanceof SkillsFleetCredentialError || typeof error === "object" && error !== null && error.name === "SkillsFleetCredentialError";
 }
-function asSkillsFleetCredentialError(error) {
+function redactVaultReference(message, vaultReference) {
+  if (!vaultReference)
+    return message;
+  return message.split(vaultReference).join(REDACTED_VAULT_REFERENCE);
+}
+function asSkillsFleetCredentialError(error, vaultReference) {
   if (!isCredentialResolutionError(error))
     return null;
-  return new SkillsFleetCredentialError(error.message, "MISSING_API_CREDENTIAL");
+  return new SkillsFleetCredentialError(redactVaultReference(error.message, vaultReference), "MISSING_API_CREDENTIAL");
 }
 function normalizeSkillsApiOrigin(apiUrl) {
   const url = new URL(apiUrl);
@@ -51907,7 +52101,7 @@ async function resolveSkillsConnection(env3 = process.env, options = {}) {
   try {
     completed = await completePointerCredential(SKILLS_APP, pointer, env3);
   } catch (error) {
-    const translated = asSkillsFleetCredentialError(error);
+    const translated = asSkillsFleetCredentialError(error, pointer.pointerVaultKey);
     if (translated)
       throw translated;
     throw error;
@@ -51963,7 +52157,7 @@ function requireSkillsFleet(action = "This command", env3 = process.env, options
     return fleet;
   throw new MissingSkillsFleetError(action);
 }
-var SKILLS_APP = "skills", ENV_KEYS, SKILLS_API_URL_ENV_KEYS, SKILLS_API_KEY_ENV_KEYS, SKILLS_API_URL_ENV, SKILLS_API_KEY_ENV, SkillsFleetCredentialError, localNoticePrinted = false, MissingSkillsFleetError;
+var SKILLS_APP = "skills", ENV_KEYS, SKILLS_API_URL_ENV_KEYS, SKILLS_API_KEY_ENV_KEYS, SKILLS_API_URL_ENV, SKILLS_API_KEY_ENV, SkillsFleetCredentialError, REDACTED_VAULT_REFERENCE = "[redacted vault reference]", localNoticePrinted = false, MissingSkillsFleetError;
 var init_fleet_credentials = __esm(() => {
   init_transport();
   init_instance_credentials();
@@ -52909,11 +53103,18 @@ async function syncSelectionProfile(profileId, options = {}) {
   return { profile, receipt, changed, downloaded, stationReported };
 }
 async function resolveSelectionContext(profileId, options = {}) {
-  const session = options.sessionId ? readSkillSession(options.sessionId, options) : null;
-  const parentSession = !session && options.parentSessionId ? readSkillSession(options.parentSessionId, options) : null;
+  const sessionState = options.sessionId ? readSkillSessionSnapshotIfExists(options.sessionId, options) : null;
+  const session = sessionState?.receipt ?? null;
+  const parentState = !session && options.parentSessionId ? readSkillSessionSnapshotIfExists(options.parentSessionId, options) : null;
+  if (!session && options.parentSessionId && !parentState) {
+    throw new SkillSelectionError("SESSION_PARENT_NOT_FOUND", "A child Skills session requires an existing parent receipt so its inherited pin can be bound exactly.");
+  }
+  const parentSession = parentState?.receipt ?? null;
+  const sessionSnapshot = sessionState ? skillSessionSnapshotBinding(sessionState) : null;
+  const parentSnapshot = parentState ? skillSessionSnapshotBinding(parentState) : undefined;
   const project = options.projectDir ? readProjectSelection(options.projectDir) : null;
   if (session && session.profile.profileId !== profileId || parentSession && parentSession.profile.profileId !== profileId || project && project.profile.profileId !== profileId) {
-    throw new SkillSelectionError("PROFILE_LOCK_MISMATCH", "The session or project is pinned to a different Skills profile. Select that profile or explicitly sync the new selection.");
+    throw new SkillSelectionError("PROFILE_LOCK_MISMATCH", "The session or project is pinned to a different Skills profile. Select the pinned profile, or review skills sessions reconcile for an intentional session change and explicit project sync for a project change.");
   }
   if (options.cached) {
     const receipt2 = session ?? parentSession ?? project ?? readSelectionProfile(profileId, options);
@@ -52921,7 +53122,7 @@ async function resolveSelectionContext(profileId, options = {}) {
       throw new SkillSelectionError("CACHED_PROFILE_MISSING", "No verified Skills profile is cached; authenticate and sync it first.");
     assertFreshCachedProfile(receipt2, options);
     assertBinding(receipt2.profile, options);
-    return { receipt: receipt2, session, inheritedLoaded: parentSession?.loaded };
+    return { receipt: receipt2, session, sessionSnapshot, parentSnapshot, inheritedLoaded: parentSession?.loaded };
   }
   const client = options.client ?? await createProfileClient();
   const current = await client.resolveProfile(profileId);
@@ -52934,7 +53135,7 @@ async function resolveSelectionContext(profileId, options = {}) {
     throw new SkillSelectionError("PROFILE_IDENTITY_MISMATCH", "The pinned selection belongs to another Skills authority or workspace.");
   }
   const receipt = locked ?? { schemaVersion: 1, verifiedAt: new Date((options.now ?? Date.now)()).toISOString(), profile: current };
-  return { receipt, session, client, inheritedLoaded: parentSession?.loaded };
+  return { receipt, session, sessionSnapshot, parentSnapshot, client, inheritedLoaded: parentSession?.loaded };
 }
 function assertBinding(profile, options) {
   if (options.authority !== undefined && profile.authority !== options.authority || options.workspaceId !== undefined && profile.workspaceId !== options.workspaceId) {
@@ -52973,7 +53174,7 @@ async function loadSelectedSkill(spec, profileId, options = {}) {
       sessionId: options.sessionId,
       loaded: [...new Set([...context.session?.loaded ?? [], selectionKey(selection)])]
     };
-    writeSelectionJson(sessionReceiptPath(options.sessionId, options), session);
+    writeSkillSession(session, { current: context.sessionSnapshot, parent: context.parentSnapshot }, options);
   }
   return { content, selection, receipt };
 }
@@ -53214,8 +53415,8 @@ var init_plugin_projection = __esm(() => {
 
 // src/lib/plugin-projection-store.ts
 import { createHash as createHash10, randomUUID as randomUUID5 } from "crypto";
-import { constants as constants7, closeSync as closeSync7, fchmodSync, fstatSync as fstatSync7, fsyncSync, linkSync, lstatSync as lstatSync13, mkdirSync as mkdirSync6, openSync as openSync7, opendirSync as opendirSync3, readSync as readSync5, renameSync as renameSync3, rmdirSync as rmdirSync2, rmSync as rmSync2, unlinkSync as unlinkSync3, writeSync as writeSync2 } from "fs";
-import { dirname as dirname10, isAbsolute as isAbsolute8, join as join25, parse as parse4, resolve as resolve9 } from "path";
+import { constants as constants7, closeSync as closeSync7, fchmodSync, fstatSync as fstatSync7, fsyncSync as fsyncSync2, linkSync, lstatSync as lstatSync13, mkdirSync as mkdirSync6, openSync as openSync7, opendirSync as opendirSync3, readSync as readSync5, renameSync as renameSync3, rmdirSync as rmdirSync2, rmSync as rmSync2, unlinkSync as unlinkSync3, writeSync as writeSync2 } from "fs";
+import { dirname as dirname10, isAbsolute as isAbsolute9, join as join25, parse as parse4, resolve as resolve10 } from "path";
 function stat(path) {
   try {
     return lstatSync13(path, { bigint: true });
@@ -53226,7 +53427,7 @@ function stat(path) {
   }
 }
 function canonical2(path) {
-  pluginNeed(typeof path === "string" && path.length <= 8192 && isAbsolute8(path) && resolve9(path) === path && !/[\x00-\x1f\x7f]/.test(path), "Plugin storage paths must be canonical absolute paths");
+  pluginNeed(typeof path === "string" && path.length <= 8192 && isAbsolute9(path) && resolve10(path) === path && !/[\x00-\x1f\x7f]/.test(path), "Plugin storage paths must be canonical absolute paths");
 }
 function owner(stats, system = false) {
   const current = uid();
@@ -53435,7 +53636,7 @@ function writeExclusive(path, bytes, mode) {
       pluginNeed(count > 0, "Plugin file write did not progress");
       offset += count;
     }
-    fsyncSync(fd);
+    fsyncSync2(fd);
   } catch (error) {
     if (created) {
       same3(created, stat(path), true);
@@ -53608,7 +53809,7 @@ var init_selected_manifest = __esm(() => {
 
 // src/lib/plugin-admission.ts
 import { homedir as homedir3 } from "os";
-import { isAbsolute as isAbsolute9, join as join26, resolve as resolve10 } from "path";
+import { isAbsolute as isAbsolute10, join as join26, resolve as resolve11 } from "path";
 function pluginAdmissionRoot() {
   return join26(homedir3(), ".hasna", "skills", "plugin-admission");
 }
@@ -53621,7 +53822,7 @@ function validatePluginTarget(value) {
   for (const registration of value.registrations) {
     pluginKeys(registration, ["scope", "projectPath"]);
     pluginNeed(registration.scope === "user" || registration.scope === "project", "Unsupported plugin registration scope");
-    pluginNeed(registration.scope === "user" ? registration.projectPath === null : typeof registration.projectPath === "string" && isAbsolute9(registration.projectPath) && resolve10(registration.projectPath) === registration.projectPath, "Plugin scope requires its exact project path");
+    pluginNeed(registration.scope === "user" ? registration.projectPath === null : typeof registration.projectPath === "string" && isAbsolute10(registration.projectPath) && resolve11(registration.projectPath) === registration.projectPath, "Plugin scope requires its exact project path");
     const key = JSON.stringify([registration.scope, registration.projectPath]);
     pluginNeed(!scopes.has(key), "Duplicate plugin registration scope");
     scopes.add(key);
@@ -53629,7 +53830,7 @@ function validatePluginTarget(value) {
   for (const key of ["native", "resolver"]) {
     pluginKeys(value[key], key === "native" ? ["version", "executable", "digest"] : ["executable", "digest"]);
     pluginText(value[key].executable);
-    pluginNeed(isAbsolute9(value[key].executable) && resolve10(value[key].executable) === value[key].executable, "Plugin executable must have a canonical absolute path");
+    pluginNeed(isAbsolute10(value[key].executable) && resolve11(value[key].executable) === value[key].executable, "Plugin executable must have a canonical absolute path");
     pluginDigest(value[key].digest);
   }
   pluginNeed(["2.1.274", "2.1.276"].includes(value.native.version), "Plugin admission requires a certified Claude command-source runtime (2.1.274 or 2.1.276)");
@@ -53779,7 +53980,7 @@ function pluginResolverCommand(binding) {
 }
 function root(options) {
   const path = options.storeRoot ?? pluginAdmissionRoot();
-  pluginNeed(isAbsolute9(path) && resolve10(path) === path, "Invalid plugin admission store root");
+  pluginNeed(isAbsolute10(path) && resolve11(path) === path, "Invalid plugin admission store root");
   return path;
 }
 function pluginBindingPath(storeRoot, id) {
@@ -53987,7 +54188,7 @@ var init_plugin_admission = __esm(() => {
 
 // src/lib/plugin-discovery.ts
 import { closeSync as closeSync8, constants as constants8, fstatSync as fstatSync8, lstatSync as lstatSync14, openSync as openSync8, opendirSync as opendirSync4, readSync as readSync6 } from "fs";
-import { basename as basename4, dirname as dirname11, isAbsolute as isAbsolute10, join as join27, resolve as resolve11 } from "path";
+import { basename as basename5, dirname as dirname11, isAbsolute as isAbsolute11, join as join27, resolve as resolve12 } from "path";
 function validateManagedPluginWitnesses(value) {
   pluginNeed(Array.isArray(value) && value.length > 0 && value.length <= PLUGIN_PROJECTION_LIMITS.registrations, "Invalid managed plugin witness collection");
   const seen = new Set;
@@ -53996,12 +54197,12 @@ function validateManagedPluginWitnesses(value) {
     pluginNeed(typeof item.bindingId === "string" && /^[a-f0-9]{64}$/.test(item.bindingId) && !seen.has(item.bindingId), "Invalid or duplicate managed plugin witness");
     seen.add(item.bindingId);
     pluginText(item.storeRoot);
-    pluginNeed(isAbsolute10(item.storeRoot) && resolve11(item.storeRoot) === item.storeRoot, "Invalid plugin receipt store path");
+    pluginNeed(isAbsolute11(item.storeRoot) && resolve12(item.storeRoot) === item.storeRoot, "Invalid plugin receipt store path");
   }
 }
 function safe3(path) {
   pluginText(path);
-  pluginNeed(isAbsolute10(path) && resolve11(path) === path, "Invalid plugin registry path");
+  pluginNeed(isAbsolute11(path) && resolve12(path) === path, "Invalid plugin registry path");
   for (let at2 = path;; at2 = dirname11(at2)) {
     pluginNeed(!lstatSync14(at2, { throwIfNoEntry: false })?.isSymbolicLink(), "Plugin registry path traverses a symlink");
     if (at2 === dirname11(at2))
@@ -54070,7 +54271,7 @@ function hashManagedPluginRegistry(path, managed) {
       pluginNeed(/^(?:[A-Za-z0-9][A-Za-z0-9._+-]*-)?[a-f0-9]{12}$/.test(row.version) && row.installPath === join27(cacheRoot, row.version), "Managed plugin cache path or version is outside its registration");
       const approval = (producer) => {
         pluginText(producer);
-        const digest = `sha256:${basename4(producer)}`;
+        const digest = `sha256:${basename5(producer)}`;
         const receipt2 = readPluginAdmissionReceipt(witness.storeRoot, witness.bindingId, digest);
         pluginNeed(receipt2.materializedPath === producer, "Managed producer path is not an approved immutable projection");
         if (!verified.has(producer)) {
@@ -54133,10 +54334,181 @@ var init_plugin_discovery = __esm(() => {
   init_plugin_projection_store();
 });
 
-// src/lib/agent-discovery.ts
+// src/lib/claude-marketplace-registry.ts
 import { createHash as createHash11 } from "crypto";
-import { lstatSync as lstatSync15, readFileSync as readFileSync14, readdirSync as readdirSync9, realpathSync as realpathSync4 } from "fs";
-import { dirname as dirname12, isAbsolute as isAbsolute11, join as join28, resolve as resolve12, sep as sep5 } from "path";
+import { closeSync as closeSync9, constants as constants9, fstatSync as fstatSync9, lstatSync as lstatSync15, openSync as openSync9, readSync as readSync7 } from "fs";
+import { basename as basename6, dirname as dirname12, isAbsolute as isAbsolute12, resolve as resolve13 } from "path";
+function need2(value, reason) {
+  if (!value)
+    throw new Error(`Claude marketplace registry ${reason}`);
+}
+function absolutePath(value) {
+  need2(typeof value === "string" && value.length > 0 && value.length <= CLAUDE_MARKETPLACE_REGISTRY_LIMITS.pathCharacters && !/[\x00-\x1f\x7f]/.test(value) && isAbsolute12(value) && resolve13(value) === value, "requires a normalized absolute path");
+}
+function parents(path) {
+  const result2 = [];
+  for (let at2 = dirname12(path);; at2 = dirname12(at2)) {
+    const stat2 = lstatSync15(at2, { bigint: true });
+    need2(stat2.isDirectory() && !stat2.isSymbolicLink(), "path traverses a symlink or non-directory");
+    result2.push([at2, stat2]);
+    if (at2 === dirname12(at2))
+      return result2;
+  }
+}
+function readRegistry2(path, budget) {
+  absolutePath(path);
+  need2(basename6(path) === "known_marketplaces.json", "requires known_marketplaces.json");
+  need2(Number.isSafeInteger(budget.remaining) && budget.remaining >= 0, "has an invalid byte budget");
+  const ancestors2 = parents(path), initial2 = lstatSync15(path, { bigint: true });
+  need2(initial2.isFile() && !initial2.isSymbolicLink() && initial2.size <= BigInt(CLAUDE_MARKETPLACE_REGISTRY_LIMITS.bytes), "is not a bounded regular file");
+  need2(initial2.size <= BigInt(budget.remaining), "exceeds its aggregate byte limit");
+  const fd = openSync9(path, constants9.O_RDONLY | constants9.O_NOFOLLOW | constants9.O_NONBLOCK);
+  try {
+    const opened = fstatSync9(fd, { bigint: true });
+    need2(opened.isFile() && sameFile(initial2, opened), "changed during open");
+    const bytes = Buffer.alloc(Number(opened.size) + 1);
+    let length = 0;
+    while (length < bytes.length) {
+      const count = readSync7(fd, bytes, length, bytes.length - length, null);
+      if (!count)
+        break;
+      length += count;
+    }
+    const after2 = fstatSync9(fd, { bigint: true }), current = lstatSync15(path, { bigint: true });
+    need2(current.isFile() && sameFile(opened, after2) && sameFile(after2, current) && BigInt(length) === opened.size, "changed during read");
+    for (const [ancestor, before2] of ancestors2) {
+      const now3 = lstatSync15(ancestor, { bigint: true });
+      need2(now3.isDirectory() && before2.dev === now3.dev && before2.ino === now3.ino && before2.mode === now3.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 marketplace registry is not strict UTF-8");
+    }
+  } finally {
+    closeSync9(fd);
+  }
+}
+function parse5(text2) {
+  let at2 = 0, nodes = 0;
+  const numberPattern = /-?(?:0|[1-9][0-9]*)(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?/y;
+  const space = () => {
+    while (at2 < text2.length && /[\x20\t\r\n]/.test(text2[at2]))
+      at2++;
+  };
+  function string() {
+    need2(text2[at2] === '"', "contains invalid JSON");
+    const start = at2++;
+    while (at2 < text2.length) {
+      const character = text2[at2++];
+      if (character === '"') {
+        let value2;
+        try {
+          value2 = JSON.parse(text2.slice(start, at2));
+        } catch {
+          throw new Error("Claude marketplace registry contains invalid JSON string");
+        }
+        need2(value2.length <= CLAUDE_MARKETPLACE_REGISTRY_LIMITS.stringCharacters, "exceeds its string limit");
+        return value2;
+      }
+      if (character === "\\")
+        at2++;
+    }
+    throw new Error("Claude marketplace registry contains an unterminated JSON string");
+  }
+  function value(depth) {
+    need2(depth <= CLAUDE_MARKETPLACE_REGISTRY_LIMITS.depth && ++nodes <= CLAUDE_MARKETPLACE_REGISTRY_LIMITS.nodes, "exceeds its nesting or node limit");
+    space();
+    const character = text2[at2];
+    if (character === '"')
+      return { kind: "string", value: string() };
+    if (character === "{" || character === "[") {
+      at2++;
+      space();
+      const object4 = character === "{", end = object4 ? "}" : "]", entries = [], items = [], keys2 = new Set;
+      if (text2[at2] !== end)
+        while (true) {
+          if (object4) {
+            space();
+            const key = string();
+            need2(!keys2.has(key), "contains a duplicate JSON key");
+            keys2.add(key);
+            space();
+            need2(text2[at2++] === ":", "contains invalid JSON");
+            entries.push([key, value(depth + 1)]);
+          } else
+            items.push(value(depth + 1));
+          space();
+          if (text2[at2] === end)
+            break;
+          need2(text2[at2++] === ",", "contains invalid JSON");
+        }
+      at2++;
+      return object4 ? { kind: "object", entries } : { kind: "array", items };
+    }
+    for (const literal of ["true", "false", "null"])
+      if (text2.startsWith(literal, at2)) {
+        at2 += literal.length;
+        return { kind: "literal", value: literal };
+      }
+    numberPattern.lastIndex = at2;
+    const number = numberPattern.exec(text2);
+    need2(number, "contains invalid JSON");
+    at2 += number[0].length;
+    return { kind: "number", value: number[0] };
+  }
+  const root2 = value(0);
+  space();
+  need2(at2 === text2.length && root2.kind === "object", "requires a JSON object without trailing content");
+  need2(root2.entries.length <= CLAUDE_MARKETPLACE_REGISTRY_LIMITS.rows, "exceeds its marketplace row limit");
+  return root2;
+}
+function exactKeys(value, keys2) {
+  return value?.kind === "object" && value.entries.length === keys2.length && value.entries.every(([key]) => keys2.includes(key));
+}
+function textField(value) {
+  need2(value?.kind === "string" && value.value.length > 0 && !/[\x00-\x1f\x7f]/.test(value.value), "contains an invalid recognized field");
+  return value.value;
+}
+function normalizeRow(row) {
+  if (!exactKeys(row, ["source", "installLocation", "lastUpdated"]))
+    return;
+  const source = field(row, "source");
+  if (source?.kind !== "object")
+    return;
+  const type = field(source, "source");
+  if (type?.kind !== "string" || !["github", "directory"].includes(type.value))
+    return;
+  const location = type.value === "github" ? "repo" : "path";
+  if (!exactKeys(source, ["source", location]))
+    return;
+  const sourceLocation = textField(field(source, location));
+  if (type.value === "directory")
+    absolutePath(sourceLocation);
+  absolutePath(textField(field(row, "installLocation")));
+  const updated = textField(field(row, "lastUpdated"));
+  need2(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/.test(updated), "contains an invalid recognized update timestamp");
+  const millis = Date.parse(updated);
+  need2(Number.isFinite(millis) && new Date(millis).toISOString() === updated, "contains an invalid recognized update timestamp");
+  row.entries = row.entries.map(([key, value]) => [key, key === "lastUpdated" ? { kind: "validated-update-time" } : value]);
+}
+function captureClaudeMarketplaceRegistry(path, budget = { remaining: 256 * 1024 * 1024 }) {
+  const value = parse5(readRegistry2(path, budget));
+  for (const [, row] of value.entries)
+    normalizeRow(row);
+  const sha2562 = createHash11("sha256").update("hasna.skills.claude-marketplace-registry.v1\x00").update(JSON.stringify(value)).digest("hex");
+  return { path, hashMode: "claude-marketplace-registry", sha256: sha2562 };
+}
+var CLAUDE_MARKETPLACE_REGISTRY_LIMITS, sameFile = (a, b) => a.dev === b.dev && a.ino === b.ino && a.mode === b.mode && a.uid === b.uid && a.gid === b.gid && a.nlink === b.nlink && a.size === b.size && a.mtimeNs === b.mtimeNs && a.ctimeNs === b.ctimeNs, field = (object4, key) => object4.entries.find(([name]) => name === key)?.[1];
+var init_claude_marketplace_registry = __esm(() => {
+  CLAUDE_MARKETPLACE_REGISTRY_LIMITS = Object.freeze({ bytes: 1024 * 1024, rows: 1024, depth: 32, nodes: 65536, stringCharacters: 16384, pathCharacters: 4096 });
+});
+
+// src/lib/agent-discovery.ts
+import { createHash as createHash12 } from "crypto";
+import { lstatSync as lstatSync16, readFileSync as readFileSync14, readdirSync as readdirSync9, realpathSync as realpathSync4 } from "fs";
+import { dirname as dirname13, isAbsolute as isAbsolute13, join as join28, resolve as resolve14, sep as sep5 } from "path";
 function parseConfig(text2, path, toml = false) {
   try {
     const value = toml ? Bun.TOML.parse(text2) : JSON.parse(text2);
@@ -54148,12 +54520,12 @@ function parseConfig(text2, path, toml = false) {
   }
 }
 function safe4(path) {
-  if (!isAbsolute11(path) || path.includes("\x00"))
+  if (!isAbsolute13(path) || path.includes("\x00"))
     throw new Error("Expected an absolute native discovery path");
-  for (let cursor = path;; cursor = dirname12(cursor)) {
-    if (lstatSync15(cursor, { throwIfNoEntry: false })?.isSymbolicLink())
+  for (let cursor = path;; cursor = dirname13(cursor)) {
+    if (lstatSync16(cursor, { throwIfNoEntry: false })?.isSymbolicLink())
       throw new Error(`Refusing symlink native discovery input: ${cursor}`);
-    if (dirname12(cursor) === cursor)
+    if (dirname13(cursor) === cursor)
       break;
   }
 }
@@ -54161,7 +54533,7 @@ function read2(path, changes) {
   safe4(path);
   if (changes?.has(path))
     return changes.get(path);
-  const stat2 = lstatSync15(path, { throwIfNoEntry: false });
+  const stat2 = lstatSync16(path, { throwIfNoEntry: false });
   if (!stat2)
     return null;
   if (!stat2.isFile() || stat2.size > 16 * 1024 * 1024)
@@ -54169,6 +54541,14 @@ function read2(path, changes) {
   return readFileSync14(path, "utf8");
 }
 function projected(source, changes, budget = discoveryByteBudget()) {
+  if (source.hashMode === "claude-marketplace-registry") {
+    if (source.format !== undefined || source.fields !== undefined || source.managedPlugins !== undefined || typeof source.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(source.sha256) || changes?.has(source.path))
+      throw new Error("Claude marketplace witnesses require an exact reviewed registry without synthetic changes");
+    const sha2562 = captureClaudeMarketplaceRegistry(source.path, budget).sha256;
+    if (sha2562 !== source.sha256)
+      throw new Error(`Native discovery input changed; run skills hook install with a fresh discovery review: ${source.path}`);
+    return sha2562;
+  }
   if (source.hashMode === "claude-plugin-registry") {
     if (source.format !== undefined || source.fields !== undefined || !source.managedPlugins || changes?.has(source.path))
       throw new Error("Managed plugin registry witnesses require verified native registrations");
@@ -54193,7 +54573,7 @@ function projected(source, changes, budget = discoveryByteBudget()) {
   const object4 = source.format === "yaml" ? parseHermesConfig(text2) : parseConfig(text2, source.path, source.format === "toml");
   if (!object4 || typeof object4 !== "object" || Array.isArray(object4))
     throw new Error("Expected native discovery configuration object");
-  return digest(JSON.stringify(Object.fromEntries((source.fields ?? []).map((field) => [field, object4[field] ?? null]))));
+  return digest(JSON.stringify(Object.fromEntries((source.fields ?? []).map((field2) => [field2, object4[field2] ?? null]))));
 }
 function verifyAgentDiscovery(binding) {
   if (!binding || !Array.isArray(binding.sources) || !Array.isArray(binding.roots) || binding.sources.length > AGENT_POLICY_LIMITS.discoverySources || binding.roots.length > AGENT_POLICY_LIMITS.discoveryRoots)
@@ -54204,9 +54584,10 @@ function verifyAgentDiscovery(binding) {
     verifyDiscoveryDirectories(binding.directories);
   const budget = discoveryByteBudget();
   for (const source of binding.sources) {
+    assertMarketplaceBinding(binding, source);
     if (source.hashMode === "claude-plugin-registry" && binding.agent !== "claude")
       throw new Error("Managed Claude registry witnesses cannot apply to another agent");
-    if (source.format !== undefined && (!["json", "toml", "yaml"].includes(source.format) || !Array.isArray(source.fields) || !source.fields.length || source.fields.length > 64 || source.fields.some((field) => typeof field !== "string" || !field)))
+    if (source.format !== undefined && (!["json", "toml", "yaml"].includes(source.format) || !Array.isArray(source.fields) || !source.fields.length || source.fields.length > 64 || source.fields.some((field2) => typeof field2 !== "string" || !field2)))
       throw new Error("Invalid native discovery projection");
     if (source.sha256 !== null && !/^[a-f0-9]{64}$/.test(source.sha256))
       throw new Error("Invalid native discovery digest");
@@ -54216,13 +54597,20 @@ function verifyAgentDiscovery(binding) {
   for (const root2 of binding.roots)
     safe4(root2);
 }
+function assertMarketplaceBinding(binding, source) {
+  if (source.hashMode === "claude-marketplace-registry" && (binding.agent !== "claude" || binding.method !== "reviewed"))
+    throw new Error("Claude marketplace witnesses require explicit reviewed Claude discovery");
+}
 function rebindAgentDiscovery(binding, changes) {
   const budget = discoveryByteBudget();
-  return { ...binding, sources: binding.sources.map((source) => ({ ...source, sha256: projected(source, changes, budget) })) };
+  return { ...binding, sources: binding.sources.map((source) => {
+    assertMarketplaceBinding(binding, source);
+    return { ...source, sha256: projected(source, changes, budget) };
+  }) };
 }
-function assertProjectDiscovery(agent, directories, home, canonical3 = resolve12, reviewed) {
+function assertProjectDiscovery(agent, directories, home, canonical3 = resolve14, reviewed) {
   for (const directory of directories) {
-    const isHome = resolve12(directory) === resolve12(home);
+    const isHome = resolve14(directory) === resolve14(home);
     if (agent === "hermes") {
       assertHermesEnvironment(home);
       continue;
@@ -54253,13 +54641,13 @@ function assertProjectDiscovery(agent, directories, home, canonical3 = resolve12
     if (agent === "claude") {
       const commands = canonical3(join28(directory, ".claude/commands"));
       safe4(commands);
-      if (lstatSync15(commands, { throwIfNoEntry: false })?.isDirectory() && readdirSync9(commands).length)
+      if (lstatSync16(commands, { throwIfNoEntry: false })?.isDirectory() && readdirSync9(commands).length)
         throw new Error("NATIVE_SKILL_DRIFT: legacy project command discovery requires a dedicated format adapter");
     }
   }
 }
 function resolveAgentDiscovery(options) {
-  const canonical3 = options.canonical ?? resolve12, home = resolve12(options.home), agent = options.agent;
+  const canonical3 = options.canonical ?? resolve14, home = resolve14(options.home), agent = options.agent;
   const sources = [], roots = new Set, builtinNames = [];
   const witness = (path, format, fields) => {
     const source = { path: canonical3(path), sha256: null, ...format ? { format, fields } : {} };
@@ -54290,7 +54678,7 @@ function resolveAgentDiscovery(options) {
         continue;
       if (normalized.startsWith("~") && normalized !== "~" && !normalized.startsWith("~/"))
         unresolved("user-specific tilde expansion requires a separate discovery adapter");
-      const path = normalized === "~" ? home : normalized.startsWith("~/") ? join28(home, normalized.slice(2)) : resolve12(home, ".hermes", normalized);
+      const path = normalized === "~" ? home : normalized.startsWith("~/") ? join28(home, normalized.slice(2)) : resolve14(home, ".hermes", normalized);
       safe4(path);
       roots.add(path);
     }
@@ -54299,21 +54687,21 @@ function resolveAgentDiscovery(options) {
     const executable = Bun.which("gemini");
     if (executable) {
       let packageRoot;
-      for (let directory = dirname12(realpathSync4(executable)), depth = 0;depth < 8; directory = dirname12(directory), depth++) {
+      for (let directory = dirname13(realpathSync4(executable)), depth = 0;depth < 8; directory = dirname13(directory), depth++) {
         const path = join28(directory, "package.json"), raw = read2(path);
         if (raw !== null && parseConfig(raw, path).name === "@google/gemini-cli") {
           packageRoot = directory;
           witness(path);
           break;
         }
-        if (dirname12(directory) === directory)
+        if (dirname13(directory) === directory)
           break;
       }
       if (!packageRoot)
         unresolved("installed Gemini package layout is not recognized");
       const builtinRoot = join28(packageRoot, "bundle/builtin");
       safe4(builtinRoot);
-      if (!lstatSync15(builtinRoot, { throwIfNoEntry: false })?.isDirectory())
+      if (!lstatSync16(builtinRoot, { throwIfNoEntry: false })?.isDirectory())
         unresolved("installed Gemini builtin root is missing");
       for (const name of readdirSync9(builtinRoot).sort()) {
         const text2 = witness(join28(builtinRoot, name, "SKILL.md"));
@@ -54351,7 +54739,7 @@ function resolveAgentDiscovery(options) {
       unresolved("plugin hooks require a separate no-skill-injection review");
     const commands = join28(root2, "commands");
     safe4(commands);
-    if (agent === "claude" && (manifest.commands !== undefined || lstatSync15(commands, { throwIfNoEntry: false })?.isDirectory() && readdirSync9(commands).length))
+    if (agent === "claude" && (manifest.commands !== undefined || lstatSync16(commands, { throwIfNoEntry: false })?.isDirectory() && readdirSync9(commands).length))
       unresolved("legacy command discovery requires retirement or a dedicated format adapter");
     const rootSkill = witness(join28(root2, "SKILL.md"));
     if (rootSkill !== null)
@@ -54362,10 +54750,10 @@ function resolveAgentDiscovery(options) {
     if (agent === "claude")
       roots.add(join28(root2, "skills"));
     for (const value of declared) {
-      const path = resolve12(root2, value);
+      const path = resolve14(root2, value);
       if (path !== root2 && !path.startsWith(root2 + sep5))
         unresolved("plugin skill path escapes its root");
-      roots.add(path.endsWith(`${sep5}SKILL.md`) ? dirname12(path) : path);
+      roots.add(path.endsWith(`${sep5}SKILL.md`) ? dirname13(path) : path);
     }
   }
   if (agent === "claude") {
@@ -54373,7 +54761,7 @@ function resolveAgentDiscovery(options) {
     const installed = registrations === null ? {} : parseConfig(registrations, join28(home, ".claude/plugins/installed_plugins.json")).plugins;
     const commands = canonical3(join28(home, ".claude/commands"));
     safe4(commands);
-    if (lstatSync15(commands, { throwIfNoEntry: false })?.isDirectory() && readdirSync9(commands).length)
+    if (lstatSync16(commands, { throwIfNoEntry: false })?.isDirectory() && readdirSync9(commands).length)
       unresolved("legacy home command discovery requires a dedicated format adapter");
     for (const [id, enabled] of Object.entries(config.enabledPlugins ?? {})) {
       if (enabled === false)
@@ -54393,7 +54781,7 @@ function resolveAgentDiscovery(options) {
         unresolved("unsupported plugin enablement");
       const split2 = id.lastIndexOf("@"), name = id.slice(0, split2), marketplace = id.slice(split2 + 1);
       const market = config.marketplaces?.[marketplace] ?? (marketplace === "personal" ? { source_type: "local", source: home } : undefined);
-      if (split2 < 1 || market?.source_type !== "local" || typeof market.source !== "string" || !isAbsolute11(market.source))
+      if (split2 < 1 || market?.source_type !== "local" || typeof market.source !== "string" || !isAbsolute13(market.source))
         unresolved("enabled plugin marketplace is not an explicit local source");
       const catalogText = witness(join28(market.source, ".agents/plugins/marketplace.json"));
       if (catalogText === null)
@@ -54401,7 +54789,7 @@ function resolveAgentDiscovery(options) {
       const catalog = parseConfig(catalogText, join28(market.source, ".agents/plugins/marketplace.json")), matches2 = Array.isArray(catalog.plugins) ? catalog.plugins.filter((item) => item.name === name) : [];
       if (matches2.length !== 1 || matches2[0]?.source?.source !== "local" || typeof matches2[0]?.source?.path !== "string")
         unresolved("plugin catalog source is missing or ambiguous");
-      plugin(resolve12(market.source, matches2[0].source.path));
+      plugin(resolve14(market.source, matches2[0].source.path));
     }
   } else if (agent === "opencode") {
     if (witness(join28(home, ".config/opencode/opencode.jsonc")) !== null || witness(join28(home, ".config/opencode/config.json")) !== null)
@@ -54409,18 +54797,18 @@ function resolveAgentDiscovery(options) {
     if ((config.plugin?.length ?? 0) > 0 || config.skills?.urls?.length)
       unresolved("external plugin or remote skill source");
     for (const path of config.skills?.paths ?? []) {
-      if (typeof path !== "string" || !isAbsolute11(path))
+      if (typeof path !== "string" || !isAbsolute13(path))
         unresolved("relative or malformed added skill root");
       roots.add(path);
     }
     const localPlugins = join28(home, ".config/opencode/plugins");
     safe4(localPlugins);
-    if (lstatSync15(localPlugins, { throwIfNoEntry: false }) && readdirSync9(localPlugins).some((name) => name !== "skills-cli.js"))
+    if (lstatSync16(localPlugins, { throwIfNoEntry: false }) && readdirSync9(localPlugins).some((name) => name !== "skills-cli.js"))
       unresolved("additional local plugin hooks require review");
   } else if (agent === "hermes") {
     for (const directory of [join28(home, ".hermes/plugins"), join28(home, ".hermes/hermes-agent")]) {
       safe4(directory);
-      if (lstatSync15(directory, { throwIfNoEntry: false }))
+      if (lstatSync16(directory, { throwIfNoEntry: false }))
         unresolved("installed runtime/plugin discovery requires reviewed source bindings");
     }
     if (Bun.which("hermes") || Object.keys(config.plugins ?? {}).length)
@@ -54430,11 +54818,11 @@ function resolveAgentDiscovery(options) {
       unresolved("custom extension or skill paths");
     const directory = join28(home, ".gemini/extensions");
     safe4(directory);
-    if (lstatSync15(directory, { throwIfNoEntry: false }))
+    if (lstatSync16(directory, { throwIfNoEntry: false }))
       for (const name of readdirSync9(directory)) {
         const root2 = join28(directory, name);
         safe4(root2);
-        if (!lstatSync15(root2)?.isDirectory())
+        if (!lstatSync16(root2)?.isDirectory())
           continue;
         const raw = witness(join28(root2, "gemini-extension.json"));
         if (raw === null)
@@ -54447,7 +54835,7 @@ function resolveAgentDiscovery(options) {
   }
   return { agent, roots: [...roots].sort(), sources, method: "automatic", ...agent === "gemini" ? { builtinNames } : {}, ...agent === "hermes" ? { directories: captureDiscoveryDirectories([join28(home, ".hermes/plugins"), join28(home, ".hermes/hermes-agent")].map((path) => canonical3(path))) } : {} };
 }
-var digest = (text2) => createHash11("sha256").update(text2).digest("hex");
+var digest = (text2) => createHash12("sha256").update(text2).digest("hex");
 var init_agent_discovery = __esm(() => {
   init_agent_policy_limits();
   init_agent_hermes();
@@ -54456,6 +54844,7 @@ var init_agent_discovery = __esm(() => {
   init_agent_discovery_path_bytes();
   init_plugin_discovery();
   init_plugin_admission();
+  init_claude_marketplace_registry();
   init_agent_discovery_directories();
 });
 
@@ -54540,7 +54929,7 @@ var init_agent_adapters = __esm(() => {
 });
 
 // src/lib/agent-codex.ts
-import { isDeepStrictEqual as isDeepStrictEqual2 } from "util";
+import { isDeepStrictEqual as isDeepStrictEqual3 } from "util";
 function assertCodexPathConfigEditable(text2) {
   const before2 = Bun.TOML.parse(text2);
   if (before2.skills?.config === undefined)
@@ -54549,7 +54938,7 @@ function assertCodexPathConfigEditable(text2) {
   delete expected.skills.config;
   try {
     const withoutSections = Bun.TOML.parse(text2.replace(CODEX_SKILL_CONFIG_SECTIONS, ""));
-    if (isDeepStrictEqual2(withoutSections, expected))
+    if (isDeepStrictEqual3(withoutSections, expected))
       return;
   } catch {}
   throw new Error("Codex skill path controls require ordinary [[skills.config]] TOML tables; preserve and convert inline or dotted config arrays before running skills hook install");
@@ -54587,7 +54976,7 @@ function disableCodexBundledSkills(text2) {
   const candidates = new Set;
   const consider = (candidate2) => {
     try {
-      if (isDeepStrictEqual2(Bun.TOML.parse(candidate2), expected))
+      if (isDeepStrictEqual3(Bun.TOML.parse(candidate2), expected))
         candidates.add(candidate2);
     } catch {}
   };
@@ -54617,16 +55006,16 @@ var init_agent_codex = __esm(() => {
 });
 
 // src/lib/agent-integration.ts
-import { createHash as createHash12, randomUUID as randomUUID6 } from "crypto";
-import { existsSync as existsSync15, lstatSync as lstatSync16, statSync as statSync8, mkdirSync as mkdirSync7, readFileSync as readFileSync15, readdirSync as readdirSync10, opendirSync as opendirSync5, readlinkSync as readlinkSync2, realpathSync as realpathSync5, renameSync as renameSync4, rmdirSync as rmdirSync3, writeFileSync as writeFileSync5, unlinkSync as unlinkSync4, chmodSync, openSync as openSync9, closeSync as closeSync9, fsyncSync as fsyncSync2, fstatSync as fstatSync9, readSync as readSync7, constants as constants9, linkSync as linkSync2 } from "fs";
-import { dirname as dirname13, join as join29, resolve as resolve13, relative as relative5, isAbsolute as isAbsolute12, sep as sep6 } from "path";
+import { createHash as createHash13, randomUUID as randomUUID6 } from "crypto";
+import { existsSync as existsSync15, lstatSync as lstatSync17, statSync as statSync8, mkdirSync as mkdirSync7, readFileSync as readFileSync15, readdirSync as readdirSync10, opendirSync as opendirSync5, readlinkSync as readlinkSync2, realpathSync as realpathSync5, renameSync as renameSync4, rmdirSync as rmdirSync3, writeFileSync as writeFileSync5, unlinkSync as unlinkSync4, chmodSync, openSync as openSync10, closeSync as closeSync10, fsyncSync as fsyncSync3, fstatSync as fstatSync10, readSync as readSync8, constants as constants10, linkSync as linkSync2 } from "fs";
+import { dirname as dirname14, join as join29, resolve as resolve15, relative as relative5, isAbsolute as isAbsolute14, sep as sep6 } from "path";
 import { homedir as homedir4 } from "os";
 function assertSafePath(path) {
-  let cursor = resolve13(path);
+  let cursor = resolve15(path);
   while (true) {
-    if (lstatSync16(cursor, { throwIfNoEntry: false })?.isSymbolicLink())
+    if (lstatSync17(cursor, { throwIfNoEntry: false })?.isSymbolicLink())
       throw new Error(`Refusing symlink path: ${cursor}`);
-    const parent = dirname13(cursor);
+    const parent = dirname14(cursor);
     if (parent === cursor)
       return;
     cursor = parent;
@@ -54635,16 +55024,16 @@ function assertSafePath(path) {
 function readRootAlias(home, agent) {
   assertSafePath(home);
   const realHome = realpathSync5(home), alias = join29(realHome, `.${agent}`);
-  const stat2 = lstatSync16(alias, { throwIfNoEntry: false, bigint: true });
+  const stat2 = lstatSync17(alias, { throwIfNoEntry: false, bigint: true });
   if (!stat2?.isSymbolicLink())
     throw new Error(`Agent root alias changed after planning: ${alias}`);
-  const link2 = readlinkSync2(alias), targetPath = resolve13(dirname13(alias), link2);
+  const link2 = readlinkSync2(alias), targetPath = resolve15(dirname14(alias), link2);
   assertSafePath(targetPath);
-  const targetStat = lstatSync16(targetPath, { throwIfNoEntry: false });
+  const targetStat = lstatSync17(targetPath, { throwIfNoEntry: false });
   if (!targetStat?.isDirectory())
     throw new Error(`Agent root alias must target an existing directory: ${alias}`);
   const target = realpathSync5(targetPath), inside = relative5(realHome, target);
-  if (!inside || inside === ".." || inside.startsWith(`..${sep6}`) || isAbsolute12(inside))
+  if (!inside || inside === ".." || inside.startsWith(`..${sep6}`) || isAbsolute14(inside))
     throw new Error(`Agent root alias target must be inside the real home: ${alias}`);
   return { agent, home: realHome, alias, target, link: link2, aliasIdentity: `${stat2.dev}:${stat2.ino}:${stat2.ctimeNs}`, targetIdentity: `${targetStat.dev}:${targetStat.ino}` };
 }
@@ -54653,14 +55042,14 @@ function rootAliases(home, allowed = false) {
     return [];
   const result2 = [];
   for (const agent of ["claude", "codex"])
-    if (lstatSync16(join29(home, `.${agent}`), { throwIfNoEntry: false })?.isSymbolicLink())
+    if (lstatSync17(join29(home, `.${agent}`), { throwIfNoEntry: false })?.isSymbolicLink())
       result2.push(readRootAlias(home, agent));
   if (result2.some((item, index) => result2.slice(index + 1).some((other) => item.target === other.target || item.target.startsWith(other.target + sep6) || other.target.startsWith(item.target + sep6))))
     throw new Error("Agent root alias targets must not overlap");
   return result2;
 }
 function canonicalAgentPath(path, aliases) {
-  const absolute = resolve13(path), binding = aliases.find((item) => absolute === item.alias || absolute.startsWith(item.alias + sep6));
+  const absolute = resolve15(path), binding = aliases.find((item) => absolute === item.alias || absolute.startsWith(item.alias + sep6));
   return binding ? join29(binding.target, relative5(binding.alias, absolute)) : absolute;
 }
 function recheckRootAliases(aliases) {
@@ -54674,35 +55063,35 @@ function recheckRootAliases(aliases) {
 }
 function readNativeBytes(path, maximum = 64 * 1024 * 1024) {
   assertSafePath(path);
-  const before2 = lstatSync16(path);
+  const before2 = lstatSync17(path);
   if (!before2.isFile() || before2.size > maximum)
     throw new Error("Unsupported or oversized native skill file");
-  const descriptor = openSync9(path, constants9.O_RDONLY | constants9.O_NOFOLLOW | constants9.O_NONBLOCK);
+  const descriptor = openSync10(path, constants10.O_RDONLY | constants10.O_NOFOLLOW | constants10.O_NONBLOCK);
   try {
-    const opened = fstatSync9(descriptor);
+    const opened = fstatSync10(descriptor);
     if (!opened.isFile() || opened.dev !== before2.dev || opened.ino !== before2.ino || opened.size !== before2.size)
       throw new Error("Native skill file changed while reading");
     const bytes = Buffer.allocUnsafe(before2.size + 1);
     let length = 0;
     while (length < bytes.length) {
-      const count = readSync7(descriptor, bytes, length, bytes.length - length, null);
+      const count = readSync8(descriptor, bytes, length, bytes.length - length, null);
       if (!count)
         break;
       length += count;
     }
-    const after2 = fstatSync9(descriptor);
+    const after2 = fstatSync10(descriptor);
     if (length !== before2.size || after2.size !== before2.size || after2.mtimeMs !== opened.mtimeMs || after2.ctimeMs !== opened.ctimeMs)
       throw new Error("Native skill file changed while reading");
     return bytes.subarray(0, length);
   } finally {
-    closeSync9(descriptor);
+    closeSync10(descriptor);
   }
 }
 function treeHash(root2) {
-  const hash2 = createHash12("sha256");
+  const hash2 = createHash13("sha256");
   let bytes = 0, files = 0;
   function visit2(path) {
-    const stat2 = lstatSync16(path);
+    const stat2 = lstatSync17(path);
     if (stat2.isSymbolicLink())
       throw new Error(`Refusing symlink in skill: ${path}`);
     const rel = relative5(root2, path);
@@ -54728,11 +55117,11 @@ function treeHash(root2) {
 function projectAncestorDirectories(projects) {
   const directories = new Set;
   for (const project of projects) {
-    for (let path = resolve13(project), depth = 0;; depth++) {
+    for (let path = resolve15(project), depth = 0;; depth++) {
       if (depth >= 100)
         throw new Error("NATIVE_SKILL_DRIFT: project ancestor discovery limit exceeded");
       directories.add(path);
-      const parent = dirname13(path);
+      const parent = dirname14(path);
       if (parent === path)
         break;
       path = parent;
@@ -54759,10 +55148,10 @@ function inventoryNativeSkills(home = homedir4(), options = {}) {
       throw new Error("Native skill discovery metadata limit exceeded");
   }
   function emptySiblingCacheAlias(path, parent) {
-    const link2 = readlinkSync2(path), target = resolve13(parent, link2);
-    if (dirname13(target) !== parent || (isAbsolute12(link2) ? link2 !== target : dirname13(link2) !== "."))
+    const link2 = readlinkSync2(path), target = resolve15(parent, link2);
+    if (dirname14(target) !== parent || (isAbsolute14(link2) ? link2 !== target : dirname14(link2) !== "."))
       return false;
-    if (!lstatSync16(target, { throwIfNoEntry: false })?.isDirectory())
+    if (!lstatSync17(target, { throwIfNoEntry: false })?.isDirectory())
       return false;
     const scan = cacheScans.get(target);
     return Boolean(scan?.complete && !scan.hasSkills && scan.entries <= maxAliasProofEntries);
@@ -54774,7 +55163,7 @@ function inventoryNativeSkills(home = homedir4(), options = {}) {
     assertSafePath(path);
     if (!existsSync15(path))
       return scan;
-    const stat2 = lstatSync16(path);
+    const stat2 = lstatSync17(path);
     if (stat2.isFile())
       return scan;
     if (!stat2.isDirectory())
@@ -54793,7 +55182,7 @@ function inventoryNativeSkills(home = homedir4(), options = {}) {
       }
       const bridge = !vendor && isOwnedCliBridge(path, bridgePaths);
       const rootAlias = aliases.find((item) => path === item.target || path.startsWith(item.target + sep6));
-      entries.push({ agent, path, hash: treeHash(path), managed, vendor, ...agent === "codex" && path.startsWith(canonicalAgentPath(join29(home, ".codex", "skills", ".system"), aliases) + sep6) ? { system: true } : {}, ...bridge ? { bridge: true, bridgeHome: resolve13(home) } : {}, ...rootAlias ? { rootAlias } : {} });
+      entries.push({ agent, path, hash: treeHash(path), managed, vendor, ...agent === "codex" && path.startsWith(canonicalAgentPath(join29(home, ".codex", "skills", ".system"), aliases) + sep6) ? { system: true } : {}, ...bridge ? { bridge: true, bridgeHome: resolve15(home) } : {}, ...rootAlias ? { rootAlias } : {} });
       return scan;
     }
     if (depth > (vendor ? 32 : 3))
@@ -54820,7 +55209,7 @@ function inventoryNativeSkills(home = homedir4(), options = {}) {
       if (isVendor && !options.includeVendor)
         continue;
       const child = join29(path, name);
-      if (isVendor && lstatSync16(child, { throwIfNoEntry: false })?.isSymbolicLink()) {
+      if (isVendor && lstatSync17(child, { throwIfNoEntry: false })?.isSymbolicLink()) {
         const target = statSync8(child, { throwIfNoEntry: false });
         if (target?.isFile() || pluginCache && target?.isDirectory() && emptySiblingCacheAlias(child, path)) {
           scan.entries++;
@@ -54942,7 +55331,7 @@ function configureHooks(config, agent, command, profileId, nativeReady) {
 function disableCodexSkills(text2, skills, aliases, bridgePath) {
   const bundled = disableCodexBundledSkills(text2);
   let result2 = bundled;
-  const bridgeSelector = (entry) => typeof entry.name === "string" && entry.name.trim() === CLI_BRIDGE_NAME || typeof entry.path === "string" && [resolve13(bridgePath), resolve13(join29(bridgePath, "SKILL.md"))].includes(canonicalAgentPath(entry.path, aliases));
+  const bridgeSelector = (entry) => typeof entry.name === "string" && entry.name.trim() === CLI_BRIDGE_NAME || typeof entry.path === "string" && [resolve15(bridgePath), resolve15(join29(bridgePath, "SKILL.md"))].includes(canonicalAgentPath(entry.path, aliases));
   const previousConfig = Bun.TOML.parse(bundled).skills?.config;
   if (previousConfig !== undefined && (!Array.isArray(previousConfig) || previousConfig.some((entry) => !entry || typeof entry !== "object" || entry.path !== undefined && entry.name !== undefined)))
     throw new Error("Codex skill controls require one path or name selector per [[skills.config]] entry; review ambiguous entries before running skills hook install");
@@ -54954,7 +55343,7 @@ function disableCodexSkills(text2, skills, aliases, bridgePath) {
     result2 = result2.replace(CODEX_SKILL_CONFIG_SECTIONS, (section) => {
       const parsed = Bun.TOML.parse(section);
       const declared = parsed.skills?.config?.[0];
-      if (!declared || !(skill.enabled && bridgeSelector(declared)) && !(typeof declared.path === "string" && [resolve13(path), resolve13(skill.path)].includes(canonicalAgentPath(declared.path, aliases))))
+      if (!declared || !(skill.enabled && bridgeSelector(declared)) && !(typeof declared.path === "string" && [resolve15(path), resolve15(skill.path)].includes(canonicalAgentPath(declared.path, aliases))))
         return section;
       found = true;
       return /^\s*enabled\s*=/m.test(section) ? section.replace(/^\s*enabled\s*=.*$/m, `enabled = ${skill.enabled}`) : `${section.trimEnd()}
@@ -54984,9 +55373,9 @@ function planAgentIntegration(options) {
     throw new Error("Invalid existing Skills bridge policy");
   if (policy.bridge?.agents !== undefined && (!Array.isArray(policy.bridge.agents) || policy.bridge.agents.some((agent) => !INTEGRATION_AGENTS.includes(agent))))
     throw new Error("Invalid existing bridge agent inventory");
-  for (const field of ["commands", "profiles"])
-    if (policy.bridge?.[field] !== undefined && (!policy.bridge[field] || typeof policy.bridge[field] !== "object" || Array.isArray(policy.bridge[field]) || Object.entries(policy.bridge[field]).some(([key, value]) => !INTEGRATION_AGENTS.includes(key) || typeof value !== "string" || !value || value.includes("\x00"))))
-      throw new Error(`Invalid existing bridge ${field} binding`);
+  for (const field2 of ["commands", "profiles"])
+    if (policy.bridge?.[field2] !== undefined && (!policy.bridge[field2] || typeof policy.bridge[field2] !== "object" || Array.isArray(policy.bridge[field2]) || Object.entries(policy.bridge[field2]).some(([key, value]) => !INTEGRATION_AGENTS.includes(key) || typeof value !== "string" || !value || value.includes("\x00"))))
+      throw new Error(`Invalid existing bridge ${field2} binding`);
   const priorAgents = policy.bridge?.agents ?? [];
   const profileId = options.profileId ?? policy.profileId ?? "default";
   const validateProfile = (value) => {
@@ -55072,7 +55461,7 @@ function planAgentIntegration(options) {
     version: CLI_BRIDGE_VERSION,
     digest: CLI_BRIDGE_DIGEST,
     agents: [...new Set([...priorAgents, ...options.agents])].sort(),
-    home: resolve13(home),
+    home: resolve15(home),
     includeVendor: true,
     ...options.agents.includes("hermes") ? { supervisors: { ...policy.bridge?.supervisors, hermes: { path: join29(dataDir3, "agent-hooks", "hermes.js"), runtime: process.execPath, sha256: sha(renderHermesSupervisor(bindings.get("hermes").command, bindings.get("hermes").profileId)) } } } : {},
     commands: { ...policy.bridge?.commands, ...Object.fromEntries([...bindings].map(([agent, binding]) => [agent, binding.command])) },
@@ -55089,7 +55478,7 @@ function planAgentIntegration(options) {
 }
 function atomicWrite2(path, content) {
   assertSafePath(path);
-  mkdirSync7(dirname13(path), { recursive: true, mode: 448 });
+  mkdirSync7(dirname14(path), { recursive: true, mode: 448 });
   const temporary = `${path}.skills-${randomUUID6()}`;
   try {
     writeFileSync5(temporary, content, { mode: 384, flag: "wx" });
@@ -55102,10 +55491,10 @@ function atomicWrite2(path, content) {
 function applyAgentIntegration(plan) {
   const policyPath = join29(plan.dataDir, "agent-policy.json");
   assertSafePath(policyPath);
-  const currentText = (path) => resolve13(path) === resolve13(policyPath) ? readManagedSkillPolicySnapshot(plan.dataDir)?.text ?? null : readOptional(path);
+  const currentText = (path) => resolve15(path) === resolve15(policyPath) ? readManagedSkillPolicySnapshot(plan.dataDir)?.text ?? null : readOptional(path);
   readManagedSkillPolicySnapshot(plan.dataDir);
   for (const change of plan.changes)
-    if (resolve13(change.path) === resolve13(policyPath))
+    if (resolve15(change.path) === resolve15(policyPath))
       parseManagedSkillPolicy(change.after);
   const aliases = plan.rootAliases ?? [];
   recheckRootAliases(aliases);
@@ -55135,7 +55524,7 @@ function applyAgentIntegration(plan) {
       recheckRootAliases(aliases);
       if (currentText(change.path) !== change.before)
         throw new Error(`Configuration changed after planning: ${change.path}`);
-      for (let directory = dirname13(change.path);!existsSync15(directory); directory = dirname13(directory))
+      for (let directory = dirname14(change.path);!existsSync15(directory); directory = dirname14(directory))
         createdDirectories.add(directory);
       const after2 = change.after;
       atomicWrite2(change.path, after2);
@@ -55175,11 +55564,11 @@ function applyAgentIntegration(plan) {
 }
 function syncArchiveDirectory(path) {
   assertSafePath(path);
-  const descriptor = openSync9(path, constants9.O_RDONLY | constants9.O_DIRECTORY | constants9.O_NOFOLLOW | constants9.O_NONBLOCK);
+  const descriptor = openSync10(path, constants10.O_RDONLY | constants10.O_DIRECTORY | constants10.O_NOFOLLOW | constants10.O_NONBLOCK);
   try {
-    fsyncSync2(descriptor);
+    fsyncSync3(descriptor);
   } finally {
-    closeSync9(descriptor);
+    closeSync10(descriptor);
   }
 }
 function writeArchiveJournal(path, value) {
@@ -55187,18 +55576,18 @@ function writeArchiveJournal(path, value) {
   const temporary = `${path}.skills-${randomUUID6()}`;
   let descriptor;
   try {
-    descriptor = openSync9(temporary, constants9.O_WRONLY | constants9.O_CREAT | constants9.O_EXCL | constants9.O_NOFOLLOW, 384);
+    descriptor = openSync10(temporary, constants10.O_WRONLY | constants10.O_CREAT | constants10.O_EXCL | constants10.O_NOFOLLOW, 384);
     writeFileSync5(descriptor, `${JSON.stringify(value)}
 `);
-    fsyncSync2(descriptor);
-    closeSync9(descriptor);
+    fsyncSync3(descriptor);
+    closeSync10(descriptor);
     descriptor = undefined;
     renameSync4(temporary, path);
-    syncArchiveDirectory(dirname13(path));
+    syncArchiveDirectory(dirname14(path));
   } finally {
     if (descriptor !== undefined)
-      closeSync9(descriptor);
-    if (lstatSync16(temporary, { throwIfNoEntry: false }))
+      closeSync10(descriptor);
+    if (lstatSync17(temporary, { throwIfNoEntry: false }))
       unlinkSync4(temporary);
   }
 }
@@ -55231,7 +55620,7 @@ function archiveNativeSkills(inventory, options) {
   const moved = [];
   const verifyArchive = (entry) => {
     assertSafePath(entry.archive);
-    const stat2 = lstatSync16(entry.archive);
+    const stat2 = lstatSync17(entry.archive);
     if (entry.discoveryOnly ? !stat2.isFile() : !stat2.isDirectory())
       throw new Error("Archive type changed");
     if ((entry.discoveryOnly ? sha(readNativeBytes(entry.archive)) : treeHash(entry.archive)) !== entry.hash)
@@ -55239,14 +55628,14 @@ function archiveNativeSkills(inventory, options) {
   };
   assertSafePath(archiveRoot);
   const created = [];
-  for (let path = archiveRoot;!existsSync15(path); path = dirname13(path))
+  for (let path = archiveRoot;!existsSync15(path); path = dirname14(path))
     created.push(path);
   mkdirSync7(archiveRoot, { recursive: true, mode: 448 });
   try {
     for (const directory of created)
       syncArchiveDirectory(directory);
     if (created.length)
-      syncArchiveDirectory(dirname13(created.at(-1)));
+      syncArchiveDirectory(dirname14(created.at(-1)));
     writeArchiveJournal(receiptPath, journal);
     for (const [index, entry] of selected.entries()) {
       recheckRootAliases(aliases);
@@ -55258,7 +55647,7 @@ function archiveNativeSkills(inventory, options) {
       writeArchiveJournal(receiptPath, journal);
       renameSync4(move.source, move.archive);
       moved.push(move);
-      syncArchiveDirectory(dirname13(move.source));
+      syncArchiveDirectory(dirname14(move.source));
       syncArchiveDirectory(archiveRoot);
       verifyArchive(move);
       move.status = "archived";
@@ -55279,7 +55668,7 @@ function archiveNativeSkills(inventory, options) {
         recheckRootAliases(aliases);
         assertSafePath(entry.source);
         assertSafePath(entry.archive);
-        if (lstatSync16(entry.source, { throwIfNoEntry: false })) {
+        if (lstatSync17(entry.source, { throwIfNoEntry: false })) {
           entry.status = "recovery-required";
           entry.conflict = "source-occupied";
           continue;
@@ -55293,10 +55682,10 @@ function archiveNativeSkills(inventory, options) {
         }
         if (entry.discoveryOnly) {
           linkSync2(entry.archive, entry.source);
-          syncArchiveDirectory(dirname13(entry.source));
+          syncArchiveDirectory(dirname14(entry.source));
           unlinkSync4(entry.archive);
         } else {
-          if (lstatSync16(entry.source, { throwIfNoEntry: false })) {
+          if (lstatSync17(entry.source, { throwIfNoEntry: false })) {
             entry.status = "recovery-required";
             entry.conflict = "source-occupied";
             continue;
@@ -55304,7 +55693,7 @@ function archiveNativeSkills(inventory, options) {
           renameSync4(entry.archive, entry.source);
         }
         entry.status = "restored";
-        syncArchiveDirectory(dirname13(entry.source));
+        syncArchiveDirectory(dirname14(entry.source));
         syncArchiveDirectory(archiveRoot);
       } catch {
         entry.status = "recovery-required";
@@ -55324,7 +55713,7 @@ function archiveNativeSkills(inventory, options) {
   return { entries: entries.map(({ status, conflict, ...entry }) => entry), receiptPath, ...aliases.length ? { rootAliases: aliases } : {} };
 }
 function assertManagedAgentBridge(agent, options = {}) {
-  const home = resolve13(options.home ?? homedir4()), dataDir3 = options.dataDir ?? getDataDirReadOnly();
+  const home = resolve15(options.home ?? homedir4()), dataDir3 = options.dataDir ?? getDataDirReadOnly();
   assertSafePath(join29(dataDir3, "agent-policy.json"));
   const snapshot = readManagedSkillPolicySnapshot(dataDir3);
   if (!snapshot)
@@ -55447,7 +55836,7 @@ function assertNativeExportAllowed(dataDir3 = getDataDirReadOnly()) {
   if (requiresCliSkillLoading(dataDir3))
     throw new Error("NATIVE_SKILL_EXPORT_DISABLED: this station loads skills through the Skills CLI; use skills sync --selection-profile <id>");
 }
-var sha = (data) => createHash12("sha256").update(data).digest("hex"), HOOK_EVENTS, ROOTS, SKILLS_LOADING_POLICY = "Skills loading policy: discover skills with `skills list` or `skills search`, and read selected instructions with `skills load <slug>`. Use `skills sync` to refresh the shared profile. The only native skill is the owned skills-cli bridge. Create and edit payload skills in the Skills authoring workspace; do not copy payload instructions into native discovery folders. Context loading does not authorize execution; use `skills run` only when the task calls for running a skill.";
+var sha = (data) => createHash13("sha256").update(data).digest("hex"), HOOK_EVENTS, ROOTS, SKILLS_LOADING_POLICY = "Skills loading policy: discover skills with `skills list` or `skills search`, and read selected instructions with `skills load <slug>`. Use `skills sync` to refresh the shared profile. The only native skill is the owned skills-cli bridge. Create and edit payload skills in the Skills authoring workspace; do not copy payload instructions into native discovery folders. Context loading does not authorize execution; use `skills run` only when the task calls for running a skill.";
 var init_agent_integration = __esm(() => {
   init_config();
   init_managed_policy();
@@ -55615,7 +56004,7 @@ var init_home_migration = __esm(() => {
 import {
   cpSync as cpSync2,
   existsSync as existsSync17,
-  lstatSync as lstatSync17,
+  lstatSync as lstatSync18,
   mkdirSync as mkdirSync9,
   mkdtempSync as mkdtempSync2,
   readFileSync as readFileSync16,
@@ -55626,14 +56015,14 @@ import {
   writeFileSync as writeFileSync7
 } from "fs";
 import { homedir as homedir5 } from "os";
-import { basename as basename5, dirname as dirname14, join as join31 } from "path";
+import { basename as basename7, dirname as dirname15, join as join31 } from "path";
 function isSkillsOwnershipMarker(marker) {
   return typeof marker === "object" && marker !== null && Object.hasOwn(marker, "managedBy") && marker.managedBy === SYNC_MARKER_MANAGED_BY;
 }
 function hasSkillsOwnershipMarker(dir) {
   const path = join31(dir, SYNC_MARKER_FILE);
   try {
-    if (!lstatSync17(path).isFile())
+    if (!lstatSync18(path).isFile())
       return false;
     const marker = JSON.parse(readFileSync16(path, "utf8"));
     return isSkillsOwnershipMarker(marker);
@@ -55858,9 +56247,9 @@ function writeManagedSkillDir(dir, skillMd, options) {
   const action = dirExists ? "update" : "create";
   if (options.dryRun)
     return { action, path: skillMdPath };
-  const parentDir = dirname14(dir);
+  const parentDir = dirname15(dir);
   mkdirSync9(parentDir, { recursive: true });
-  const transactionDir = mkdtempSync2(join31(parentDir, `.hasna-skills-write-${basename5(dir)}-`));
+  const transactionDir = mkdtempSync2(join31(parentDir, `.hasna-skills-write-${basename7(dir)}-`));
   const candidateDir = join31(transactionDir, "candidate");
   const backupDir = join31(transactionDir, "backup");
   const candidateSkillMdPath = join31(candidateDir, "SKILL.md");
@@ -57710,7 +58099,7 @@ var _parse = (_Err) => {
     return result2.value;
   };
   return fn;
-}, parse5, _parseAsync = (_Err) => {
+}, parse6, _parseAsync = (_Err) => {
   const fn = async (schema, value, _ctx, params) => {
     const ctx = _ctx ? { ..._ctx, async: true } : { async: true };
     let result2 = schema._zod.run({ value, issues: [] }, ctx);
@@ -57755,16 +58144,16 @@ var _parse = (_Err) => {
     result2 = await result2;
   return result2.issues.length === 0;
 }, _encode = (_Err) => {
-  const parse6 = _parse(_Err);
+  const parse7 = _parse(_Err);
   const fn = (schema, value, _ctx, _params) => {
     const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
-    return parse6(schema, value, ctx, finalizeParams(fn, _params));
+    return parse7(schema, value, ctx, finalizeParams(fn, _params));
   };
   return fn;
 }, encode, _decode = (_Err) => {
-  const parse6 = _parse(_Err);
+  const parse7 = _parse(_Err);
   const fn = (schema, value, _ctx, _params) => {
-    return parse6(schema, value, _ctx, finalizeParams(fn, _params));
+    return parse7(schema, value, _ctx, finalizeParams(fn, _params));
   };
   return fn;
 }, decode, _encodeAsync = (_Err) => {
@@ -57795,7 +58184,7 @@ var init_parse = __esm(() => {
   init_core();
   init_errors();
   init_util();
-  parse5 = /* @__PURE__ */ _parse($ZodRealError);
+  parse6 = /* @__PURE__ */ _parse($ZodRealError);
   parseAsync = /* @__PURE__ */ _parseAsync($ZodRealError);
   safeParse = /* @__PURE__ */ _safeParse($ZodRealError);
   safeParseAsync = /* @__PURE__ */ _safeParseAsync($ZodRealError);
@@ -59758,14 +60147,14 @@ var init_schemas = __esm(() => {
       const shape = zod.def.shape;
       const propValues = {};
       for (const key in shape) {
-        const field = shape[key]._zod;
-        if (field.values) {
+        const field2 = shape[key]._zod;
+        if (field2.values) {
           if (!Object.prototype.hasOwnProperty.call(propValues, key)) {
             assignProp(propValues, key, new Set);
           }
-          for (const v of field.values)
+          for (const v of field2.values)
             propValues[key].add(v);
-          if (field.optin !== undefined)
+          if (field2.optin !== undefined)
             propValues[key].add(undefined);
         }
       }
@@ -60720,10 +61109,10 @@ var init_schemas = __esm(() => {
         throw new Error("implement() must be called with a function");
       }
       return Object.defineProperty(function(...args) {
-        const parsedArgs = inst._def.input ? parse5(inst._def.input, args) : args;
+        const parsedArgs = inst._def.input ? parse6(inst._def.input, args) : args;
         const result2 = Reflect.apply(func, this, parsedArgs);
         if (inst._def.output) {
-          return parse5(inst._def.output, result2);
+          return parse6(inst._def.output, result2);
         }
         return result2;
       }, "_zod", { value: inst._zod, enumerable: false });
@@ -72040,11 +72429,11 @@ var formatMap, stringProcessor = (schema, ctx, _json, _params) => {
   }
   const allKeys = new Set(Object.keys(shape));
   const requiredKeys = new Set([...allKeys].filter((key) => {
-    const field = def.shape[key];
+    const field2 = def.shape[key];
     if (ctx.io === "input") {
-      return inputOptin(field) === undefined;
+      return inputOptin(field2) === undefined;
     } else {
-      return field._zod.optout === undefined;
+      return field2._zod.optout === undefined;
     }
   }));
   if (requiredKeys.size > 0) {
@@ -72424,7 +72813,7 @@ __export(exports_core2, {
   prettifyError: () => prettifyError,
   parseURLObject: () => parseURLObject,
   parseAsync: () => parseAsync,
-  parse: () => parse5,
+  parse: () => parse6,
   meta: () => meta,
   mergeValues: () => mergeValues,
   memoizer: () => memoizer,
@@ -72814,12 +73203,12 @@ var init_errors2 = __esm(() => {
 });
 
 // node_modules/zod/v4/classic/parse.js
-var parse7, parseAsync2, safeParse2, safeParseAsync2, encode2, decode2, encodeAsync2, decodeAsync2, safeEncode2, safeDecode2, safeEncodeAsync2, safeDecodeAsync2;
+var parse8, parseAsync2, safeParse2, safeParseAsync2, encode2, decode2, encodeAsync2, decodeAsync2, safeEncode2, safeDecode2, safeEncodeAsync2, safeDecodeAsync2;
 var init_parse2 = __esm(() => {
   init_core2();
   init_errors2();
   init_core2();
-  parse7 = /* @__PURE__ */ _parse(ZodRealError);
+  parse8 = /* @__PURE__ */ _parse(ZodRealError);
   parseAsync2 = /* @__PURE__ */ _parseAsync(ZodRealError);
   safeParse2 = /* @__PURE__ */ _safeParse(ZodRealError);
   safeParseAsync2 = /* @__PURE__ */ _safeParseAsync(ZodRealError);
@@ -73620,7 +74009,7 @@ var init_schemas2 = __esm(() => {
       exports_util.own(this, "~standard", value);
     },
     parse: function _parse2(data, params) {
-      return parse7(this, data, params, { callee: _parse2 });
+      return parse8(this, data, params, { callee: _parse2 });
     },
     parseAsync: async function _parseAsync2(data, params) {
       return await parseAsync2(this, data, params, { callee: _parseAsync2 });
@@ -75313,7 +75702,7 @@ __export(exports_external, {
   pipe: () => pipe,
   partialRecord: () => partialRecord,
   parseAsync: () => parseAsync2,
-  parse: () => parse7,
+  parse: () => parse8,
   overwrite: () => _overwrite,
   output: () => output,
   optional: () => optional,
@@ -75794,7 +76183,7 @@ var init_v4 = __esm(() => {
 });
 
 // src/lib/canonical-json.ts
-import { createHash as createHash13 } from "crypto";
+import { createHash as createHash14 } from "crypto";
 function canonicalJson2(value, maximumBytes = 2 * 1024 * 1024) {
   return canonicalJsonAtDepth(value, maximumBytes, 64);
 }
@@ -75838,7 +76227,7 @@ function canonicalJsonAtDepth(value, maximumBytes, maximumDepth) {
   return visit3(value, 0);
 }
 function canonicalJsonSha256(value, maximumBytes) {
-  return createHash13("sha256").update(canonicalJson2(value, maximumBytes)).digest("hex");
+  return createHash14("sha256").update(canonicalJson2(value, maximumBytes)).digest("hex");
 }
 var init_canonical_json = () => {};
 
@@ -76592,13 +76981,13 @@ var init_remote_workspace_leave = __esm(() => {
 
 // src/lib/auth-store.ts
 import { chmodSync as chmodSync2, existsSync as existsSync20, mkdirSync as mkdirSync11, readFileSync as readFileSync19, renameSync as renameSync7, statSync as statSync11, unlinkSync as unlinkSync5, writeFileSync as writeFileSync9 } from "fs";
-import { basename as basename6, dirname as dirname15, join as join34 } from "path";
+import { basename as basename8, dirname as dirname16, join as join34 } from "path";
 function getAuthFilePath(env3 = process.env) {
   return skillsCredentialFilePath(env3);
 }
 function getIdentityFilePath(env3 = process.env) {
   const file2 = skillsCredentialFilePath(env3);
-  return join34(dirname15(file2), basename6(file2).replace(/^credentials/, "identity") + ".json");
+  return join34(dirname16(file2), basename8(file2).replace(/^credentials/, "identity") + ".json");
 }
 function getAuthIdentity(env3 = process.env) {
   return readIdentity(env3);
@@ -76614,10 +77003,10 @@ function readIdentity(env3 = process.env) {
     if (selected && normalizeSkillsApiOrigin(bound) !== selected)
       return {};
     const identity4 = {};
-    for (const field of ["email", "orgId", "orgSlug", "userId"]) {
-      const value = record6[field];
+    for (const field2 of ["email", "orgId", "orgSlug", "userId"]) {
+      const value = record6[field2];
       if (typeof value === "string" && value.length > 0)
-        identity4[field] = value;
+        identity4[field2] = value;
     }
     return identity4;
   } catch {
@@ -76632,7 +77021,7 @@ function getAuthConfig(env3 = process.env, options = {}) {
 }
 function writeCredentialValues(values2, env3 = process.env) {
   const file2 = skillsCredentialFilePath(env3);
-  mkdirSync11(dirname15(file2), { recursive: true, mode: 448 });
+  mkdirSync11(dirname16(file2), { recursive: true, mode: 448 });
   const lines = [];
   const written = new Set;
   if (existsSync20(file2)) {
@@ -76700,10 +77089,10 @@ function saveAuthConfig(config2, env3 = process.env, authenticatedOrigin) {
   const apiUrl = authenticatedOrigin ? normalizeSkillsApiOrigin(authenticatedOrigin) : resolveSkillsApiOrigin(env3)?.origin ?? defaultFleetGatewayBaseUrl("skills");
   const file2 = writeCredentialValues({ SKILLS_API_KEY: null, SKILLS_API_URL: null, [SKILLS_API_KEY_REF]: null, [SKILLS_API_KEY_ENV]: apiKey, [SKILLS_BOUND_API_URL]: apiUrl, [SKILLS_API_URL_ENV]: apiUrl }, env3);
   const identity4 = {};
-  for (const field of ["email", "orgId", "orgSlug", "userId"]) {
-    const value = config2[field];
+  for (const field2 of ["email", "orgId", "orgSlug", "userId"]) {
+    const value = config2[field2];
     if (typeof value === "string" && value.length > 0)
-      identity4[field] = value;
+      identity4[field2] = value;
   }
   const identityFile = getIdentityFilePath(env3);
   if (Object.keys(identity4).length > 0) {
@@ -76896,15 +77285,44 @@ var init_remote_account = __esm(() => {
   };
 });
 
+// src/lib/remote-credit-checkout.ts
+function creditCheckoutRequestKey(value) {
+  if (value === undefined)
+    return crypto.randomUUID();
+  if (typeof value !== "string" || !creditCheckoutKeyPattern.test(value))
+    throw new Error("Checkout idempotency key must be 8-255 URL-safe characters");
+  return value;
+}
+function creditCheckoutFailure(value, status, key) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return { code: "CREDIT_CHECKOUT_UNCONFIRMED" };
+  const row = value;
+  if (row.requestIdempotencyKey !== undefined && row.requestIdempotencyKey !== key)
+    return { code: "CREDIT_CHECKOUT_UNCONFIRMED" };
+  const code = status === 409 && row.error === "credit checkout in_progress" ? "CREDIT_CHECKOUT_IN_PROGRESS" : status === 409 && row.error === "credit checkout expired" && row.requestIdempotencyKey === key ? "CREDIT_CHECKOUT_EXPIRED" : status === 409 && row.error === "credit checkout fulfilled" && row.requestIdempotencyKey === key ? "CREDIT_CHECKOUT_FULFILLED" : "CREDIT_CHECKOUT_UNCONFIRMED";
+  const delay2 = row.retryAfterSeconds;
+  return { code, ...code === "CREDIT_CHECKOUT_IN_PROGRESS" || status === 503 && row.error === "credit checkout creation unresolved" ? typeof delay2 === "number" && Number.isSafeInteger(delay2) && delay2 > 0 && delay2 <= 3600 ? { retryAfterSeconds: delay2 } : {} : {} };
+}
+var creditCheckoutKeyPattern, creditCheckoutMessages;
+var init_remote_credit_checkout = __esm(() => {
+  creditCheckoutKeyPattern = /^[A-Za-z0-9._:-]{8,255}$/;
+  creditCheckoutMessages = {
+    CREDIT_CHECKOUT_UNCONFIRMED: "Checkout creation could not be confirmed. Keep the request idempotency key, inspect billing, and use the same key for an explicit retry on the same server, account and pack. No automatic retry was made.",
+    CREDIT_CHECKOUT_IN_PROGRESS: "This checkout is still being created. Wait before explicitly retrying the same server, account and pack with the same request idempotency key. No automatic retry was made.",
+    CREDIT_CHECKOUT_EXPIRED: "This checkout has expired. Inspect billing before deliberately starting a new purchase with a new request idempotency key. Do not retry this checkout automatically.",
+    CREDIT_CHECKOUT_FULFILLED: "This checkout is already fulfilled. Inspect the account balance; do not create another checkout to recover this purchase."
+  };
+});
+
 // src/lib/remote-profile.ts
-function customerNamePatch(input2, field) {
-  if (!isRecord4(input2) || Object.keys(input2).length !== 1 || !Object.hasOwn(input2, field))
+function customerNamePatch(input2, field2) {
+  if (!isRecord4(input2) || Object.keys(input2).length !== 1 || !Object.hasOwn(input2, field2))
     throw new Error("Provide only the requested name field.");
-  const value = input2[field];
+  const value = input2[field2];
   if (typeof value !== "string" || /[\p{Cc}\p{Cs}\u2028\u2029]/u.test(value) || !value.trim() || [...value.trim()].length > 100) {
     throw new Error("Use a name of 1\u2013100 characters without control characters or newlines.");
   }
-  return { [field]: value.trim() };
+  return { [field2]: value.trim() };
 }
 function isRecord4(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
@@ -76941,10 +77359,10 @@ async function readQuoteUnavailableCode(response) {
   let timer;
   let deadlineExceeded = false;
   const expired = Symbol("quote body deadline");
-  const deadline = new Promise((resolve14) => {
+  const deadline = new Promise((resolve16) => {
     timer = setTimeout(() => {
       deadlineExceeded = true;
-      resolve14(expired);
+      resolve16(expired);
       reader.cancel().catch(() => {});
     }, 1500);
   });
@@ -77059,6 +77477,7 @@ __export(exports_remote_client, {
   RemoteRouteUnsupportedError: () => RemoteRouteUnsupportedError,
   RemoteRequestError: () => RemoteRequestError,
   RemoteQuoteUnavailableError: () => RemoteQuoteUnavailableError,
+  RemoteCreditCheckoutError: () => RemoteCreditCheckoutError,
   RemoteCapabilityUnavailableError: () => RemoteCapabilityUnavailableError
 });
 
@@ -77509,14 +77928,43 @@ class RemoteSkillsClient {
   async listCreditPacks() {
     return parseRemoteCreditPacks(await (await this.requestNewRoute("/api/v1/billing/credits")).json());
   }
-  async createCreditCheckout(packId) {
+  async createCreditCheckout(packId, options = {}) {
+    const requestIdempotencyKey = creditCheckoutRequestKey(options.idempotencyKey);
     const packs = await this.listCreditPacks();
     if (!packs.some((pack) => pack.id === packId))
       throw new Error("Choose a credit pack returned by skills credits packs");
-    return parseRemoteCheckout(await (await this.requestNewRoute("/api/v1/billing/credits", {
-      method: "POST",
-      body: JSON.stringify({ packId })
-    })).json());
+    let response;
+    try {
+      response = await this.request("/api/v1/billing/credits", {
+        method: "POST",
+        body: JSON.stringify({ packId, idempotencyKey: requestIdempotencyKey })
+      });
+    } catch {
+      throw new RemoteCreditCheckoutError("CREDIT_CHECKOUT_UNCONFIRMED", 0, requestIdempotencyKey);
+    }
+    if (response.status === 404 || response.status === 405) {
+      response.body?.cancel().catch(() => {});
+      throw new RemoteRouteUnsupportedError("/api/v1/billing/credits", response.status, this.apiUrl);
+    }
+    let value;
+    try {
+      value = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(await readBoundedResponse(response, 4096)));
+    } catch {
+      throw new RemoteCreditCheckoutError("CREDIT_CHECKOUT_UNCONFIRMED", response.status, requestIdempotencyKey);
+    }
+    if (!response.ok) {
+      const failure = creditCheckoutFailure(value, response.status, requestIdempotencyKey);
+      throw new RemoteCreditCheckoutError(failure.code, response.status, requestIdempotencyKey, failure.retryAfterSeconds);
+    }
+    try {
+      const checkout = parseRemoteCheckout(value);
+      const echo = value.requestIdempotencyKey;
+      if (echo !== undefined && echo !== requestIdempotencyKey)
+        throw new Error("checkout request key changed");
+      return { ...checkout, requestIdempotencyKey };
+    } catch {
+      throw new RemoteCreditCheckoutError("CREDIT_CHECKOUT_UNCONFIRMED", response.status, requestIdempotencyKey);
+    }
   }
   async getUsage() {
     return this.arrayResponse("/api/v1/billing/usage");
@@ -77749,13 +78197,13 @@ class RemoteSkillsClient {
     return normalizeUpdatedSincePage(await response.json());
   }
 }
-function requireOptionalString(record7, field) {
-  if (record7[field] === undefined)
+function requireOptionalString(record7, field2) {
+  if (record7[field2] === undefined)
     return;
-  if (typeof record7[field] !== "string") {
-    throw new Error(`Remote payload did not match the expected contract (${field} must be a string when present)`);
+  if (typeof record7[field2] !== "string") {
+    throw new Error(`Remote payload did not match the expected contract (${field2} must be a string when present)`);
   }
-  return record7[field];
+  return record7[field2];
 }
 function isVersionRecord(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
@@ -77886,7 +78334,7 @@ async function createRemoteSkillsClient(env3 = process.env) {
 function createRemoteSkillsClientReadOnly(env3 = process.env) {
   return createRemoteSkillsClient(env3);
 }
-var RemoteRouteUnsupportedError, RemoteRequestError, RemoteQuoteUnavailableError, RemoteWorkspaceMemberError, RemoteWorkspaceSelectionError, RemoteCapabilityUnavailableError, INVALID_SKILL_VERSION_RESPONSE = "Remote skill version payload did not match the expected contract.";
+var RemoteRouteUnsupportedError, RemoteRequestError, RemoteCreditCheckoutError, RemoteQuoteUnavailableError, RemoteWorkspaceMemberError, RemoteWorkspaceSelectionError, RemoteCapabilityUnavailableError, INVALID_SKILL_VERSION_RESPONSE = "Remote skill version payload did not match the expected contract.";
 var init_remote_client = __esm(() => {
   init_remote_recurring();
   init_remote_invitations();
@@ -77898,6 +78346,7 @@ var init_remote_client = __esm(() => {
   init_fleet_credentials();
   init_remote_account();
   init_remote_files();
+  init_remote_credit_checkout();
   init_remote_quote_errors();
   init_remote_permissions();
   RemoteRouteUnsupportedError = class RemoteRouteUnsupportedError extends Error {
@@ -77922,6 +78371,19 @@ var init_remote_client = __esm(() => {
       this.name = "RemoteRequestError";
     }
   };
+  RemoteCreditCheckoutError = class RemoteCreditCheckoutError extends RemoteRequestError {
+    code;
+    requestIdempotencyKey;
+    retryAfterSeconds;
+    constructor(code, status, requestIdempotencyKey, retryAfterSeconds) {
+      super("/api/v1/billing/credits", status);
+      this.code = code;
+      this.requestIdempotencyKey = requestIdempotencyKey;
+      this.retryAfterSeconds = retryAfterSeconds;
+      this.name = "RemoteCreditCheckoutError";
+      this.message = creditCheckoutMessages[code];
+    }
+  };
   RemoteQuoteUnavailableError = class RemoteQuoteUnavailableError extends RemoteRequestError {
     code;
     constructor(path, code) {
@@ -77962,7 +78424,7 @@ var init_remote_client = __esm(() => {
 });
 
 // src/lib/revision.ts
-import { createHash as createHash14 } from "crypto";
+import { createHash as createHash15 } from "crypto";
 function revisionIdOf(content) {
   const canonical3 = JSON.stringify({
     slug: content.slug,
@@ -77977,7 +78439,7 @@ function revisionIdOf(content) {
     bundleSha256: content.bundleSha256 ?? null,
     bundleByteSize: content.bundleByteSize ?? null
   });
-  return createHash14("sha256").update(canonical3).digest("hex");
+  return createHash15("sha256").update(canonical3).digest("hex");
 }
 var REVISION_ID_PATTERN;
 var init_revision = __esm(() => {
@@ -78007,7 +78469,7 @@ var init_skill_bundles = __esm(() => {
 
 // src/lib/pull.ts
 import { existsSync as existsSync21, mkdirSync as mkdirSync12, mkdtempSync as mkdtempSync3, readFileSync as readFileSync20, renameSync as renameSync8, rmSync as rmSync6, writeFileSync as writeFileSync10 } from "fs";
-import { dirname as dirname16, join as join35 } from "path";
+import { dirname as dirname17, join as join35 } from "path";
 async function pullSkills(options = {}) {
   const client2 = options.client !== undefined ? options.client : await createRemoteSkillsClient();
   if (!client2) {
@@ -78311,7 +78773,7 @@ function installBundleAtomically(name, entries, options = {}, marker = {}) {
   try {
     for (const entry of entries) {
       const destination = join35(staging, entry.path);
-      mkdirSync12(dirname16(destination), { recursive: true });
+      mkdirSync12(dirname17(destination), { recursive: true });
       writeFileSync10(destination, entry.bytes, { mode: entry.mode });
     }
     writePullMarker(staging, {
@@ -78426,8 +78888,8 @@ var init_pull = __esm(() => {
 });
 
 // src/lib/skill-context.ts
-import { createHash as createHash15 } from "crypto";
-import { resolve as resolve14 } from "path";
+import { createHash as createHash16 } from "crypto";
+import { resolve as resolve16 } from "path";
 function words2(value) {
   return new Set(value.toLowerCase().match(/[a-z0-9]+/g) ?? []);
 }
@@ -78462,7 +78924,7 @@ async function buildSkillContext(input2, options = {}) {
   const promptWords = words2(prompt);
   const promptNames = new Set(prompt.toLowerCase().match(/[a-z0-9]+(?:-[a-z0-9]+)*/g) ?? []);
   const loaded = new Set(resolved.session?.loaded ?? []);
-  const paths = [...input2.paths ?? [], ...input2.cwd ? [input2.cwd, resolve14(input2.cwd)] : []];
+  const paths = [...input2.paths ?? [], ...input2.cwd ? [input2.cwd, resolve16(input2.cwd)] : []];
   const candidates = profile.selections.map((selection) => {
     const key = selectionKey(selection);
     if (input2.restore && loaded.has(key))
@@ -78515,7 +78977,7 @@ ${content}`;
 `);
   const receipt = {
     schemaVersion: 1,
-    id: createHash15("sha256").update(JSON.stringify({ profile: profile.profileRevision, sessionId, selections, omitted })).digest("hex"),
+    id: createHash16("sha256").update(JSON.stringify({ profile: profile.profileRevision, sessionId, selections, omitted })).digest("hex"),
     profileId: profile.profileId,
     profileRevision: profile.profileRevision,
     authority: profile.authority,
@@ -78527,7 +78989,7 @@ ${content}`;
     selections
   };
   if (sessionId)
-    writeSelectionJson(sessionReceiptPath(sessionId, options), { ...resolved.receipt, sessionId, loaded: [...loaded] });
+    writeSkillSession({ ...resolved.receipt, sessionId, loaded: [...loaded] }, { current: resolved.sessionSnapshot, parent: resolved.parentSnapshot }, options);
   return { context, selections, omitted, receipt };
 }
 var init_skill_context = __esm(() => {
@@ -78536,6 +78998,107 @@ var init_skill_context = __esm(() => {
   init_selected_document();
 });
 
+// src/lib/session-reconciliation.ts
+import { createHash as createHash17 } from "crypto";
+function exactTimestamp(value) {
+  const parsed = value === undefined ? Number.NaN : Date.parse(value);
+  if (!Number.isFinite(parsed) || new Date(parsed).toISOString() !== value) {
+    throw new SkillSelectionError("SESSION_PLAN_WINDOW_INVALID", "The reviewed plan must include its exact canonical issuedAt and expiresAt timestamps.");
+  }
+  return parsed;
+}
+function assertPlanWindow(issuedAt, expiresAt, now3) {
+  const issued = exactTimestamp(issuedAt), expires = exactTimestamp(expiresAt);
+  if (expires - issued !== SESSION_RECONCILIATION_PLAN_TTL_MS) {
+    throw new SkillSelectionError("SESSION_PLAN_WINDOW_INVALID", "A session reconciliation approval is valid for exactly five minutes and cannot be extended by the caller.");
+  }
+  if (now3 < issued || now3 >= expires) {
+    throw new SkillSelectionError("SESSION_PLAN_EXPIRED", "The reviewed session reconciliation plan is not currently valid; inspect the receipt and prepare a new plan.");
+  }
+}
+function inspectSkillSession(sessionId, options = {}) {
+  const snapshot = readSkillSessionSnapshot(sessionId, options), { receipt } = snapshot;
+  return {
+    sessionId,
+    path: snapshot.path,
+    receiptSha256: snapshot.sha256,
+    generation: snapshot.generation,
+    verifiedAt: receipt.verifiedAt,
+    authority: receipt.profile.authority,
+    workspaceId: receipt.profile.workspaceId,
+    profileId: receipt.profile.profileId,
+    profileRevision: receipt.profile.profileRevision,
+    selectionCount: receipt.profile.selections.length,
+    loadedCount: receipt.loaded.length
+  };
+}
+async function reconcileSkillSession(input2, options = {}) {
+  if (![input2.fromProfile, input2.fromRevision, input2.selectionProfile, input2.profileRevision].every((value) => typeof value === "string" && value.trim()) || !/^[a-f0-9]{64}$/.test(input2.receiptSha256)) {
+    throw new SkillSelectionError("INVALID_SESSION_RECONCILIATION", "Name the exact old receipt SHA256, old profile/revision and intended target profile/revision.");
+  }
+  if (input2.apply && (!input2.planDigest || !input2.planIssuedAt || !input2.planExpiresAt)) {
+    throw new SkillSelectionError("SESSION_PLAN_REQUIRED", "Review the session reconciliation plan and provide its exact digest, issuedAt and expiresAt before applying it.");
+  }
+  if (!input2.apply && (input2.planDigest !== undefined || input2.planIssuedAt !== undefined || input2.planExpiresAt !== undefined)) {
+    throw new SkillSelectionError("SESSION_PLAN_WINDOW_INVALID", "Plan timestamps are minted by the planner and may only be replayed with --apply.");
+  }
+  const now3 = (options.now ?? Date.now)();
+  const issuedAt = input2.apply ? input2.planIssuedAt : new Date(now3).toISOString();
+  const expiresAt = input2.apply ? input2.planExpiresAt : new Date(now3 + SESSION_RECONCILIATION_PLAN_TTL_MS).toISOString();
+  if (input2.apply)
+    assertPlanWindow(issuedAt, expiresAt, now3);
+  const snapshot = readSkillSessionSnapshot(input2.sessionId, options), old = snapshot.receipt;
+  if (snapshot.sha256 !== input2.receiptSha256 || old.profile.profileId !== input2.fromProfile || old.profile.profileRevision !== input2.fromRevision) {
+    throw new SkillSelectionError("SESSION_RECEIPT_CHANGED", "The current session receipt does not match the reviewed old bytes, profile and revision.");
+  }
+  const client2 = options.client ?? await createProfileClient();
+  const target = structuredClone(await client2.resolveProfile(input2.selectionProfile));
+  validateResolvedProfile(target, client2.authority);
+  if (target.profileId !== input2.selectionProfile || target.profileRevision !== input2.profileRevision) {
+    throw new SkillSelectionError("SESSION_TARGET_CHANGED", "The API selection profile does not match the intended target revision; review the current selection before proceeding.");
+  }
+  if (old.profile.authority !== target.authority || old.profile.workspaceId !== target.workspaceId) {
+    throw new SkillSelectionError("PROFILE_IDENTITY_MISMATCH", "A session reconciliation cannot change its Skills authority or workspace.");
+  }
+  const targetKeys = new Set(target.selections.map(selectionKey));
+  const loaded = old.loaded.filter((key) => targetKeys.has(key));
+  const replacementGeneration = nextSkillSessionGeneration(snapshot.generation);
+  const plan = {
+    schemaVersion: 1,
+    issuedAt,
+    expiresAt,
+    sessionId: input2.sessionId,
+    sessionPath: snapshot.path,
+    before: { receiptSha256: snapshot.sha256, generation: snapshot.generation, profileId: old.profile.profileId, profileRevision: old.profile.profileRevision, selectionCount: old.profile.selections.length },
+    target: { authority: target.authority, workspaceId: target.workspaceId, profileId: target.profileId, profileRevision: target.profileRevision, profileSha256: digest3(target), selectionCount: target.selections.length },
+    replacementGeneration,
+    retainedLoadedCount: loaded.length,
+    retiredLoadedCount: old.loaded.length - loaded.length,
+    scope: "Only this receipt; existing child sessions, project locks, shared profiles, hooks and running processes are unchanged."
+  };
+  const planDigest = digest3(plan);
+  if (input2.planDigest !== undefined && input2.planDigest !== planDigest)
+    throw new SkillSelectionError("SESSION_PLAN_CHANGED", "The session reconciliation plan differs from the reviewed plan.");
+  if (!input2.apply)
+    return { applied: false, plan, planDigest, archivePath: undefined, receiptPath: undefined, beforeSha256: snapshot.sha256, afterSha256: undefined };
+  assertPlanWindow(issuedAt, expiresAt, (options.now ?? Date.now)());
+  const replacement = {
+    ...old,
+    generation: replacementGeneration,
+    verifiedAt: new Date((options.now ?? Date.now)()).toISOString(),
+    profile: target,
+    loaded
+  };
+  const result2 = replaceSkillSession(skillSessionSnapshotBinding(snapshot), replacement, { ...plan, planDigest }, options, () => assertPlanWindow(issuedAt, expiresAt, (options.now ?? Date.now)()));
+  return { applied: true, plan, planDigest, ...result2 };
+}
+var SESSION_RECONCILIATION_PLAN_TTL_MS, digest3 = (value) => createHash17("sha256").update(JSON.stringify(value)).digest("hex");
+var init_session_reconciliation = __esm(() => {
+  init_profile_client();
+  init_selection_cache();
+  SESSION_RECONCILIATION_PLAN_TTL_MS = 5 * 60 * 1000;
+});
+
 // src/cli/commands/context.ts
 var exports_context = {};
 __export(exports_context, {
@@ -78545,7 +79108,7 @@ __export(exports_context, {
   parseSkillContextInput: () => parseSkillContextInput,
   contextResolverOptions: () => contextResolverOptions
 });
-import { readSync as readSync8 } from "fs";
+import { readSync as readSync9 } from "fs";
 function selectedProfileId(explicit) {
   return explicit ?? process.env.HASNA_SKILLS_SELECTION_PROFILE ?? readManagedSkillPolicy()?.profileId ?? "default";
 }
@@ -78559,6 +79122,25 @@ function contextResolverOptions(options) {
   return { cached: true, authority };
 }
 function registerContextCommands(parent) {
+  const sessions = parent.command("sessions").description("Inspect exact session pins and explicitly reconcile one reviewed receipt");
+  sessions.command("show <id>").option("--json", "Return metadata as JSON", false).description("Inspect one session receipt without displaying payloads or changing its pin").action(async (id, options) => {
+    try {
+      const result2 = inspectSkillSession(id);
+      await writeCliOutput(options.json ? JSON.stringify(result2) : `${JSON.stringify(id)}: ${result2.profileId} at ${result2.profileRevision}
+Receipt SHA256: ${result2.receiptSha256}`);
+    } catch (error61) {
+      reportContextError(error61, options.json);
+    }
+  });
+  sessions.command("reconcile <id>").requiredOption("--from-profile <id>", "Expected current session profile").requiredOption("--from-revision <revision>", "Expected current session profile revision").requiredOption("--receipt-sha256 <sha256>", "Expected exact current receipt bytes").requiredOption("--selection-profile <id>", "Intended target selection profile").requiredOption("--profile-revision <revision>", "Expected current API target revision").option("--apply", "Archive the old receipt and atomically apply the reviewed plan", false).option("--plan-digest <sha256>", "Exact reviewed plan digest; required with --apply").option("--plan-issued-at <timestamp>", "Exact reviewed plan issuedAt; required with --apply").option("--plan-expires-at <timestamp>", "Exact reviewed plan expiresAt; required with --apply").option("--json", "Return the plan or application receipt as JSON", false).description("Plan an intentional migration of one session pin; ordinary hooks never migrate pins").action(async (id, options) => {
+    try {
+      const result2 = await reconcileSkillSession({ ...options, sessionId: id });
+      await writeCliOutput(options.json ? JSON.stringify(result2) : result2.applied ? `Reconciled ${JSON.stringify(id)} to ${result2.plan.target.profileId} at ${result2.plan.target.profileRevision}.
+Preserved original receipt: ${result2.archivePath}` : `Planned one session reconciliation. Review --json output, then use --apply --plan-digest ${result2.planDigest} --plan-issued-at ${result2.plan.issuedAt} --plan-expires-at ${result2.plan.expiresAt}.`);
+    } catch (error61) {
+      reportContextError(error61, options.json);
+    }
+  });
   parent.command("load <skill>").description("Load an exact API-selected skill and return its version/digest receipt").option("--selection-profile <id>", "Selection profile (separate from the credential --profile)").option("--cached", "Use only an explicitly selected verified cache, at most 24 hours old", false).option("--session <id>", "Pin this load to a session").option("--file <path>", "Read an exact bundle file (default: SKILL.md, README.md, then CLAUDE.md)").option("--json", "Return content and provenance as JSON", false).action(async (skill, options) => {
     try {
       const result2 = await loadSelectedSkill(skill, selectedProfileId(options.selectionProfile), {
@@ -78604,7 +79186,7 @@ async function readContextStdin() {
   let size2 = 0;
   while (true) {
     const chunk2 = Buffer.allocUnsafe(8192);
-    const count = readSync8(0, chunk2, 0, chunk2.length, null);
+    const count = readSync9(0, chunk2, 0, chunk2.length, null);
     if (count === 0)
       break;
     size2 += count;
@@ -78662,6 +79244,7 @@ var init_context = __esm(() => {
   init_selection_resolver();
   init_selection_cache();
   init_managed_policy();
+  init_session_reconciliation();
 });
 
 // src/cli/commands/profile-sync.ts
@@ -79080,12 +79663,12 @@ function handleBrowseError(error61) {
 async function writeJson(value, space) {
   const text3 = `${JSON.stringify(value, null, space)}
 `;
-  await new Promise((resolve15, reject2) => {
+  await new Promise((resolve17, reject2) => {
     process.stdout.write(text3, (error61) => {
       if (error61)
         reject2(error61);
       else
-        resolve15();
+        resolve17();
     });
   });
 }
@@ -80429,7 +81012,7 @@ var init_init = __esm(() => {
 });
 
 // src/lib/home-adoption.ts
-import { constants as constants10, closeSync as closeSync10, fstatSync as fstatSync10, lstatSync as lstatSync18, openSync as openSync10, readSync as readSync9, existsSync as existsSync24, mkdirSync as mkdirSync13, readdirSync as readdirSync13, readFileSync as readFileSync25, rmSync as rmSync7, statSync as statSync12, writeFileSync as writeFileSync12 } from "fs";
+import { constants as constants11, closeSync as closeSync11, fstatSync as fstatSync11, lstatSync as lstatSync19, openSync as openSync11, readSync as readSync10, existsSync as existsSync24, mkdirSync as mkdirSync13, readdirSync as readdirSync13, readFileSync as readFileSync25, rmSync as rmSync7, statSync as statSync12, writeFileSync as writeFileSync12 } from "fs";
 import { homedir as homedir7 } from "os";
 import { join as join38 } from "path";
 function indexCanonicalCorpus(corpusRoot) {
@@ -80584,25 +81167,25 @@ function adoptUnmarkedHomes(options = {}) {
 function pruneOwnership(dir) {
   let descriptor;
   try {
-    const directory = lstatSync18(dir);
+    const directory = lstatSync19(dir);
     if (!directory.isDirectory())
       return;
-    const markerPath = join38(dir, SYNC_MARKER_FILE), markerPathBefore = lstatSync18(markerPath);
+    const markerPath = join38(dir, SYNC_MARKER_FILE), markerPathBefore = lstatSync19(markerPath);
     if (!markerPathBefore.isFile())
       return;
-    descriptor = openSync10(markerPath, constants10.O_RDONLY | constants10.O_NOFOLLOW | constants10.O_NONBLOCK);
-    const before2 = fstatSync10(descriptor);
+    descriptor = openSync11(markerPath, constants11.O_RDONLY | constants11.O_NOFOLLOW | constants11.O_NONBLOCK);
+    const before2 = fstatSync11(descriptor);
     if (!before2.isFile() || before2.dev !== markerPathBefore.dev || before2.ino !== markerPathBefore.ino || before2.size !== markerPathBefore.size || before2.mtimeMs !== markerPathBefore.mtimeMs || before2.ctimeMs !== markerPathBefore.ctimeMs || before2.size < 1 || before2.size > 65536)
       return;
     const bytes = Buffer.alloc(before2.size + 1);
     let length = 0;
     while (length < bytes.length) {
-      const count = readSync9(descriptor, bytes, length, bytes.length - length, length);
+      const count = readSync10(descriptor, bytes, length, bytes.length - length, length);
       if (!count)
         break;
       length += count;
     }
-    const after2 = fstatSync10(descriptor), current = lstatSync18(dir), markerPathAfter = lstatSync18(markerPath);
+    const after2 = fstatSync11(descriptor), current = lstatSync19(dir), markerPathAfter = lstatSync19(markerPath);
     if (!markerPathAfter.isFile() || markerPathAfter.dev !== before2.dev || markerPathAfter.ino !== before2.ino || markerPathAfter.size !== before2.size || markerPathAfter.mtimeMs !== before2.mtimeMs || markerPathAfter.ctimeMs !== before2.ctimeMs || length !== before2.size || after2.size !== before2.size || after2.mtimeMs !== before2.mtimeMs || after2.ctimeMs !== before2.ctimeMs || !current.isDirectory() || current.dev !== directory.dev || current.ino !== directory.ino)
       return;
     const text3 = bytes.subarray(0, length).toString("utf8"), marker = JSON.parse(text3);
@@ -80613,7 +81196,7 @@ function pruneOwnership(dir) {
     return;
   } finally {
     if (descriptor !== undefined)
-      closeSync10(descriptor);
+      closeSync11(descriptor);
   }
 }
 function pruneStrayHomes(options = {}) {
@@ -80798,7 +81381,7 @@ var init_home_census = __esm(() => {
 });
 
 // src/cli/env-assignment.ts
-import { closeSync as closeSync11, constants as constants11, fstatSync as fstatSync11, ftruncateSync as ftruncateSync2, lstatSync as lstatSync19, openSync as openSync11, readFileSync as readFileSync27, writeSync as writeSync3 } from "fs";
+import { closeSync as closeSync12, constants as constants12, fstatSync as fstatSync12, ftruncateSync as ftruncateSync2, lstatSync as lstatSync20, openSync as openSync12, readFileSync as readFileSync27, writeSync as writeSync3 } from "fs";
 function serializeValue(value) {
   if (controls.test(value))
     throw new EnvAssignmentError("Environment values cannot contain control characters or newlines.");
@@ -80877,7 +81460,7 @@ function setEnvAssignment(path, assignment) {
   try {
     const previous = (() => {
       try {
-        return lstatSync19(path);
+        return lstatSync20(path);
       } catch (error61) {
         if (error61.code === "ENOENT")
           return;
@@ -80886,8 +81469,8 @@ function setEnvAssignment(path, assignment) {
     })();
     if (previous && !previous.isFile())
       throw new EnvAssignmentError("The project .env must be a regular file, not a symlink or special file.");
-    descriptor = openSync11(path, previous ? constants11.O_RDWR | constants11.O_NOFOLLOW | constants11.O_NONBLOCK : constants11.O_WRONLY | constants11.O_CREAT | constants11.O_EXCL | constants11.O_NOFOLLOW, 384);
-    const opened = fstatSync11(descriptor);
+    descriptor = openSync12(path, previous ? constants12.O_RDWR | constants12.O_NOFOLLOW | constants12.O_NONBLOCK : constants12.O_WRONLY | constants12.O_CREAT | constants12.O_EXCL | constants12.O_NOFOLLOW, 384);
+    const opened = fstatSync12(descriptor);
     if (!opened.isFile() || previous && (opened.ino !== previous.ino || opened.dev !== previous.dev)) {
       throw new EnvAssignmentError("The project .env changed while opening it; retry with a regular file.");
     }
@@ -80914,7 +81497,7 @@ function setEnvAssignment(path, assignment) {
     throw new EnvAssignmentError("Cannot safely read or write the project .env file.");
   } finally {
     if (descriptor !== undefined)
-      closeSync11(descriptor);
+      closeSync12(descriptor);
   }
 }
 var INVALID_LAYOUT = "Cannot safely update .env with multiline or unsupported assignments. Use single-line KEY=VALUE entries or edit the file manually.", controls, EnvAssignmentError;
@@ -81397,12 +81980,12 @@ function parseExecution(value) {
   ].includes(v.status) || typeof v.skill !== "string" || typeof v.version !== "string" || !Array.isArray(v.artifacts))
     throw Error("Unsupported cloud execution response");
   runId(v.id);
-  for (const field of [
+  for (const field2 of [
     "bundleDigest",
     "inputDigest",
     "runtimeImageDigest"
   ])
-    if (typeof v[field] !== "string" || !/^(sha256:)?[a-f0-9]{64}$/.test(v[field]))
+    if (typeof v[field2] !== "string" || !/^(sha256:)?[a-f0-9]{64}$/.test(v[field2]))
       throw Error("Invalid cloud execution integrity receipt");
   return v;
 }
@@ -81423,11 +82006,11 @@ var init_cloud_executions = __esm(() => {
 // node_modules/@hasna/secrets/dist/sdk.js
 import { isIP as isIP3 } from "net";
 import { spawnSync as spawnSync2 } from "child_process";
-import { closeSync as closeSync12, fstatSync as fstatSync12, openSync as openSync12, readFileSync as readFileSync29 } from "fs";
+import { closeSync as closeSync13, fstatSync as fstatSync13, openSync as openSync13, readFileSync as readFileSync29 } from "fs";
 import { O_NOFOLLOW as O_NOFOLLOW3, O_NONBLOCK as O_NONBLOCK3, O_RDONLY as O_RDONLY3 } from "constants";
 import { createRequire as createRequire2 } from "module";
 import { hostname as osHostname2 } from "os";
-import { isAbsolute as isAbsolute13, join as join41 } from "path";
+import { isAbsolute as isAbsolute15, join as join41 } from "path";
 import { createRequire as createRequire22 } from "module";
 function envToken2(name) {
   return name.toUpperCase().replace(/-/g, "_");
@@ -81451,7 +82034,7 @@ function homeDir2(env3) {
 }
 function absoluteOverride2(env3, key) {
   const value = env3[key]?.trim();
-  return value && isAbsolute13(value) ? value : null;
+  return value && isAbsolute15(value) ? value : null;
 }
 function hasnaHomeDir2(env3) {
   const override = absoluteOverride2(env3, HASNA_HOME_ENV_KEY2);
@@ -81528,7 +82111,7 @@ function readAppConfigFile2(path) {
   };
   let fd = -1;
   try {
-    fd = openSync12(path, O_RDONLY3 | O_NOFOLLOW3 | O_NONBLOCK3);
+    fd = openSync13(path, O_RDONLY3 | O_NOFOLLOW3 | O_NONBLOCK3);
   } catch (error61) {
     const code = error61.code;
     if (code === "ENOENT" || code === "ENOTDIR")
@@ -81538,7 +82121,7 @@ function readAppConfigFile2(path) {
     unsafe(`the path could not be opened (${code ?? "unknown error"})`);
   }
   try {
-    const before2 = fstatSync12(fd);
+    const before2 = fstatSync13(fd);
     if (!before2.isFile())
       unsafe("the path is not a regular file");
     if (!configFileModeAllowed2(before2.mode)) {
@@ -81550,14 +82133,14 @@ function readAppConfigFile2(path) {
     if (before2.size > MAX_CREDENTIAL_FILE_BYTES2)
       unsafe("the file exceeds the size limit");
     const bytes = readFileSync29(fd);
-    const after2 = fstatSync12(fd);
+    const after2 = fstatSync13(fd);
     if (!configFileReadsCoherent2(before2, after2)) {
       unsafe("the file changed while being read");
     }
     return parseEnvFile2(bytes.toString("utf8"));
   } finally {
     if (fd !== -1)
-      closeSync12(fd);
+      closeSync13(fd);
   }
 }
 function readCredentialFile2(path, apiKeyKeys) {
@@ -82588,7 +83171,7 @@ function createSecretsClientFromEnv(env3 = process.env, overrides = {}) {
   });
   return new SecretsClient({ ...clientOverrides, baseUrl, apiKey });
 }
-var __esm2 = (fn, res) => () => (fn && (res = fn(fn = 0)), res), CREDENTIAL_PROFILE_ENV_KEY2 = "HASNA_PROFILE", CredentialResolutionError2, CredentialFileUnsafeError2, HASNA_HOME_ENV_KEY2 = "HASNA_HOME", HASNA_CONFIG_HOME_ENV_KEY2 = "HASNA_CONFIG_HOME", KEYCHAIN_STATION_ENV_KEY2 = "HASNA_STATION", HASNA_HOME_DIR2 = ".hasna", CONFIG_SUBDIR2 = "config", CREDENTIALS_FILE2 = "credentials", KEYCHAIN_SECURITY_BIN2 = "/usr/bin/security", KEYCHAIN_SERVICE_PREFIX2 = "hasna.credentials", KEYCHAIN_ITEM_NOT_FOUND_STATUS2 = 44, KEYCHAIN_SPAWN_TIMEOUT_MS2 = 1e4, MAX_CREDENTIAL_FILE_BYTES2, SAFE_APP_SLUG2, SAFE_PROFILE2, ILLEGAL_IN_HEADER_VALUE2, VAULT_POINTER_SHAPE2, CREDENTIAL_SHAPED_KEY2, INSPECT_CUSTOM2, CREDENTIAL_SEAL2, CALLER_SUPPLIED_CREDENTIAL_PROVIDER_SOURCE = "caller-supplied CredentialProvider", AMBIENT_ENVIRONMENT2, SECRETS_PACKAGE_SPECIFIER, requireSecretsSdk2, DEFAULT_FLEET_GATEWAY_ORIGIN2 = "https://api.hasna.com", DEFAULT_AUTHORITY_SOURCE = "default", ASCII_CONTROL_PATTERN2, DNS_LABEL_PATTERN2, ClientTransportConfigurationError2, HasnaHttpError, DEFAULT_RETRY_STATUSES, IDEMPOTENT_METHODS2, AUTHORITY_OVERRIDE_HEADERS2, defaultSleep = (ms) => new Promise((resolve15) => setTimeout(resolve15, ms)), init_transport2, MAX_CREDENTIAL_FILE_BYTES22, INSPECT_CUSTOM22, CREDENTIAL_SEAL22, AMBIENT_ENVIRONMENT22, SECRETS_PACKAGE_SPECIFIER2, requireSecretsSdk22, IDEMPOTENT_METHODS22, AUTHORITY_OVERRIDE_HEADERS22, init_storage, PATHS_RESOLVER_APP_SLUG_RE3, SQLITE_SIDECAR_FILES, LEGACY_SERVICE_FILES, init_data_dir, SecretsTestIsolationError, TEST_ENTRYPOINT_RE, init_test_isolation, init_client, ApiError;
+var __esm2 = (fn, res) => () => (fn && (res = fn(fn = 0)), res), CREDENTIAL_PROFILE_ENV_KEY2 = "HASNA_PROFILE", CredentialResolutionError2, CredentialFileUnsafeError2, HASNA_HOME_ENV_KEY2 = "HASNA_HOME", HASNA_CONFIG_HOME_ENV_KEY2 = "HASNA_CONFIG_HOME", KEYCHAIN_STATION_ENV_KEY2 = "HASNA_STATION", HASNA_HOME_DIR2 = ".hasna", CONFIG_SUBDIR2 = "config", CREDENTIALS_FILE2 = "credentials", KEYCHAIN_SECURITY_BIN2 = "/usr/bin/security", KEYCHAIN_SERVICE_PREFIX2 = "hasna.credentials", KEYCHAIN_ITEM_NOT_FOUND_STATUS2 = 44, KEYCHAIN_SPAWN_TIMEOUT_MS2 = 1e4, MAX_CREDENTIAL_FILE_BYTES2, SAFE_APP_SLUG2, SAFE_PROFILE2, ILLEGAL_IN_HEADER_VALUE2, VAULT_POINTER_SHAPE2, CREDENTIAL_SHAPED_KEY2, INSPECT_CUSTOM2, CREDENTIAL_SEAL2, CALLER_SUPPLIED_CREDENTIAL_PROVIDER_SOURCE = "caller-supplied CredentialProvider", AMBIENT_ENVIRONMENT2, SECRETS_PACKAGE_SPECIFIER, requireSecretsSdk2, DEFAULT_FLEET_GATEWAY_ORIGIN2 = "https://api.hasna.com", DEFAULT_AUTHORITY_SOURCE = "default", ASCII_CONTROL_PATTERN2, DNS_LABEL_PATTERN2, ClientTransportConfigurationError2, HasnaHttpError, DEFAULT_RETRY_STATUSES, IDEMPOTENT_METHODS2, AUTHORITY_OVERRIDE_HEADERS2, defaultSleep = (ms) => new Promise((resolve17) => setTimeout(resolve17, ms)), init_transport2, MAX_CREDENTIAL_FILE_BYTES22, INSPECT_CUSTOM22, CREDENTIAL_SEAL22, AMBIENT_ENVIRONMENT22, SECRETS_PACKAGE_SPECIFIER2, requireSecretsSdk22, IDEMPOTENT_METHODS22, AUTHORITY_OVERRIDE_HEADERS22, init_storage, PATHS_RESOLVER_APP_SLUG_RE3, SQLITE_SIDECAR_FILES, LEGACY_SERVICE_FILES, init_data_dir, SecretsTestIsolationError, TEST_ENTRYPOINT_RE, init_test_isolation, init_client, ApiError;
 var init_sdk = __esm(() => {
   init_transport2 = __esm2(() => {
     CredentialResolutionError2 = class CredentialResolutionError3 extends Error {
@@ -82723,7 +83306,7 @@ var init_sdk = __esm(() => {
 });
 
 // src/lib/execution-secrets.ts
-import { constants as constants12, closeSync as closeSync13, fstatSync as fstatSync13, openSync as openSync13, readSync as readSync10, realpathSync as realpathSync6 } from "fs";
+import { constants as constants13, closeSync as closeSync14, fstatSync as fstatSync14, openSync as openSync14, readSync as readSync11, realpathSync as realpathSync6 } from "fs";
 import { hostname as stationHostname } from "os";
 function selectedSecretBindingsTemplate(scope, names, createClient2 = createSecretsClientFromEnv) {
   let secretsAuthority;
@@ -82747,7 +83330,7 @@ function refuse(code, message) {
 function record7(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
-function exactKeys(value, keys2) {
+function exactKeys2(value, keys2) {
   return Object.keys(value).length === keys2.length && keys2.every((key) => Object.hasOwn(value, key));
 }
 function identifier2(value) {
@@ -82767,13 +83350,13 @@ function declaredSecretNames(value) {
 function readSelectedSecretBindings(path) {
   let fd;
   try {
-    fd = openSync13(path, constants12.O_RDONLY | constants12.O_NOFOLLOW | constants12.O_NONBLOCK);
-    const stat2 = fstatSync13(fd);
+    fd = openSync14(path, constants13.O_RDONLY | constants13.O_NOFOLLOW | constants13.O_NONBLOCK);
+    const stat2 = fstatSync14(fd);
     if (!stat2.isFile() || stat2.size > 65536)
       throw new Error;
     const bytes = Buffer.alloc(65537);
     let size2 = 0, count;
-    while ((count = readSync10(fd, bytes, size2, bytes.length - size2, null)) > 0) {
+    while ((count = readSync11(fd, bytes, size2, bytes.length - size2, null)) > 0) {
       size2 += count;
       if (size2 > 65536)
         throw new Error;
@@ -82783,11 +83366,11 @@ function readSelectedSecretBindings(path) {
     return refuse("INVALID_SECRET_BINDINGS", "Secret bindings must be a regular JSON file of at most 64 KiB, containing reference names only.");
   } finally {
     if (fd !== undefined)
-      closeSync13(fd);
+      closeSync14(fd);
   }
 }
 function validateSelectedSecretBindings(value, scope, names) {
-  if (!record7(value) || !exactKeys(value, ["schema", "selection", "consumer", "secretsAuthority", "bindings"]) || value.schema !== "hasna.skills-secret-bindings.v1" || !record7(value.selection) || !exactKeys(value.selection, ["authority", "workspaceId", "profileId", "profileRevision", "slug", "version", "bundleDigest"]) || !record7(value.consumer) || !exactKeys(value.consumer, ["stationId", "workspaceDirectory"]) || !record7(value.bindings)) {
+  if (!record7(value) || !exactKeys2(value, ["schema", "selection", "consumer", "secretsAuthority", "bindings"]) || value.schema !== "hasna.skills-secret-bindings.v1" || !record7(value.selection) || !exactKeys2(value.selection, ["authority", "workspaceId", "profileId", "profileRevision", "slug", "version", "bundleDigest"]) || !record7(value.consumer) || !exactKeys2(value.consumer, ["stationId", "workspaceDirectory"]) || !record7(value.bindings)) {
     return refuse("INVALID_SECRET_BINDINGS", "Secret bindings do not match the hasna.skills-secret-bindings.v1 contract.");
   }
   for (const [key, expected] of Object.entries({ authority: scope.selection.authority, workspaceId: scope.selection.workspaceId, profileId: scope.profileId, profileRevision: scope.selection.profileRevision, slug: scope.selection.slug, version: scope.selection.version, bundleDigest: scope.selection.bundleDigest })) {
@@ -82812,7 +83395,7 @@ function validateSelectedSecretBindings(value, scope, names) {
   } catch {
     return refuse("INVALID_SECRET_BINDINGS", "Secret bindings require a canonical HTTPS Secrets /v1 authority (loopback HTTP is allowed).");
   }
-  if (!exactKeys(value.bindings, names) || Object.values(value.bindings).some((key) => !identifier2(key) || !/^[A-Za-z0-9][A-Za-z0-9._/-]*$/.test(key) || key.split("/").some((part) => !part || part === "." || part === ".."))) {
+  if (!exactKeys2(value.bindings, names) || Object.values(value.bindings).some((key) => !identifier2(key) || !/^[A-Za-z0-9][A-Za-z0-9._/-]*$/.test(key) || key.split("/").some((part) => !part || part === "." || part === ".."))) {
     return refuse("INVALID_SECRET_BINDINGS", "Bind every declared environment name exactly once to a vault key; undeclared bindings and values are refused.");
   }
   return structuredClone(value);
@@ -82990,7 +83573,7 @@ var init_execution_grants = __esm(() => {
 });
 
 // src/lib/execution-grant-client.ts
-import { isDeepStrictEqual as isDeepStrictEqual3 } from "util";
+import { isDeepStrictEqual as isDeepStrictEqual4 } from "util";
 function id(value) {
   if (!grantIdentifier(value))
     throw new Error("Invalid execution grant profile or revision identifier.");
@@ -83042,7 +83625,7 @@ async function saveExecutionGrantPolicy(profileId, grants, revision) {
     headers: revision === undefined ? { "If-None-Match": "*" } : { "If-Match": `"${revision}"` },
     body: JSON.stringify({ grants: snapshot })
   }));
-  if (policy.profileId !== profileId || policy.previousRevision !== (revision ?? null) || !isDeepStrictEqual3(policy.grants, snapshot)) {
+  if (policy.profileId !== profileId || policy.previousRevision !== (revision ?? null) || !isDeepStrictEqual4(policy.grants, snapshot)) {
     throw new Error("The API did not preserve the reviewed execution grant policy; read it before retrying.");
   }
   return policy;
@@ -83053,7 +83636,7 @@ async function resolveExecutionGrant(input2) {
   if (!grantRecord(value) || Object.keys(value).length !== 3 || !grantIdentifier(value.policyRevision) || !grantIdentifier(value.grantId) || !grantRecord(value.bindings)) {
     throw new SkillSelectionError("INVALID_EXECUTION_GRANT", "The Skills API returned an invalid execution grant.");
   }
-  if (!isDeepStrictEqual3(value.bindings.selection, snapshot.selection) || !isDeepStrictEqual3(value.bindings.consumer, snapshot.consumer)) {
+  if (!isDeepStrictEqual4(value.bindings.selection, snapshot.selection) || !isDeepStrictEqual4(value.bindings.consumer, snapshot.consumer)) {
     throw new SkillSelectionError("EXECUTION_GRANT_SCOPE_MISMATCH", "The Skills API returned a grant for a different selection or consumer.");
   }
   return value;
@@ -83072,10 +83655,10 @@ __export(exports_selected_run, {
   prepareSelectedSecretBindings: () => prepareSelectedSecretBindings,
   executeSelectedLocal: () => executeSelectedLocal
 });
-import { createHash as createHash16 } from "crypto";
+import { createHash as createHash18 } from "crypto";
 import { spawn as spawn2 } from "child_process";
 import { mkdirSync as mkdirSync14, mkdtempSync as mkdtempSync4, writeFileSync as writeFileSync13, realpathSync as realpathSync7 } from "fs";
-import { dirname as dirname17, join as join42, resolve as resolve15 } from "path";
+import { dirname as dirname18, join as join42, resolve as resolve17 } from "path";
 import { tmpdir, hostname as stationHostname2 } from "os";
 async function resolveSelectedRun(spec, profileId, options = {}) {
   const context = await resolveSelectionContext(profileId, options);
@@ -83164,11 +83747,11 @@ async function executeSelectedLocal(selected, options = {}) {
       throw new SkillSelectionError("INVALID_BUNDLE_PATH", "The execution bundle path exceeds its limit.");
     });
     const destination = join42(runDirectory, entry.path);
-    mkdirSync14(dirname17(destination), { recursive: true, mode: 448 });
+    mkdirSync14(dirname18(destination), { recursive: true, mode: 448 });
     writeFileSync13(destination, entry.bytes, { flag: "wx", mode: entry.mode & 511 });
   }
   env3.SKILLS_INPUT_JSON = input2;
-  env3.SKILLS_WORKSPACE_DIR = resolve15(options.cwd ?? process.cwd());
+  env3.SKILLS_WORKSPACE_DIR = resolve17(options.cwd ?? process.cwd());
   env3.SKILLS_RUN_DIR = runDirectory;
   if (runtime.version) {
     const version2 = await subprocess([executable, ...runtimeName === "bun" ? ["--no-env-file"] : [], "--version"], runDirectory, env3, "", Math.min(timeoutMs, 5000));
@@ -83198,7 +83781,7 @@ async function executeSelectedLocal(selected, options = {}) {
     selection: selection2,
     target: "local",
     runtime: runtimeName,
-    inputDigest: `sha256:${createHash16("sha256").update(input2).digest("hex")}`,
+    inputDigest: `sha256:${createHash18("sha256").update(input2).digest("hex")}`,
     runDirectory,
     ...executionGrant ? { executionGrant } : {},
     ...bindings ? { secretBinding: { schema: bindings.schema, selection: bindings.selection, consumer: bindings.consumer, secretsAuthority: bindings.secretsAuthority, bindings: bindings.bindings } } : {},
@@ -87415,7 +87998,7 @@ var init_runs = __esm(() => {
 });
 
 // src/lib/run-state.ts
-import { createHash as createHash17, randomBytes } from "crypto";
+import { createHash as createHash19, randomBytes } from "crypto";
 import { existsSync as existsSync27, mkdirSync as mkdirSync15, readFileSync as readFileSync30, readdirSync as readdirSync16, statSync as statSync15, writeFileSync as writeFileSync14 } from "fs";
 import { extname, join as join43, relative as relative6 } from "path";
 function createSkillRun(params, targetDir = process.cwd()) {
@@ -87552,7 +88135,7 @@ function collectRunArtifacts(context) {
     artifacts.push({
       path: toProjectRelative(context.targetDir, path),
       mime: mimeForPath(path),
-      sha256: createHash17("sha256").update(bytes).digest("hex"),
+      sha256: createHash19("sha256").update(bytes).digest("hex"),
       sizeBytes: stat2.size
     });
   }
@@ -88555,12 +89138,12 @@ class StdioServerTransport {
     this.onclose?.();
   }
   send(message) {
-    return new Promise((resolve16) => {
+    return new Promise((resolve18) => {
       const json2 = serializeMessage(message);
       if (this._stdout.write(json2)) {
-        resolve16();
+        resolve18();
       } else {
-        this._stdout.once("drain", resolve16);
+        this._stdout.once("drain", resolve18);
       }
     });
   }
@@ -88602,7 +89185,7 @@ var init_schemas3 = __esm(() => {
       own(this, "with", value);
     },
     parse(data, params) {
-      return parse5(this, data, params, { callee: this.parse });
+      return parse6(this, data, params, { callee: this.parse });
     },
     parseAsync(data, params) {
       return parseAsync(this, data, params, { callee: this.parseAsync });
@@ -90746,7 +91329,7 @@ class Protocol {
           return;
         }
         const pollInterval = task2.pollInterval ?? this._options?.defaultTaskPollInterval ?? 1000;
-        await new Promise((resolve16) => setTimeout(resolve16, pollInterval));
+        await new Promise((resolve18) => setTimeout(resolve18, pollInterval));
         options?.signal?.throwIfAborted();
       }
     } catch (error61) {
@@ -90758,7 +91341,7 @@ class Protocol {
   }
   request(request2, resultSchema, options) {
     const { relatedRequestId, resumptionToken, onresumptiontoken, task, relatedTask } = options ?? {};
-    return new Promise((resolve16, reject2) => {
+    return new Promise((resolve18, reject2) => {
       const earlyReject = (error61) => {
         reject2(error61);
       };
@@ -90836,7 +91419,7 @@ class Protocol {
           if (!parseResult.success) {
             reject2(parseResult.error);
           } else {
-            resolve16(parseResult.data);
+            resolve18(parseResult.data);
           }
         } catch (error61) {
           reject2(error61);
@@ -91027,12 +91610,12 @@ class Protocol {
         interval = task.pollInterval;
       }
     } catch {}
-    return new Promise((resolve16, reject2) => {
+    return new Promise((resolve18, reject2) => {
       if (signal.aborted) {
         reject2(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
         return;
       }
-      const timeoutId = setTimeout(resolve16, interval);
+      const timeoutId = setTimeout(resolve18, interval);
       signal.addEventListener("abort", () => {
         clearTimeout(timeoutId);
         reject2(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
@@ -91509,11 +92092,11 @@ var require_codegen = __commonJS((exports) => {
       const rhs = this.rhs === undefined ? "" : ` = ${this.rhs}`;
       return `${varKind} ${this.name}${rhs};` + _n;
     }
-    optimizeNames(names, constants13) {
+    optimizeNames(names, constants14) {
       if (!names[this.name.str])
         return;
       if (this.rhs)
-        this.rhs = optimizeExpr(this.rhs, names, constants13);
+        this.rhs = optimizeExpr(this.rhs, names, constants14);
       return this;
     }
     get names() {
@@ -91531,10 +92114,10 @@ var require_codegen = __commonJS((exports) => {
     render({ _n }) {
       return `${this.lhs} = ${this.rhs};` + _n;
     }
-    optimizeNames(names, constants13) {
+    optimizeNames(names, constants14) {
       if (this.lhs instanceof code_1.Name && !names[this.lhs.str] && !this.sideEffects)
         return;
-      this.rhs = optimizeExpr(this.rhs, names, constants13);
+      this.rhs = optimizeExpr(this.rhs, names, constants14);
       return this;
     }
     get names() {
@@ -91600,8 +92183,8 @@ var require_codegen = __commonJS((exports) => {
     optimizeNodes() {
       return `${this.code}` ? this : undefined;
     }
-    optimizeNames(names, constants13) {
-      this.code = optimizeExpr(this.code, names, constants13);
+    optimizeNames(names, constants14) {
+      this.code = optimizeExpr(this.code, names, constants14);
       return this;
     }
     get names() {
@@ -91631,12 +92214,12 @@ var require_codegen = __commonJS((exports) => {
       }
       return nodes.length > 0 ? this : undefined;
     }
-    optimizeNames(names, constants13) {
+    optimizeNames(names, constants14) {
       const { nodes } = this;
       let i = nodes.length;
       while (i--) {
         const n2 = nodes[i];
-        if (n2.optimizeNames(names, constants13))
+        if (n2.optimizeNames(names, constants14))
           continue;
         subtractNames(names, n2.names);
         nodes.splice(i, 1);
@@ -91693,12 +92276,12 @@ var require_codegen = __commonJS((exports) => {
         return;
       return this;
     }
-    optimizeNames(names, constants13) {
+    optimizeNames(names, constants14) {
       var _a3;
-      this.else = (_a3 = this.else) === null || _a3 === undefined ? undefined : _a3.optimizeNames(names, constants13);
-      if (!(super.optimizeNames(names, constants13) || this.else))
+      this.else = (_a3 = this.else) === null || _a3 === undefined ? undefined : _a3.optimizeNames(names, constants14);
+      if (!(super.optimizeNames(names, constants14) || this.else))
         return;
-      this.condition = optimizeExpr(this.condition, names, constants13);
+      this.condition = optimizeExpr(this.condition, names, constants14);
       return this;
     }
     get names() {
@@ -91723,10 +92306,10 @@ var require_codegen = __commonJS((exports) => {
     render(opts) {
       return `for(${this.iteration})` + super.render(opts);
     }
-    optimizeNames(names, constants13) {
-      if (!super.optimizeNames(names, constants13))
+    optimizeNames(names, constants14) {
+      if (!super.optimizeNames(names, constants14))
         return;
-      this.iteration = optimizeExpr(this.iteration, names, constants13);
+      this.iteration = optimizeExpr(this.iteration, names, constants14);
       return this;
     }
     get names() {
@@ -91764,10 +92347,10 @@ var require_codegen = __commonJS((exports) => {
     render(opts) {
       return `for(${this.varKind} ${this.name} ${this.loop} ${this.iterable})` + super.render(opts);
     }
-    optimizeNames(names, constants13) {
-      if (!super.optimizeNames(names, constants13))
+    optimizeNames(names, constants14) {
+      if (!super.optimizeNames(names, constants14))
         return;
-      this.iterable = optimizeExpr(this.iterable, names, constants13);
+      this.iterable = optimizeExpr(this.iterable, names, constants14);
       return this;
     }
     get names() {
@@ -91812,11 +92395,11 @@ var require_codegen = __commonJS((exports) => {
       (_b = this.finally) === null || _b === undefined || _b.optimizeNodes();
       return this;
     }
-    optimizeNames(names, constants13) {
+    optimizeNames(names, constants14) {
       var _a3, _b;
-      super.optimizeNames(names, constants13);
-      (_a3 = this.catch) === null || _a3 === undefined || _a3.optimizeNames(names, constants13);
-      (_b = this.finally) === null || _b === undefined || _b.optimizeNames(names, constants13);
+      super.optimizeNames(names, constants14);
+      (_a3 = this.catch) === null || _a3 === undefined || _a3.optimizeNames(names, constants14);
+      (_b = this.finally) === null || _b === undefined || _b.optimizeNames(names, constants14);
       return this;
     }
     get names() {
@@ -92090,7 +92673,7 @@ var require_codegen = __commonJS((exports) => {
   function addExprNames(names, from) {
     return from instanceof code_1._CodeOrName ? addNames(names, from.names) : names;
   }
-  function optimizeExpr(expr, names, constants13) {
+  function optimizeExpr(expr, names, constants14) {
     if (expr instanceof code_1.Name)
       return replaceName(expr);
     if (!canOptimize(expr))
@@ -92105,14 +92688,14 @@ var require_codegen = __commonJS((exports) => {
       return items;
     }, []));
     function replaceName(n2) {
-      const c = constants13[n2.str];
+      const c = constants14[n2.str];
       if (c === undefined || names[n2.str] !== 1)
         return n2;
       delete names[n2.str];
       return c;
     }
     function canOptimize(e2) {
-      return e2 instanceof code_1._Code && e2._items.some((c) => c instanceof code_1.Name && names[c.str] === 1 && constants13[c.str] !== undefined);
+      return e2 instanceof code_1._Code && e2._items.some((c) => c instanceof code_1.Name && names[c.str] === 1 && constants14[c.str] !== undefined);
     }
   }
   function subtractNames(names, from) {
@@ -94017,7 +94600,7 @@ var require_compile = __commonJS((exports) => {
     const schOrFunc = root2.refs[ref];
     if (schOrFunc)
       return schOrFunc;
-    let _sch = resolve16.call(this, root2, ref);
+    let _sch = resolve18.call(this, root2, ref);
     if (_sch === undefined) {
       const schema = (_a3 = root2.localRefs) === null || _a3 === undefined ? undefined : _a3[ref];
       const { schemaId } = this.opts;
@@ -94044,7 +94627,7 @@ var require_compile = __commonJS((exports) => {
   function sameSchemaEnv(s1, s2) {
     return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
   }
-  function resolve16(root2, ref) {
+  function resolve18(root2, ref) {
     let sch;
     while (typeof (sch = this.refs[ref]) == "string")
       ref = sch;
@@ -94842,11 +95425,11 @@ var require_fast_uri = __commonJS((exports, module) => {
     if (typeof uri === "string") {
       uri = normalizeString(uri, options);
     } else if (typeof uri === "object") {
-      uri = parse10(serialize(uri, options), options);
+      uri = parse11(serialize(uri, options), options);
     }
     return uri;
   }
-  function resolve16(baseURI, relativeURI, options) {
+  function resolve18(baseURI, relativeURI, options) {
     const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
     const {
       parsed: baseParsed,
@@ -94882,8 +95465,8 @@ var require_fast_uri = __commonJS((exports, module) => {
   function resolveComponent(base2, relative7, options, skipNormalization) {
     const target = {};
     if (!skipNormalization) {
-      base2 = parse10(serialize(base2, options), options);
-      relative7 = parse10(serialize(relative7, options), options);
+      base2 = parse11(serialize(base2, options), options);
+      relative7 = parse11(serialize(relative7, options), options);
     }
     options = options || {};
     if (!options.tolerant && relative7.scheme) {
@@ -95183,7 +95766,7 @@ var require_fast_uri = __commonJS((exports, module) => {
     }
     return { parsed, malformedAuthorityOrPort, malformedPercentEncoding, malformedSchemeSpecific, malformedHost, malformedScheme };
   }
-  function parse10(uri, opts) {
+  function parse11(uri, opts) {
     return parseWithStatus(uri, opts).parsed;
   }
   function normalizeString(uri, opts) {
@@ -95216,11 +95799,11 @@ var require_fast_uri = __commonJS((exports, module) => {
   var fastUri = {
     SCHEMES,
     normalize: normalize3,
-    resolve: resolve16,
+    resolve: resolve18,
     resolveComponent,
     equal,
     serialize,
-    parse: parse10
+    parse: parse11
   };
   module.exports = fastUri;
   module.exports.default = fastUri;
@@ -99002,7 +99585,7 @@ class McpServer {
     let task = createTaskResult.task;
     const pollInterval = task.pollInterval ?? 5000;
     while (task.status !== "completed" && task.status !== "failed" && task.status !== "cancelled") {
-      await new Promise((resolve16) => setTimeout(resolve16, pollInterval));
+      await new Promise((resolve18) => setTimeout(resolve18, pollInterval));
       const updatedTask = await extra.taskStore.getTask(taskId);
       if (!updatedTask) {
         throw new McpError(ErrorCode.InternalError, `Task ${taskId} not found during polling`);
@@ -99045,11 +99628,11 @@ class McpServer {
       return EMPTY_COMPLETION_RESULT;
     }
     const promptShape = getObjectShape(prompt.argsSchema);
-    const field = promptShape?.[request2.params.argument.name];
-    if (!isCompletable(field)) {
+    const field2 = promptShape?.[request2.params.argument.name];
+    if (!isCompletable(field2)) {
       return EMPTY_COMPLETION_RESULT;
     }
-    const completer = getCompleter(field);
+    const completer = getCompleter(field2);
     if (!completer) {
       return EMPTY_COMPLETION_RESULT;
     }
@@ -99321,8 +99904,8 @@ class McpServer {
     };
     this._registeredPrompts[name] = registeredPrompt;
     if (argsSchema) {
-      const hasCompletable = Object.values(argsSchema).some((field) => {
-        const inner = field instanceof ZodOptional ? field._def?.innerType : field;
+      const hasCompletable = Object.values(argsSchema).some((field2) => {
+        const inner = field2 instanceof ZodOptional ? field2._def?.innerType : field2;
         return isCompletable(inner);
       });
       if (hasCompletable) {
@@ -99514,9 +100097,9 @@ function promptArgumentsFromSchema(schema) {
   const shape = getObjectShape(schema);
   if (!shape)
     return [];
-  return Object.entries(shape).map(([name, field]) => {
-    const description = getSchemaDescription(field);
-    const isOptional = isSchemaOptional(field);
+  return Object.entries(shape).map(([name, field2]) => {
+    const description = getSchemaDescription(field2);
+    const isOptional = isSchemaOptional(field2);
     return {
       name,
       description,
@@ -99575,7 +100158,7 @@ var init_remote_customer_operations = __esm(() => {
     { name: "list_remote_skills", title: "List Remote Skills", parameter: null, mutates: false, invoke: (client2) => client2.listSkills() },
     { name: "get_billing_status", title: "Get Billing Status", parameter: null, mutates: false, invoke: (client2) => client2.getBillingStatus() },
     { name: "list_credit_packs", title: "List Credit Packs", parameter: null, mutates: false, invoke: (client2) => client2.listCreditPacks() },
-    { name: "create_credit_checkout", title: "Create Credit Checkout", parameter: "pack_id", mutates: true, invoke: (client2, value) => client2.createCreditCheckout(value) },
+    { name: "create_credit_checkout", title: "Create Credit Checkout", parameter: "pack_id", mutates: true, invoke: (client2, value, options) => client2.createCreditCheckout(value, options) },
     { name: "get_billing_usage", title: "Get Billing Usage", parameter: null, mutates: false, invoke: (client2) => client2.getUsage() },
     { name: "list_invoices", title: "List Invoices", parameter: null, mutates: false, invoke: (client2) => client2.listInvoices() },
     { name: "create_billing_checkout", title: "Create Billing Checkout", parameter: null, mutates: true, invoke: (client2) => client2.createBillingCheckout() },
@@ -99689,7 +100272,7 @@ var init_remote_invitation_recovery = __esm(() => {
 });
 
 // src/lib/remote-private-publications.ts
-import { createHash as createHash18 } from "crypto";
+import { createHash as createHash20 } from "crypto";
 function checkedPublicationDeclaration(value) {
   if (!exact(value, ["idempotencyKey", "version", "expectedCurrentVersionId", "manifestText", "archiveSha256", "archiveByteSize"]) || !publicationUuid(value.idempotencyKey) || !(value.expectedCurrentVersionId === null || publicationUuid(value.expectedCurrentVersionId)) || typeof value.version !== "string" || !value.version || value.version.length > 128 || /[\p{Cc}\p{Cs}]/u.test(value.version) || typeof value.manifestText !== "string" || Buffer.byteLength(value.manifestText) > 16384 || !hash3(value.archiveSha256) || !Number.isSafeInteger(value.archiveByteSize) || Number(value.archiveByteSize) < 1 || Number(value.archiveByteSize) > PRIVATE_PUBLICATION_MAX_BYTES)
     return bad();
@@ -99934,12 +100517,12 @@ class RemotePrivatePublicationsClient {
       previous = view;
       if (!["queued", "verifying"].includes(view.state) || Date.now() >= until)
         return view;
-      await new Promise((resolve16) => {
+      await new Promise((resolve18) => {
         const timer = setTimeout(done, Math.min(1000, until - Date.now()));
         function done() {
           clearTimeout(timer);
           options.signal?.removeEventListener("abort", done);
-          resolve16();
+          resolve18();
         }
         options.signal?.addEventListener("abort", done, { once: true });
       });
@@ -99950,7 +100533,7 @@ var PRIVATE_PUBLICATION_MAX_BYTES, failures2, PrivatePublicationError, bad = ()
   throw new PrivatePublicationError("INVALID_PUBLICATION_INPUT", "Invalid publication input or recovery data.");
 }, invalid5 = () => {
   throw new PrivatePublicationError("INVALID_PUBLICATION_RESPONSE", "The server returned an invalid publication result.");
-}, publicationUuid = (v) => typeof v === "string" && /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/.test(v), hash3 = (v) => typeof v === "string" && /^[a-f0-9]{64}$/.test(v), record10 = (v) => !!v && typeof v === "object" && !Array.isArray(v), exact = (v, keys3) => record10(v) && Object.keys(v).sort().join(",") === keys3.sort().join(","), date6 = (v) => typeof v === "string" && /^\d{4}-\d\d-\d\dT[0-9:.]+(?:Z|[+-](?:[01]\d|2[0-3]):[0-5]\d)$/.test(v) && Number.isFinite(Date.parse(v)), publicationSha256 = (bytes) => createHash18("sha256").update(bytes).digest("hex");
+}, publicationUuid = (v) => typeof v === "string" && /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/.test(v), hash3 = (v) => typeof v === "string" && /^[a-f0-9]{64}$/.test(v), record10 = (v) => !!v && typeof v === "object" && !Array.isArray(v), exact = (v, keys3) => record10(v) && Object.keys(v).sort().join(",") === keys3.sort().join(","), date6 = (v) => typeof v === "string" && /^\d{4}-\d\d-\d\dT[0-9:.]+(?:Z|[+-](?:[01]\d|2[0-3]):[0-5]\d)$/.test(v) && Number.isFinite(Date.parse(v)), publicationSha256 = (bytes) => createHash20("sha256").update(bytes).digest("hex");
 var init_remote_private_publications = __esm(() => {
   init_fleet_credentials();
   init_remote_workspace_selection();
@@ -100227,11 +100810,11 @@ var init_remote_auth = __esm(() => {
 });
 
 // src/lib/workspace-profile.ts
-import { constants as constants13, closeSync as closeSync14, fstatSync as fstatSync14, lstatSync as lstatSync20, mkdirSync as mkdirSync16, mkdtempSync as mkdtempSync5, openSync as openSync14, readFileSync as readFileSync31, renameSync as renameSync9, rmSync as rmSync8, writeFileSync as writeFileSync15 } from "fs";
-import { dirname as dirname18, join as join44 } from "path";
+import { constants as constants14, closeSync as closeSync15, fstatSync as fstatSync15, lstatSync as lstatSync21, mkdirSync as mkdirSync16, mkdtempSync as mkdtempSync5, openSync as openSync15, readFileSync as readFileSync31, renameSync as renameSync9, rmSync as rmSync8, writeFileSync as writeFileSync15 } from "fs";
+import { dirname as dirname19, join as join44 } from "path";
 function stat2(path) {
   try {
-    return lstatSync20(path);
+    return lstatSync21(path);
   } catch (error61) {
     if (error61.code === "ENOENT")
       return null;
@@ -100241,14 +100824,14 @@ function stat2(path) {
 function safeText(file2) {
   if (stat2(file2) === null)
     return null;
-  const fd = openSync14(file2, constants13.O_RDONLY | constants13.O_NOFOLLOW | constants13.O_NONBLOCK);
+  const fd = openSync15(file2, constants14.O_RDONLY | constants14.O_NOFOLLOW | constants14.O_NONBLOCK);
   try {
-    const s = fstatSync14(fd);
+    const s = fstatSync15(fd);
     if (!s.isFile() || s.size > 65536 || ![256, 384].includes(s.mode & 4095) || process.getuid && s.uid !== process.getuid())
       return fail2("The selected profile must use bounded owner-only regular files.");
     return readFileSync31(fd, "utf8");
   } finally {
-    closeSync14(fd);
+    closeSync15(fd);
   }
 }
 function checkIdentityMetadata(file2, identity4) {
@@ -100313,18 +100896,18 @@ async function prepareWorkspaceEnrollment(membershipId, source = process.env) {
 `);
   if (Buffer.byteLength(credentialBody("x".repeat(8192)), "utf8") > 65536)
     return fail2("The selected profile has insufficient space for a bounded credential. Reduce its unrelated configuration before signing in.");
-  const parents = [];
-  for (let path = dirname18(file2);; path = dirname18(path)) {
+  const parents2 = [];
+  for (let path = dirname19(file2);; path = dirname19(path)) {
     const before2 = stat2(path);
     if (before2 && (!before2.isDirectory() || before2.isSymbolicLink()))
       return fail2("The profile directory must not be a symbolic link.");
-    parents.push([path, before2]);
-    if (path === dirname18(path))
+    parents2.push([path, before2]);
+    if (path === dirname19(path))
       break;
   }
   const unchanged2 = () => {
     unchangedFiles();
-    for (const [path, before2] of parents) {
+    for (const [path, before2] of parents2) {
       const now3 = stat2(path);
       if (!before2 ? now3 !== null : !now3 || !now3.isDirectory() || before2.dev !== now3.dev || before2.ino !== now3.ino)
         changed();
@@ -100378,14 +100961,14 @@ async function prepareWorkspaceEnrollment(membershipId, source = process.env) {
           return fail2("The new profile exceeds the credential reader size limit.");
         const identity4 = JSON.stringify({ email: verified.user.email, userId: verified.user.id, orgId: verified.organization.id, orgSlug: verified.organization.slug, apiUrl: origin }, null, 2) + `
 `;
-        mkdirSync16(dirname18(file2), { recursive: true, mode: 448 });
-        const temp = mkdtempSync5(join44(dirname18(file2), ".workspace-login-"));
+        mkdirSync16(dirname19(file2), { recursive: true, mode: 448 });
+        const temp = mkdtempSync5(join44(dirname19(file2), ".workspace-login-"));
         let identityInstalled = false;
         try {
           writeFileSync15(join44(temp, "credentials"), body, { mode: 384, flag: "wx" });
           writeFileSync15(join44(temp, "identity"), identity4, { mode: 384, flag: "wx" });
           unchangedFiles();
-          for (const [path, before2] of parents) {
+          for (const [path, before2] of parents2) {
             const now3 = stat2(path);
             if (!now3 || !now3.isDirectory() || now3.isSymbolicLink() || before2 && (before2.dev !== now3.dev || before2.ino !== now3.ino))
               changed();
@@ -100595,8 +101178,8 @@ var init_recurring_customer = __esm(() => {
 });
 
 // src/lib/recurring-recovery.ts
-import { constants as constants14, closeSync as closeSync15, fsyncSync as fsyncSync3, fstatSync as fstatSync15, lstatSync as lstatSync21, mkdirSync as mkdirSync17, openSync as openSync15, readSync as readSync11, realpathSync as realpathSync8, renameSync as renameSync10, unlinkSync as unlinkSync6, writeFileSync as writeFileSync16 } from "fs";
-import { dirname as dirname19, isAbsolute as isAbsolute14, join as join45, resolve as resolve16 } from "path";
+import { constants as constants15, closeSync as closeSync16, fsyncSync as fsyncSync4, fstatSync as fstatSync16, lstatSync as lstatSync22, mkdirSync as mkdirSync17, openSync as openSync16, readSync as readSync12, realpathSync as realpathSync8, renameSync as renameSync10, unlinkSync as unlinkSync6, writeFileSync as writeFileSync16 } from "fs";
+import { dirname as dirname20, isAbsolute as isAbsolute16, join as join45, resolve as resolve18 } from "path";
 import { randomUUID as randomUUID7 } from "crypto";
 
 class RecoveryOwner {
@@ -100604,14 +101187,14 @@ class RecoveryOwner {
   parents = [];
   constructor(directory) {
     this.directory = directory;
-    if (!isAbsolute14(directory) || resolve16(directory) !== directory || realpathSync8(directory) !== directory)
+    if (!isAbsolute16(directory) || resolve18(directory) !== directory || realpathSync8(directory) !== directory)
       invalid6();
-    for (let path = directory;; path = dirname19(path)) {
-      const stat3 = lstatSync21(path);
+    for (let path = directory;; path = dirname20(path)) {
+      const stat3 = lstatSync22(path);
       if (!stat3.isDirectory() || stat3.isSymbolicLink())
         invalid6();
       this.parents.push({ path, dev: stat3.dev, ino: stat3.ino });
-      if (path === dirname19(path))
+      if (path === dirname20(path))
         break;
     }
     this.assert();
@@ -100620,59 +101203,59 @@ class RecoveryOwner {
     if (realpathSync8(this.directory) !== this.directory)
       invalid6();
     for (const prior of this.parents) {
-      const now3 = lstatSync21(prior.path);
+      const now3 = lstatSync22(prior.path);
       if (!now3.isDirectory() || now3.isSymbolicLink() || now3.dev !== prior.dev || now3.ino !== prior.ino)
         invalid6();
     }
-    const own2 = lstatSync21(this.directory);
+    const own2 = lstatSync22(this.directory);
     if ((own2.mode & 511) !== 448 || (own2.mode & 3584) !== 0 || process.getuid && own2.uid !== process.getuid())
       invalid6();
   }
   read(name) {
     this.assert();
-    const fd = openSync15(join45(this.directory, name), constants14.O_RDONLY | constants14.O_NOFOLLOW | constants14.O_NONBLOCK);
+    const fd = openSync16(join45(this.directory, name), constants15.O_RDONLY | constants15.O_NOFOLLOW | constants15.O_NONBLOCK);
     try {
-      const before2 = fstatSync15(fd);
+      const before2 = fstatSync16(fd);
       if (!before2.isFile() || before2.nlink !== 1 || (before2.mode & 4095) !== 384 || before2.size < 1 || before2.size > 8192 || process.getuid && before2.uid !== process.getuid())
         invalid6();
       const bytes = Buffer.alloc(before2.size + 1);
       let size2 = 0;
       while (size2 < bytes.length) {
-        const n2 = readSync11(fd, bytes, size2, bytes.length - size2, size2);
+        const n2 = readSync12(fd, bytes, size2, bytes.length - size2, size2);
         if (!n2)
           break;
         size2 += n2;
       }
-      const after2 = fstatSync15(fd), path = lstatSync21(join45(this.directory, name));
+      const after2 = fstatSync16(fd), path = lstatSync22(join45(this.directory, name));
       if (size2 !== before2.size || after2.size !== before2.size || before2.mtimeMs !== after2.mtimeMs || before2.ctimeMs !== after2.ctimeMs || path.dev !== before2.dev || path.ino !== before2.ino || !path.isFile() || path.isSymbolicLink())
         invalid6();
       this.assert();
       return new TextDecoder("utf-8", { fatal: true }).decode(bytes.subarray(0, size2));
     } finally {
-      closeSync15(fd);
+      closeSync16(fd);
     }
   }
   write(name, value) {
     this.assert();
     const bytes = canonicalJson2(value, 8192) + `
 `;
-    const fd = openSync15(join45(this.directory, name), constants14.O_WRONLY | constants14.O_CREAT | constants14.O_EXCL | constants14.O_NOFOLLOW, 384);
+    const fd = openSync16(join45(this.directory, name), constants15.O_WRONLY | constants15.O_CREAT | constants15.O_EXCL | constants15.O_NOFOLLOW, 384);
     try {
       writeFileSync16(fd, bytes);
-      fsyncSync3(fd);
+      fsyncSync4(fd);
     } finally {
-      closeSync15(fd);
+      closeSync16(fd);
     }
     this.assert();
     this.sync();
   }
   sync() {
     this.assert();
-    const fd = openSync15(this.directory, constants14.O_RDONLY | constants14.O_NOFOLLOW);
+    const fd = openSync16(this.directory, constants15.O_RDONLY | constants15.O_NOFOLLOW);
     try {
-      fsyncSync3(fd);
+      fsyncSync4(fd);
     } finally {
-      closeSync15(fd);
+      closeSync16(fd);
     }
   }
   saveState(state, expected) {
@@ -100690,20 +101273,20 @@ class RecoveryOwner {
     this.assert();
     let fd;
     try {
-      fd = openSync15(join45(this.directory, "operation.lock"), constants14.O_WRONLY | constants14.O_CREAT | constants14.O_EXCL | constants14.O_NOFOLLOW, 384);
+      fd = openSync16(join45(this.directory, "operation.lock"), constants15.O_WRONLY | constants15.O_CREAT | constants15.O_EXCL | constants15.O_NOFOLLOW, 384);
     } catch {
       throw new RecurringCustomerError("RECURRING_RECOVERY_BUSY", "Recovery is locked. Confirm the original process has stopped before explicitly reconciling the retained lock; no request was retried.");
     }
-    const owner2 = fstatSync15(fd);
+    const owner2 = fstatSync16(fd);
     try {
       writeFileSync16(fd, JSON.stringify({ pid: process.pid }));
-      fsyncSync3(fd);
+      fsyncSync4(fd);
       this.sync();
       return await action();
     } finally {
-      closeSync15(fd);
+      closeSync16(fd);
       this.assert();
-      const now3 = lstatSync21(join45(this.directory, "operation.lock"));
+      const now3 = lstatSync22(join45(this.directory, "operation.lock"));
       if (owner2.dev !== now3.dev || owner2.ino !== now3.ino || !now3.isFile() || now3.isSymbolicLink())
         invalid6();
       unlinkSync6(join45(this.directory, "operation.lock"));
@@ -100739,7 +101322,7 @@ function base2(customer, organizationId) {
   };
 }
 function create3(directory, intent) {
-  if (!isAbsolute14(directory) || resolve16(directory) !== directory || realpathSync8(dirname19(directory)) !== dirname19(directory))
+  if (!isAbsolute16(directory) || resolve18(directory) !== directory || realpathSync8(dirname20(directory)) !== dirname20(directory))
     invalid6();
   mkdirSync17(directory, { mode: 448 });
   const owner2 = new RecoveryOwner(directory), checked = intentSchema.parse(intent), intentSha256 = canonicalJsonSha256(checked);
@@ -100902,7 +101485,7 @@ var init_recurring_recovery = __esm(() => {
 });
 
 // src/lib/recurring-surface.ts
-import { isAbsolute as isAbsolute15 } from "path";
+import { isAbsolute as isAbsolute17 } from "path";
 function recurringMcpSchema(action) {
   return action === "activate" ? recurringSurfaceSchemas.activate.extend({ code, confirm: exports_external.literal(true) }) : recurringSurfaceSchemas[action];
 }
@@ -101007,7 +101590,7 @@ var init_recurring_surface = __esm(() => {
   uuid13 = exports_external.string().regex(/^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/);
   context = { userId: uuid13.optional(), membershipId: uuid13.optional() };
   page2 = { limit: exports_external.number().int().min(1).max(100).optional(), cursor: exports_external.string().min(1).max(2048).optional() };
-  directory = exports_external.string().max(4096).refine(isAbsolute15, "Use an absolute recovery directory");
+  directory = exports_external.string().max(4096).refine(isAbsolute17, "Use an absolute recovery directory");
   email4 = exports_external.string().trim().toLowerCase().email().max(254);
   code = exports_external.string().regex(/^\d{6}$/);
   recurringSurfaceSchemas = {
@@ -101976,11 +102559,11 @@ var init_mcp_contracts = __esm(() => {
     name: operation.name,
     title: operation.title,
     description: `${operation.title} on the configured server; unavailable capabilities fail explicitly.`,
-    params: operation.parameter ? [operation.parameter] : [],
+    params: operation.parameter ? [operation.parameter, ...operation.name === "create_credit_checkout" ? ["idempotency_key?"] : []] : [],
     category: "execution",
     sideEffects: operation.mutates ? "local-process-or-remote-run" : "none",
     stable: true,
-    inputSchema: objectSchema(operation.parameter ? { [operation.parameter]: stringSchema("Server resource identifier.") } : {}, operation.parameter ? [operation.parameter] : []),
+    inputSchema: objectSchema(operation.parameter ? { [operation.parameter]: stringSchema("Server resource identifier."), ...operation.name === "create_credit_checkout" ? { idempotency_key: { type: "string", pattern: "^[A-Za-z0-9._:-]{8,255}$", description: "Caller-owned key retained before submission; reuse only for explicit recovery of the same server/account/pack." } } : {} } : {}, operation.parameter ? [operation.parameter] : []),
     outputSchema: { oneOf: [objectSchema({}, [], "Server response.", true), { type: "array", items: objectSchema({}, [], "Server record.", true) }] }
   }));
   remoteCustomerContracts.push({
@@ -102913,14 +103496,14 @@ var init_operation_tools = __esm(() => {
 
 // src/lib/feedback.ts
 import { appendFileSync as appendFileSync2, existsSync as existsSync29, mkdirSync as mkdirSync18 } from "fs";
-import { dirname as dirname20, join as join47 } from "path";
+import { dirname as dirname21, join as join47 } from "path";
 import { Database } from "bun:sqlite";
 function getFeedbackDbPath() {
   return join47(getDataDir(), "skills.db");
 }
 function getFeedbackDb() {
   const dbPath = getFeedbackDbPath();
-  const dir = dirname20(dbPath);
+  const dir = dirname21(dbPath);
   if (!existsSync29(dir))
     mkdirSync18(dir, { recursive: true });
   const db = new Database(dbPath);
@@ -102949,7 +103532,7 @@ function saveFeedback(input2) {
   const category = input2.category ?? "general";
   if (isApiMode()) {
     const path = join47(getDataDir(), "feedback.jsonl");
-    const dir = dirname20(path);
+    const dir = dirname21(path);
     if (!existsSync29(dir))
       mkdirSync18(dir, { recursive: true });
     appendFileSync2(path, JSON.stringify({ message, category, email: input2.email ?? null, agent: input2.agent ?? null, version: input2.version ?? null, createdAt: new Date().toISOString() }) + `
@@ -103427,7 +104010,7 @@ var init_schedule_tools = __esm(() => {
 });
 
 // src/lib/native-storage.ts
-import { createHash as createHash19, createHmac as createHmac3 } from "crypto";
+import { createHash as createHash21, createHmac as createHmac3 } from "crypto";
 import {
   existsSync as existsSync31,
   mkdirSync as mkdirSync20,
@@ -103436,7 +104019,7 @@ import {
   statSync as statSync17,
   writeFileSync as writeFileSync18
 } from "fs";
-import { dirname as dirname21, join as join49, normalize as normalize3, relative as relative7, sep as sep7 } from "path";
+import { dirname as dirname22, join as join49, normalize as normalize3, relative as relative7, sep as sep7 } from "path";
 function resolveSkillsNativeStorageConfig(env3 = process.env) {
   assertNoRetiredModeEnvVars(env3, {
     app: SKILLS_ENV_NAMESPACE,
@@ -103504,7 +104087,7 @@ function exportSkillsLocalSnapshot(targetDir = process.cwd(), options = {}) {
       files.push({
         path: relativePath,
         sizeBytes: bytes.byteLength,
-        sha256: createHash19("sha256").update(bytes).digest("hex"),
+        sha256: createHash21("sha256").update(bytes).digest("hex"),
         ...options.includeFileContents ? { contentBase64: Buffer.from(bytes).toString("base64") } : {}
       });
     }
@@ -103796,20 +104379,20 @@ var init_private_publication_customer = __esm(() => {
 });
 
 // src/lib/private-publication-recovery.ts
-import { constants as constants15, closeSync as closeSync16, fsyncSync as fsyncSync4, fstatSync as fstatSync16, lstatSync as lstatSync22, mkdirSync as mkdirSync21, openSync as openSync16, readSync as readSync12, realpathSync as realpathSync9, renameSync as renameSync11, unlinkSync as unlinkSync7, writeFileSync as writeFileSync19 } from "fs";
-import { dirname as dirname22, isAbsolute as isAbsolute16, join as join50, resolve as resolve17 } from "path";
+import { constants as constants16, closeSync as closeSync17, fsyncSync as fsyncSync5, fstatSync as fstatSync17, lstatSync as lstatSync23, mkdirSync as mkdirSync21, openSync as openSync17, readSync as readSync13, realpathSync as realpathSync9, renameSync as renameSync11, unlinkSync as unlinkSync7, writeFileSync as writeFileSync19 } from "fs";
+import { dirname as dirname23, isAbsolute as isAbsolute18, join as join50, resolve as resolve19 } from "path";
 import { randomUUID as randomUUID8 } from "crypto";
 function safeDirectory(directory2) {
-  if (!isAbsolute16(directory2) || directory2 !== resolve17(directory2) || realpathSync9(directory2) !== directory2)
+  if (!isAbsolute18(directory2) || directory2 !== resolve19(directory2) || realpathSync9(directory2) !== directory2)
     return fail3();
-  for (let path = directory2;; path = dirname22(path)) {
-    const stat3 = lstatSync22(path);
+  for (let path = directory2;; path = dirname23(path)) {
+    const stat3 = lstatSync23(path);
     if (!stat3.isDirectory() || stat3.isSymbolicLink())
       return fail3();
-    if (path === dirname22(path))
+    if (path === dirname23(path))
       break;
   }
-  const own2 = lstatSync22(directory2);
+  const own2 = lstatSync23(directory2);
   if ((own2.mode & 63) !== 0 || process.getuid && own2.uid !== process.getuid())
     return fail3();
   return { dev: own2.dev, ino: own2.ino };
@@ -103821,35 +104404,35 @@ function unchangedDirectory(directory2, identity4) {
 }
 function readOwned(directory2, name, max2) {
   const identity4 = safeDirectory(directory2), file2 = join50(directory2, name);
-  const fd = openSync16(file2, constants15.O_RDONLY | constants15.O_NOFOLLOW);
+  const fd = openSync17(file2, constants16.O_RDONLY | constants16.O_NOFOLLOW);
   try {
-    const stat3 = fstatSync16(fd);
+    const stat3 = fstatSync17(fd);
     if (!stat3.isFile() || stat3.nlink !== 1 || stat3.size > max2 || stat3.size < 1 || (stat3.mode & 63) !== 0 || process.getuid && stat3.uid !== process.getuid())
       return fail3();
     const buffer = Buffer.alloc(Math.min(max2, stat3.size) + 1);
     let length = 0;
     while (length < buffer.length) {
-      const count = readSync12(fd, buffer, length, buffer.length - length, length);
+      const count = readSync13(fd, buffer, length, buffer.length - length, length);
       if (count === 0)
         break;
       length += count;
     }
-    const bytes = buffer.subarray(0, length), after2 = fstatSync16(fd);
+    const bytes = buffer.subarray(0, length), after2 = fstatSync17(fd);
     unchangedDirectory(directory2, identity4);
     if (bytes.length !== stat3.size || stat3.size !== after2.size || stat3.mtimeMs !== after2.mtimeMs || stat3.ctimeMs !== after2.ctimeMs)
       return fail3();
     return bytes;
   } finally {
-    closeSync16(fd);
+    closeSync17(fd);
   }
 }
 function writeOwned(directory2, name, bytes) {
-  const fd = openSync16(join50(directory2, name), constants15.O_WRONLY | constants15.O_CREAT | constants15.O_EXCL | constants15.O_NOFOLLOW, 384);
+  const fd = openSync17(join50(directory2, name), constants16.O_WRONLY | constants16.O_CREAT | constants16.O_EXCL | constants16.O_NOFOLLOW, 384);
   try {
     writeFileSync19(fd, bytes);
-    fsyncSync4(fd);
+    fsyncSync5(fd);
   } finally {
-    closeSync16(fd);
+    closeSync17(fd);
   }
 }
 function save(directory2, value) {
@@ -103858,11 +104441,11 @@ function save(directory2, value) {
 `);
   unchangedDirectory(directory2, identity4);
   renameSync11(join50(directory2, temporary), join50(directory2, "receipt.json"));
-  const fd = openSync16(directory2, constants15.O_RDONLY | constants15.O_NOFOLLOW);
+  const fd = openSync17(directory2, constants16.O_RDONLY | constants16.O_NOFOLLOW);
   try {
-    fsyncSync4(fd);
+    fsyncSync5(fd);
   } finally {
-    closeSync16(fd);
+    closeSync17(fd);
   }
 }
 function bind2(client2, receipt) {
@@ -103873,20 +104456,20 @@ async function locked(directory2, action) {
   const identity4 = safeDirectory(directory2), file2 = join50(directory2, "operation.lock");
   let fd;
   try {
-    fd = openSync16(file2, constants15.O_WRONLY | constants15.O_CREAT | constants15.O_EXCL | constants15.O_NOFOLLOW, 384);
+    fd = openSync17(file2, constants16.O_WRONLY | constants16.O_CREAT | constants16.O_EXCL | constants16.O_NOFOLLOW, 384);
   } catch {
     throw new PrivatePublicationError("PUBLICATION_RECOVERY_BUSY", "Another operation holds this recovery directory. If it crashed, confirm that process has stopped before explicitly removing operation.lock and resuming.");
   }
-  const lock = fstatSync16(fd);
+  const lock = fstatSync17(fd);
   try {
     writeFileSync19(fd, JSON.stringify({ pid: process.pid }) + `
 `);
-    fsyncSync4(fd);
+    fsyncSync5(fd);
     return await action();
   } finally {
-    closeSync16(fd);
+    closeSync17(fd);
     unchangedDirectory(directory2, identity4);
-    const now3 = lstatSync22(file2);
+    const now3 = lstatSync23(file2);
     if (now3.dev !== lock.dev || now3.ino !== lock.ino || !now3.isFile() || now3.isSymbolicLink())
       fail3();
     unlinkSync7(file2);
@@ -103938,15 +104521,15 @@ async function preparePrivatePublication(client2, sourceDirectory, recoveryDirec
     phase: "prepared",
     intent: null
   };
-  if (!isAbsolute16(recoveryDirectory) || resolve17(recoveryDirectory) !== recoveryDirectory || realpathSync9(dirname22(recoveryDirectory)) !== dirname22(recoveryDirectory))
+  if (!isAbsolute18(recoveryDirectory) || resolve19(recoveryDirectory) !== recoveryDirectory || realpathSync9(dirname23(recoveryDirectory)) !== dirname23(recoveryDirectory))
     return fail3();
   mkdirSync21(recoveryDirectory, { mode: 448 });
   safeDirectory(recoveryDirectory);
-  const parent = openSync16(dirname22(recoveryDirectory), constants15.O_RDONLY | constants15.O_NOFOLLOW);
+  const parent = openSync17(dirname23(recoveryDirectory), constants16.O_RDONLY | constants16.O_NOFOLLOW);
   try {
-    fsyncSync4(parent);
+    fsyncSync5(parent);
   } finally {
-    closeSync16(parent);
+    closeSync17(parent);
   }
   writeOwned(recoveryDirectory, "bundle.tgz", packed.bytes);
   save(recoveryDirectory, receipt);
@@ -104039,10 +104622,10 @@ var init_private_publication_recovery = __esm(() => {
 });
 
 // src/mcp/private-publication-tools.ts
-import { isAbsolute as isAbsolute17 } from "path";
+import { isAbsolute as isAbsolute19 } from "path";
 function registerPrivatePublicationTools(server) {
   const uuid9 = exports_external.string().regex(/^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/);
-  const directory2 = exports_external.string().max(4096).refine(isAbsolute17, "Use an absolute local directory");
+  const directory2 = exports_external.string().max(4096).refine(isAbsolute19, "Use an absolute local directory");
   const verification2 = { email: exports_external.string().email().max(254), code: exports_external.string().regex(/^\d{6}$/), userId: uuid9, membershipId: uuid9, recoveryDirectory: directory2 };
   const description = "Manage a private source publication using fresh workspace-bound verification and a host-local recovery directory. Publishing requires explicit UUID current-version comparison and upload consent. Resume reuses immutable saved bytes and intent; an uncertain PUT is finalized for server verification, never uploaded twice. Sessions and signed URLs are not returned or persisted. Private execution is unavailable. Host request history may contain the supplied verification code.";
   const handler = (action) => async (value) => {
@@ -104197,6 +104780,14 @@ function registerRemoteCustomerTools(server) {
     });
   }
   for (const operation of REMOTE_CUSTOMER_OPERATIONS) {
+    if (operation.name === "create_credit_checkout") {
+      server.registerTool(operation.name, {
+        title: operation.title,
+        description: "Create one external checkout link on the selected Skills server. Retain an idempotency_key before calling and reuse it only for explicit recovery on the same server, account and pack. No automatic retries; payment requires customer confirmation.",
+        inputSchema: { pack_id: exports_external.string().min(1), idempotency_key: exports_external.string().regex(/^[A-Za-z0-9._:-]{8,255}$/).optional() }
+      }, ({ pack_id, idempotency_key }) => callRemote((client2) => operation.invoke(client2, pack_id, { idempotencyKey: idempotency_key })));
+      continue;
+    }
     const inputSchema = {};
     if (operation.parameter)
       inputSchema[operation.parameter] = exports_external.string().min(1);
@@ -104273,6 +104864,15 @@ async function callRemote(action) {
       return mcpError("AUTH_REQUIRED", "Configure a Skills API and sign in with skills auth login");
     return mcpJson(await action(client2));
   } catch (error61) {
+    if (error61 instanceof RemoteCreditCheckoutError) {
+      return { ...mcpJson({
+        code: error61.code,
+        message: error61.message,
+        status: error61.status,
+        requestIdempotencyKey: error61.requestIdempotencyKey,
+        ...error61.retryAfterSeconds === undefined ? {} : { retryAfterSeconds: error61.retryAfterSeconds }
+      }), isError: true };
+    }
     if (error61 instanceof RemoteCapabilityUnavailableError) {
       return { ...mcpJson({ code: error61.code, message: error61.message, status: error61.status }), isError: true };
     }
@@ -104385,7 +104985,7 @@ var init_mcp2 = __esm(() => {
 // src/cli/commands/runtime-mcp.ts
 import { existsSync as existsSync32, mkdirSync as mkdirSync22, readFileSync as readFileSync34, writeFileSync as writeFileSync20 } from "fs";
 import { homedir as homedir9 } from "os";
-import { dirname as dirname23, join as join51 } from "path";
+import { dirname as dirname24, join as join51 } from "path";
 async function handleMcp(options) {
   if (options.register) {
     let agents;
@@ -104559,7 +105159,7 @@ function writeJsonObject(path, data) {
 `);
 }
 function writeTextFile(path, content) {
-  mkdirSync22(dirname23(path), { recursive: true });
+  mkdirSync22(dirname24(path), { recursive: true });
   writeFileSync20(path, content.endsWith(`
 `) ? content : `${content}
 `);
@@ -104622,7 +105222,7 @@ function registerRemoteAccount(parent) {
   billing.command("portal").option("--json", "Output as JSON", false).description("Create an external customer billing portal link").action((options) => execute(options, (client2) => client2.createBillingPortal()));
   const credits = parent.command("credits").description("Inspect and purchase credits from the configured server");
   credits.command("packs").option("--json", "Output as JSON", false).action((options) => execute(options, (client2) => client2.listCreditPacks()));
-  credits.command("buy").argument("<pack-id>", "An ID returned by credits packs").option("--json", "Output as JSON", false).description("Create an external checkout link; payment is confirmed in the browser").action((packId, options) => execute(options, (client2) => client2.createCreditCheckout(packId)));
+  credits.command("buy").argument("<pack-id>", "An ID returned by credits packs").option("--json", "Output as JSON", false).option("--idempotency-key <key>", "Retain and reuse this request key for explicit checkout recovery").description("Create an external checkout link; payment is confirmed in the browser. No automatic retries.").action((packId, options) => execute(options, (client2) => client2.createCreditCheckout(packId, { idempotencyKey: options.idempotencyKey })));
 }
 async function execute(options, action) {
   try {
@@ -104633,6 +105233,23 @@ async function execute(options, action) {
     console.log(JSON.stringify(result2, null, 2));
   } catch (error61) {
     const message = error61 instanceof Error ? error61.message : "The Skills server request failed";
+    if (error61 instanceof RemoteCreditCheckoutError) {
+      const result2 = {
+        error: error61.message,
+        code: error61.code,
+        status: error61.status,
+        requestIdempotencyKey: error61.requestIdempotencyKey,
+        ...error61.retryAfterSeconds === undefined ? {} : { retryAfterSeconds: error61.retryAfterSeconds }
+      };
+      if (options.json)
+        console.log(JSON.stringify(result2));
+      else
+        console.error(`${error61.message}
+Request key: ${error61.requestIdempotencyKey}` + (error61.code === "CREDIT_CHECKOUT_UNCONFIRMED" || error61.code === "CREDIT_CHECKOUT_IN_PROGRESS" ? `
+For explicit recovery, pass this key with --idempotency-key. Keep the same server, account and pack.` : ""));
+      process.exitCode = 1;
+      return;
+    }
     if (options.json)
       console.log(JSON.stringify({
         error: message,
@@ -104652,9 +105269,9 @@ var exports_runtime = {};
 __export(exports_runtime, {
   registerRuntime: () => registerRuntime
 });
-import { createHash as createHash20, randomUUID as randomUUID9 } from "crypto";
-import { lstatSync as lstatSync23, mkdirSync as mkdirSync23, readFileSync as readFileSync35, realpathSync as realpathSync10, writeFileSync as writeFileSync21 } from "fs";
-import { basename as basename7, isAbsolute as isAbsolute18, join as join52 } from "path";
+import { createHash as createHash22, randomUUID as randomUUID9 } from "crypto";
+import { lstatSync as lstatSync24, mkdirSync as mkdirSync23, readFileSync as readFileSync35, realpathSync as realpathSync10, writeFileSync as writeFileSync21 } from "fs";
+import { basename as basename9, isAbsolute as isAbsolute20, join as join52 } from "path";
 import { createInterface } from "readline";
 function registerRuntime(parent) {
   parent.command("run").argument("<skill>", "Skill name").argument("[args...]", "Arguments to pass to the skill; use -- to end Skills options").allowUnknownOption(true).passThroughOptions(true).option("--json", "Output result as JSON", false).option("--remote", "Run on the configured server, using its catalog and quote", false).option("--target <target>", "Execution target: local or cloud").option("--secret-bindings <path>", "Reviewed, exact-selection local execution vault bindings (JSON file)").option("--secret-bindings-template", "Print a scoped bindings template without resolving secrets or running the skill", false).option("--input <json>", "Structured cloud execution input").option("--skill-version <version>", "Exact selected skill version").option("--selection-profile <id>", "Selected Skills profile").option("--session <id>", "Pinned Skills session").option("--cached", "Use the explicit verified selected cache", false).option("--yes", "Approve the server's quoted credit cost for this run", false).option("--idempotency-key <key>", "Reuse this key when retrying the same remote submission").option("--file <path>", "Attach a local input file to a remote run (repeatable)", (value, prior) => [...prior, value], []).option("--wait", "Poll remote runs until a terminal status", false).option("--poll-interval-ms <ms>", "Remote polling interval in milliseconds", "1000").option("--poll-timeout-ms <ms>", "Maximum time to wait for a remote run", "300000").description("Run a skill directly").action(async (name, args2, options, command) => {
@@ -104684,7 +105301,7 @@ function registerRuntime(parent) {
       if (!expected)
         throw new Error("Cloud artifact not found");
       const bytes = await client2.download(id2, name);
-      if (bytes.length !== expected.byteSize || createHash20("sha256").update(bytes).digest("hex") !== expected.sha256)
+      if (bytes.length !== expected.byteSize || createHash22("sha256").update(bytes).digest("hex") !== expected.sha256)
         throw new Error("Cloud artifact integrity verification failed");
       writeFileSync21(options.output, bytes, { flag: "wx", mode: 384 });
       console.log(JSON.stringify({ path: options.output, sha256: expected.sha256, byteSize: bytes.length }));
@@ -104772,7 +105389,7 @@ Updating ${name}...
 async function readUpdatedVersion(bunExecutable) {
   const output2 = await readUpdateCommand([bunExecutable, "pm", "bin", "-g"]);
   const globalBin = output2.replace(/\r?\n$/, "");
-  if (!globalBin || !isAbsolute18(globalBin) || /[\r\n\0]/.test(globalBin))
+  if (!globalBin || !isAbsolute20(globalBin) || /[\r\n\0]/.test(globalBin))
     throw new Error("Update bin discovery failed");
   const installed = Bun.which("skills", { PATH: globalBin, cwd: globalBin });
   const selected = Bun.which("skills");
@@ -104908,14 +105525,14 @@ function requireHttpUrl(value) {
 }
 function promptLine(question) {
   const rl = createInterface({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve18) => {
+  return new Promise((resolve20) => {
     let settled = false;
     const finish = (answer) => {
       if (settled)
         return;
       settled = true;
       rl.close();
-      resolve18(answer);
+      resolve20(answer);
     };
     rl.once("SIGINT", () => finish(null));
     rl.once("close", () => finish(null));
@@ -105092,10 +105709,10 @@ async function handleRun(name, args2, options, separatorBeforeSkill) {
     try {
       parsePollingOptions(options);
       inputFiles = (options.file ?? []).map((path) => {
-        const info = lstatSync23(path);
+        const info = lstatSync24(path);
         if (!info.isFile() || info.size > 20 * 1024 * 1024)
           throw new Error("Input must be a regular file no larger than 20 MiB");
-        return { name: basename7(path), bytes: new Uint8Array(readFileSync35(path)) };
+        return { name: basename9(path), bytes: new Uint8Array(readFileSync35(path)) };
       });
       describeRemoteFiles(inputFiles);
       client2 = new RemoteSkillsClient(routing.apiKey, routing.apiOrigin);
@@ -105522,7 +106139,7 @@ function ensureSafeExportParent(root2, relativePath) {
     if (part)
       parent = join52(parent, part);
     try {
-      if (!lstatSync23(parent).isDirectory() || lstatSync23(parent).isSymbolicLink())
+      if (!lstatSync24(parent).isDirectory() || lstatSync24(parent).isSymbolicLink())
         throw new Error("Unsafe artifact directory");
     } catch (error61) {
       if (error61.code !== "ENOENT")
@@ -105560,7 +106177,7 @@ async function pollRemoteRun(client2, runId2, options) {
     const remaining = deadline - Date.now();
     if (remaining <= 0)
       break;
-    await new Promise((resolve18) => setTimeout(resolve18, Math.min(options.intervalMs, remaining)));
+    await new Promise((resolve20) => setTimeout(resolve20, Math.min(options.intervalMs, remaining)));
   }
   return {
     run: current ?? { id: runId2, status: "queued" },
@@ -105752,7 +106369,7 @@ async function readCode() {
 function promptCode() {
   const { stdin, stderr: output2 } = process;
   const { isRaw: wasRaw, readableFlowing: wasFlowing } = stdin;
-  return new Promise((resolve18) => {
+  return new Promise((resolve20) => {
     let value = "", settled = false;
     const finish = (answer) => {
       if (settled)
@@ -105769,7 +106386,7 @@ function promptCode() {
 `);
       if (answer === null)
         process.exitCode = 130;
-      resolve18(answer);
+      resolve20(answer);
     };
     const cancel = () => finish(null);
     const keypress = (text3, key) => {
@@ -105814,37 +106431,37 @@ var exports_recurring = {};
 __export(exports_recurring, {
   registerRecurringCommands: () => registerRecurringCommands
 });
-import { constants as constants16, closeSync as closeSync17, fstatSync as fstatSync17, lstatSync as lstatSync24, openSync as openSync17, readSync as readSync13 } from "fs";
+import { constants as constants17, closeSync as closeSync18, fstatSync as fstatSync18, lstatSync as lstatSync25, openSync as openSync18, readSync as readSync14 } from "fs";
 import { createInterface as createInterface2 } from "readline";
 function readRequest(path) {
-  const fd = openSync17(path, constants16.O_RDONLY | constants16.O_NOFOLLOW | constants16.O_NONBLOCK);
+  const fd = openSync18(path, constants17.O_RDONLY | constants17.O_NOFOLLOW | constants17.O_NONBLOCK);
   try {
-    const before2 = fstatSync17(fd);
+    const before2 = fstatSync18(fd);
     if (!before2.isFile() || before2.size > 1048576 || before2.size < 1)
       throw new RecurringInputError;
     const bytes = Buffer.alloc(before2.size + 1);
     let length = 0;
     while (length < bytes.length) {
-      const n2 = readSync13(fd, bytes, length, bytes.length - length, length);
+      const n2 = readSync14(fd, bytes, length, bytes.length - length, length);
       if (!n2)
         break;
       length += n2;
     }
-    const after2 = fstatSync17(fd), current = lstatSync24(path);
+    const after2 = fstatSync18(fd), current = lstatSync25(path);
     if (length !== before2.size || after2.size !== before2.size || before2.mtimeMs !== after2.mtimeMs || before2.ctimeMs !== after2.ctimeMs || current.dev !== before2.dev || current.ino !== before2.ino || !current.isFile() || current.isSymbolicLink())
       throw new RecurringInputError;
     return JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes.subarray(0, length)));
   } catch {
     throw new RecurringInputError;
   } finally {
-    closeSync17(fd);
+    closeSync18(fd);
   }
 }
 async function acceptAtTerminal(draft) {
-  await new Promise((resolve18, reject2) => process.stderr.write(`${jsonText(draft)}
+  await new Promise((resolve20, reject2) => process.stderr.write(`${jsonText(draft)}
 This grants an additional recurring budget. Each occurrence reprices within the approved ceilings. Revocation prevents new authority; an already-authorized attempt may finish, and cancellation is separate.
-`, (error61) => error61 ? reject2(error61) : resolve18()));
-  return new Promise((resolve18) => {
+`, (error61) => error61 ? reject2(error61) : resolve20()));
+  return new Promise((resolve20) => {
     const rl = createInterface2({ input: process.stdin, output: process.stderr });
     let settled = false;
     const finish = (accepted) => {
@@ -105855,7 +106472,7 @@ This grants an additional recurring budget. Each occurrence reprices within the
       rl.close();
       if (!accepted)
         process.exitCode = 130;
-      resolve18(accepted);
+      resolve20(accepted);
     };
     const timer = setTimeout(() => finish(false), 5 * 60 * 1000);
     rl.once("SIGINT", () => finish(false));
@@ -106263,7 +106880,7 @@ var init_portable_snapshot_filter = __esm(() => {
 });
 
 // src/lib/station-snapshot.ts
-import { createHash as createHash21 } from "crypto";
+import { createHash as createHash23 } from "crypto";
 import {
   copyFileSync,
   mkdirSync as mkdirSync24,
@@ -106271,14 +106888,14 @@ import {
   statSync as statSync19,
   writeFileSync as writeFileSync22
 } from "fs";
-import { dirname as dirname25, isAbsolute as isAbsolute19, relative as relative8, resolve as resolve18, sep as sep9 } from "path";
+import { dirname as dirname26, isAbsolute as isAbsolute21, relative as relative8, resolve as resolve20, sep as sep9 } from "path";
 function validateStationId(stationId) {
   if (!/^[a-z0-9-]+$/.test(stationId)) {
     throw new StationSnapshotError("INVALID_STATION", `station id must be a slug, got: ${stationId}`);
   }
 }
 function sha256File(filePath) {
-  return createHash21("sha256").update(readFileSync36(filePath)).digest("hex");
+  return createHash23("sha256").update(readFileSync36(filePath)).digest("hex");
 }
 function scanHome(definition, homesRoot) {
   const homePath = homePathFor(definition, homesRoot);
@@ -106349,7 +106966,7 @@ function humanHomes(scanned) {
   }));
 }
 function writeStationSnapshot(options) {
-  const repoRoot = resolve18(options.repoRoot ?? process.cwd());
+  const repoRoot = resolve20(options.repoRoot ?? process.cwd());
   const { scanned, plans, totalBytes } = planStationSnapshot(options);
   const manifestFiles = plans.map((plan) => ({
     relativePath: plan.source.relativePath,
@@ -106375,9 +106992,9 @@ function writeStationSnapshot(options) {
   const conflicts = [];
   const untouched = [];
   for (const plan of plans) {
-    const destination = resolve18(repoRoot, plan.destination);
+    const destination = resolve20(repoRoot, plan.destination);
     const destinationRelative = relative8(repoRoot, destination);
-    if (destinationRelative.startsWith("..") || destinationRelative.startsWith(sep9) || isAbsolute19(destinationRelative)) {
+    if (destinationRelative.startsWith("..") || destinationRelative.startsWith(sep9) || isAbsolute21(destinationRelative)) {
       throw new StationSnapshotError("DESTINATION_ESCAPE", `destination escapes repo root: ${plan.destination}`);
     }
     let existingDigest = null;
@@ -106398,8 +107015,8 @@ function writeStationSnapshot(options) {
   }
   let written = 0;
   for (const plan of untouched) {
-    const destination = resolve18(repoRoot, plan.destination);
-    mkdirSync24(dirname25(destination), { recursive: true });
+    const destination = resolve20(repoRoot, plan.destination);
+    mkdirSync24(dirname26(destination), { recursive: true });
     copyFileSync(plan.source.fullPath, destination);
     written += 1;
   }
@@ -106417,8 +107034,8 @@ function writeStationSnapshot(options) {
     },
     files: manifestFiles
   };
-  const manifestPath = resolve18(repoRoot, "resources", options.stationId, "skills", "sync-manifest.json");
-  mkdirSync24(dirname25(manifestPath), { recursive: true });
+  const manifestPath = resolve20(repoRoot, "resources", options.stationId, "skills", "sync-manifest.json");
+  mkdirSync24(dirname26(manifestPath), { recursive: true });
   writeFileSync22(manifestPath, `${JSON.stringify(manifest, null, 2)}
 `);
   return {
@@ -106852,10 +107469,10 @@ var init_create_sync_config = __esm(() => {
 // src/lib/codex-hook-rpc.ts
 import { execFile, spawn as spawn3 } from "child_process";
 import { realpathSync as realpathSync11, statSync as statSync20 } from "fs";
-import { isAbsolute as isAbsolute20 } from "path";
+import { isAbsolute as isAbsolute22 } from "path";
 import { promisify } from "util";
 async function connectCodexHookRpc(options) {
-  const found = isAbsolute20(options.command) ? options.command : Bun.which(options.command, { PATH: process.env.PATH });
+  const found = isAbsolute22(options.command) ? options.command : Bun.which(options.command, { PATH: process.env.PATH });
   if (!found)
     throw new Error("CODEX_HOOK_TRUST_NATIVE_UNAVAILABLE: install Codex or pass --codex-command");
   const binary = realpathSync11(found), stat3 = statSync20(binary);
@@ -106941,13 +107558,13 @@ async function connectCodexHookRpc(options) {
     request(method2, params) {
       if (stopped)
         return Promise.reject(new Error("CODEX_HOOK_TRUST_NATIVE_RPC_CLOSED"));
-      return new Promise((resolve19, reject2) => {
+      return new Promise((resolve21, reject2) => {
         const id2 = nextId++;
         const timer = setTimeout(() => {
           fail4();
           child.kill();
         }, 20000);
-        pending.set(id2, { resolve: resolve19, reject: reject2, timer });
+        pending.set(id2, { resolve: resolve21, reject: reject2, timer });
         child.stdin.write(JSON.stringify({ id: id2, method: method2, params }) + `
 `);
       });
@@ -106957,14 +107574,14 @@ async function connectCodexHookRpc(options) {
       child.stdin.end();
       if (child.exitCode !== null || child.signalCode !== null)
         return;
-      await new Promise((resolve19) => {
+      await new Promise((resolve21) => {
         const timer = setTimeout(() => {
           child.kill();
-          resolve19();
+          resolve21();
         }, 1000);
         child.once("exit", () => {
           clearTimeout(timer);
-          resolve19();
+          resolve21();
         });
       });
     }
@@ -106985,7 +107602,7 @@ var init_codex_hook_rpc = __esm(() => {
 });
 
 // src/lib/codex-hook-trust-layout.ts
-import { isDeepStrictEqual as isDeepStrictEqual4 } from "util";
+import { isDeepStrictEqual as isDeepStrictEqual5 } from "util";
 function codexTrustTextWitness(text3, keys3) {
   const parsed = Bun.TOML.parse(text3), wanted = new Set(keys3);
   const headers = [...text3.matchAll(/^[ \t]*(\[[^\r\n]+\])[ \t]*(#[^\r\n]*)?(?:\r?\n|$)/gm)];
@@ -107032,11 +107649,11 @@ function codexTrustTextWitness(text3, keys3) {
           comments.push(line);
           continue;
         }
-        const field = /^[ \t]*(?:enabled|trusted_hash)[ \t]*=[ \t]*(?:true|false|"(?:[^"\\]|\\.)*"|'[^']*')[ \t]*(#[^\r\n]*)?$/.exec(line);
-        if (!field)
+        const field2 = /^[ \t]*(?:enabled|trusted_hash)[ \t]*=[ \t]*(?:true|false|"(?:[^"\\]|\\.)*"|'[^']*')[ \t]*(#[^\r\n]*)?$/.exec(line);
+        if (!field2)
           throw fail4();
-        if (field[1])
-          comments.push(field[1]);
+        if (field2[1])
+          comments.push(field2[1]);
       }
       replacements2.push({ start, end, comments: comments.join(`
 `) + `
@@ -107050,7 +107667,7 @@ function codexTrustTextWitness(text3, keys3) {
   if (expected.hooks)
     delete expected.hooks.state;
   try {
-    if (!isDeepStrictEqual4(prune(Bun.TOML.parse(noState)), prune(expected)))
+    if (!isDeepStrictEqual5(prune(Bun.TOML.parse(noState)), prune(expected)))
       throw fail4();
   } catch {
     throw fail4();
@@ -107071,59 +107688,59 @@ var fail4 = () => new Error('CODEX_HOOK_TRUST_UNSUPPORTED_LAYOUT: preserve and c
 var init_codex_hook_trust_layout = () => {};
 
 // src/lib/codex-hook-trust-files.ts
-import { closeSync as closeSync18, constants as constants17, fstatSync as fstatSync18, fsyncSync as fsyncSync5, lstatSync as lstatSync25, openSync as openSync18, readSync as readSync14, writeFileSync as writeFileSync23 } from "fs";
-import { createHash as createHash22 } from "crypto";
-import { dirname as dirname26 } from "path";
-function need2(value, code2) {
+import { closeSync as closeSync19, constants as constants18, fstatSync as fstatSync19, fsyncSync as fsyncSync6, lstatSync as lstatSync26, openSync as openSync19, readSync as readSync15, writeFileSync as writeFileSync23 } from "fs";
+import { createHash as createHash24 } from "crypto";
+import { dirname as dirname27 } from "path";
+function need3(value, code2) {
   if (!value)
     throw new Error(`CODEX_HOOK_TRUST_${code2}`);
 }
 function safeParents(file2) {
-  for (let p = dirname26(file2);; p = dirname26(p)) {
-    const s = lstatSync25(p);
-    need2(s.isDirectory() && !s.isSymbolicLink(), "UNSAFE_PARENT");
-    need2((s.mode & 18) === 0 || s.uid === 0 && (s.mode & 512) !== 0, "UNSAFE_PARENT");
-    if (dirname26(p) === p)
+  for (let p = dirname27(file2);; p = dirname27(p)) {
+    const s = lstatSync26(p);
+    need3(s.isDirectory() && !s.isSymbolicLink(), "UNSAFE_PARENT");
+    need3((s.mode & 18) === 0 || s.uid === 0 && (s.mode & 512) !== 0, "UNSAFE_PARENT");
+    if (dirname27(p) === p)
       break;
   }
 }
 function snapshot(file2, privateFile = false, options = {}) {
   const readOnlyPackage = options.readOnlyPackage === true && !privateFile;
   safeParents(file2);
-  const initial2 = lstatSync25(file2, { bigint: true });
-  need2(initial2.isFile() && initial2.uid === BigInt(process.getuid()) && (initial2.nlink === 1n || readOnlyPackage && initial2.nlink > 1n) && (initial2.mode & 0o022n) === 0n && (!privateFile || (initial2.mode & 0o777n) === 0o600n), "UNSAFE_FILE");
-  need2(initial2.size <= 8n * 1024n * 1024n, "FILE_BOUND");
-  const fd = openSync18(file2, constants17.O_RDONLY | constants17.O_NOFOLLOW | constants17.O_NONBLOCK);
+  const initial2 = lstatSync26(file2, { bigint: true });
+  need3(initial2.isFile() && initial2.uid === BigInt(process.getuid()) && (initial2.nlink === 1n || readOnlyPackage && initial2.nlink > 1n) && (initial2.mode & 0o022n) === 0n && (!privateFile || (initial2.mode & 0o777n) === 0o600n), "UNSAFE_FILE");
+  need3(initial2.size <= 8n * 1024n * 1024n, "FILE_BOUND");
+  const fd = openSync19(file2, constants18.O_RDONLY | constants18.O_NOFOLLOW | constants18.O_NONBLOCK);
   try {
-    const before2 = fstatSync18(fd, { bigint: true });
-    need2(sameStat(initial2, before2), "INPUT_CHANGED");
+    const before2 = fstatSync19(fd, { bigint: true });
+    need3(sameStat(initial2, before2), "INPUT_CHANGED");
     const bytes = Buffer.alloc(Number(before2.size) + 1);
     let length = 0;
     while (length < bytes.length) {
-      const n2 = readSync14(fd, bytes, length, bytes.length - length, null);
+      const n2 = readSync15(fd, bytes, length, bytes.length - length, null);
       if (!n2)
         break;
       length += n2;
     }
-    need2(length === Number(before2.size) && sameStat(before2, fstatSync18(fd, { bigint: true })) && sameStat(before2, lstatSync25(file2, { bigint: true })), "INPUT_CHANGED");
+    need3(length === Number(before2.size) && sameStat(before2, fstatSync19(fd, { bigint: true })) && sameStat(before2, lstatSync26(file2, { bigint: true })), "INPUT_CHANGED");
     const content = bytes.subarray(0, length), text3 = new TextDecoder("utf-8", { fatal: true }).decode(content);
-    return { file: file2, privateFile, readOnlyPackage, text: text3, bytes: content, stat: before2, sha256: createHash22("sha256").update(content).digest("hex") };
+    return { file: file2, privateFile, readOnlyPackage, text: text3, bytes: content, stat: before2, sha256: createHash24("sha256").update(content).digest("hex") };
   } finally {
-    closeSync18(fd);
+    closeSync19(fd);
   }
 }
 function unchanged2(before2) {
   const after2 = snapshot(before2.file, before2.privateFile, before2.readOnlyPackage ? { readOnlyPackage: true } : {});
-  need2(sameStat(before2.stat, after2.stat) && after2.sha256 === before2.sha256, "INPUT_CHANGED");
+  need3(sameStat(before2.stat, after2.stat) && after2.sha256 === before2.sha256, "INPUT_CHANGED");
 }
 function save2(file2, content) {
   safeParents(file2);
-  const fd = openSync18(file2, constants17.O_WRONLY | constants17.O_CREAT | constants17.O_EXCL | constants17.O_NOFOLLOW, 384);
+  const fd = openSync19(file2, constants18.O_WRONLY | constants18.O_CREAT | constants18.O_EXCL | constants18.O_NOFOLLOW, 384);
   try {
     writeFileSync23(fd, content);
-    fsyncSync5(fd);
+    fsyncSync6(fd);
   } finally {
-    closeSync18(fd);
+    closeSync19(fd);
   }
 }
 var sameStat = (a, b) => ["dev", "ino", "uid", "nlink", "mode", "size", "mtimeNs", "ctimeNs"].every((key) => a[key] === b[key]);
@@ -107131,26 +107748,26 @@ var init_codex_hook_trust_files = () => {};
 
 // src/lib/codex-hook-trust-identity.ts
 import { realpathSync as realpathSync12 } from "fs";
-import { dirname as dirname27, isAbsolute as isAbsolute21, join as join55 } from "path";
+import { dirname as dirname28, isAbsolute as isAbsolute23, join as join55 } from "path";
 function bindSkillsCli(command, reviewed) {
   const normal = Bun.which("skills", { PATH: process.env.PATH });
-  need2(normal, "SKILLS_COMMAND_UNAVAILABLE");
+  need3(normal, "SKILLS_COMMAND_UNAVAILABLE");
   const resolved = realpathSync12(normal);
-  const bound = isAbsolute21(command) ? command : command === "skills" ? normal : undefined;
-  need2(bound && realpathSync12(bound) === resolved, "SKILLS_COMMAND_MISMATCH");
+  const bound = isAbsolute23(command) ? command : command === "skills" ? normal : undefined;
+  need3(bound && realpathSync12(bound) === resolved, "SKILLS_COMMAND_MISMATCH");
   const entrypoint = reviewed?.path ?? process.argv[1];
-  need2(entrypoint && realpathSync12(entrypoint) === resolved, "SKILLS_ENTRYPOINT_MISMATCH");
+  need3(entrypoint && realpathSync12(entrypoint) === resolved, "SKILLS_ENTRYPOINT_MISMATCH");
   const cli = snapshot(resolved, false, { readOnlyPackage: true });
-  const manifest = snapshot(join55(dirname27(dirname27(resolved)), "package.json"), false, { readOnlyPackage: true });
+  const manifest = snapshot(join55(dirname28(dirname28(resolved)), "package.json"), false, { readOnlyPackage: true });
   const pkg = JSON.parse(manifest.text);
-  need2(pkg.name === "@hasna/skills" && /^\d+\.\d+\.\d+$/.test(pkg.version) && pkg.bin?.skills === "bin/index.js" && resolved === join55(dirname27(manifest.file), "bin/index.js"), "SKILLS_PACKAGE_MISMATCH");
+  need3(pkg.name === "@hasna/skills" && /^\d+\.\d+\.\d+$/.test(pkg.version) && pkg.bin?.skills === "bin/index.js" && resolved === join55(dirname28(manifest.file), "bin/index.js"), "SKILLS_PACKAGE_MISMATCH");
   if (reviewed)
-    need2(/^[a-f0-9]{64}$/.test(reviewed.sha256) && reviewed.sha256 === cli.sha256 && reviewed.version === pkg.version, "SKILLS_RELEASE_MISMATCH");
-  need2((cli.stat.mode & 0o100n) !== 0n, "SKILLS_COMMAND_NOT_EXECUTABLE");
+    need3(/^[a-f0-9]{64}$/.test(reviewed.sha256) && reviewed.sha256 === cli.sha256 && reviewed.version === pkg.version, "SKILLS_RELEASE_MISMATCH");
+  need3((cli.stat.mode & 0o100n) !== 0n, "SKILLS_COMMAND_NOT_EXECUTABLE");
   return {
     receipt: { path: resolved, version: pkg.version, sha256: cli.sha256, manifestSha256: manifest.sha256 },
     recheck() {
-      need2(Bun.which("skills", { PATH: process.env.PATH }) === normal && realpathSync12(normal) === resolved && realpathSync12(bound) === resolved && realpathSync12(entrypoint) === resolved, "SKILLS_COMMAND_CHANGED");
+      need3(Bun.which("skills", { PATH: process.env.PATH }) === normal && realpathSync12(normal) === resolved && realpathSync12(bound) === resolved && realpathSync12(entrypoint) === resolved, "SKILLS_COMMAND_CHANGED");
       unchanged2(cli);
       unchanged2(manifest);
     }
@@ -107161,15 +107778,15 @@ var init_codex_hook_trust_identity = __esm(() => {
 });
 
 // src/lib/agent-codex-trust.ts
-import { lstatSync as lstatSync26, mkdirSync as mkdirSync25, readdirSync as readdirSync20 } from "fs";
-import { createHash as createHash23, randomUUID as randomUUID10 } from "crypto";
-import { join as join56, resolve as resolve19 } from "path";
+import { lstatSync as lstatSync27, mkdirSync as mkdirSync25, readdirSync as readdirSync20 } from "fs";
+import { createHash as createHash25, randomUUID as randomUUID10 } from "crypto";
+import { join as join56, resolve as resolve21 } from "path";
 import { homedir as homedir11 } from "os";
-import { isDeepStrictEqual as isDeepStrictEqual5 } from "util";
+import { isDeepStrictEqual as isDeepStrictEqual6 } from "util";
 async function enrollCodexNativeHooks(options = {}, connect = connectCodexHookRpc) {
   let rpc, journal;
   try {
-    const home = resolve19(options.home ?? homedir11()), dataDir3 = resolve19(options.dataDir ?? getDataDirReadOnly());
+    const home = resolve21(options.home ?? homedir11()), dataDir3 = resolve21(options.dataDir ?? getDataDirReadOnly());
     assertManagedAgentBridge("codex", { home, dataDir: dataDir3, projectDir: home });
     const policyFile = snapshot(join56(dataDir3, "agent-policy.json"), true), policy = parseManagedSkillPolicy(policyFile.text);
     const binding = policy.bridge, alias = binding.rootAliases?.find((item) => item.agent === "codex");
@@ -107180,35 +107797,35 @@ async function enrollCodexNativeHooks(options = {}, connect = connectCodexHookRp
     for (const [event, [nativeEvent, label]] of Object.entries(eventNames)) {
       const command = renderAgentHookCommand(binding.commands.codex, "codex", binding.profiles.codex, event);
       const groups = declarations[event];
-      need2(Array.isArray(groups), "DECLARATION_CHANGED");
+      need3(Array.isArray(groups), "DECLARATION_CHANGED");
       const matches2 = groups.flatMap((group, gi) => (group.hooks ?? []).flatMap((entry, hi) => entry.command === command ? [{ group, entry, gi, hi }] : []));
-      need2(matches2.length === 1 && isDeepStrictEqual5(matches2[0].group, { hooks: [{ type: "command", command, timeout: 15 }] }), "DECLARATION_CHANGED");
+      need3(matches2.length === 1 && isDeepStrictEqual6(matches2[0].group, { hooks: [{ type: "command", command, timeout: 15 }] }), "DECLARATION_CHANGED");
       expected.push({ event: nativeEvent, key: `${join56(home, ".codex/hooks.json")}:${label}:${matches2[0].gi}:${matches2[0].hi}`, command });
     }
     codexTrustTextWitness(configFile.text, expected.map((h) => h.key));
     rpc = await connect({ command: options.codexCommand ?? "codex", home, codexHome });
-    need2(SUPPORTED_CODEX_HOOK_VERSIONS.includes(rpc.version), "NATIVE_UNSUPPORTED_VERSION");
+    need3(SUPPORTED_CODEX_HOOK_VERSIONS.includes(rpc.version), "NATIVE_UNSUPPORTED_VERSION");
     const list2 = async () => {
       const response = await rpc.request("hooks/list", { cwds: [home] });
-      need2(Array.isArray(response?.data) && response.data.length === 1 && response.data[0].cwd === home && Array.isArray(response.data[0].hooks) && response.data[0].hooks.length <= 1e4 && !response.data[0].errors?.length && !response.data[0].warnings?.length, "NATIVE_DISCOVERY_REFUSED");
+      need3(Array.isArray(response?.data) && response.data.length === 1 && response.data[0].cwd === home && Array.isArray(response.data[0].hooks) && response.data[0].hooks.length <= 1e4 && !response.data[0].errors?.length && !response.data[0].warnings?.length, "NATIVE_DISCOVERY_REFUSED");
       return response.data[0].hooks;
     };
     const admit = (hooks) => expected.map((wanted) => {
       const canonicalKey = wanted.key.replace(join56(home, ".codex/hooks.json"), hooksPath);
       const matches2 = hooks.filter((h2) => h2.key === wanted.key || h2.key === canonicalKey);
-      need2(matches2.length === 1, "AMBIGUOUS_IDENTITY");
+      need3(matches2.length === 1, "AMBIGUOUS_IDENTITY");
       const h = matches2[0];
-      need2(h.eventName === wanted.event && h.handlerType === "command" && h.command === wanted.command && h.matcher === null && h.timeoutSec === 15 && h.async === false && h.statusMessage === null && h.additionalContextLimit === null && [hooksPath, join56(home, ".codex/hooks.json")].includes(h.sourcePath) && h.source === "user" && h.pluginId === null && h.isManaged === false && /^sha256:[a-f0-9]{64}$/.test(h.currentHash) && typeof h.enabled === "boolean", "NATIVE_IDENTITY_CHANGED");
-      need2(hooks.filter((other) => other.command === wanted.command).length === 1, "AMBIGUOUS_IDENTITY");
-      need2(["trusted", "untrusted", "modified"].includes(h.trustStatus), "UNKNOWN_TRUST_STATUS");
+      need3(h.eventName === wanted.event && h.handlerType === "command" && h.command === wanted.command && h.matcher === null && h.timeoutSec === 15 && h.async === false && h.statusMessage === null && h.additionalContextLimit === null && [hooksPath, join56(home, ".codex/hooks.json")].includes(h.sourcePath) && h.source === "user" && h.pluginId === null && h.isManaged === false && /^sha256:[a-f0-9]{64}$/.test(h.currentHash) && typeof h.enabled === "boolean", "NATIVE_IDENTITY_CHANGED");
+      need3(hooks.filter((other) => other.command === wanted.command).length === 1, "AMBIGUOUS_IDENTITY");
+      need3(["trusted", "untrusted", "modified"].includes(h.trustStatus), "UNKNOWN_TRUST_STATUS");
       return { key: h.key, event: wanted.event, command: wanted.command, handlerType: h.handlerType, timeoutSec: h.timeoutSec, sourcePath: h.sourcePath, currentHash: h.currentHash, enabled: h.enabled, trustStatus: h.trustStatus };
     });
     const discovered = await list2(), admitted = admit(discovered);
     const config2 = await rpc.request("config/read", { includeLayers: true, cwd: home });
     const layers = config2?.layers?.filter((layer) => layer.name?.type === "user" && layer.name.file === configPath && !layer.name.profile);
-    need2(layers?.length === 1 && /^sha256:[a-f0-9]{64}$/.test(layers[0].version) && !layers[0].disabledReason && isDeepStrictEqual5(layers[0].config, original), "NATIVE_CONFIG_MISMATCH");
-    need2(config2.config && config2.config.features?.hooks !== false, "NATIVE_HOOKS_DISABLED");
-    need2(config2.layers.slice(0, config2.layers.indexOf(layers[0])).every((layer) => layer.config?.hooks === undefined && layer.config?.features?.hooks === undefined), "NATIVE_CONFIG_OVERRIDDEN");
+    need3(layers?.length === 1 && /^sha256:[a-f0-9]{64}$/.test(layers[0].version) && !layers[0].disabledReason && isDeepStrictEqual6(layers[0].config, original), "NATIVE_CONFIG_MISMATCH");
+    need3(config2.config && config2.config.features?.hooks !== false, "NATIVE_HOOKS_DISABLED");
+    need3(config2.layers.slice(0, config2.layers.indexOf(layers[0])).every((layer) => layer.config?.hooks === undefined && layer.config?.features?.hooks === undefined), "NATIVE_CONFIG_OVERRIDDEN");
     const keys3 = admitted.map((h) => h.key), planned = admitted.filter((h) => !h.enabled || h.trustStatus !== "trusted");
     const preservationText = codexTrustTextWitness(configFile.text, keys3);
     const checkInputs = () => {
@@ -107219,19 +107836,19 @@ async function enrollCodexNativeHooks(options = {}, connect = connectCodexHookRp
       unchanged2(configFile);
     };
     checkInputs();
-    const planDigest = createHash23("sha256").update(json2({ version: 1, home, configPath, configSha256: configFile.sha256, configVersion: layers[0].version, policySha256: policyFile.sha256, hooksSha256: hooksFile.sha256, skillsCli: skillsCli.receipt, nativeVersion: rpc.version, declarations: expected, admitted })).digest("hex");
+    const planDigest = createHash25("sha256").update(json2({ version: 1, home, configPath, configSha256: configFile.sha256, configVersion: layers[0].version, policySha256: policyFile.sha256, hooksSha256: hooksFile.sha256, skillsCli: skillsCli.receipt, nativeVersion: rpc.version, declarations: expected, admitted })).digest("hex");
     const baseReceipt = { planDigest, skillsCli: skillsCli.receipt, nativeVersion: rpc.version, ownedNativeProcessId: rpc.processId, agent: "codex", applied: false, planned, nativeEligible: planned.length === 0, transport: "owned-stdio-process", existingSessionsReloaded: false, nativeExecutionVerified: false };
     if (options.apply)
-      need2(options.reviewedPlanDigest === planDigest, "PLAN_CHANGED: run the dry-run again and pass its reviewed --plan-digest with --apply");
+      need3(options.reviewedPlanDigest === planDigest, "PLAN_CHANGED: run the dry-run again and pass its reviewed --plan-digest with --apply");
     const parent = join56(dataDir3, "native-hook-trust");
-    const st = lstatSync26(parent, { throwIfNoEntry: false });
+    const st = lstatSync27(parent, { throwIfNoEntry: false });
     if (st) {
-      need2(st.isDirectory() && !st.isSymbolicLink() && st.uid === process.getuid() && (st.mode & 511) === 448, "UNSAFE_JOURNAL");
+      need3(st.isDirectory() && !st.isSymbolicLink() && st.uid === process.getuid() && (st.mode & 511) === 448, "UNSAFE_JOURNAL");
       const priorJournals = readdirSync20(parent);
-      need2(priorJournals.length < 1000, "JOURNAL_BOUND");
+      need3(priorJournals.length < 1000, "JOURNAL_BOUND");
       for (const name of priorJournals) {
-        need2(/^[a-f0-9-]{36}$/.test(name), "UNSAFE_JOURNAL");
-        need2(lstatSync26(join56(parent, name, "receipt.json"), { throwIfNoEntry: false })?.isFile(), "RECONCILE_REQUIRED: inspect the incomplete private journal before applying again");
+        need3(/^[a-f0-9-]{36}$/.test(name), "UNSAFE_JOURNAL");
+        need3(lstatSync27(join56(parent, name, "receipt.json"), { throwIfNoEntry: false })?.isFile(), "RECONCILE_REQUIRED: inspect the incomplete private journal before applying again");
       }
     }
     if (!options.apply || !planned.length)
@@ -107244,7 +107861,7 @@ async function enrollCodexNativeHooks(options = {}, connect = connectCodexHookRp
     save2(join56(journal, "hooks.before.json"), hooksFile.bytes);
     save2(join56(journal, "policy.before.json"), policyFile.bytes);
     save2(join56(journal, "intent.json"), json2({ version: 1, planDigest, skillsCli: skillsCli.receipt, nativeVersion: rpc.version, configPath, beforeSha256: configFile.sha256, hooksSha256: hooksFile.sha256, policySha256: policyFile.sha256, expectedVersion: layers[0].version, hooks: planned }));
-    need2(isDeepStrictEqual5(admit(await list2()), admitted), "NATIVE_DISCOVERY_CHANGED");
+    need3(isDeepStrictEqual6(admit(await list2()), admitted), "NATIVE_DISCOVERY_CHANGED");
     checkInputs();
     let result2;
     try {
@@ -107252,19 +107869,19 @@ async function enrollCodexNativeHooks(options = {}, connect = connectCodexHookRp
     } catch {
       throw new Error("CODEX_HOOK_TRUST_NATIVE_WRITE_FAILED: reconcile the private journal before retrying");
     }
-    need2(result2?.status === "ok" && result2.filePath === configPath && /^sha256:[a-f0-9]{64}$/.test(result2.version), "NATIVE_WRITE_OVERRIDDEN");
+    need3(result2?.status === "ok" && result2.filePath === configPath && /^sha256:[a-f0-9]{64}$/.test(result2.version), "NATIVE_WRITE_OVERRIDDEN");
     const after2 = snapshot(configPath, true), expectedConfig = structuredClone(original);
     expectedConfig.hooks ??= {};
     expectedConfig.hooks.state ??= {};
     for (const h of planned)
       expectedConfig.hooks.state[h.key] = { ...expectedConfig.hooks.state[h.key], enabled: true, trusted_hash: h.currentHash };
-    need2(isDeepStrictEqual5(structure(after2.text), expectedConfig) && codexTrustTextWitness(after2.text, keys3) === preservationText, "PRESERVATION_FAILED");
+    need3(isDeepStrictEqual6(structure(after2.text), expectedConfig) && codexTrustTextWitness(after2.text, keys3) === preservationText, "PRESERVATION_FAILED");
     unchanged2(policyFile);
     unchanged2(hooksFile);
     assertManagedAgentBridge("codex", { home, dataDir: dataDir3, projectDir: home });
     const current = await list2(), confirmed = admit(current);
-    need2(confirmed.every((h) => h.enabled && h.trustStatus === "trusted") && isDeepStrictEqual5(confirmed.map((h) => [h.key, h.currentHash]), admitted.map((h) => [h.key, h.currentHash])), "NATIVE_NOT_ELIGIBLE");
-    need2(isDeepStrictEqual5(current.filter((h) => !keys3.includes(h.key)), discovered.filter((h) => !keys3.includes(h.key))), "UNRELATED_HOOK_CHANGED");
+    need3(confirmed.every((h) => h.enabled && h.trustStatus === "trusted") && isDeepStrictEqual6(confirmed.map((h) => [h.key, h.currentHash]), admitted.map((h) => [h.key, h.currentHash])), "NATIVE_NOT_ELIGIBLE");
+    need3(isDeepStrictEqual6(current.filter((h) => !keys3.includes(h.key)), discovered.filter((h) => !keys3.includes(h.key))), "UNRELATED_HOOK_CHANGED");
     unchanged2(after2);
     unchanged2(hooksFile);
     unchanged2(policyFile);
@@ -107298,39 +107915,142 @@ var init_agent_codex_trust = __esm(() => {
   eventNames = { UserPromptSubmit: ["userPromptSubmit", "user_prompt_submit"], SessionStart: ["sessionStart", "session_start"], SubagentStart: ["subagentStart", "subagent_start"] };
 });
 
+// src/lib/hook-diagnostics.ts
+function hookChildError(stdout, stage) {
+  let code2;
+  if (stdout.length <= 16 * 1024) {
+    try {
+      code2 = JSON.parse(stdout)?.error?.code;
+    } catch {}
+  }
+  return new HookDiagnosticError(typeof code2 === "string" && CONTEXT_ERROR_CODES.has(code2) ? code2 : "SKILLS_CONTEXT_FAILED", stage);
+}
+function hookFailureReason(error61, profileId) {
+  const owned = error61 instanceof HookDiagnosticError;
+  const code2 = owned && (CONTEXT_ERROR_CODES.has(error61.code) || ["SKILLS_HOOK_TIMEOUT", "SKILLS_HOOK_INVALID_RESPONSE"].includes(error61.code)) ? error61.code : "SKILLS_HOOK_FAILED";
+  const profile = typeof profileId === "string" && /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/.test(profileId) && !profileId.includes("..") ? profileId : undefined;
+  const identity4 = [profile ? `profile=${profile}` : undefined, owned ? `stage=${error61.stage}` : undefined].filter(Boolean).join(", ");
+  const prefix = `Skills context is unavailable [${code2}]${identity4 ? ` (${identity4})` : ""}.`;
+  if (code2 === "PROFILE_LOCK_MISMATCH") {
+    return `${prefix} This session or project is pinned to a different profile. Inspect the session with skills sessions show <session-id> --json; review skills sessions reconcile for an intentional session change, or explicit project sync for a project change. Sync alone does not change that pin.`;
+  }
+  if (code2.startsWith("SESSION_")) {
+    return `${prefix} Inspect the session with skills sessions show <session-id> --json and review its parent or concurrent writer before retrying. Do not remove or rewrite its receipt to bypass this refusal.`;
+  }
+  if (["PROFILE_IDENTITY_MISMATCH", "BUNDLE_DIGEST_MISMATCH", "BUNDLE_IDENTITY_MISMATCH", "INVALID_RECEIPT", "INVALID_CACHE_FILE", "UNSAFE_CACHE_PATH"].includes(code2)) {
+    return `${prefix} Verify the selected authority and receipt integrity before repairing the profile; do not bypass verification or substitute another cache.`;
+  }
+  const selected = profile ?? "<id>";
+  return `${prefix} Run skills sync --selection-profile ${selected} --json, then diagnose with skills context --stdin --json --cached --selection-profile ${selected} using the same hook session and working-directory fields. Do not include credentials in diagnostic input.`;
+}
+var CONTEXT_ERROR_CODES, HookDiagnosticError;
+var init_hook_diagnostics = __esm(() => {
+  CONTEXT_ERROR_CODES = new Set([
+    "SKILLS_CONTEXT_FAILED",
+    "PROFILE_LOCK_MISMATCH",
+    "PROFILE_IDENTITY_MISMATCH",
+    "PROFILE_APPLIED_REPORT_FAILED",
+    "CACHED_AUTHORITY_REQUIRED",
+    "CACHED_PROFILE_EXPIRED",
+    "CACHED_PROFILE_MISSING",
+    "CACHED_BUNDLE_MISSING",
+    "INVALID_CONTEXT_INPUT",
+    "CONTEXT_INPUT_TOO_LARGE",
+    "INVALID_CONTEXT_BUDGET",
+    "INVALID_SELECTION",
+    "INVALID_SELECTION_ALIASES",
+    "INVALID_RECEIPT",
+    "INVALID_CACHE_FILE",
+    "UNSAFE_CACHE_PATH",
+    "RECEIPT_TOO_LARGE",
+    "BUNDLE_DIGEST_MISMATCH",
+    "BUNDLE_IDENTITY_MISMATCH",
+    "BUNDLE_UNAVAILABLE",
+    "BUNDLE_TOO_LARGE",
+    "SKILL_NOT_SELECTED",
+    "INVALID_SESSION",
+    "SESSION_PARENT_NOT_FOUND",
+    "SESSION_NOT_FOUND",
+    "SESSION_GENERATION_CHANGED",
+    "SESSION_GENERATION_EXHAUSTED",
+    "SESSION_PARENT_CHANGED",
+    "SESSION_RECEIPT_CHANGED",
+    "SESSION_RECONCILIATION_INCOMPLETE",
+    "SESSION_WRITE_LOCKED",
+    "SESSION_WRITE_LOCK_CHANGED"
+  ]);
+  HookDiagnosticError = class HookDiagnosticError extends Error {
+    code;
+    stage;
+    constructor(code2, stage) {
+      super("Skills hook operation failed");
+      this.code = code2;
+      this.stage = stage;
+    }
+  };
+});
+
 // src/cli/commands/agent-integration.ts
 var exports_agent_integration = {};
 __export(exports_agent_integration, {
   registerAgentIntegration: () => registerAgentIntegration
 });
 import { readFileSync as readFileSync37 } from "fs";
-import { isAbsolute as isAbsolute22 } from "path";
+import { isAbsolute as isAbsolute24 } from "path";
+function pinnedHookProfile(input3, configuredProfile) {
+  try {
+    const parsed = parseSkillContextInput(JSON.stringify(input3));
+    if (!parsed.sessionId)
+      return configuredProfile;
+    const sessionId = parsed.agentId ? `${parsed.sessionId}:${parsed.agentId}` : parsed.sessionId;
+    const session = readSkillSessionSnapshotIfExists(sessionId);
+    const parent = !session && parsed.agentId ? readSkillSessionSnapshotIfExists(parsed.sessionId) : null;
+    return session?.receipt.profile.profileId ?? parent?.receipt.profile.profileId ?? configuredProfile;
+  } catch (error61) {
+    if (error61 instanceof SkillSelectionError)
+      throw new HookDiagnosticError(error61.code, "context");
+    throw error61;
+  }
+}
 async function contextForHook(input3, profileId, cached2, deadline) {
   const remaining = deadline - Date.now();
   if (remaining <= 0)
-    throw new Error("Skills hook deadline exceeded");
+    throw new HookDiagnosticError("SKILLS_HOOK_TIMEOUT", "context");
   const args2 = [process.execPath, process.argv[1], "context", "--stdin", "--json", "--selection-profile", profileId];
   if (cached2)
     args2.push("--cached");
   const child = Bun.spawn(args2, { stdin: new Blob([JSON.stringify(input3)]), stdout: "pipe", stderr: "pipe", env: { ...process.env, NO_COLOR: "1" } });
-  const timer = setTimeout(() => child.kill("SIGKILL"), Math.min(6500, remaining));
+  let timedOut = false;
+  const timer = setTimeout(() => {
+    timedOut = true;
+    child.kill("SIGKILL");
+  }, Math.min(6500, remaining));
   let result2;
   let status;
+  let output2;
   try {
     const [stdout, , exitCode] = await Promise.all([new Response(child.stdout).text(), new Response(child.stderr).text(), child.exited]);
+    if (timedOut)
+      throw new HookDiagnosticError("SKILLS_HOOK_TIMEOUT", "context");
     status = exitCode;
-    result2 = JSON.parse(stdout);
+    output2 = stdout;
   } finally {
     clearTimeout(timer);
   }
   if (status !== 0) {
-    if (cached2 && RECOVERABLE_CONTEXT_CACHE_ERRORS.has(result2?.error?.code)) {
+    const failure = hookChildError(output2, "context");
+    if (cached2 && RECOVERABLE_CONTEXT_CACHE_ERRORS.has(failure.code)) {
       return contextForHook(input3, profileId, false, deadline);
     }
-    throw new Error("Skills context could not be resolved");
+    throw failure;
+  }
+  try {
+    result2 = JSON.parse(output2);
+  } catch {
+    throw new HookDiagnosticError("SKILLS_HOOK_INVALID_RESPONSE", "context");
   }
   if (typeof result2?.context !== "string")
-    throw new Error("Invalid Skills context response");
+    throw new HookDiagnosticError("SKILLS_HOOK_INVALID_RESPONSE", "context");
   return result2;
 }
 function agents(value) {
@@ -107377,6 +108097,7 @@ function registerAgentIntegration(parent) {
   hook.command("user-prompt").requiredOption("--agent <agent>", `Native payload/output adapter: ${INTEGRATION_AGENTS.join(", ")}`).option("--event <event>", "Native lifecycle event supplied by the installed adapter").option("--selection-profile <id>", "Selection profile to load").description("Read native lifecycle JSON on stdin and return selected context").action(async (options) => {
     const deadline = Date.now() + 12000;
     let event = options.agent === "hermes" && options.event === "pre_tool_call" ? "pre_tool_call" : "UserPromptSubmit";
+    let selectionProfile;
     try {
       if (agents(options.agent).length !== 1)
         throw new Error("A hook invocation requires one agent");
@@ -107393,18 +108114,18 @@ function registerAgentIntegration(parent) {
       input3.hook_event_name = event;
       const projects = [process.cwd()];
       if (input3.cwd !== undefined) {
-        if (typeof input3.cwd !== "string" || !isAbsolute22(input3.cwd) || input3.cwd.includes("\x00"))
+        if (typeof input3.cwd !== "string" || !isAbsolute24(input3.cwd) || input3.cwd.includes("\x00"))
           throw new Error("Invalid native hook working directory");
         projects.push(input3.cwd);
       }
       if (options.agent === "cursor") {
-        if (!Array.isArray(input3.workspace_roots) || input3.workspace_roots.length > 32 || input3.workspace_roots.some((path) => typeof path !== "string" || !isAbsolute22(path) || path.includes("\x00")))
+        if (!Array.isArray(input3.workspace_roots) || input3.workspace_roots.length > 32 || input3.workspace_roots.some((path) => typeof path !== "string" || !isAbsolute24(path) || path.includes("\x00")))
           throw new Error("Invalid Cursor workspace roots");
         projects.push(...input3.workspace_roots);
         input3.cwd ??= input3.workspace_roots[0] ?? process.cwd();
         input3.session_id ??= input3.conversation_id;
       }
-      const selectionProfile = selectedProfileId(options.selectionProfile);
+      selectionProfile = selectedProfileId(options.selectionProfile);
       if (options.agent === "hermes" && event === "pre_tool_call") {
         assertManagedAgentBridge("hermes", { projectDirs: projects, profileId: selectionProfile });
         assertHermesTool(input3);
@@ -107426,17 +108147,24 @@ function registerAgentIntegration(parent) {
       if (event === "SessionStart") {
         const remaining = deadline - Date.now();
         if (remaining <= 0)
-          throw new Error("Skills hook deadline exceeded");
+          throw new HookDiagnosticError("SKILLS_HOOK_TIMEOUT", "sync");
         const refresh = Bun.spawn([process.execPath, process.argv[1], "sync", "--selection-profile", selectionProfile, "--json"], { stdin: "ignore", stdout: "pipe", stderr: "pipe", env: { ...process.env, NO_COLOR: "1" } });
-        const timer = setTimeout(() => refresh.kill("SIGKILL"), Math.min(6500, remaining));
+        let timedOut = false;
+        const timer = setTimeout(() => {
+          timedOut = true;
+          refresh.kill("SIGKILL");
+        }, Math.min(6500, remaining));
         try {
-          const [, , status] = await Promise.all([new Response(refresh.stdout).text(), new Response(refresh.stderr).text(), refresh.exited]);
+          const [stdout, , status] = await Promise.all([new Response(refresh.stdout).text(), new Response(refresh.stderr).text(), refresh.exited]);
+          if (timedOut)
+            throw new HookDiagnosticError("SKILLS_HOOK_TIMEOUT", "sync");
           if (status !== 0)
-            throw new Error("Session profile refresh failed");
+            throw hookChildError(stdout, "sync");
         } finally {
           clearTimeout(timer);
         }
       }
+      selectionProfile = pinnedHookProfile(input3, selectionProfile);
       const result2 = await contextForHook(input3, selectionProfile, true, deadline);
       const output2 = hookContextOutput(event, result2);
       if (options.agent === "hermes") {
@@ -107449,7 +108177,7 @@ function registerAgentIntegration(parent) {
         await writeCliOutput(JSON.stringify(output2));
       }
     } catch (error61) {
-      const reason = error61 instanceof Error && error61.message.startsWith("NATIVE_SKILL_DRIFT:") ? error61.message : "Skills context is unavailable. Run skills sync --selection-profile <id> and skills context --stdin --json to diagnose the selected profile.";
+      const reason = error61 instanceof Error && error61.message.startsWith("NATIVE_SKILL_DRIFT:") ? error61.message : hookFailureReason(error61, selectionProfile);
       if (options.agent === "hermes") {
         await writeCliOutput(JSON.stringify(event === "pre_tool_call" ? { action: "block", message: reason } : { context: `Required Skills context is unavailable. ${reason} Do not substitute native skill payloads; stop and repair the bridge before task actions.` }));
       } else if (options.agent === "claude" && event === "PreToolUse")
@@ -107489,6 +108217,8 @@ var init_agent_integration2 = __esm(() => {
   init_agent_adapters();
   init_agent_integration();
   init_agent_codex_trust();
+  init_hook_diagnostics();
+  init_selection_cache();
   RECOVERABLE_CONTEXT_CACHE_ERRORS = new Set(["CACHED_PROFILE_EXPIRED", "CACHED_PROFILE_MISSING", "CACHED_BUNDLE_MISSING"]);
 });
 
@@ -107627,17 +108357,17 @@ var exports_profiles = {};
 __export(exports_profiles, {
   registerProfiles: () => registerProfiles
 });
-import { closeSync as closeSync19, constants as constants18, fstatSync as fstatSync19, openSync as openSync19, readSync as readSync15, writeFileSync as writeFileSync24 } from "fs";
+import { closeSync as closeSync20, constants as constants19, fstatSync as fstatSync20, openSync as openSync20, readSync as readSync16, writeFileSync as writeFileSync24 } from "fs";
 function readProfileInput(path) {
-  const fd = openSync19(path, constants18.O_RDONLY | constants18.O_NONBLOCK);
+  const fd = openSync20(path, constants19.O_RDONLY | constants19.O_NONBLOCK);
   try {
-    const stat3 = fstatSync19(fd);
+    const stat3 = fstatSync20(fd);
     if (!stat3.isFile() || stat3.size > MAX_PROFILE_DOCUMENT_BYTES)
       throw new Error("Profile input exceeds the size limit or is not a regular file");
     const bytes = Buffer.alloc(MAX_PROFILE_DOCUMENT_BYTES + 1);
     let size2 = 0;
     while (size2 < bytes.length) {
-      const read3 = readSync15(fd, bytes, size2, bytes.length - size2, null);
+      const read3 = readSync16(fd, bytes, size2, bytes.length - size2, null);
       if (!read3)
         break;
       size2 += read3;
@@ -107646,7 +108376,7 @@ function readProfileInput(path) {
       throw new Error("Profile input exceeds the size limit");
     return new TextDecoder("utf-8", { fatal: true }).decode(bytes.subarray(0, size2));
   } finally {
-    closeSync19(fd);
+    closeSync20(fd);
   }
 }
 function registerProfiles(parent) {
@@ -107697,23 +108427,23 @@ __export(exports_grants, {
   registerGrants: () => registerGrants
 });
 import {
-  constants as constants19,
-  closeSync as closeSync20,
-  fstatSync as fstatSync20,
-  openSync as openSync20,
-  readSync as readSync16,
+  constants as constants20,
+  closeSync as closeSync21,
+  fstatSync as fstatSync21,
+  openSync as openSync21,
+  readSync as readSync17,
   writeFileSync as writeFileSync25
 } from "fs";
 function readInput(path) {
-  const fd = openSync20(path, constants19.O_RDONLY | constants19.O_NONBLOCK);
+  const fd = openSync21(path, constants20.O_RDONLY | constants20.O_NONBLOCK);
   try {
-    const stat3 = fstatSync20(fd);
+    const stat3 = fstatSync21(fd);
     if (!stat3.isFile() || stat3.size > MAX_EXECUTION_GRANT_BYTES)
       throw new Error("Grant input must be a regular file within the policy size limit.");
     const bytes = Buffer.alloc(MAX_EXECUTION_GRANT_BYTES + 1);
     let size2 = 0;
     while (size2 < bytes.length) {
-      const count = readSync16(fd, bytes, size2, bytes.length - size2, null);
+      const count = readSync17(fd, bytes, size2, bytes.length - size2, null);
       if (!count)
         break;
       size2 += count;
@@ -107726,7 +108456,7 @@ function readInput(path) {
       throw new Error("Grant input must be a JSON document containing a grants array.");
     }
   } finally {
-    closeSync20(fd);
+    closeSync21(fd);
   }
 }
 function registerGrants(parent) {
@@ -107762,7 +108492,7 @@ var init_grants = __esm(() => {
 });
 
 // src/lib/station-hydrate.ts
-import { createHash as createHash24 } from "crypto";
+import { createHash as createHash26 } from "crypto";
 import {
   copyFileSync as copyFileSync2,
   mkdirSync as mkdirSync26,
@@ -107771,7 +108501,7 @@ import {
   statSync as statSync21,
   writeFileSync as writeFileSync26
 } from "fs";
-import { dirname as dirname28, join as join57, resolve as resolve20, sep as sep10 } from "path";
+import { dirname as dirname29, join as join57, resolve as resolve22, sep as sep10 } from "path";
 function fail5(code2, message, detail = []) {
   throw new StationSnapshotError(code2, message, detail);
 }
@@ -107965,12 +108695,12 @@ function skillSha256(skill) {
     return sha256File(skill.files[0].winner.fullPath);
   }
   const joined = skill.files.map((file2) => sha256File(file2.winner.fullPath));
-  return createHash24("sha256").update(joined.sort().join(`
+  return createHash26("sha256").update(joined.sort().join(`
 `)).digest("hex");
 }
 function writeStationHydration(options) {
-  const repoRoot = resolve20(options.repoRoot ?? process.cwd());
-  const cacheRoot = resolve20(options.cacheRoot ?? resolveCorpusRoot());
+  const repoRoot = resolve22(options.repoRoot ?? process.cwd());
+  const cacheRoot = resolve22(options.cacheRoot ?? resolveCorpusRoot());
   const plan = planStationHydration(options.stationId, repoRoot);
   const resultSkills = plan.winners.map((skill) => ({
     ident: skill.ident,
@@ -108004,13 +108734,13 @@ function writeStationHydration(options) {
   for (const skill of plan.winners) {
     for (const file2 of skill.files) {
       const destination = join57(cacheRoot, skill.ident, file2.withinIdent);
-      const digest3 = sha256File(file2.winner.fullPath);
+      const digest4 = sha256File(file2.winner.fullPath);
       let existingDigest = null;
       try {
         existingDigest = sha256File(destination);
       } catch {}
       if (existingDigest !== null) {
-        if (existingDigest === digest3) {
+        if (existingDigest === digest4) {
           continue;
         }
         conflicts.push(`existing destination differs from snapshot winner: ${destination}`);
@@ -108024,7 +108754,7 @@ function writeStationHydration(options) {
   }
   let written = 0;
   for (const entry of toWrite) {
-    mkdirSync26(dirname28(entry.destination), { recursive: true });
+    mkdirSync26(dirname29(entry.destination), { recursive: true });
     copyFileSync2(entry.fullPath, entry.destination);
     written += 1;
   }
@@ -108045,8 +108775,8 @@ function writeStationHydration(options) {
     },
     skills: resultSkills
   };
-  const hydrationManifestPath = join57(dirname28(cacheRoot), `hydration-${options.stationId}.json`);
-  mkdirSync26(dirname28(hydrationManifestPath), { recursive: true });
+  const hydrationManifestPath = join57(dirname29(cacheRoot), `hydration-${options.stationId}.json`);
+  mkdirSync26(dirname29(hydrationManifestPath), { recursive: true });
   writeFileSync26(hydrationManifestPath, `${JSON.stringify(hydration, null, 2)}
 `);
   return {
@@ -108122,10 +108852,10 @@ var init_hydrate = __esm(() => {
 });
 
 // src/lib/prepare-skill.ts
-import { createHash as createHash25, randomUUID as randomUUID11 } from "crypto";
-import { chmodSync as chmodSync3, existsSync as existsSync34, lstatSync as lstatSync27, mkdirSync as mkdirSync27, mkdtempSync as mkdtempSync6, readFileSync as readFileSync39, readdirSync as readdirSync22, renameSync as renameSync12, rmSync as rmSync9, writeFileSync as writeFileSync27 } from "fs";
+import { createHash as createHash27, randomUUID as randomUUID11 } from "crypto";
+import { chmodSync as chmodSync3, existsSync as existsSync34, lstatSync as lstatSync28, mkdirSync as mkdirSync27, mkdtempSync as mkdtempSync6, readFileSync as readFileSync39, readdirSync as readdirSync22, renameSync as renameSync12, rmSync as rmSync9, writeFileSync as writeFileSync27 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
-import { dirname as dirname29, isAbsolute as isAbsolute23, join as join58, relative as relative9, resolve as resolve21, sep as sep11 } from "path";
+import { dirname as dirname30, isAbsolute as isAbsolute25, join as join58, relative as relative9, resolve as resolve23, sep as sep11 } from "path";
 function prepareSkill(name, options) {
   const normalized = normalizePortableSkillName(name);
   if (!new RegExp(SEMVER_PATTERN).test(options.version))
@@ -108170,7 +108900,7 @@ function prepareSkill(name, options) {
       mkdirSync27(join58(staging, directory2), { recursive: true });
     for (const file2 of before2.files) {
       const destination = join58(staging, file2.path);
-      mkdirSync27(dirname29(destination), { recursive: true });
+      mkdirSync27(dirname30(destination), { recursive: true });
       writeFileSync27(destination, file2.bytes, { mode: file2.mode });
     }
     const stagedManifest = join58(staging, "skill.json");
@@ -108230,8 +108960,8 @@ function validateRuntimeEntrypoint(candidate2, root2) {
   const entry = candidate2.runtime.entrypoint;
   if (typeof entry !== "string")
     return;
-  const target = resolve21(root2, entry), rel = relative9(root2, target);
-  if (isAbsolute23(entry) || /^[a-zA-Z]:/.test(entry) || entry.includes("\\") || !rel || rel === ".." || rel.startsWith(`..${sep11}`) || isAbsolute23(rel) || !existsSync34(target) || !lstatSync27(target).isFile()) {
+  const target = resolve23(root2, entry), rel = relative9(root2, target);
+  if (isAbsolute25(entry) || /^[a-zA-Z]:/.test(entry) || entry.includes("\\") || !rel || rel === ".." || rel.startsWith(`..${sep11}`) || isAbsolute25(rel) || !existsSync34(target) || !lstatSync28(target).isFile()) {
     throw new Error("Executable runtime.entrypoint must name an existing regular file inside the skill directory.");
   }
 }
@@ -108239,31 +108969,31 @@ function isRecord6(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function validateRawCandidate(candidate2) {
-  for (const field of ["standard", "name", "description", "version"]) {
-    if (typeof candidate2[field] !== "string" || !candidate2[field].trim())
-      throw new Error(`skill.json ${field} is required.`);
+  for (const field2 of ["standard", "name", "description", "version"]) {
+    if (typeof candidate2[field2] !== "string" || !candidate2[field2].trim())
+      throw new Error(`skill.json ${field2} is required.`);
   }
-  for (const field of ["displayName", "category"]) {
-    if (candidate2[field] !== undefined && (typeof candidate2[field] !== "string" || !candidate2[field].trim()))
-      throw new Error(`Invalid skill.json ${field}.`);
+  for (const field2 of ["displayName", "category"]) {
+    if (candidate2[field2] !== undefined && (typeof candidate2[field2] !== "string" || !candidate2[field2].trim()))
+      throw new Error(`Invalid skill.json ${field2}.`);
   }
   if (candidate2.tags !== undefined && (!Array.isArray(candidate2.tags) || candidate2.tags.some((tag) => typeof tag !== "string" || !tag.trim())))
     throw new Error("Invalid skill.json tags.");
   const issues = validatePortableManifestContract(candidate2, { strict: true });
   if (issues.length)
     throw new Error(`Invalid skill.json: ${issues.map((issue2) => issue2.code).join(", ")}`);
-  for (const field of ["inputs", "commands"]) {
-    const items = candidate2[field];
+  for (const field2 of ["inputs", "commands"]) {
+    const items = candidate2[field2];
     if (items === undefined)
       continue;
     if (!Array.isArray(items))
-      throw new Error(`skill.json ${field} must be an array.`);
+      throw new Error(`skill.json ${field2} must be an array.`);
     for (const item of items) {
       if (!isRecord6(item) || typeof item.name !== "string" || !item.name.trim())
-        throw new Error(`Invalid skill.json ${field} name.`);
-      if (field === "inputs" && (typeof item.type !== "string" || !item.type.trim() || item.required !== undefined && typeof item.required !== "boolean"))
+        throw new Error(`Invalid skill.json ${field2} name.`);
+      if (field2 === "inputs" && (typeof item.type !== "string" || !item.type.trim() || item.required !== undefined && typeof item.required !== "boolean"))
         throw new Error("Invalid skill.json input type or required flag.");
-      if (field === "commands") {
+      if (field2 === "commands") {
         if (!/^[a-z0-9][a-z0-9._-]*$/.test(item.name))
           throw new Error("Invalid skill.json command name.");
         for (const target of ["entry", "command"])
@@ -108303,11 +109033,11 @@ function compareVersions(left, right) {
   return 0;
 }
 function snapshot2(root2) {
-  const rootStat = lstatSync27(root2);
+  const rootStat = lstatSync28(root2);
   if (rootStat.isSymbolicLink() || !rootStat.isDirectory())
     throw new Error("Skill root must be a real directory, not a symlink.");
   const files = [], directories = [];
-  const hash4 = createHash25("sha256").update(`${rootStat.dev}:${rootStat.ino}\x00`);
+  const hash4 = createHash27("sha256").update(`${rootStat.dev}:${rootStat.ino}\x00`);
   let count = 0, bytes = 0;
   const walk2 = (relative10) => {
     for (const name of readdirSync22(join58(root2, relative10)).sort()) {
@@ -108316,7 +109046,7 @@ function snapshot2(root2) {
       const path = relative10 ? `${relative10}/${name}` : name;
       if (++count > 20000)
         throw new Error("Skill exceeds the preparation entry limit (20000).");
-      const absolute = join58(root2, path), stat3 = lstatSync27(absolute);
+      const absolute = join58(root2, path), stat3 = lstatSync28(absolute);
       if (stat3.isSymbolicLink())
         throw new Error(`Skill contains a symlink: ${path}. No files were changed.`);
       if (stat3.isDirectory() && name === "node_modules")
@@ -108731,7 +109461,7 @@ var init_schedule = __esm(() => {
 
 // src/lib/registry-sync.ts
 import { mkdirSync as mkdirSync28, writeFileSync as writeFileSync28 } from "fs";
-import { dirname as dirname30, relative as relative10 } from "path";
+import { dirname as dirname31, relative as relative10 } from "path";
 function createRegistrySyncArtifact(options = {}) {
   const profile = options.profile ?? "all";
   const includeDocs = options.includeDocs ?? true;
@@ -108788,7 +109518,7 @@ function createRegistrySyncArtifact(options = {}) {
   };
 }
 function writeRegistrySyncArtifact(path, artifact) {
-  mkdirSync28(dirname30(path), { recursive: true });
+  mkdirSync28(dirname31(path), { recursive: true });
   writeFileSync28(path, `${JSON.stringify(artifact, null, 2)}
 `);
 }
@@ -108821,12 +109551,12 @@ function registerRegistry(parent) {
 async function writeJson2(value, space) {
   const text3 = `${JSON.stringify(value, null, space)}
 `;
-  await new Promise((resolve22, reject2) => {
+  await new Promise((resolve24, reject2) => {
     process.stdout.write(text3, (error61) => {
       if (error61)
         reject2(error61);
       else
-        resolve22();
+        resolve24();
     });
   });
 }
@@ -109283,7 +110013,7 @@ var exports_private_publications = {};
 __export(exports_private_publications, {
   registerPrivatePublications: () => registerPrivatePublications
 });
-import { resolve as resolve22 } from "path";
+import { resolve as resolve24 } from "path";
 function verifyOptions(options, action) {
   if (options.userId === undefined !== (options.membershipId === undefined) || options.userId !== undefined && (!publicationUuid(options.userId) || !publicationUuid(options.membershipId)))
     throw new PrivatePublicationError("PUBLICATION_CONTEXT_REQUIRED", "Provide both observed --user-id and --membership-id UUIDs.");
@@ -109328,9 +110058,9 @@ function registerPrivatePublications(parent) {
         if (code2 === null)
           return;
         const context2 = options.userId ? { userId: options.userId, membershipId: options.membershipId } : undefined;
-        const client2 = await privatePublicationSession(options.email, code2, context2), directory2 = resolve22(options.recoveryDir);
+        const client2 = await privatePublicationSession(options.email, code2, context2), directory2 = resolve24(options.recoveryDir);
         if (action === "publish")
-          await preparePrivatePublication(client2, resolve22(args2[0]), directory2, { skillId: options.skillId, expectedCurrentVersionId: options.expectedCurrentVersion ?? null, idempotencyKey: options.idempotencyKey });
+          await preparePrivatePublication(client2, resolve24(args2[0]), directory2, { skillId: options.skillId, expectedCurrentVersionId: options.expectedCurrentVersion ?? null, idempotencyKey: options.idempotencyKey });
         const result2 = action === "publish" || action === "resume" ? await continuePrivatePublication(client2, directory2, { confirm: true, waitMs: Number(options.waitSeconds) * 1000 }) : await inspectPrivatePublication(client2, directory2, action === "cancel");
         print2(result2, options.json);
       } catch (error61) {
@@ -109431,7 +110161,7 @@ __export(exports_auth, {
 import { createInterface as createInterface3 } from "readline";
 function prompt(question) {
   const rl = createInterface3({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve23) => {
+  return new Promise((resolve25) => {
     let settled = false;
     const finish = (answer) => {
       if (settled)
@@ -109440,7 +110170,7 @@ function prompt(question) {
       rl.close();
       if (answer === null)
         process.exitCode = 130;
-      resolve23(answer);
+      resolve25(answer);
     };
     rl.once("SIGINT", () => finish(null));
     rl.once("close", () => finish(null));
@@ -109548,7 +110278,7 @@ function printWhoami(payload) {
     console.log(source_default.dim("(offline \u2014 showing cached info)"));
 }
 function sleep(ms) {
-  return new Promise((resolve23) => setTimeout(resolve23, ms));
+  return new Promise((resolve25) => setTimeout(resolve25, ms));
 }
 function browserCommand(url2) {
   if (process.platform === "darwin")
@@ -110050,7 +110780,7 @@ function promptInvitationProof(kind) {
   const label = kind === "token" ? "invitation token" : "recovery code";
   const character = kind === "token" ? /^[A-Za-z0-9_-]$/ : /^\d$/;
   const { stdin, stderr: output2 } = process, wasRaw = stdin.isRaw, wasFlowing = stdin.readableFlowing;
-  return new Promise((resolve23) => {
+  return new Promise((resolve25) => {
     let value = "", settled = false, overflow = false;
     const finish = (answer) => {
       if (settled)
@@ -110067,7 +110797,7 @@ function promptInvitationProof(kind) {
 `);
       if (answer === null)
         process.exitCode = 130;
-      resolve23(answer);
+      resolve25(answer);
     };
     const cancel = () => finish(null);
     const keypress = (text3, key) => {
@@ -110777,8 +111507,8 @@ async function currentRemoteDigest(client2, slug2) {
   }
   if (!body || typeof body !== "object")
     return;
-  const digest3 = body.bundleSha256;
-  return typeof digest3 === "string" && digest3 ? digest3 : undefined;
+  const digest4 = body.bundleSha256;
+  return typeof digest4 === "string" && digest4 ? digest4 : undefined;
 }
 async function reconcileRegistry(options = {}) {
   const conflict = options.conflict ?? "skip";