@hasna/skills 0.8.10 → 0.8.12

package/dist/index.js

@@ -9650,7 +9650,7 @@ import { homedir as homedir5 } from "os";
 import {
   cpSync as cpSync2,
   existsSync as existsSync12,
-  lstatSync as lstatSync17,
+  lstatSync as lstatSync19,
   mkdirSync as mkdirSync8,
   mkdtempSync as mkdtempSync2,
   readFileSync as readFileSync15,
@@ -9661,12 +9661,12 @@ import {
   writeFileSync as writeFileSync6
 } from "fs";
 import { homedir as homedir4 } from "os";
-import { basename as basename5, dirname as dirname14, join as join26 } from "path";
+import { basename as basename9, dirname as dirname16, join as join26 } from "path";
 
 // src/lib/agent-integration.ts
-import { createHash as createHash12, randomUUID as randomUUID3 } from "crypto";
-import { existsSync as existsSync11, lstatSync as lstatSync16, statSync as statSync8, mkdirSync as mkdirSync7, readFileSync as readFileSync14, 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 constants8, linkSync as linkSync2 } from "fs";
-import { dirname as dirname13, join as join25, resolve as resolve12, relative as relative5, isAbsolute as isAbsolute12, sep as sep6 } from "path";
+import { createHash as createHash14, randomUUID as randomUUID3 } from "crypto";
+import { existsSync as existsSync11, lstatSync as lstatSync18, statSync as statSync8, mkdirSync as mkdirSync7, readFileSync as readFileSync14, 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 openSync11, closeSync as closeSync11, fsyncSync as fsyncSync3, fstatSync as fstatSync11, readSync as readSync9, constants as constants10, linkSync as linkSync2 } from "fs";
+import { dirname as dirname15, join as join25, resolve as resolve15, relative as relative5, isAbsolute as isAbsolute15, sep as sep6 } from "path";
 import { homedir as homedir3 } from "os";
 
 // src/lib/managed-policy.ts
@@ -9675,8 +9675,9 @@ import { join as join11 } from "path";
 
 // src/lib/selection-cache.ts
 import { createHash as createHash3, randomUUID } from "crypto";
-import { closeSync, constants, fstatSync, lstatSync as lstatSync3, mkdirSync as mkdirSync4, openSync, readSync, renameSync as renameSync2, unlinkSync, writeFileSync as writeFileSync4 } from "fs";
+import { closeSync, constants, 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 join10, parse, resolve as resolve3 } from "path";
+import { isDeepStrictEqual } from "util";
 
 // src/lib/skill-bundle.ts
 import { createHash as createHash2 } from "crypto";
@@ -10271,7 +10272,7 @@ function selectionSnapshotsEqual(left, right) {
 var MAX_PROFILE_SELECTIONS = 4096;
 var MAX_PROFILE_DOCUMENT_BYTES = 8 * 1024 * 1024;
 var MAX_SKILL_SESSION_ID_CHARS = 256;
-var PROFILE_SESSION_ENVELOPE_BYTES = MAX_PROFILE_SELECTIONS * 67 + MAX_SKILL_SESSION_ID_CHARS * 6 + 256;
+var PROFILE_SESSION_ENVELOPE_BYTES = MAX_PROFILE_SELECTIONS * 67 + MAX_SKILL_SESSION_ID_CHARS * 12 + 512;
 var MAX_RESOLVED_PROFILE_BYTES = MAX_PROFILE_DOCUMENT_BYTES - PROFILE_SESSION_ENVELOPE_BYTES;
 var LEGACY_PROFILE_SELECTIONS = 256;
 var LEGACY_PROFILE_DOCUMENT_BYTES = 1e6;
@@ -10420,12 +10421,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 = join10(dirname4(path), `.selection-${randomUUID()}.tmp`);
   try {
-    writeFileSync4(temporary, bytes, { flag: "wx", mode });
+    const fd = openSync(temporary, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.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);
@@ -10544,19 +10554,194 @@ function sessionReceiptPath(sessionId, options = {}) {
     throw new SkillSelectionError("INVALID_SESSION", `A Skills session id must contain 1\u2013${MAX_SKILL_SESSION_ID_CHARS} characters.`);
   return join10(selectionCacheRoot(options), "sessions", `${hash(sessionId)}.json`);
 }
-function readSkillSession(sessionId, options = {}) {
-  const receipt = readSelectionJson(sessionReceiptPath(sessionId, options));
-  if (receipt) {
-    validateSelectionReceipt(receipt);
-    const keys = new Set(receipt.profile.selections.map(selectionKey));
-    if (receipt.sessionId !== sessionId || !Array.isArray(receipt.loaded) || receipt.loaded.length > keys.size || new Set(receipt.loaded).size !== receipt.loaded.length || !receipt.loaded.every((key) => keys.has(key))) {
-      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 keys = new Set(receipt.profile.selections.map(selectionKey));
+  if (receipt.sessionId !== sessionId || !Array.isArray(receipt.loaded) || receipt.loaded.length > keys.size || new Set(receipt.loaded).size !== receipt.loaded.length || !receipt.loaded.every((key) => keys.has(key)) || receipt.generation !== undefined && (!Number.isSafeInteger(receipt.generation) || receipt.generation < 1)) {
+    throw new SkillSelectionError("INVALID_RECEIPT", "The Skills session receipt is invalid.");
+  }
+  if (receipt.parent) {
+    validateSkillSessionBinding(receipt.parent);
+    if (receipt.parent.sessionId === sessionId)
+      throw new SkillSelectionError("INVALID_RECEIPT", "A Skills child session cannot name itself as its parent.");
+  }
+}
+function readSkillSessionSnapshotIfExists(sessionId, options = {}) {
+  const path = sessionReceiptPath(sessionId, options), bytes = readRegularFile(path, MAX_PROFILE_DOCUMENT_BYTES);
+  if (!bytes)
+    return null;
+  let receipt;
+  try {
+    receipt = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+  } catch {
+    throw new SkillSelectionError("INVALID_RECEIPT", "The Skills session receipt is unreadable.");
+  }
+  validateSkillSessionReceipt(receipt, sessionId);
+  const sha256 = sha256Hex(bytes);
+  return { path, bytes, receipt, sha256, sessionId, generation: skillSessionGeneration(receipt), receiptSha256: sha256 };
+}
+function readSkillSessionSnapshot(sessionId, options = {}) {
+  const snapshot = readSkillSessionSnapshotIfExists(sessionId, options);
+  if (!snapshot)
+    throw new SkillSelectionError("SESSION_NOT_FOUND", "The requested Skills session receipt does not exist.");
+  return snapshot;
+}
+function skillSessionSnapshotBinding(snapshot) {
+  return { sessionId: snapshot.sessionId, generation: snapshot.generation, receiptSha256: snapshot.receiptSha256 };
+}
+function withSessionWriteLocks(sessionIds, options, action) {
+  const operationId = randomUUID();
+  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, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.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);
+    }
+  }
+}
+function withSessionWriteLock(sessionId, options, action) {
+  return withSessionWriteLocks([sessionId], options, action);
+}
+function sameSnapshot(actual, expected) {
+  return actual === null ? expected === null : expected !== null && actual.sessionId === expected.sessionId && actual.generation === expected.generation && actual.receiptSha256 === expected.receiptSha256;
+}
+function nextSkillSessionGeneration(generation) {
+  if (!Number.isSafeInteger(generation) || generation < 0 || generation >= Number.MAX_SAFE_INTEGER) {
+    throw new SkillSelectionError("SESSION_GENERATION_EXHAUSTED", "The Skills session generation cannot advance safely; preserve the receipt and review recovery before continuing.");
+  }
+  return generation + 1;
+}
+function parentChanged() {
+  throw new SkillSelectionError("SESSION_PARENT_CHANGED", "The parent Skills session changed while the child was resolving; resolve the child again from the current parent pin.");
+}
+function writeSkillSession(receipt, expected, options = {}) {
+  validateSkillSessionReceipt(receipt, receipt.sessionId);
+  if (expected.parent)
+    validateSkillSessionBinding(expected.parent);
+  if (expected.parent?.sessionId === receipt.sessionId)
+    throw new SkillSelectionError("INVALID_RECEIPT", "A Skills child session cannot name itself as its parent.");
+  const lockIds = expected.parent ? [receipt.sessionId, expected.parent.sessionId] : [receipt.sessionId];
+  withSessionWriteLocks(lockIds, options, (assertOwned) => {
+    const current = readSkillSessionSnapshotIfExists(receipt.sessionId, options);
+    if (!sameSnapshot(current, expected.current) || current && !isDeepStrictEqual(current.receipt.profile, receipt.profile)) {
+      throw new SkillSelectionError("SESSION_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 || !isDeepStrictEqual(parent.receipt.profile, receipt.profile))
+        parentChanged();
+    }
+    const generation = nextSkillSessionGeneration(current?.generation ?? 0);
+    const next = current ? { ...current.receipt, generation, loaded: [...new Set([...current.receipt.loaded, ...receipt.loaded])] } : { ...receipt, generation, ...expected.parent ? { parent: expected.parent } : {} };
+    assertOwned();
+    if (expected.parent) {
+      parent = readSkillSessionSnapshotIfExists(expected.parent.sessionId, options);
+      if (!sameSnapshot(parent, expected.parent))
+        parentChanged();
+    }
+    writeSelectionJson(sessionReceiptPath(receipt.sessionId, options), next);
+  });
+}
+function syncDirectory(path) {
+  assertRegularPath(path);
+  const fd = openSync(path, constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW);
+  try {
+    fsyncSync(fd);
+  } finally {
+    closeSync(fd);
+  }
+}
+function archiveBytes(path, bytes) {
+  assertRegularPath(path, true);
+  const fd = openSync(path, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 384);
+  try {
+    writeFileSync4(fd, bytes);
+    fsyncSync(fd);
+  } finally {
+    closeSync(fd);
   }
-  return receipt;
+}
+function replaceSkillSession(expected, replacement, plan, options = {}, beforeCommit = () => {}) {
+  validateSkillSessionReceipt(replacement, replacement.sessionId);
+  const bytes = Buffer.from(`${JSON.stringify(replacement)}
+`);
+  if (bytes.length > MAX_PROFILE_DOCUMENT_BYTES)
+    throw new SkillSelectionError("RECEIPT_TOO_LARGE", "The Skills selection receipt exceeds its size limit.");
+  return withSessionWriteLock(replacement.sessionId, options, (assertOwned) => {
+    const before = readSkillSessionSnapshot(replacement.sessionId, options);
+    if (!sameSnapshot(before, expected))
+      throw new SkillSelectionError("SESSION_RECEIPT_CHANGED", "The Skills session receipt generation or bytes changed after review; inspect it and prepare a new plan.");
+    if (replacement.generation !== nextSkillSessionGeneration(before.generation))
+      throw new SkillSelectionError("SESSION_GENERATION_CHANGED", "The replacement Skills session must advance exactly one generation.");
+    if (before.receipt.profile.authority !== replacement.profile.authority || before.receipt.profile.workspaceId !== replacement.profile.workspaceId) {
+      throw new SkillSelectionError("PROFILE_IDENTITY_MISMATCH", "A session reconciliation cannot change its Skills authority or workspace.");
+    }
+    const directory = join10(selectionCacheRoot(options), "session-reconciliations", randomUUID());
+    const archivePath = join10(directory, "original.json"), replacementPath = join10(directory, "replacement.json"), receiptPath = join10(directory, "receipt.json");
+    const afterSha256 = sha256Hex(bytes);
+    archiveBytes(archivePath, before.bytes);
+    archiveBytes(replacementPath, bytes);
+    const receipt = { schemaVersion: 1, status: "prepared", sessionId: replacement.sessionId, beforeGeneration: before.generation, afterGeneration: replacement.generation, beforeSha256: before.sha256, afterSha256, archivePath, replacementPath, plan };
+    archiveBytes(receiptPath, Buffer.from(`${JSON.stringify(receipt)}
+`));
+    syncDirectory(directory);
+    syncDirectory(dirname4(directory));
+    syncDirectory(selectionCacheRoot(options));
+    if (sha256Hex(readRegularFile(archivePath, MAX_PROFILE_DOCUMENT_BYTES)) !== before.sha256 || !sameSnapshot(readSkillSessionSnapshot(replacement.sessionId, options), expected)) {
+      throw new SkillSelectionError("SESSION_RECEIPT_CHANGED", "The session or its preservation archive changed before replacement; retained evidence must be reviewed.");
+    }
+    beforeCommit();
+    assertOwned();
+    try {
+      atomicWrite(before.path, bytes, 384, true);
+      atomicWrite(receiptPath, Buffer.from(`${JSON.stringify({ ...receipt, status: "applied" })}
+`), 384, true);
+    } catch {
+      throw new SkillSelectionError("SESSION_RECONCILIATION_INCOMPLETE", `Inspect sessions show and the preserved operation receipt at ${receiptPath} before any retry; replacement may already have committed.`);
+    }
+    return { archivePath, receiptPath, beforeSha256: before.sha256, afterSha256 };
+  });
 }
 
 // src/lib/agent-policy-limits.ts
+import { basename as basename3, isAbsolute as isAbsolute3, resolve as resolve4 } from "path";
 var AGENT_POLICY_LIMITS = Object.freeze({ bytes: 1024 * 1024, agents: 16, discoverySources: 2048, discoveryRawSourceBytes: 64 * 1024 * 1024, discoveryRawTotalBytes: 256 * 1024 * 1024, discoveryPathLinks: 40, discoveryPathSteps: 256, discoveryPathSourceMetadataBytes: 64 * 1024, discoveryPathTotalMetadataBytes: 8 * 1024 * 1024, discoveryRoots: 512, discoveryDirectories: 64, discoveryDirectoryEntries: 20000, discoveryDirectoryBytes: 8 * 1024 * 1024, builtinNames: 2048, rootAliases: 2, fields: 64, pathCharacters: 4096 });
 function object(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
@@ -10622,7 +10807,11 @@ 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", "claude-settings-v1"].includes(source.hashMode) && source.format === undefined && source.fields === undefined && (source.hashMode === "bytes" || source.sha256 !== null));
+      if (source.hashMode === "claude-settings-v1")
+        requireBound(agent === "claude" && value.agent === "claude" && value.method === "reviewed" && !/[\x00-\x1f\x7f]/.test(source.path) && isAbsolute3(source.path) && resolve4(source.path) === source.path && basename3(source.path) === "settings.json");
+      if (source.hashMode === "claude-marketplace-registry")
+        requireBound(agent === "claude" && value.agent === "claude" && value.method === "reviewed" && !/[\x00-\x1f\x7f]/.test(source.path) && isAbsolute3(source.path) && resolve4(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);
@@ -10774,9 +10963,9 @@ function isOwnedCliBridge(path, expectedPaths) {
 }
 
 // src/lib/agent-discovery.ts
-import { createHash as createHash11 } from "crypto";
-import { lstatSync as lstatSync15, readFileSync as readFileSync13, readdirSync as readdirSync9, realpathSync as realpathSync4 } from "fs";
-import { dirname as dirname12, isAbsolute as isAbsolute11, join as join23, resolve as resolve11, sep as sep5 } from "path";
+import { createHash as createHash13 } from "crypto";
+import { lstatSync as lstatSync17, readFileSync as readFileSync13, readdirSync as readdirSync9, realpathSync as realpathSync4 } from "fs";
+import { basename as basename8, dirname as dirname14, isAbsolute as isAbsolute14, join as join23, resolve as resolve14, sep as sep5 } from "path";
 
 // node_modules/yaml/dist/index.js
 var composer = require_composer();
@@ -10825,7 +11014,7 @@ var $visit = visit.visit;
 var $visitAsync = visit.visitAsync;
 
 // src/lib/agent-hermes.ts
-import { dirname as dirname5, isAbsolute as isAbsolute3, join as join13, resolve as resolve4 } from "path";
+import { dirname as dirname5, isAbsolute as isAbsolute4, join as join13, resolve as resolve5 } from "path";
 import { lstatSync as lstatSync6, readFileSync as readFileSync9, opendirSync } from "fs";
 var HERMES_OPT_OUT = ".no-bundled-skills";
 var EVENTS = ["pre_llm_call", "pre_tool_call"];
@@ -10863,7 +11052,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") };
@@ -10899,14 +11088,14 @@ 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) || resolve4(selected) !== join13(resolve4(home), ".hermes")))
+  if (selected && (!isAbsolute4(selected) || resolve5(selected) !== join13(resolve5(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");
 }
 function assertNoHermesLegacyShadow(root) {
   let entries = 0;
-  for (let cursor = resolve4(root);; cursor = dirname5(cursor)) {
+  for (let cursor = resolve5(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)
@@ -10992,13 +11181,13 @@ if (failed) process.exitCode = 2;
 // 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 join14, resolve as resolve5 } from "path";
+import { dirname as dirname6, isAbsolute as isAbsolute5, join as join14, resolve as resolve6 } 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) && resolve5(path) === path && !path.includes("\x00"), "Expected a canonical absolute discovery directory path");
+  need(typeof path === "string" && path.length <= AGENT_POLICY_LIMITS.pathCharacters && isAbsolute5(path) && resolve6(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)
@@ -11063,12 +11252,12 @@ function verifyDiscoveryDirectories(directories) {
 // src/lib/agent-discovery-bytes.ts
 import { createHash as createHash6 } from "crypto";
 import { closeSync as closeSync3, constants as constants3, fstatSync as fstatSync3, lstatSync as lstatSync8, openSync as openSync3, readSync as readSync3 } from "fs";
-import { dirname as dirname7, isAbsolute as isAbsolute5, resolve as resolve6 } from "path";
+import { dirname as dirname7, isAbsolute as isAbsolute6, resolve as resolve7 } from "path";
 function discoveryByteBudget() {
   return { remaining: AGENT_POLICY_LIMITS.discoveryRawTotalBytes };
 }
 function safe2(path) {
-  if (typeof path !== "string" || !isAbsolute5(path) || path !== resolve6(path) || path.length > AGENT_POLICY_LIMITS.pathCharacters || path.includes("\x00"))
+  if (typeof path !== "string" || !isAbsolute6(path) || path !== resolve7(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())
@@ -11131,7 +11320,7 @@ function hashRawDiscoveryFile(path, budget, changes) {
 // 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 join15, parse as parse2, resolve as resolve7, sep as sep3 } from "path";
+import { dirname as dirname8, isAbsolute as isAbsolute7, join as join15, parse as parse2, resolve as resolve8, sep as sep3 } from "path";
 function identity2(stat, mutable = false) {
   return {
     dev: String(stat.dev),
@@ -11143,7 +11332,7 @@ function identity2(stat, mutable = false) {
   };
 }
 function canonical(path) {
-  if (typeof path !== "string" || !isAbsolute6(path) || path !== resolve7(path) || path.length > AGENT_POLICY_LIMITS.pathCharacters || path.includes("\x00") || Buffer.from(path).toString("utf8") !== path)
+  if (typeof path !== "string" || !isAbsolute7(path) || path !== resolve8(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) {
@@ -11192,11 +11381,11 @@ function trace(path) {
       if (!target || target.includes("\x00") || Buffer.byteLength(target) > AGENT_POLICY_LIMITS.pathCharacters || !after.isSymbolicLink() || JSON.stringify(identity2(stat, true)) !== JSON.stringify(identity2(after, true)))
         throw new Error("Discovery link changed during read");
       record2(candidate, { type: "link", target, ...identity2(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");
@@ -11244,15 +11433,15 @@ function hashDiscoveryPathFile(path, budget, changes) {
 
 // src/lib/plugin-discovery.ts
 import { closeSync as closeSync8, constants as constants7, 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 join21, resolve as resolve10 } from "path";
+import { basename as basename5, dirname as dirname11, isAbsolute as isAbsolute11, join as join21, resolve as resolve11 } from "path";
 
 // src/lib/plugin-admission.ts
 import { homedir as homedir2 } from "os";
-import { isAbsolute as isAbsolute9, join as join20, resolve as resolve9 } from "path";
+import { isAbsolute as isAbsolute10, join as join20, resolve as resolve10 } from "path";
 // package.json
 var package_default = {
   name: "@hasna/skills",
-  version: "0.8.10",
+  version: "0.8.12",
   description: "Skills library for AI coding agents",
   type: "module",
   bin: {
@@ -11314,10 +11503,11 @@ var package_default = {
     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",
@@ -11339,7 +11529,6 @@ var package_default = {
   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",
@@ -11352,6 +11541,7 @@ var package_default = {
     "@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",
@@ -11386,12 +11576,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 readFileSync10, 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 join16, relative as relative4, sep as sep4 } from "path";
+import { basename as basename4, dirname as dirname9, join as join16, relative as relative4, sep as sep4 } from "path";
 import { fileURLToPath, pathToFileURL } from "url";
 function envToken(name) {
   return name.toUpperCase().replace(/-/g, "_");
@@ -11499,7 +11689,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 = join16(directory, "node_modules", PACKAGE);
       let absent = false;
       try {
@@ -11559,7 +11749,7 @@ function homeDir(env) {
 }
 function absoluteOverride(env, key) {
   const value = env[key]?.trim();
-  return value && isAbsolute7(value) ? value : null;
+  return value && isAbsolute8(value) ? value : null;
 }
 function hasnaHomeDir(env) {
   const override = absoluteOverride(env, HASNA_HOME_ENV_KEY);
@@ -12338,10 +12528,16 @@ function isCredentialResolutionError(error) {
 function isSkillsFleetCredentialError(error) {
   return error instanceof SkillsFleetCredentialError || typeof error === "object" && error !== null && error.name === "SkillsFleetCredentialError";
 }
-function asSkillsFleetCredentialError(error) {
+var REDACTED_VAULT_REFERENCE = "[redacted vault reference]";
+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);
@@ -12526,7 +12722,7 @@ async function resolveSkillsConnection(env = process.env, options = {}) {
   try {
     completed = await completePointerCredential(SKILLS_APP, pointer, env);
   } catch (error) {
-    const translated = asSkillsFleetCredentialError(error);
+    const translated = asSkillsFleetCredentialError(error, pointer.pointerVaultKey);
     if (translated)
       throw translated;
     throw error;
@@ -13407,11 +13603,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);
@@ -13419,7 +13622,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);
@@ -13432,7 +13635,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) {
@@ -13661,8 +13864,8 @@ function buildPluginProjection(entries) {
 
 // src/lib/plugin-projection-store.ts
 import { createHash as createHash10, randomUUID as randomUUID2 } from "crypto";
-import { constants as constants6, 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 join19, parse as parse4, resolve as resolve8 } from "path";
+import { constants as constants6, 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 join19, parse as parse4, resolve as resolve9 } from "path";
 var READ_FLAGS = constants6.O_RDONLY | constants6.O_NOFOLLOW | constants6.O_NONBLOCK;
 var WRITE_FLAGS = constants6.O_WRONLY | constants6.O_CREAT | constants6.O_EXCL | constants6.O_NOFOLLOW | constants6.O_NONBLOCK;
 var uid = () => typeof process.getuid === "function" ? BigInt(process.getuid()) : undefined;
@@ -13677,7 +13880,7 @@ function stat(path) {
   }
 }
 function canonical2(path) {
-  pluginNeed(typeof path === "string" && path.length <= 8192 && isAbsolute8(path) && resolve8(path) === path && !/[\x00-\x1f\x7f]/.test(path), "Plugin storage paths must be canonical absolute paths");
+  pluginNeed(typeof path === "string" && path.length <= 8192 && isAbsolute9(path) && resolve9(path) === path && !/[\x00-\x1f\x7f]/.test(path), "Plugin storage paths must be canonical absolute paths");
 }
 function owner(stats, system = false) {
   const current = uid();
@@ -13886,7 +14089,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);
@@ -14060,7 +14263,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) && resolve9(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) && resolve10(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);
@@ -14068,7 +14271,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) && resolve9(value[key].executable) === value[key].executable, "Plugin executable must have a canonical absolute path");
+    pluginNeed(isAbsolute10(value[key].executable) && resolve10(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)");
@@ -14220,7 +14423,7 @@ function pluginResolverCommand(binding) {
 }
 function root(options) {
   const path = options.storeRoot ?? pluginAdmissionRoot();
-  pluginNeed(isAbsolute9(path) && resolve9(path) === path, "Invalid plugin admission store root");
+  pluginNeed(isAbsolute10(path) && resolve10(path) === path, "Invalid plugin admission store root");
   return path;
 }
 function pluginBindingPath(storeRoot, id) {
@@ -14425,12 +14628,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) && resolve10(item.storeRoot) === item.storeRoot, "Invalid plugin receipt store path");
+    pluginNeed(isAbsolute11(item.storeRoot) && resolve11(item.storeRoot) === item.storeRoot, "Invalid plugin receipt store path");
   }
 }
 function safe3(path) {
   pluginText(path);
-  pluginNeed(isAbsolute10(path) && resolve10(path) === path, "Invalid plugin registry path");
+  pluginNeed(isAbsolute11(path) && resolve11(path) === path, "Invalid plugin registry path");
   for (let at = path;; at = dirname11(at)) {
     pluginNeed(!lstatSync14(at, { throwIfNoEntry: false })?.isSymbolicLink(), "Plugin registry path traverses a symlink");
     if (at === dirname11(at))
@@ -14499,7 +14702,7 @@ function hashManagedPluginRegistry(path, managed) {
       pluginNeed(/^(?:[A-Za-z0-9][A-Za-z0-9._+-]*-)?[a-f0-9]{12}$/.test(row.version) && row.installPath === join21(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)) {
@@ -14560,8 +14763,398 @@ function captureManagedPluginRegistry(path, managedPlugins) {
   return { path, hashMode: "claude-plugin-registry", managedPlugins, sha256: hashManagedPluginRegistry(path, managedPlugins) };
 }
 
+// src/lib/claude-marketplace-registry.ts
+import { createHash as createHash11 } from "crypto";
+import { closeSync as closeSync9, constants as constants8, 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 resolve12 } from "path";
+var CLAUDE_MARKETPLACE_REGISTRY_LIMITS = Object.freeze({ bytes: 1024 * 1024, rows: 1024, depth: 32, nodes: 65536, stringCharacters: 16384, pathCharacters: 4096 });
+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) && resolve12(value) === value, "requires a normalized absolute path");
+}
+var sameFile = (a, b) => a.dev === b.dev && a.ino === b.ino && a.mode === b.mode && a.uid === b.uid && a.gid === b.gid && a.nlink === b.nlink && a.size === b.size && a.mtimeNs === b.mtimeNs && a.ctimeNs === b.ctimeNs;
+function parents(path) {
+  const result = [];
+  for (let at = dirname12(path);; at = dirname12(at)) {
+    const stat2 = lstatSync15(at, { bigint: true });
+    need2(stat2.isDirectory() && !stat2.isSymbolicLink(), "path traverses a symlink or non-directory");
+    result.push([at, stat2]);
+    if (at === dirname12(at))
+      return result;
+  }
+}
+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), initial = lstatSync15(path, { bigint: true });
+  need2(initial.isFile() && !initial.isSymbolicLink() && initial.size <= BigInt(CLAUDE_MARKETPLACE_REGISTRY_LIMITS.bytes), "is not a bounded regular file");
+  need2(initial.size <= BigInt(budget.remaining), "exceeds its aggregate byte limit");
+  const fd = openSync9(path, constants8.O_RDONLY | constants8.O_NOFOLLOW | constants8.O_NONBLOCK);
+  try {
+    const opened = fstatSync9(fd, { bigint: true });
+    need2(opened.isFile() && sameFile(initial, opened), "changed during open");
+    const bytes = Buffer.alloc(Number(opened.size) + 1);
+    let length = 0;
+    while (length < bytes.length) {
+      const count = readSync7(fd, bytes, length, bytes.length - length, null);
+      if (!count)
+        break;
+      length += count;
+    }
+    const after = fstatSync9(fd, { bigint: true }), current = lstatSync15(path, { bigint: true });
+    need2(current.isFile() && sameFile(opened, after) && sameFile(after, current) && BigInt(length) === opened.size, "changed during read");
+    for (const [ancestor, before] of ancestors2) {
+      const now = lstatSync15(ancestor, { bigint: true });
+      need2(now.isDirectory() && before.dev === now.dev && before.ino === now.ino && before.mode === now.mode, "parent changed during read");
+    }
+    budget.remaining -= length;
+    try {
+      return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes.subarray(0, length));
+    } catch {
+      throw new Error("Claude marketplace registry is not strict UTF-8");
+    }
+  } finally {
+    closeSync9(fd);
+  }
+}
+function parse5(text2) {
+  let at = 0, nodes = 0;
+  const numberPattern = /-?(?:0|[1-9][0-9]*)(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?/y;
+  const space = () => {
+    while (at < text2.length && /[\x20\t\r\n]/.test(text2[at]))
+      at++;
+  };
+  function string() {
+    need2(text2[at] === '"', "contains invalid JSON");
+    const start = at++;
+    while (at < text2.length) {
+      const character = text2[at++];
+      if (character === '"') {
+        let value2;
+        try {
+          value2 = JSON.parse(text2.slice(start, at));
+        } catch {
+          throw new Error("Claude marketplace registry contains invalid JSON string");
+        }
+        need2(value2.length <= CLAUDE_MARKETPLACE_REGISTRY_LIMITS.stringCharacters, "exceeds its string limit");
+        return value2;
+      }
+      if (character === "\\")
+        at++;
+    }
+    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[at];
+    if (character === '"')
+      return { kind: "string", value: string() };
+    if (character === "{" || character === "[") {
+      at++;
+      space();
+      const object4 = character === "{", end = object4 ? "}" : "]", entries = [], items = [], keys = new Set;
+      if (text2[at] !== end)
+        while (true) {
+          if (object4) {
+            space();
+            const key = string();
+            need2(!keys.has(key), "contains a duplicate JSON key");
+            keys.add(key);
+            space();
+            need2(text2[at++] === ":", "contains invalid JSON");
+            entries.push([key, value(depth + 1)]);
+          } else
+            items.push(value(depth + 1));
+          space();
+          if (text2[at] === end)
+            break;
+          need2(text2[at++] === ",", "contains invalid JSON");
+        }
+      at++;
+      return object4 ? { kind: "object", entries } : { kind: "array", items };
+    }
+    for (const literal of ["true", "false", "null"])
+      if (text2.startsWith(literal, at)) {
+        at += literal.length;
+        return { kind: "literal", value: literal };
+      }
+    numberPattern.lastIndex = at;
+    const number = numberPattern.exec(text2);
+    need2(number, "contains invalid JSON");
+    at += number[0].length;
+    return { kind: "number", value: number[0] };
+  }
+  const root2 = value(0);
+  space();
+  need2(at === 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, keys) {
+  return value?.kind === "object" && value.entries.length === keys.length && value.entries.every(([key]) => keys.includes(key));
+}
+var field = (object4, key) => object4.entries.find(([name]) => name === key)?.[1];
+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 };
+}
+
+// src/lib/claude-settings-witness.ts
+import { createHash as createHash12 } from "crypto";
+import { closeSync as closeSync10, constants as constants9, fstatSync as fstatSync10, lstatSync as lstatSync16, openSync as openSync10, readSync as readSync8 } from "fs";
+import { basename as basename7, dirname as dirname13, isAbsolute as isAbsolute13, resolve as resolve13 } from "path";
+var CLAUDE_SETTINGS_WITNESS_LIMITS = Object.freeze({ bytes: 1024 * 1024, rows: 1024, depth: 32, nodes: 65536, stringCharacters: 16384, pathCharacters: 4096 });
+function need3(value, reason) {
+  if (!value)
+    throw new Error(`Claude settings witness ${reason}`);
+}
+function absolutePath2(value) {
+  need3(typeof value === "string" && value.length > 0 && value.length <= CLAUDE_SETTINGS_WITNESS_LIMITS.pathCharacters && !/[\x00-\x1f\x7f]/.test(value) && isAbsolute13(value) && resolve13(value) === value, "requires a normalized absolute path");
+}
+var sameFile2 = (a, b) => a.dev === b.dev && a.ino === b.ino && a.mode === b.mode && a.uid === b.uid && a.gid === b.gid && a.nlink === b.nlink && a.size === b.size && a.mtimeNs === b.mtimeNs && a.ctimeNs === b.ctimeNs;
+function parents2(path) {
+  const result = [];
+  for (let at = dirname13(path);; at = dirname13(at)) {
+    const stat2 = lstatSync16(at, { bigint: true });
+    need3(stat2.isDirectory() && !stat2.isSymbolicLink(), "path traverses a symlink or non-directory");
+    result.push([at, stat2]);
+    if (at === dirname13(at))
+      return result;
+  }
+}
+function readSettings(path, budget) {
+  absolutePath2(path);
+  need3(basename7(path) === "settings.json", "requires settings.json");
+  need3(Number.isSafeInteger(budget.remaining) && budget.remaining >= 0, "has an invalid byte budget");
+  const ancestors2 = parents2(path), initial = lstatSync16(path, { bigint: true });
+  need3(initial.isFile() && !initial.isSymbolicLink() && initial.size <= BigInt(CLAUDE_SETTINGS_WITNESS_LIMITS.bytes), "is not a bounded regular file");
+  need3(initial.size <= BigInt(budget.remaining), "exceeds its aggregate byte limit");
+  const fd = openSync10(path, constants9.O_RDONLY | constants9.O_NOFOLLOW | constants9.O_NONBLOCK);
+  try {
+    const opened = fstatSync10(fd, { bigint: true });
+    need3(opened.isFile() && sameFile2(initial, opened), "changed during open");
+    const bytes = Buffer.alloc(Number(opened.size) + 1);
+    let length = 0;
+    while (length < bytes.length) {
+      const count = readSync8(fd, bytes, length, bytes.length - length, null);
+      if (!count)
+        break;
+      length += count;
+    }
+    const after = fstatSync10(fd, { bigint: true }), current = lstatSync16(path, { bigint: true });
+    need3(current.isFile() && sameFile2(opened, after) && sameFile2(after, current) && BigInt(length) === opened.size, "changed during read");
+    for (const [ancestor, before] of ancestors2) {
+      const now = lstatSync16(ancestor, { bigint: true });
+      need3(now.isDirectory() && before.dev === now.dev && before.ino === now.ino && before.mode === now.mode, "parent changed during read");
+    }
+    budget.remaining -= length;
+    try {
+      return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes.subarray(0, length));
+    } catch {
+      throw new Error("Claude settings witness is not strict UTF-8");
+    }
+  } finally {
+    closeSync10(fd);
+  }
+}
+function parse6(text2) {
+  let at = 0, nodes = 0;
+  const numberPattern = /-?(?:0|[1-9][0-9]*)(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?/y;
+  const space = () => {
+    while (at < text2.length && /[\x20\t\r\n]/.test(text2[at]))
+      at++;
+  };
+  function string() {
+    need3(text2[at] === '"', "contains invalid JSON");
+    const start = at++;
+    while (at < text2.length) {
+      const character = text2[at++];
+      if (character === '"') {
+        let value2;
+        try {
+          value2 = JSON.parse(text2.slice(start, at));
+        } catch {
+          throw new Error("Claude settings witness contains invalid JSON string");
+        }
+        need3(value2.length <= CLAUDE_SETTINGS_WITNESS_LIMITS.stringCharacters, "exceeds its string limit");
+        return value2;
+      }
+      if (character === "\\")
+        at++;
+    }
+    throw new Error("Claude settings witness contains an unterminated JSON string");
+  }
+  function value(depth) {
+    need3(depth <= CLAUDE_SETTINGS_WITNESS_LIMITS.depth && ++nodes <= CLAUDE_SETTINGS_WITNESS_LIMITS.nodes, "exceeds its nesting or node limit");
+    space();
+    const character = text2[at];
+    if (character === '"')
+      return { kind: "string", value: string() };
+    if (character === "{" || character === "[") {
+      at++;
+      space();
+      const object4 = character === "{", end = object4 ? "}" : "]", entries = [], items = [], keys = new Set;
+      if (text2[at] !== end)
+        while (true) {
+          if (object4) {
+            space();
+            const key = string();
+            need3(!keys.has(key), "contains a duplicate JSON key");
+            keys.add(key);
+            space();
+            need3(text2[at++] === ":", "contains invalid JSON");
+            entries.push([key, value(depth + 1)]);
+          } else
+            items.push(value(depth + 1));
+          space();
+          if (text2[at] === end)
+            break;
+          need3(text2[at++] === ",", "contains invalid JSON");
+        }
+      at++;
+      return object4 ? { kind: "object", entries } : { kind: "array", items };
+    }
+    for (const literal of ["true", "false", "null"])
+      if (text2.startsWith(literal, at)) {
+        at += literal.length;
+        return { kind: "literal", value: literal };
+      }
+    numberPattern.lastIndex = at;
+    const number = numberPattern.exec(text2);
+    need3(number, "contains invalid JSON");
+    at += number[0].length;
+    return { kind: "number", value: number[0] };
+  }
+  const root2 = value(0);
+  space();
+  need3(at === text2.length && root2.kind === "object", "requires a JSON object without trailing content");
+  need3(root2.entries.length <= CLAUDE_SETTINGS_WITNESS_LIMITS.rows, "exceeds its settings field limit");
+  return root2;
+}
+var BOOLEAN_PREFERENCES = new Set([
+  "autoScrollEnabled",
+  "axScreenReader",
+  "emojiCompletionEnabled",
+  "prefersReducedMotion",
+  "showTurnDuration",
+  "spinnerTipsEnabled",
+  "syntaxHighlightingDisabled",
+  "terminalProgressBarEnabled",
+  "terminalTitleFromRename",
+  "verbose",
+  "wheelScrollAccelerationEnabled"
+]);
+var ENUM_PREFERENCES = Object.freeze({
+  editorMode: ["normal", "vim"],
+  tui: ["default", "fullscreen"],
+  viewMode: ["default", "verbose", "focus"]
+});
+var BUILTIN_MODEL_SELECTIONS = new Set([
+  "default",
+  "best",
+  "fable",
+  "fable[1m]",
+  "sonnet",
+  "sonnet[1m]",
+  "opus",
+  "opus[1m]",
+  "haiku",
+  "opusplan",
+  "claude-fable-5-1",
+  "claude-fable-5",
+  "claude-fable-5[1m]",
+  "claude-opus-5",
+  "claude-sonnet-5",
+  "claude-haiku-4-5-20251001",
+  "claude-opus-4-6",
+  "claude-sonnet-4-5",
+  "claude-sonnet-4-5-20250929",
+  "claude-opus-4-8",
+  "claude-opus-4-8[1m]",
+  "claude-opus-4-7",
+  "claude-sonnet-4-6",
+  "claude-opus-4-5-20251101",
+  "claude-opus-4-5",
+  "claude-haiku-4-5",
+  "claude-fable-5-1[1m]",
+  "claude-opus-5[1m]",
+  "claude-opus-4-7[1m]",
+  "claude-opus-4-6[1m]",
+  "claude-sonnet-4-6[1m]"
+]);
+function canonical3(value) {
+  if (value.kind === "object")
+    return { kind: "object", entries: value.entries.map(([key, child]) => [key, canonical3(child)]).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0) };
+  if (value.kind === "array")
+    return { kind: "array", items: value.items.map(canonical3) };
+  return value;
+}
+function settingsDigest(text2) {
+  const value = parse6(text2);
+  value.entries = value.entries.filter(([key, child]) => {
+    if (key === "model") {
+      need3(child.kind === "string", "contains an invalid model selection");
+      return !BUILTIN_MODEL_SELECTIONS.has(child.value);
+    }
+    if (BOOLEAN_PREFERENCES.has(key)) {
+      need3(child.kind === "literal" && (child.value === "true" || child.value === "false"), "contains an invalid display preference");
+      return false;
+    }
+    if (Object.hasOwn(ENUM_PREFERENCES, key)) {
+      need3(child.kind === "string" && ENUM_PREFERENCES[key].includes(child.value), "contains an invalid display preference");
+      return false;
+    }
+    return true;
+  });
+  return createHash12("sha256").update("hasna.skills.claude-settings.v1\x00").update(JSON.stringify(canonical3(value))).digest("hex");
+}
+function hashClaudeSettingsReplacement(text2, budget) {
+  need3(typeof text2 === "string", "requires settings text");
+  const bytes = Buffer.byteLength(text2);
+  need3(bytes <= CLAUDE_SETTINGS_WITNESS_LIMITS.bytes && Number.isSafeInteger(budget.remaining) && budget.remaining >= bytes, "exceeds its byte limit");
+  budget.remaining -= bytes;
+  return settingsDigest(text2);
+}
+function captureClaudeSettings(path, budget = { remaining: 256 * 1024 * 1024 }) {
+  return { path, hashMode: "claude-settings-v1", sha256: settingsDigest(readSettings(path, budget)) };
+}
+
 // src/lib/agent-discovery.ts
-var digest = (text2) => createHash11("sha256").update(text2).digest("hex");
+var digest = (text2) => createHash13("sha256").update(text2).digest("hex");
 function parseConfig(text2, path, toml = false) {
   try {
     const value = toml ? Bun.TOML.parse(text2) : JSON.parse(text2);
@@ -14573,12 +15166,12 @@ function parseConfig(text2, path, toml = false) {
   }
 }
 function safe4(path) {
-  if (!isAbsolute11(path) || path.includes("\x00"))
+  if (!isAbsolute14(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 = dirname14(cursor)) {
+    if (lstatSync17(cursor, { throwIfNoEntry: false })?.isSymbolicLink())
       throw new Error(`Refusing symlink native discovery input: ${cursor}`);
-    if (dirname12(cursor) === cursor)
+    if (dirname14(cursor) === cursor)
       break;
   }
 }
@@ -14586,7 +15179,7 @@ function read(path, changes) {
   safe4(path);
   if (changes?.has(path))
     return changes.get(path);
-  const stat2 = lstatSync15(path, { throwIfNoEntry: false });
+  const stat2 = lstatSync17(path, { throwIfNoEntry: false });
   if (!stat2)
     return null;
   if (!stat2.isFile() || stat2.size > 16 * 1024 * 1024)
@@ -14594,6 +15187,22 @@ function read(path, changes) {
   return readFileSync13(path, "utf8");
 }
 function projected(source, changes, budget = discoveryByteBudget()) {
+  if (source.hashMode === "claude-settings-v1") {
+    if (source.format !== undefined || source.fields !== undefined || source.managedPlugins !== undefined || typeof source.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(source.sha256))
+      throw new Error("Claude settings witnesses require exact typed metadata");
+    const current = captureClaudeSettings(source.path, budget).sha256;
+    if (current !== source.sha256)
+      throw new Error(`Native discovery input changed; run skills hook install with a fresh discovery review: ${source.path}`);
+    return changes?.has(source.path) ? hashClaudeSettingsReplacement(changes.get(source.path), budget) : current;
+  }
+  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");
@@ -14618,7 +15227,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)
@@ -14629,9 +15238,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");
@@ -14641,9 +15251,18 @@ function verifyAgentDiscovery(binding) {
   for (const root2 of binding.roots)
     safe4(root2);
 }
+function assertMarketplaceBinding(binding, source) {
+  if (source.hashMode === "claude-settings-v1" && (binding.agent !== "claude" || binding.method !== "reviewed" || basename8(source.path) !== "settings.json"))
+    throw new Error("Claude settings witnesses require explicit reviewed Claude configuration");
+  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 captureDiscoveryByteSources(paths) {
   if (!Array.isArray(paths) || paths.length > AGENT_POLICY_LIMITS.discoverySources || new Set(paths).size !== paths.length)
@@ -14658,10 +15277,10 @@ function captureDiscoveryPathSources(paths) {
   return paths.map((path) => ({ path, hashMode: "path-bytes", sha256: hashDiscoveryPathFile(path, budget) }));
 }
 function resolveAgentDiscovery(options) {
-  const canonical3 = options.canonical ?? resolve11, home = resolve11(options.home), agent = options.agent;
+  const canonical4 = 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 } : {} };
+    const source = { path: canonical4(path), sha256: null, ...format ? { format, fields } : {} };
     source.sha256 = projected(source);
     sources.push(source);
     return read(source.path);
@@ -14689,7 +15308,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("~/") ? join23(home, normalized.slice(2)) : resolve11(home, ".hermes", normalized);
+      const path = normalized === "~" ? home : normalized.startsWith("~/") ? join23(home, normalized.slice(2)) : resolve14(home, ".hermes", normalized);
       safe4(path);
       roots.add(path);
     }
@@ -14698,21 +15317,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 = dirname14(realpathSync4(executable)), depth = 0;depth < 8; directory = dirname14(directory), depth++) {
         const path = join23(directory, "package.json"), raw = read(path);
         if (raw !== null && parseConfig(raw, path).name === "@google/gemini-cli") {
           packageRoot = directory;
           witness(path);
           break;
         }
-        if (dirname12(directory) === directory)
+        if (dirname14(directory) === directory)
           break;
       }
       if (!packageRoot)
         unresolved("installed Gemini package layout is not recognized");
       const builtinRoot = join23(packageRoot, "bundle/builtin");
       safe4(builtinRoot);
-      if (!lstatSync15(builtinRoot, { throwIfNoEntry: false })?.isDirectory())
+      if (!lstatSync17(builtinRoot, { throwIfNoEntry: false })?.isDirectory())
         unresolved("installed Gemini builtin root is missing");
       for (const name of readdirSync9(builtinRoot).sort()) {
         const text2 = witness(join23(builtinRoot, name, "SKILL.md"));
@@ -14733,12 +15352,14 @@ function resolveAgentDiscovery(options) {
     if (review.sources.some((source) => source.format !== undefined || source.fields !== undefined))
       throw new Error("Explicit discovery reviews require full source-file hashes");
     verifyAgentDiscovery(supplied);
-    if (!review.sources.some((source) => source.path === canonical3(configPath)))
+    if (review.sources.some((source) => source.hashMode === "claude-settings-v1" && source.path !== canonical4(configPath)))
+      throw new Error("Semantic settings witnesses must name the configured Claude configuration source");
+    if (!review.sources.some((source) => source.path === canonical4(configPath)))
       throw new Error("Discovery review must include the agent configuration source");
     return { ...supplied, roots: [...new Set([...roots, ...supplied.roots])].sort(), sources: [...sources, ...review.sources], ...agent === "gemini" ? { builtinNames } : {} };
   }
   function plugin(root2) {
-    root2 = canonical3(root2);
+    root2 = canonical4(root2);
     safe4(root2);
     const manifestPath = join23(root2, agent === "claude" ? ".claude-plugin/plugin.json" : ".codex-plugin/plugin.json");
     const raw = witness(manifestPath);
@@ -14750,7 +15371,7 @@ function resolveAgentDiscovery(options) {
       unresolved("plugin hooks require a separate no-skill-injection review");
     const commands = join23(root2, "commands");
     safe4(commands);
-    if (agent === "claude" && (manifest.commands !== undefined || lstatSync15(commands, { throwIfNoEntry: false })?.isDirectory() && readdirSync9(commands).length))
+    if (agent === "claude" && (manifest.commands !== undefined || lstatSync17(commands, { throwIfNoEntry: false })?.isDirectory() && readdirSync9(commands).length))
       unresolved("legacy command discovery requires retirement or a dedicated format adapter");
     const rootSkill = witness(join23(root2, "SKILL.md"));
     if (rootSkill !== null)
@@ -14761,18 +15382,18 @@ function resolveAgentDiscovery(options) {
     if (agent === "claude")
       roots.add(join23(root2, "skills"));
     for (const value of declared) {
-      const path = resolve11(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`) ? dirname14(path) : path);
     }
   }
   if (agent === "claude") {
     const registrations = witness(join23(home, ".claude/plugins/installed_plugins.json"));
     const installed = registrations === null ? {} : parseConfig(registrations, join23(home, ".claude/plugins/installed_plugins.json")).plugins;
-    const commands = canonical3(join23(home, ".claude/commands"));
+    const commands = canonical4(join23(home, ".claude/commands"));
     safe4(commands);
-    if (lstatSync15(commands, { throwIfNoEntry: false })?.isDirectory() && readdirSync9(commands).length)
+    if (lstatSync17(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)
@@ -14792,7 +15413,7 @@ function resolveAgentDiscovery(options) {
         unresolved("unsupported plugin enablement");
       const split = id.lastIndexOf("@"), name = id.slice(0, split), marketplace = id.slice(split + 1);
       const market = config.marketplaces?.[marketplace] ?? (marketplace === "personal" ? { source_type: "local", source: home } : undefined);
-      if (split < 1 || market?.source_type !== "local" || typeof market.source !== "string" || !isAbsolute11(market.source))
+      if (split < 1 || market?.source_type !== "local" || typeof market.source !== "string" || !isAbsolute14(market.source))
         unresolved("enabled plugin marketplace is not an explicit local source");
       const catalogText = witness(join23(market.source, ".agents/plugins/marketplace.json"));
       if (catalogText === null)
@@ -14800,7 +15421,7 @@ function resolveAgentDiscovery(options) {
       const catalog = parseConfig(catalogText, join23(market.source, ".agents/plugins/marketplace.json")), matches = Array.isArray(catalog.plugins) ? catalog.plugins.filter((item) => item.name === name) : [];
       if (matches.length !== 1 || matches[0]?.source?.source !== "local" || typeof matches[0]?.source?.path !== "string")
         unresolved("plugin catalog source is missing or ambiguous");
-      plugin(resolve11(market.source, matches[0].source.path));
+      plugin(resolve14(market.source, matches[0].source.path));
     }
   } else if (agent === "opencode") {
     if (witness(join23(home, ".config/opencode/opencode.jsonc")) !== null || witness(join23(home, ".config/opencode/config.json")) !== null)
@@ -14808,18 +15429,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" || !isAbsolute14(path))
         unresolved("relative or malformed added skill root");
       roots.add(path);
     }
     const localPlugins = join23(home, ".config/opencode/plugins");
     safe4(localPlugins);
-    if (lstatSync15(localPlugins, { throwIfNoEntry: false }) && readdirSync9(localPlugins).some((name) => name !== "skills-cli.js"))
+    if (lstatSync17(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 [join23(home, ".hermes/plugins"), join23(home, ".hermes/hermes-agent")]) {
       safe4(directory);
-      if (lstatSync15(directory, { throwIfNoEntry: false }))
+      if (lstatSync17(directory, { throwIfNoEntry: false }))
         unresolved("installed runtime/plugin discovery requires reviewed source bindings");
     }
     if (Bun.which("hermes") || Object.keys(config.plugins ?? {}).length)
@@ -14829,11 +15450,11 @@ function resolveAgentDiscovery(options) {
       unresolved("custom extension or skill paths");
     const directory = join23(home, ".gemini/extensions");
     safe4(directory);
-    if (lstatSync15(directory, { throwIfNoEntry: false }))
+    if (lstatSync17(directory, { throwIfNoEntry: false }))
       for (const name of readdirSync9(directory)) {
         const root2 = join23(directory, name);
         safe4(root2);
-        if (!lstatSync15(root2)?.isDirectory())
+        if (!lstatSync17(root2)?.isDirectory())
           continue;
         const raw = witness(join23(root2, "gemini-extension.json"));
         if (raw === null)
@@ -14844,7 +15465,7 @@ function resolveAgentDiscovery(options) {
         roots.add(join23(root2, "skills"));
       }
   }
-  return { agent, roots: [...roots].sort(), sources, method: "automatic", ...agent === "gemini" ? { builtinNames } : {}, ...agent === "hermes" ? { directories: captureDiscoveryDirectories([join23(home, ".hermes/plugins"), join23(home, ".hermes/hermes-agent")].map((path) => canonical3(path))) } : {} };
+  return { agent, roots: [...roots].sort(), sources, method: "automatic", ...agent === "gemini" ? { builtinNames } : {}, ...agent === "hermes" ? { directories: captureDiscoveryDirectories([join23(home, ".hermes/plugins"), join23(home, ".hermes/hermes-agent")].map((path) => canonical4(path))) } : {} };
 }
 
 // src/lib/agent-adapters.ts
@@ -14914,7 +15535,7 @@ export default async ({ directory }) => {
 }
 
 // src/lib/agent-codex.ts
-import { isDeepStrictEqual } from "util";
+import { isDeepStrictEqual as isDeepStrictEqual2 } from "util";
 var CODEX_SKILL_CONFIG_SECTIONS = /^\[\[skills\.config\]\][^\n]*(?:\n(?!\s*\[)[^\n]*)*/gm;
 function assertCodexPathConfigEditable(text2) {
   const before = Bun.TOML.parse(text2);
@@ -14924,7 +15545,7 @@ function assertCodexPathConfigEditable(text2) {
   delete expected.skills.config;
   try {
     const withoutSections = Bun.TOML.parse(text2.replace(CODEX_SKILL_CONFIG_SECTIONS, ""));
-    if (isDeepStrictEqual(withoutSections, expected))
+    if (isDeepStrictEqual2(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");
@@ -14962,7 +15583,7 @@ function disableCodexBundledSkills(text2) {
   const candidates = new Set;
   const consider = (candidate2) => {
     try {
-      if (isDeepStrictEqual(Bun.TOML.parse(candidate2), expected))
+      if (isDeepStrictEqual2(Bun.TOML.parse(candidate2), expected))
         candidates.add(candidate2);
     } catch {}
   };
@@ -14988,7 +15609,7 @@ function disableCodexBundledSkills(text2) {
 }
 
 // src/lib/agent-integration.ts
-var sha = (data) => createHash12("sha256").update(data).digest("hex");
+var sha = (data) => createHash14("sha256").update(data).digest("hex");
 var ROOTS = [
   ["claude", ".claude/skills"],
   ["codex", ".codex/skills"],
@@ -15007,11 +15628,11 @@ var ROOTS = [
   ["copilot", ".github/skills"]
 ];
 function assertSafePath(path) {
-  let cursor = resolve12(path);
+  let cursor = resolve15(path);
   while (true) {
-    if (lstatSync16(cursor, { throwIfNoEntry: false })?.isSymbolicLink())
+    if (lstatSync18(cursor, { throwIfNoEntry: false })?.isSymbolicLink())
       throw new Error(`Refusing symlink path: ${cursor}`);
-    const parent = dirname13(cursor);
+    const parent = dirname15(cursor);
     if (parent === cursor)
       return;
     cursor = parent;
@@ -15020,16 +15641,16 @@ function assertSafePath(path) {
 function readRootAlias(home, agent) {
   assertSafePath(home);
   const realHome = realpathSync5(home), alias = join25(realHome, `.${agent}`);
-  const stat2 = lstatSync16(alias, { throwIfNoEntry: false, bigint: true });
+  const stat2 = lstatSync18(alias, { throwIfNoEntry: false, bigint: true });
   if (!stat2?.isSymbolicLink())
     throw new Error(`Agent root alias changed after planning: ${alias}`);
-  const link = readlinkSync2(alias), targetPath = resolve12(dirname13(alias), link);
+  const link = readlinkSync2(alias), targetPath = resolve15(dirname15(alias), link);
   assertSafePath(targetPath);
-  const targetStat = lstatSync16(targetPath, { throwIfNoEntry: false });
+  const targetStat = lstatSync18(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}`) || isAbsolute15(inside))
     throw new Error(`Agent root alias target must be inside the real home: ${alias}`);
   return { agent, home: realHome, alias, target, link, aliasIdentity: `${stat2.dev}:${stat2.ino}:${stat2.ctimeNs}`, targetIdentity: `${targetStat.dev}:${targetStat.ino}` };
 }
@@ -15038,14 +15659,14 @@ function rootAliases(home, allowed = false) {
     return [];
   const result = [];
   for (const agent of ["claude", "codex"])
-    if (lstatSync16(join25(home, `.${agent}`), { throwIfNoEntry: false })?.isSymbolicLink())
+    if (lstatSync18(join25(home, `.${agent}`), { throwIfNoEntry: false })?.isSymbolicLink())
       result.push(readRootAlias(home, agent));
   if (result.some((item, index) => result.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 result;
 }
 function canonicalAgentPath(path, aliases) {
-  const absolute = resolve12(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 ? join25(binding.target, relative5(binding.alias, absolute)) : absolute;
 }
 function recheckRootAliases(aliases) {
@@ -15059,35 +15680,35 @@ function recheckRootAliases(aliases) {
 }
 function readNativeBytes(path, maximum = 64 * 1024 * 1024) {
   assertSafePath(path);
-  const before = lstatSync16(path);
+  const before = lstatSync18(path);
   if (!before.isFile() || before.size > maximum)
     throw new Error("Unsupported or oversized native skill file");
-  const descriptor = openSync9(path, constants8.O_RDONLY | constants8.O_NOFOLLOW | constants8.O_NONBLOCK);
+  const descriptor = openSync11(path, constants10.O_RDONLY | constants10.O_NOFOLLOW | constants10.O_NONBLOCK);
   try {
-    const opened = fstatSync9(descriptor);
+    const opened = fstatSync11(descriptor);
     if (!opened.isFile() || opened.dev !== before.dev || opened.ino !== before.ino || opened.size !== before.size)
       throw new Error("Native skill file changed while reading");
     const bytes = Buffer.allocUnsafe(before.size + 1);
     let length = 0;
     while (length < bytes.length) {
-      const count = readSync7(descriptor, bytes, length, bytes.length - length, null);
+      const count = readSync9(descriptor, bytes, length, bytes.length - length, null);
       if (!count)
         break;
       length += count;
     }
-    const after = fstatSync9(descriptor);
+    const after = fstatSync11(descriptor);
     if (length !== before.size || after.size !== before.size || after.mtimeMs !== opened.mtimeMs || after.ctimeMs !== opened.ctimeMs)
       throw new Error("Native skill file changed while reading");
     return bytes.subarray(0, length);
   } finally {
-    closeSync9(descriptor);
+    closeSync11(descriptor);
   }
 }
 function treeHash(root2) {
-  const hash2 = createHash12("sha256");
+  const hash2 = createHash14("sha256");
   let bytes = 0, files = 0;
   function visit2(path) {
-    const stat2 = lstatSync16(path);
+    const stat2 = lstatSync18(path);
     if (stat2.isSymbolicLink())
       throw new Error(`Refusing symlink in skill: ${path}`);
     const rel = relative5(root2, path);
@@ -15113,11 +15734,11 @@ function treeHash(root2) {
 function projectAncestorDirectories(projects) {
   const directories = new Set;
   for (const project of projects) {
-    for (let path = resolve12(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 = dirname15(path);
       if (parent === path)
         break;
       path = parent;
@@ -15144,10 +15765,10 @@ function inventoryNativeSkills(home = homedir3(), options = {}) {
       throw new Error("Native skill discovery metadata limit exceeded");
   }
   function emptySiblingCacheAlias(path, parent) {
-    const link = readlinkSync2(path), target = resolve12(parent, link);
-    if (dirname13(target) !== parent || (isAbsolute12(link) ? link !== target : dirname13(link) !== "."))
+    const link = readlinkSync2(path), target = resolve15(parent, link);
+    if (dirname15(target) !== parent || (isAbsolute15(link) ? link !== target : dirname15(link) !== "."))
       return false;
-    if (!lstatSync16(target, { throwIfNoEntry: false })?.isDirectory())
+    if (!lstatSync18(target, { throwIfNoEntry: false })?.isDirectory())
       return false;
     const scan = cacheScans.get(target);
     return Boolean(scan?.complete && !scan.hasSkills && scan.entries <= maxAliasProofEntries);
@@ -15159,7 +15780,7 @@ function inventoryNativeSkills(home = homedir3(), options = {}) {
     assertSafePath(path);
     if (!existsSync11(path))
       return scan;
-    const stat2 = lstatSync16(path);
+    const stat2 = lstatSync18(path);
     if (stat2.isFile())
       return scan;
     if (!stat2.isDirectory())
@@ -15178,7 +15799,7 @@ function inventoryNativeSkills(home = homedir3(), 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(join25(home, ".codex", "skills", ".system"), aliases) + sep6) ? { system: true } : {}, ...bridge ? { bridge: true, bridgeHome: resolve12(home) } : {}, ...rootAlias ? { rootAlias } : {} });
+      entries.push({ agent, path, hash: treeHash(path), managed, vendor, ...agent === "codex" && path.startsWith(canonicalAgentPath(join25(home, ".codex", "skills", ".system"), aliases) + sep6) ? { system: true } : {}, ...bridge ? { bridge: true, bridgeHome: resolve15(home) } : {}, ...rootAlias ? { rootAlias } : {} });
       return scan;
     }
     if (depth > (vendor ? 32 : 3))
@@ -15205,7 +15826,7 @@ function inventoryNativeSkills(home = homedir3(), options = {}) {
       if (isVendor && !options.includeVendor)
         continue;
       const child = join25(path, name);
-      if (isVendor && lstatSync16(child, { throwIfNoEntry: false })?.isSymbolicLink()) {
+      if (isVendor && lstatSync18(child, { throwIfNoEntry: false })?.isSymbolicLink()) {
         const target = statSync8(child, { throwIfNoEntry: false });
         if (target?.isFile() || pluginCache && target?.isDirectory() && emptySiblingCacheAlias(child, path)) {
           scan.entries++;
@@ -15327,7 +15948,7 @@ function configureHooks(config, agent, command, profileId, nativeReady) {
 function disableCodexSkills(text2, skills, aliases, bridgePath) {
   const bundled = disableCodexBundledSkills(text2);
   let result = bundled;
-  const bridgeSelector = (entry) => typeof entry.name === "string" && entry.name.trim() === CLI_BRIDGE_NAME || typeof entry.path === "string" && [resolve12(bridgePath), resolve12(join25(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(join25(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");
@@ -15339,7 +15960,7 @@ function disableCodexSkills(text2, skills, aliases, bridgePath) {
     result = result.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" && [resolve12(path), resolve12(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()}
@@ -15369,9 +15990,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) => {
@@ -15457,7 +16078,7 @@ function planAgentIntegration(options) {
     version: CLI_BRIDGE_VERSION,
     digest: CLI_BRIDGE_DIGEST,
     agents: [...new Set([...priorAgents, ...options.agents])].sort(),
-    home: resolve12(home),
+    home: resolve15(home),
     includeVendor: true,
     ...options.agents.includes("hermes") ? { supervisors: { ...policy.bridge?.supervisors, hermes: { path: join25(dataDir2, "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])) },
@@ -15474,7 +16095,7 @@ function planAgentIntegration(options) {
 }
 function atomicWrite2(path, content) {
   assertSafePath(path);
-  mkdirSync7(dirname13(path), { recursive: true, mode: 448 });
+  mkdirSync7(dirname15(path), { recursive: true, mode: 448 });
   const temporary = `${path}.skills-${randomUUID3()}`;
   try {
     writeFileSync5(temporary, content, { mode: 384, flag: "wx" });
@@ -15487,10 +16108,10 @@ function atomicWrite2(path, content) {
 function applyAgentIntegration(plan) {
   const policyPath = join25(plan.dataDir, "agent-policy.json");
   assertSafePath(policyPath);
-  const currentText = (path) => resolve12(path) === resolve12(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 (resolve12(change.path) === resolve12(policyPath))
+    if (resolve15(change.path) === resolve15(policyPath))
       parseManagedSkillPolicy(change.after);
   const aliases = plan.rootAliases ?? [];
   recheckRootAliases(aliases);
@@ -15520,7 +16141,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);!existsSync11(directory); directory = dirname13(directory))
+      for (let directory = dirname15(change.path);!existsSync11(directory); directory = dirname15(directory))
         createdDirectories.add(directory);
       const after = change.after;
       atomicWrite2(change.path, after);
@@ -15560,11 +16181,11 @@ function applyAgentIntegration(plan) {
 }
 function syncArchiveDirectory(path) {
   assertSafePath(path);
-  const descriptor = openSync9(path, constants8.O_RDONLY | constants8.O_DIRECTORY | constants8.O_NOFOLLOW | constants8.O_NONBLOCK);
+  const descriptor = openSync11(path, constants10.O_RDONLY | constants10.O_DIRECTORY | constants10.O_NOFOLLOW | constants10.O_NONBLOCK);
   try {
-    fsyncSync2(descriptor);
+    fsyncSync3(descriptor);
   } finally {
-    closeSync9(descriptor);
+    closeSync11(descriptor);
   }
 }
 function writeArchiveJournal(path, value) {
@@ -15572,18 +16193,18 @@ function writeArchiveJournal(path, value) {
   const temporary = `${path}.skills-${randomUUID3()}`;
   let descriptor;
   try {
-    descriptor = openSync9(temporary, constants8.O_WRONLY | constants8.O_CREAT | constants8.O_EXCL | constants8.O_NOFOLLOW, 384);
+    descriptor = openSync11(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);
+    closeSync11(descriptor);
     descriptor = undefined;
     renameSync4(temporary, path);
-    syncArchiveDirectory(dirname13(path));
+    syncArchiveDirectory(dirname15(path));
   } finally {
     if (descriptor !== undefined)
-      closeSync9(descriptor);
-    if (lstatSync16(temporary, { throwIfNoEntry: false }))
+      closeSync11(descriptor);
+    if (lstatSync18(temporary, { throwIfNoEntry: false }))
       unlinkSync4(temporary);
   }
 }
@@ -15616,7 +16237,7 @@ function archiveNativeSkills(inventory, options) {
   const moved = [];
   const verifyArchive = (entry) => {
     assertSafePath(entry.archive);
-    const stat2 = lstatSync16(entry.archive);
+    const stat2 = lstatSync18(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)
@@ -15624,14 +16245,14 @@ function archiveNativeSkills(inventory, options) {
   };
   assertSafePath(archiveRoot);
   const created = [];
-  for (let path = archiveRoot;!existsSync11(path); path = dirname13(path))
+  for (let path = archiveRoot;!existsSync11(path); path = dirname15(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(dirname15(created.at(-1)));
     writeArchiveJournal(receiptPath, journal);
     for (const [index, entry] of selected.entries()) {
       recheckRootAliases(aliases);
@@ -15643,7 +16264,7 @@ function archiveNativeSkills(inventory, options) {
       writeArchiveJournal(receiptPath, journal);
       renameSync4(move.source, move.archive);
       moved.push(move);
-      syncArchiveDirectory(dirname13(move.source));
+      syncArchiveDirectory(dirname15(move.source));
       syncArchiveDirectory(archiveRoot);
       verifyArchive(move);
       move.status = "archived";
@@ -15664,7 +16285,7 @@ function archiveNativeSkills(inventory, options) {
         recheckRootAliases(aliases);
         assertSafePath(entry.source);
         assertSafePath(entry.archive);
-        if (lstatSync16(entry.source, { throwIfNoEntry: false })) {
+        if (lstatSync18(entry.source, { throwIfNoEntry: false })) {
           entry.status = "recovery-required";
           entry.conflict = "source-occupied";
           continue;
@@ -15678,10 +16299,10 @@ function archiveNativeSkills(inventory, options) {
         }
         if (entry.discoveryOnly) {
           linkSync2(entry.archive, entry.source);
-          syncArchiveDirectory(dirname13(entry.source));
+          syncArchiveDirectory(dirname15(entry.source));
           unlinkSync4(entry.archive);
         } else {
-          if (lstatSync16(entry.source, { throwIfNoEntry: false })) {
+          if (lstatSync18(entry.source, { throwIfNoEntry: false })) {
             entry.status = "recovery-required";
             entry.conflict = "source-occupied";
             continue;
@@ -15689,7 +16310,7 @@ function archiveNativeSkills(inventory, options) {
           renameSync4(entry.archive, entry.source);
         }
         entry.status = "restored";
-        syncArchiveDirectory(dirname13(entry.source));
+        syncArchiveDirectory(dirname15(entry.source));
         syncArchiveDirectory(archiveRoot);
       } catch {
         entry.status = "recovery-required";
@@ -15728,7 +16349,7 @@ function isSkillsOwnershipMarker(marker) {
 function hasSkillsOwnershipMarker(dir) {
   const path = join26(dir, SYNC_MARKER_FILE);
   try {
-    if (!lstatSync17(path).isFile())
+    if (!lstatSync19(path).isFile())
       return false;
     const marker = JSON.parse(readFileSync15(path, "utf8"));
     return isSkillsOwnershipMarker(marker);
@@ -15954,9 +16575,9 @@ function writeManagedSkillDir(dir, skillMd, options) {
   const action = dirExists ? "update" : "create";
   if (options.dryRun)
     return { action, path: skillMdPath };
-  const parentDir = dirname14(dir);
+  const parentDir = dirname16(dir);
   mkdirSync8(parentDir, { recursive: true });
-  const transactionDir = mkdtempSync2(join26(parentDir, `.hasna-skills-write-${basename5(dir)}-`));
+  const transactionDir = mkdtempSync2(join26(parentDir, `.hasna-skills-write-${basename9(dir)}-`));
   const candidateDir = join26(transactionDir, "candidate");
   const backupDir = join26(transactionDir, "backup");
   const candidateSkillMdPath = join26(candidateDir, "SKILL.md");
@@ -16445,7 +17066,7 @@ function loadProjectConfigCompat(targetDir) {
   return loadProjectConfig(targetDir);
 }
 // src/lib/run-state.ts
-import { createHash as createHash13, randomBytes } from "crypto";
+import { createHash as createHash15, randomBytes } from "crypto";
 import { existsSync as existsSync15, mkdirSync as mkdirSync10, readFileSync as readFileSync18, readdirSync as readdirSync12, statSync as statSync10, writeFileSync as writeFileSync8 } from "fs";
 import { extname, join as join29, relative as relative6 } from "path";
 function createSkillRun(params, targetDir = process.cwd()) {
@@ -16572,7 +17193,7 @@ function collectRunArtifacts(context) {
     artifacts.push({
       path: toProjectRelative(context.targetDir, path),
       mime: mimeForPath(path),
-      sha256: createHash13("sha256").update(bytes).digest("hex"),
+      sha256: createHash15("sha256").update(bytes).digest("hex"),
       sizeBytes: stat2.size
     });
   }
@@ -16700,7 +17321,7 @@ __export(exports_external, {
   pipe: () => pipe,
   partialRecord: () => partialRecord,
   parseAsync: () => parseAsync2,
-  parse: () => parse7,
+  parse: () => parse9,
   overwrite: () => _overwrite,
   output: () => output,
   optional: () => optional,
@@ -16920,7 +17541,7 @@ __export(exports_core2, {
   prettifyError: () => prettifyError,
   parseURLObject: () => parseURLObject,
   parseAsync: () => parseAsync,
-  parse: () => parse5,
+  parse: () => parse7,
   meta: () => meta,
   mergeValues: () => mergeValues,
   memoizer: () => memoizer,
@@ -18374,7 +18995,7 @@ var _parse = (_Err) => {
   };
   return fn;
 };
-var parse5 = /* @__PURE__ */ _parse($ZodRealError);
+var parse7 = /* @__PURE__ */ _parse($ZodRealError);
 var _parseAsync = (_Err) => {
   const fn = async (schema, value, _ctx, params) => {
     const ctx = _ctx ? { ..._ctx, async: true } : { async: true };
@@ -18445,18 +19066,18 @@ var validateAsync = async (schema, value, _ctx) => {
   return result.issues.length === 0;
 };
 var _encode = (_Err) => {
-  const parse6 = _parse(_Err);
+  const parse8 = _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 parse8(schema, value, ctx, finalizeParams(fn, _params));
   };
   return fn;
 };
 var encode = /* @__PURE__ */ _encode($ZodRealError);
 var _decode = (_Err) => {
-  const parse6 = _parse(_Err);
+  const parse8 = _parse(_Err);
   const fn = (schema, value, _ctx, _params) => {
-    return parse6(schema, value, _ctx, finalizeParams(fn, _params));
+    return parse8(schema, value, _ctx, finalizeParams(fn, _params));
   };
   return fn;
 };
@@ -20101,14 +20722,14 @@ var $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => {
     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);
       }
     }
@@ -21379,10 +22000,10 @@ var $ZodFunction = /* @__PURE__ */ $constructor("$ZodFunction", (inst, def) => {
       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 ? parse7(inst._def.input, args) : args;
       const result = Reflect.apply(func, this, parsedArgs);
       if (inst._def.output) {
-        return parse5(inst._def.output, result);
+        return parse7(inst._def.output, result);
       }
       return result;
     }, "_zod", { value: inst._zod, enumerable: false });
@@ -32301,11 +32922,11 @@ var objectProcessor = (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) {
@@ -33020,7 +33641,7 @@ var ZodRealError = /* @__PURE__ */ $constructor("ZodError", initializer2, undefi
 });
 
 // node_modules/zod/v4/classic/parse.js
-var parse7 = /* @__PURE__ */ _parse(ZodRealError);
+var parse9 = /* @__PURE__ */ _parse(ZodRealError);
 var parseAsync2 = /* @__PURE__ */ _parseAsync(ZodRealError);
 var safeParse2 = /* @__PURE__ */ _safeParse(ZodRealError);
 var safeParseAsync2 = /* @__PURE__ */ _safeParseAsync(ZodRealError);
@@ -33156,7 +33777,7 @@ var ZodType = /* @__PURE__ */ $constructor("ZodType", (inst, def) => {
     exports_util.own(this, "~standard", value);
   },
   parse: function _parse2(data, params) {
-    return parse7(this, data, params, { callee: _parse2 });
+    return parse9(this, data, params, { callee: _parse2 });
   },
   parseAsync: async function _parseAsync2(data, params) {
     return await parseAsync2(this, data, params, { callee: _parseAsync2 });
@@ -35987,7 +36608,7 @@ function clone2(value) {
   return value === undefined ? undefined : JSON.parse(JSON.stringify(value));
 }
 // src/lib/canonical-json.ts
-import { createHash as createHash14 } from "crypto";
+import { createHash as createHash16 } from "crypto";
 function canonicalJson2(value, maximumBytes = 2 * 1024 * 1024) {
   return canonicalJsonAtDepth(value, maximumBytes, 64);
 }
@@ -36031,7 +36652,7 @@ function canonicalJsonAtDepth(value, maximumBytes, maximumDepth) {
   return visit3(value, 0);
 }
 function canonicalJsonSha256(value, maximumBytes) {
-  return createHash14("sha256").update(canonicalJson2(value, maximumBytes)).digest("hex");
+  return createHash16("sha256").update(canonicalJson2(value, maximumBytes)).digest("hex");
 }
 
 // src/lib/remote-recurring-contract.ts
@@ -36913,15 +37534,41 @@ function object5(value) {
   return value;
 }
 
+// src/lib/remote-credit-checkout.ts
+var creditCheckoutKeyPattern = /^[A-Za-z0-9._:-]{8,255}$/;
+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;
+}
+var 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."
+};
+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 delay = row.retryAfterSeconds;
+  return { code, ...code === "CREDIT_CHECKOUT_IN_PROGRESS" || status === 503 && row.error === "credit checkout creation unresolved" ? typeof delay === "number" && Number.isSafeInteger(delay) && delay > 0 && delay <= 3600 ? { retryAfterSeconds: delay } : {} : {} };
+}
+
 // 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);
@@ -36966,10 +37613,10 @@ async function readQuoteUnavailableCode(response) {
   let timer;
   let deadlineExceeded = false;
   const expired = Symbol("quote body deadline");
-  const deadline = new Promise((resolve13) => {
+  const deadline = new Promise((resolve16) => {
     timer = setTimeout(() => {
       deadlineExceeded = true;
-      resolve13(expired);
+      resolve16(expired);
       reader.cancel().catch(() => {});
     }, 1500);
   });
@@ -37086,6 +37733,20 @@ class RemoteRequestError extends Error {
   }
 }
 
+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];
+  }
+}
+
 class RemoteQuoteUnavailableError extends RemoteRequestError {
   code;
   constructor(path, code) {
@@ -37574,14 +38235,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");
@@ -37814,13 +38504,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];
 }
 var INVALID_SKILL_VERSION_RESPONSE = "Remote skill version payload did not match the expected contract.";
 function isVersionRecord(value) {
@@ -38154,10 +38844,10 @@ function recordScheduleRun(id, status, targetDir) {
   saveSchedules(data, targetDir);
 }
 // src/lib/revision.ts
-import { createHash as createHash15 } from "crypto";
+import { createHash as createHash17 } from "crypto";
 var REVISION_ID_PATTERN = /^[0-9a-f]{64}$/;
 function revisionIdOf(content) {
-  const canonical3 = JSON.stringify({
+  const canonical4 = JSON.stringify({
     slug: content.slug,
     displayName: content.displayName,
     description: content.description,
@@ -38170,14 +38860,14 @@ function revisionIdOf(content) {
     bundleSha256: content.bundleSha256 ?? null,
     bundleByteSize: content.bundleByteSize ?? null
   });
-  return createHash15("sha256").update(canonical3).digest("hex");
+  return createHash17("sha256").update(canonical4).digest("hex");
 }
 function revisionIdOfRecord(record7) {
   return revisionIdOf(record7);
 }
 // src/lib/pull.ts
 import { existsSync as existsSync17, mkdirSync as mkdirSync12, mkdtempSync as mkdtempSync3, readFileSync as readFileSync20, renameSync as renameSync6, rmSync as rmSync5, writeFileSync as writeFileSync10 } from "fs";
-import { dirname as dirname15, join as join31 } from "path";
+import { dirname as dirname17, join as join31 } from "path";
 
 // src/lib/skill-bundles.ts
 import { createHmac, timingSafeEqual } from "crypto";
@@ -38519,7 +39209,7 @@ function installBundleAtomically(name, entries, options = {}, marker = {}) {
   try {
     for (const entry of entries) {
       const destination = join31(staging, entry.path);
-      mkdirSync12(dirname15(destination), { recursive: true });
+      mkdirSync12(dirname17(destination), { recursive: true });
       writeFileSync10(destination, entry.bytes, { mode: entry.mode });
     }
     writePullMarker(staging, {
@@ -38613,7 +39303,7 @@ function splitNameVersion(raw) {
   return version2 ? { name, version: version2 } : { name };
 }
 // src/lib/recurring-surface.ts
-import { isAbsolute as isAbsolute13 } from "path";
+import { isAbsolute as isAbsolute16 } from "path";
 
 // src/lib/remote-invitation-recovery.ts
 class InvitationEmailInputError extends Error {
@@ -38711,7 +39401,7 @@ async function requestInvitationEmail(origin, action, input2) {
 }
 
 // src/lib/remote-private-publications.ts
-import { createHash as createHash16 } from "crypto";
+import { createHash as createHash18 } from "crypto";
 var PRIVATE_PUBLICATION_MAX_BYTES = 16 * 1024 * 1024;
 var failures2 = {
   INVALID_REQUEST: [400, "The publication request is invalid."],
@@ -38758,7 +39448,7 @@ var hash3 = (v) => typeof v === "string" && /^[a-f0-9]{64}$/.test(v);
 var record8 = (v) => !!v && typeof v === "object" && !Array.isArray(v);
 var exact = (v, keys) => record8(v) && Object.keys(v).sort().join(",") === keys.sort().join(",");
 var date5 = (v) => typeof v === "string" && /^\d{4}-\d\d-\d\dT[0-9:.]+(?:Z|[+-](?:[01]\d|2[0-3]):[0-5]\d)$/.test(v) && Number.isFinite(Date.parse(v));
-var publicationSha256 = (bytes) => createHash16("sha256").update(bytes).digest("hex");
+var publicationSha256 = (bytes) => createHash18("sha256").update(bytes).digest("hex");
 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();
@@ -39003,12 +39693,12 @@ class RemotePrivatePublicationsClient {
       previous = view;
       if (!["queued", "verifying"].includes(view.state) || Date.now() >= until)
         return view;
-      await new Promise((resolve13) => {
+      await new Promise((resolve16) => {
         const timer = setTimeout(done, Math.min(1000, until - Date.now()));
         function done() {
           clearTimeout(timer);
           options.signal?.removeEventListener("abort", done);
-          resolve13();
+          resolve16();
         }
         options.signal?.addEventListener("abort", done, { once: true });
       });
@@ -39272,7 +39962,7 @@ var stateSchema = exports_external.object({
 var 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}$/);
 var context = { userId: uuid13.optional(), membershipId: uuid13.optional() };
 var page2 = { limit: exports_external.number().int().min(1).max(100).optional(), cursor: exports_external.string().min(1).max(2048).optional() };
-var directory = exports_external.string().max(4096).refine(isAbsolute13, "Use an absolute recovery directory");
+var directory = exports_external.string().max(4096).refine(isAbsolute16, "Use an absolute recovery directory");
 var email4 = exports_external.string().trim().toLowerCase().email().max(254);
 var code = exports_external.string().regex(/^\d{6}$/);
 var recurringSurfaceSchemas = {
@@ -39423,7 +40113,7 @@ function findSkillsParityForMcpTool(tool) {
 }
 // src/lib/registry-sync.ts
 import { mkdirSync as mkdirSync13, writeFileSync as writeFileSync11 } from "fs";
-import { dirname as dirname16, relative as relative7 } from "path";
+import { dirname as dirname18, relative as relative7 } from "path";
 function createRegistrySyncArtifact(options = {}) {
   const profile = options.profile ?? "all";
   const includeDocs = options.includeDocs ?? true;
@@ -39480,7 +40170,7 @@ function createRegistrySyncArtifact(options = {}) {
   };
 }
 function writeRegistrySyncArtifact(path, artifact) {
-  mkdirSync13(dirname16(path), { recursive: true });
+  mkdirSync13(dirname18(path), { recursive: true });
   writeFileSync11(path, `${JSON.stringify(artifact, null, 2)}
 `);
 }
@@ -39498,7 +40188,7 @@ var REMOTE_CUSTOMER_OPERATIONS = [
   { 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() },
@@ -40320,11 +41010,11 @@ var remoteCustomerContracts = REMOTE_CUSTOMER_OPERATIONS.map((operation) => ({
   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({
@@ -40565,14 +41255,14 @@ function clone3(value) {
 }
 // src/lib/feedback.ts
 import { appendFileSync, existsSync as existsSync18, mkdirSync as mkdirSync14 } from "fs";
-import { dirname as dirname17, join as join32 } from "path";
+import { dirname as dirname19, join as join32 } from "path";
 import { Database } from "bun:sqlite";
 function getFeedbackDbPath() {
   return join32(getDataDir(), "skills.db");
 }
 function getFeedbackDb() {
   const dbPath = getFeedbackDbPath();
-  const dir = dirname17(dbPath);
+  const dir = dirname19(dbPath);
   if (!existsSync18(dir))
     mkdirSync14(dir, { recursive: true });
   const db = new Database(dbPath);
@@ -40601,7 +41291,7 @@ function saveFeedback(input2) {
   const category = input2.category ?? "general";
   if (isApiMode()) {
     const path = join32(getDataDir(), "feedback.jsonl");
-    const dir = dirname17(path);
+    const dir = dirname19(path);
     if (!existsSync18(dir))
       mkdirSync14(dir, { recursive: true });
     appendFileSync(path, JSON.stringify({ message, category, email: input2.email ?? null, agent: input2.agent ?? null, version: input2.version ?? null, createdAt: new Date().toISOString() }) + `
@@ -40624,7 +41314,7 @@ function isApiMode(env = process.env) {
   }
 }
 // src/lib/native-storage.ts
-import { createHash as createHash17, createHmac as createHmac2 } from "crypto";
+import { createHash as createHash19, createHmac as createHmac2 } from "crypto";
 import {
   existsSync as existsSync19,
   mkdirSync as mkdirSync15,
@@ -40633,7 +41323,7 @@ import {
   statSync as statSync11,
   writeFileSync as writeFileSync12
 } from "fs";
-import { dirname as dirname18, join as join33, normalize as normalize3, relative as relative8, sep as sep7 } from "path";
+import { dirname as dirname20, join as join33, normalize as normalize3, relative as relative8, sep as sep7 } from "path";
 var SKILLS_STORAGE_TABLES = [
   "skills_sync_records",
   "skills_sync_cursors"
@@ -40800,7 +41490,7 @@ function exportSkillsLocalSnapshot(targetDir = process.cwd(), options = {}) {
       files.push({
         path: relativePath,
         sizeBytes: bytes.byteLength,
-        sha256: createHash17("sha256").update(bytes).digest("hex"),
+        sha256: createHash19("sha256").update(bytes).digest("hex"),
         ...options.includeFileContents ? { contentBase64: Buffer.from(bytes).toString("base64") } : {}
       });
     }
@@ -40819,18 +41509,18 @@ function importSkillsLocalSnapshot(snapshot, targetDir = process.cwd(), options
       skipped += 1;
       continue;
     }
-    const absolutePath = resolveSnapshotPath(targetDir, file2.path);
-    if (existsSync19(absolutePath) && !options.overwrite) {
+    const absolutePath3 = resolveSnapshotPath(targetDir, file2.path);
+    if (existsSync19(absolutePath3) && !options.overwrite) {
       skipped += 1;
       continue;
     }
     const bytes = Buffer.from(file2.contentBase64, "base64");
-    const hash4 = createHash17("sha256").update(bytes).digest("hex");
+    const hash4 = createHash19("sha256").update(bytes).digest("hex");
     if (hash4 !== file2.sha256) {
       throw new Error(`Snapshot file checksum mismatch: ${file2.path}`);
     }
-    mkdirSync15(dirname18(absolutePath), { recursive: true });
-    writeFileSync12(absolutePath, bytes);
+    mkdirSync15(dirname20(absolutePath3), { recursive: true });
+    writeFileSync12(absolutePath3, bytes);
     written += 1;
   }
   return { written, skipped };
@@ -41157,7 +41847,7 @@ function toIsoString(value) {
   return Number.isNaN(date6.getTime()) ? value : date6.toISOString();
 }
 function sha256Hex2(value) {
-  return createHash17("sha256").update(value).digest("hex");
+  return createHash19("sha256").update(value).digest("hex");
 }
 function normalizeHeaders(headers) {
   const result = {};
@@ -41209,7 +41899,7 @@ function toArrayBuffer(bytes) {
   return buffer;
 }
 // src/lib/station-snapshot.ts
-import { createHash as createHash18 } from "crypto";
+import { createHash as createHash20 } from "crypto";
 import {
   copyFileSync,
   mkdirSync as mkdirSync16,
@@ -41217,7 +41907,7 @@ import {
   statSync as statSync13,
   writeFileSync as writeFileSync13
 } from "fs";
-import { dirname as dirname19, isAbsolute as isAbsolute14, relative as relative9, resolve as resolve13, sep as sep9 } from "path";
+import { dirname as dirname21, isAbsolute as isAbsolute17, relative as relative9, resolve as resolve16, sep as sep9 } from "path";
 
 // src/lib/portable-snapshot-filter.ts
 import { readdirSync as readdirSync14, statSync as statSync12 } from "fs";
@@ -41384,7 +42074,7 @@ function validateStationId(stationId) {
   }
 }
 function sha256File(filePath) {
-  return createHash18("sha256").update(readFileSync23(filePath)).digest("hex");
+  return createHash20("sha256").update(readFileSync23(filePath)).digest("hex");
 }
 function scanHome(definition, homesRoot) {
   const homePath = homePathFor(definition, homesRoot);
@@ -41455,7 +42145,7 @@ function humanHomes(scanned) {
   }));
 }
 function writeStationSnapshot(options) {
-  const repoRoot = resolve13(options.repoRoot ?? process.cwd());
+  const repoRoot = resolve16(options.repoRoot ?? process.cwd());
   const { scanned, plans, totalBytes } = planStationSnapshot(options);
   const manifestFiles = plans.map((plan) => ({
     relativePath: plan.source.relativePath,
@@ -41481,9 +42171,9 @@ function writeStationSnapshot(options) {
   const conflicts = [];
   const untouched = [];
   for (const plan of plans) {
-    const destination = resolve13(repoRoot, plan.destination);
+    const destination = resolve16(repoRoot, plan.destination);
     const destinationRelative = relative9(repoRoot, destination);
-    if (destinationRelative.startsWith("..") || destinationRelative.startsWith(sep9) || isAbsolute14(destinationRelative)) {
+    if (destinationRelative.startsWith("..") || destinationRelative.startsWith(sep9) || isAbsolute17(destinationRelative)) {
       throw new StationSnapshotError("DESTINATION_ESCAPE", `destination escapes repo root: ${plan.destination}`);
     }
     let existingDigest = null;
@@ -41504,8 +42194,8 @@ function writeStationSnapshot(options) {
   }
   let written = 0;
   for (const plan of untouched) {
-    const destination = resolve13(repoRoot, plan.destination);
-    mkdirSync16(dirname19(destination), { recursive: true });
+    const destination = resolve16(repoRoot, plan.destination);
+    mkdirSync16(dirname21(destination), { recursive: true });
     copyFileSync(plan.source.fullPath, destination);
     written += 1;
   }
@@ -41523,8 +42213,8 @@ function writeStationSnapshot(options) {
     },
     files: manifestFiles
   };
-  const manifestPath = resolve13(repoRoot, "resources", options.stationId, "skills", "sync-manifest.json");
-  mkdirSync16(dirname19(manifestPath), { recursive: true });
+  const manifestPath = resolve16(repoRoot, "resources", options.stationId, "skills", "sync-manifest.json");
+  mkdirSync16(dirname21(manifestPath), { recursive: true });
   writeFileSync13(manifestPath, `${JSON.stringify(manifest, null, 2)}
 `);
   return {
@@ -41535,7 +42225,7 @@ function writeStationSnapshot(options) {
   };
 }
 // src/lib/station-hydrate.ts
-import { createHash as createHash19 } from "crypto";
+import { createHash as createHash21 } from "crypto";
 import {
   copyFileSync as copyFileSync2,
   mkdirSync as mkdirSync17,
@@ -41544,7 +42234,7 @@ import {
   statSync as statSync14,
   writeFileSync as writeFileSync14
 } from "fs";
-import { dirname as dirname20, join as join35, resolve as resolve14, sep as sep10 } from "path";
+import { dirname as dirname22, join as join35, resolve as resolve17, sep as sep10 } from "path";
 var STATION_HYDRATION_MANIFEST_SCHEMA = "hasna.fleet-resources.skills-hydration-manifest/v1";
 var STATION_HYDRATION_PRODUCER = { name: "@hasna/skills", version: package_default.version };
 var MANIFEST_HASH_KEY_SEP = String.fromCharCode(0);
@@ -41741,12 +42431,12 @@ function skillSha256(skill) {
     return sha256File(skill.files[0].winner.fullPath);
   }
   const joined = skill.files.map((file2) => sha256File(file2.winner.fullPath));
-  return createHash19("sha256").update(joined.sort().join(`
+  return createHash21("sha256").update(joined.sort().join(`
 `)).digest("hex");
 }
 function writeStationHydration(options) {
-  const repoRoot = resolve14(options.repoRoot ?? process.cwd());
-  const cacheRoot = resolve14(options.cacheRoot ?? resolveCorpusRoot());
+  const repoRoot = resolve17(options.repoRoot ?? process.cwd());
+  const cacheRoot = resolve17(options.cacheRoot ?? resolveCorpusRoot());
   const plan = planStationHydration(options.stationId, repoRoot);
   const resultSkills = plan.winners.map((skill) => ({
     ident: skill.ident,
@@ -41800,7 +42490,7 @@ function writeStationHydration(options) {
   }
   let written = 0;
   for (const entry of toWrite) {
-    mkdirSync17(dirname20(entry.destination), { recursive: true });
+    mkdirSync17(dirname22(entry.destination), { recursive: true });
     copyFileSync2(entry.fullPath, entry.destination);
     written += 1;
   }
@@ -41821,8 +42511,8 @@ function writeStationHydration(options) {
     },
     skills: resultSkills
   };
-  const hydrationManifestPath = join35(dirname20(cacheRoot), `hydration-${options.stationId}.json`);
-  mkdirSync17(dirname20(hydrationManifestPath), { recursive: true });
+  const hydrationManifestPath = join35(dirname22(cacheRoot), `hydration-${options.stationId}.json`);
+  mkdirSync17(dirname22(hydrationManifestPath), { recursive: true });
   writeFileSync14(hydrationManifestPath, `${JSON.stringify(hydration, null, 2)}
 `);
   return {
@@ -41833,23 +42523,23 @@ function writeStationHydration(options) {
   };
 }
 // src/lib/private-publication-recovery.ts
-import { constants as constants9, closeSync as closeSync10, fsyncSync as fsyncSync3, fstatSync as fstatSync10, lstatSync as lstatSync18, mkdirSync as mkdirSync18, openSync as openSync10, readSync as readSync8, realpathSync as realpathSync6, renameSync as renameSync7, unlinkSync as unlinkSync5, writeFileSync as writeFileSync15 } from "fs";
-import { dirname as dirname21, isAbsolute as isAbsolute15, join as join36, resolve as resolve15 } from "path";
+import { constants as constants11, closeSync as closeSync12, fsyncSync as fsyncSync4, fstatSync as fstatSync12, lstatSync as lstatSync20, mkdirSync as mkdirSync18, openSync as openSync12, readSync as readSync10, realpathSync as realpathSync6, renameSync as renameSync7, unlinkSync as unlinkSync5, writeFileSync as writeFileSync15 } from "fs";
+import { dirname as dirname23, isAbsolute as isAbsolute18, join as join36, resolve as resolve18 } from "path";
 import { randomUUID as randomUUID4 } from "crypto";
 var fail2 = () => {
   throw new PrivatePublicationError("PUBLICATION_RECOVERY_INVALID", "The recovery directory is invalid or changed. Preserve it and inspect the existing intent; do not start a replacement automatically.");
 };
 function safeDirectory(directory2) {
-  if (!isAbsolute15(directory2) || directory2 !== resolve15(directory2) || realpathSync6(directory2) !== directory2)
+  if (!isAbsolute18(directory2) || directory2 !== resolve18(directory2) || realpathSync6(directory2) !== directory2)
     return fail2();
-  for (let path = directory2;; path = dirname21(path)) {
-    const stat2 = lstatSync18(path);
+  for (let path = directory2;; path = dirname23(path)) {
+    const stat2 = lstatSync20(path);
     if (!stat2.isDirectory() || stat2.isSymbolicLink())
       return fail2();
-    if (path === dirname21(path))
+    if (path === dirname23(path))
       break;
   }
-  const own2 = lstatSync18(directory2);
+  const own2 = lstatSync20(directory2);
   if ((own2.mode & 63) !== 0 || process.getuid && own2.uid !== process.getuid())
     return fail2();
   return { dev: own2.dev, ino: own2.ino };
@@ -41861,35 +42551,35 @@ function unchangedDirectory(directory2, identity3) {
 }
 function readOwned(directory2, name, max) {
   const identity3 = safeDirectory(directory2), file2 = join36(directory2, name);
-  const fd = openSync10(file2, constants9.O_RDONLY | constants9.O_NOFOLLOW);
+  const fd = openSync12(file2, constants11.O_RDONLY | constants11.O_NOFOLLOW);
   try {
-    const stat2 = fstatSync10(fd);
+    const stat2 = fstatSync12(fd);
     if (!stat2.isFile() || stat2.nlink !== 1 || stat2.size > max || stat2.size < 1 || (stat2.mode & 63) !== 0 || process.getuid && stat2.uid !== process.getuid())
       return fail2();
     const buffer = Buffer.alloc(Math.min(max, stat2.size) + 1);
     let length = 0;
     while (length < buffer.length) {
-      const count = readSync8(fd, buffer, length, buffer.length - length, length);
+      const count = readSync10(fd, buffer, length, buffer.length - length, length);
       if (count === 0)
         break;
       length += count;
     }
-    const bytes = buffer.subarray(0, length), after = fstatSync10(fd);
+    const bytes = buffer.subarray(0, length), after = fstatSync12(fd);
     unchangedDirectory(directory2, identity3);
     if (bytes.length !== stat2.size || stat2.size !== after.size || stat2.mtimeMs !== after.mtimeMs || stat2.ctimeMs !== after.ctimeMs)
       return fail2();
     return bytes;
   } finally {
-    closeSync10(fd);
+    closeSync12(fd);
   }
 }
 function writeOwned(directory2, name, bytes) {
-  const fd = openSync10(join36(directory2, name), constants9.O_WRONLY | constants9.O_CREAT | constants9.O_EXCL | constants9.O_NOFOLLOW, 384);
+  const fd = openSync12(join36(directory2, name), constants11.O_WRONLY | constants11.O_CREAT | constants11.O_EXCL | constants11.O_NOFOLLOW, 384);
   try {
     writeFileSync15(fd, bytes);
-    fsyncSync3(fd);
+    fsyncSync4(fd);
   } finally {
-    closeSync10(fd);
+    closeSync12(fd);
   }
 }
 function save(directory2, value) {
@@ -41898,11 +42588,11 @@ function save(directory2, value) {
 `);
   unchangedDirectory(directory2, identity3);
   renameSync7(join36(directory2, temporary), join36(directory2, "receipt.json"));
-  const fd = openSync10(directory2, constants9.O_RDONLY | constants9.O_NOFOLLOW);
+  const fd = openSync12(directory2, constants11.O_RDONLY | constants11.O_NOFOLLOW);
   try {
-    fsyncSync3(fd);
+    fsyncSync4(fd);
   } finally {
-    closeSync10(fd);
+    closeSync12(fd);
   }
 }
 function bind(client2, receipt) {
@@ -41913,20 +42603,20 @@ async function locked(directory2, action) {
   const identity3 = safeDirectory(directory2), file2 = join36(directory2, "operation.lock");
   let fd;
   try {
-    fd = openSync10(file2, constants9.O_WRONLY | constants9.O_CREAT | constants9.O_EXCL | constants9.O_NOFOLLOW, 384);
+    fd = openSync12(file2, constants11.O_WRONLY | constants11.O_CREAT | constants11.O_EXCL | constants11.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 = fstatSync10(fd);
+  const lock = fstatSync12(fd);
   try {
     writeFileSync15(fd, JSON.stringify({ pid: process.pid }) + `
 `);
-    fsyncSync3(fd);
+    fsyncSync4(fd);
     return await action();
   } finally {
-    closeSync10(fd);
+    closeSync12(fd);
     unchangedDirectory(directory2, identity3);
-    const now = lstatSync18(file2);
+    const now = lstatSync20(file2);
     if (now.dev !== lock.dev || now.ino !== lock.ino || !now.isFile() || now.isSymbolicLink())
       fail2();
     unlinkSync5(file2);
@@ -41978,15 +42668,15 @@ async function preparePrivatePublication(client2, sourceDirectory, recoveryDirec
     phase: "prepared",
     intent: null
   };
-  if (!isAbsolute15(recoveryDirectory) || resolve15(recoveryDirectory) !== recoveryDirectory || realpathSync6(dirname21(recoveryDirectory)) !== dirname21(recoveryDirectory))
+  if (!isAbsolute18(recoveryDirectory) || resolve18(recoveryDirectory) !== recoveryDirectory || realpathSync6(dirname23(recoveryDirectory)) !== dirname23(recoveryDirectory))
     return fail2();
   mkdirSync18(recoveryDirectory, { mode: 448 });
   safeDirectory(recoveryDirectory);
-  const parent = openSync10(dirname21(recoveryDirectory), constants9.O_RDONLY | constants9.O_NOFOLLOW);
+  const parent = openSync12(dirname23(recoveryDirectory), constants11.O_RDONLY | constants11.O_NOFOLLOW);
   try {
-    fsyncSync3(parent);
+    fsyncSync4(parent);
   } finally {
-    closeSync10(parent);
+    closeSync12(parent);
   }
   writeOwned(recoveryDirectory, "bundle.tgz", packed.bytes);
   save(recoveryDirectory, receipt);
@@ -42069,8 +42759,8 @@ async function inspectLocked(client2, directory2, cancel) {
   return privatePublicationResult(directory2, receipt);
 }
 // src/lib/skill-context.ts
-import { createHash as createHash20 } from "crypto";
-import { resolve as resolve16 } from "path";
+import { createHash as createHash22 } from "crypto";
+import { resolve as resolve19 } from "path";
 function words(value) {
   return new Set(value.toLowerCase().match(/[a-z0-9]+/g) ?? []);
 }
@@ -42105,7 +42795,7 @@ async function buildSkillContext(input2, options = {}) {
   const promptWords = words(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, resolve16(input2.cwd)] : []];
+  const paths = [...input2.paths ?? [], ...input2.cwd ? [input2.cwd, resolve19(input2.cwd)] : []];
   const candidates = profile.selections.map((selection) => {
     const key = selectionKey(selection);
     if (input2.restore && loaded.has(key))
@@ -42158,7 +42848,7 @@ ${content}`;
 `);
   const receipt = {
     schemaVersion: 1,
-    id: createHash20("sha256").update(JSON.stringify({ profile: profile.profileRevision, sessionId, selections, omitted })).digest("hex"),
+    id: createHash22("sha256").update(JSON.stringify({ profile: profile.profileRevision, sessionId, selections, omitted })).digest("hex"),
     profileId: profile.profileId,
     profileRevision: profile.profileRevision,
     authority: profile.authority,
@@ -42170,9 +42860,105 @@ ${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: context2, selections, omitted, receipt };
 }
+// src/lib/session-reconciliation.ts
+import { createHash as createHash23 } from "crypto";
+var SESSION_RECONCILIATION_PLAN_TTL_MS = 5 * 60 * 1000;
+var digest3 = (value) => createHash23("sha256").update(JSON.stringify(value)).digest("hex");
+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, now) {
+  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 (now < issued || now >= 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 now = (options.now ?? Date.now)();
+  const issuedAt = input2.apply ? input2.planIssuedAt : new Date(now).toISOString();
+  const expiresAt = input2.apply ? input2.planExpiresAt : new Date(now + SESSION_RECONCILIATION_PLAN_TTL_MS).toISOString();
+  if (input2.apply)
+    assertPlanWindow(issuedAt, expiresAt, now);
+  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 result = replaceSkillSession(skillSessionSnapshotBinding(snapshot), replacement, { ...plan, planDigest }, options, () => assertPlanWindow(issuedAt, expiresAt, (options.now ?? Date.now)()));
+  return { applied: true, plan, planDigest, ...result };
+}
 export {
   writeStationSnapshot,
   writeStationHydration,
@@ -42237,6 +43023,7 @@ export {
   removeSchedule,
   removeManagedAgentSkill,
   recordScheduleRun,
+  reconcileSkillSession,
   readPrivatePublicationRecovery,
   readPortableSkillManifest,
   pullSkills,
@@ -42292,6 +43079,7 @@ export {
   installSkillManifest,
   installSkillForAgent,
   installSkill,
+  inspectSkillSession,
   inspectPrivatePublication,
   importSkillsLocalSnapshot,
   homePathFor,
@@ -42367,6 +43155,8 @@ export {
   captureDiscoveryPathSources,
   captureDiscoveryDirectories,
   captureDiscoveryByteSources,
+  captureClaudeSettings,
+  captureClaudeMarketplaceRegistry,
   canonicalizeManifest,
   buildSkillsS3ObjectUrl,
   buildSkillsApiUrl,
@@ -42430,6 +43220,7 @@ export {
   RemotePrivatePublicationsClient,
   RemoteInvitationEmailUnconfirmedError,
   RemoteInvitationEmailError,
+  RemoteCreditCheckoutError,
   RemoteCreditApprovalError,
   RemoteCapabilityUnavailableError,
   REMOTE_SKILL_RUN_CONTRACT_VERSION,