@hasna/skills 0.10.81 → 0.10.82

package/bin/index.js

@@ -36888,7 +36888,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@hasna/skills",
-    version: "0.10.81",
+    version: "0.10.82",
     description: "Skills library for AI coding agents",
     type: "module",
     bin: {
@@ -40624,7 +40624,7 @@ function hashClaudePluginCacheOrphanMarker(path, budget2, changes) {
   if (!before2)
     return null;
   const uid = process.getuid?.();
-  if (!before2.isFile() || uid === undefined || before2.uid !== uid || before2.size > 32)
+  if (!before2.isFile() || uid === undefined || before2.uid !== uid || before2.size > 32 || (before2.mode & 73) !== 0)
     throw new Error("Invalid Claude orphan marker file or owner");
   const fd = openSync3(path, constants4.O_RDONLY | constants4.O_NOFOLLOW | constants4.O_NONBLOCK);
   try {
@@ -48216,7 +48216,7 @@ function safe2(path) {
 function same2(before2, after2) {
   return Boolean(after2 && after2.isDirectory() && before2.dev === after2.dev && before2.ino === after2.ino && before2.mtimeMs === after2.mtimeMs && before2.ctimeMs === after2.ctimeMs);
 }
-function capture(path, budget2, excludedRoots, omittedRoots = [], rows) {
+function capture(path, budget2, excludedRoots, omittedRoots = [], rows, claudeMarkers) {
   safe2(path);
   if (omittedRoots.some((root2) => path === root2 || path.startsWith(root2 + "/")))
     return { path, sha256: null };
@@ -48244,6 +48244,11 @@ function capture(path, budget2, excludedRoots, omittedRoots = [], rows) {
       need3(child2.length <= AGENT_POLICY_LIMITS.pathCharacters, "Native discovery directory path limit exceeded");
       const stat = lstatSync7(child2);
       need3(stat.isFile() || stat.isDirectory(), "Refusing symlink or special native discovery directory member");
+      if (claudeMarkers && isClaudePluginCacheOrphanMarker(child2)) {
+        need3(hashClaudePluginCacheOrphanMarker(child2) !== null, "Claude orphan marker changed while reading directory");
+        if (claudeMarkers === "omit")
+          continue;
+      }
       const row = JSON.stringify([childRelative, stat.isDirectory() ? "directory" : "file"]) + `
 `;
       budget2.bytes += Buffer.byteLength(row);
@@ -48300,25 +48305,33 @@ function verifyDiscoveryDirectoryProjection(directories, omittedRoots, tolerance
       witnessChanged(new NativeDiscoveryWitnessChange("membership", directories[i].path, "Native discovery directory membership changed outside retired Codex roots"), tolerance, tolerance?.acceptsMembership(directories[i].path) === true);
     }
 }
-function captureDiscoveryDirectories(paths, excludedRoots = []) {
+function captureOrdinaryDirectories(paths, excludedRoots, claudeMarkers) {
   need3(Array.isArray(paths) && paths.length <= AGENT_POLICY_LIMITS.discoveryDirectories && new Set(paths).size === paths.length, "Invalid native discovery directory collection");
   const budget2 = { entries: 0, bytes: 0 };
   for (const root of excludedRoots)
     safe2(root);
-  return paths.map((path) => capture(path, budget2, excludedRoots));
+  return paths.map((path) => capture(path, budget2, excludedRoots, [], undefined, claudeMarkers));
+}
+function captureDiscoveryDirectories(paths, excludedRoots = []) {
+  return captureOrdinaryDirectories(paths, excludedRoots, "omit");
 }
 function verifyDiscoveryDirectories(directories, excludedRoots = [], tolerance) {
   need3(Array.isArray(directories) && directories.length <= AGENT_POLICY_LIMITS.discoveryDirectories, "Invalid native discovery directory collection");
   for (const directory of directories)
     need3(directory && typeof directory === "object" && (directory.sha256 === null || typeof directory.sha256 === "string" && /^[a-f0-9]{64}$/.test(directory.sha256)), "Invalid native discovery directory digest");
   const current = captureDiscoveryDirectories(directories.map((directory) => directory.path), excludedRoots);
+  let legacy;
   for (let i = 0;i < directories.length; i++)
     if (current[i].sha256 !== directories[i].sha256) {
+      legacy ??= captureOrdinaryDirectories(directories.map((directory) => directory.path), excludedRoots, "retain");
+      if (legacy[i].sha256 === directories[i].sha256)
+        continue;
       witnessChanged(new NativeDiscoveryWitnessChange("membership", directories[i].path, `Native discovery directory membership changed; run skills hook install with a fresh discovery review: ${directories[i].path}`), tolerance, tolerance?.acceptsMembership(directories[i].path) === true);
     }
 }
 var init_agent_discovery_directories = __esm(() => {
   init_agent_policy_limits();
+  init_claude_plugin_cache_marker();
   init_native_discovery_witness_change();
 });
 
@@ -67851,7 +67864,7 @@ function checkedPublicationView(value, skillId, intentId, declaration) {
     return invalid3();
   return Object.freeze({ ...value });
 }
-async function boundedJson(url, init, token, mutation, budget2 = 15000, signal, create3 = false) {
+async function boundedJson(url, init, token, mutation, budget2 = 15000, signal, create3 = false, readBinding) {
   const controller = new AbortController;
   let reader;
   let response;
@@ -67867,8 +67880,18 @@ async function boundedJson(url, init, token, mutation, budget2 = 15000, signal,
         redirect: "error",
         credentials: "omit",
         signal: controller.signal,
-        headers: { "Content-Type": "application/json", Authorization: `Bearer ${token}` }
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${token}`,
+          ...readBinding ? {
+            "x-skills-user-id": readBinding.userId,
+            "x-skills-workspace-id": readBinding.organizationId,
+            "x-skills-membership-id": readBinding.membershipId
+          } : {}
+        }
       });
+      if (readBinding && response.ok && response.status !== 200)
+        return invalid3();
       const length = response.headers.get("content-length");
       if (length !== null && (!/^\d+$/.test(length) || Number(length) > 65536))
         return invalid3();
@@ -67936,6 +67959,81 @@ async function boundedJson(url, init, token, mutation, budget2 = 15000, signal,
       response?.body?.cancel().catch(() => {});
   }
 }
+function historyDate(value) {
+  if (typeof value !== "string")
+    return false;
+  const parts = /^(\d{4})-(\d{2})-(\d{2})(T| )(\d{2}):(\d{2}):(\d{2})(?:\.(\d{1,9}))?(Z|[+-](\d{2})(?::(\d{2}))?)$/.exec(value);
+  if (!parts)
+    return false;
+  const [, y, m, d, separator, h, minute, second, fraction, zone, offsetHour, offsetMinute] = parts;
+  if (separator === " " ? zone === "Z" || (fraction?.length ?? 0) > 6 : zone !== "Z" && offsetMinute === undefined)
+    return false;
+  const year = Number(y), month = Number(m), day = Number(d);
+  const leap = year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+  const days = [31, leap ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+  return year > 0 && month >= 1 && month <= 12 && day >= 1 && day <= days[month - 1] && Number(h) <= 23 && Number(minute) <= 59 && Number(second) <= 59 && (zone === "Z" || Number(offsetHour) <= 23 && Number(offsetMinute ?? 0) <= 59);
+}
+function privateHistory(value, organizationId, skillId, limit, cursor) {
+  if (!record7(value) || value.organizationId !== organizationId || value.skillId !== skillId || typeof value.slug !== "string" || !/^[a-z0-9-]+$/.test(value.slug) || !(value.currentVersion === null || historyText(value.currentVersion)) || !(value.currentVersionId === null || publicationUuid(value.currentVersionId)) || value.currentVersion === null !== (value.currentVersionId === null) || !(value.nextCursor === null || publicationUuid(value.nextCursor)) || !Array.isArray(value.versions) || value.versions.length > limit)
+    return historyResponse();
+  const seen = new Set;
+  let previous = cursor;
+  const versions = value.versions.map((row) => {
+    if (!record7(row) || !publicationUuid(row.id) || seen.has(row.id) || previous !== undefined && row.id >= previous || !historyText(row.version) || !(row.releasedAt === null || historyDate(row.releasedAt)) || !historyDate(row.createdAt) || row.id === value.currentVersionId !== (row.version === value.currentVersion))
+      return historyResponse();
+    seen.add(row.id);
+    previous = row.id;
+    return Object.freeze({ id: row.id, version: row.version, releasedAt: row.releasedAt, createdAt: row.createdAt });
+  });
+  if (value.nextCursor !== null && (!versions.length || value.nextCursor !== versions.at(-1).id))
+    return historyResponse();
+  return Object.freeze({
+    organizationId,
+    skillId,
+    slug: value.slug,
+    currentVersion: value.currentVersion,
+    currentVersionId: value.currentVersionId,
+    versions: Object.freeze(versions),
+    nextCursor: value.nextCursor
+  });
+}
+
+class RemotePrivateSkillHistoryClient {
+  apiOrigin;
+  organizationId;
+  userId;
+  membershipId;
+  #token;
+  constructor(apiUrl, session) {
+    const checked = parseWorkspaceSession(session, { userId: session?.user?.id, membershipId: session?.user?.membershipId });
+    this.apiOrigin = normalizeSkillsApiOrigin(apiUrl);
+    this.#token = checked.token;
+    this.organizationId = checked.organization.id;
+    this.userId = checked.user.id;
+    this.membershipId = checked.user.membershipId;
+    Object.freeze(this);
+  }
+  async listVersions(skillId, options = {}) {
+    if (!publicationUuid(skillId) || options.limit !== undefined && (!Number.isSafeInteger(options.limit) || options.limit < 1 || options.limit > 50) || options.cursor !== undefined && !publicationUuid(options.cursor) || options.timeoutMs !== undefined && (!Number.isSafeInteger(options.timeoutMs) || options.timeoutMs < 1 || options.timeoutMs > 15000))
+      return historyInput();
+    const limit = options.limit ?? 20, cursor = options.cursor;
+    const query = new URLSearchParams;
+    if (options.limit !== undefined)
+      query.set("limit", String(limit));
+    if (cursor !== undefined)
+      query.set("cursor", cursor);
+    const path = `/api/v1/skills/${skillId}/versions${query.size ? `?${query}` : ""}`;
+    let value;
+    try {
+      value = await boundedJson(skillsApiRequestUrl(this.apiOrigin, path), { method: "GET" }, this.#token, false, options.timeoutMs, options.signal, false, this);
+    } catch (error) {
+      if (error instanceof PrivatePublicationError && error.code === "INVALID_PUBLICATION_RESPONSE")
+        return historyResponse();
+      throw new PrivatePublicationError("PRIVATE_HISTORY_UNAVAILABLE", "Unable to read private version history. Check the selected server, current membership and fresh sign-in; no skill or credential was changed.", false, error instanceof PrivatePublicationError ? error.status : undefined);
+    }
+    return privateHistory(value, this.organizationId, skillId, limit, cursor);
+  }
+}
 
 class RemotePrivatePublicationsClient {
   apiOrigin;
@@ -68109,7 +68207,11 @@ var PRIVATE_PUBLICATION_MAX_BYTES, skillCreateFailures, failures, PrivatePublica
   throw new PrivatePublicationError("INVALID_PUBLICATION_INPUT", "Invalid publication input or recovery data.");
 }, invalid3 = () => {
   throw new PrivatePublicationError("INVALID_PUBLICATION_RESPONSE", "The server returned an invalid publication result.");
-}, publicationUuid = (v) => typeof v === "string" && /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/.test(v), hash4 = (v) => typeof v === "string" && /^[a-f0-9]{64}$/.test(v), record7 = (v) => !!v && typeof v === "object" && !Array.isArray(v), exact = (v, keys3) => record7(v) && Object.keys(v).sort().join(",") === keys3.sort().join(","), date = (v) => typeof v === "string" && /^\d{4}-\d\d-\d\dT[0-9:.]+(?:Z|[+-](?:[01]\d|2[0-3]):[0-5]\d)$/.test(v) && Number.isFinite(Date.parse(v)), publicationSha256 = (bytes) => createHash31("sha256").update(bytes).digest("hex");
+}, publicationUuid = (v) => typeof v === "string" && /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/.test(v), hash4 = (v) => typeof v === "string" && /^[a-f0-9]{64}$/.test(v), record7 = (v) => !!v && typeof v === "object" && !Array.isArray(v), exact = (v, keys3) => record7(v) && Object.keys(v).sort().join(",") === keys3.sort().join(","), date = (v) => typeof v === "string" && /^\d{4}-\d\d-\d\dT[0-9:.]+(?:Z|[+-](?:[01]\d|2[0-3]):[0-5]\d)$/.test(v) && Number.isFinite(Date.parse(v)), publicationSha256 = (bytes) => createHash31("sha256").update(bytes).digest("hex"), historyInput = () => {
+  throw new PrivatePublicationError("INVALID_PRIVATE_HISTORY_INPUT", "Provide a private skill UUID, limit from 1 to 50, and an optional UUID cursor; timeoutMs must be from 1 to 15000.");
+}, historyResponse = () => {
+  throw new PrivatePublicationError("INVALID_PRIVATE_HISTORY_RESPONSE", "The server returned invalid private version history.");
+}, historyText = (value) => typeof value === "string" && value.length > 0 && value.length <= 128 && !/[\p{Cc}\p{Cs}\u2028\u2029]/u.test(value);
 var init_remote_private_publications = __esm(() => {
   init_fleet_credentials();
   init_remote_workspace_selection();
@@ -89514,6 +89616,10 @@ class RemoteSkillsAuthClient {
     const origin = this.apiOrigin, captured = workspaceContext(context);
     return new RemotePrivatePublicationsClient(origin, await this.switchWorkspace(email4, code, captured));
   }
+  async openPrivateSkillHistory(email4, code, context) {
+    const origin = this.apiOrigin, captured = workspaceContext(context);
+    return new RemotePrivateSkillHistoryClient(origin, await this.switchWorkspace(email4, code, captured));
+  }
   requestInvitationEmailChallenge(input2) {
     return requestInvitationEmail(this.apiOrigin, "challenge", input2);
   }
@@ -116446,7 +116552,7 @@ var init_remote_invitation_tools = __esm(() => {
 });
 
 // src/lib/private-publication-customer.ts
-function preparePrivatePublicationSession(requested) {
+function preparePrivateSession(requested, action, open2) {
   const selectors = [
     "HASNA_PROFILE",
     "HASNA_HOME",
@@ -116460,7 +116566,7 @@ function preparePrivatePublicationSession(requested) {
     "SKILLS_API_KEY"
   ];
   const before2 = new Map(selectors.map((key2) => [key2, process.env[key2]]));
-  const profile = selectedSkillsProfile(process.env), pending = prepareProfileWorkspace("Manage private publications");
+  const profile = selectedSkillsProfile(process.env), pending = prepareProfileWorkspace(action);
   const captured = requested ? { ...requested } : undefined;
   const unchanged3 = () => {
     if (selectors.some((key2) => process.env[key2] !== before2.get(key2)) || selectedSkillsProfile(process.env) !== profile)
@@ -116474,12 +116580,18 @@ function preparePrivatePublicationSession(requested) {
       throw new PrivatePublicationError("PUBLICATION_CONTEXT_REQUIRED", "Provide the observed user and membership IDs, or select an enrolled workspace profile.");
     unchanged3();
     target.unchanged();
-    const client2 = await new RemoteSkillsAuthClient(target.origin).openPrivatePublications(email5, code2, context2);
+    const client2 = await open2(new RemoteSkillsAuthClient(target.origin), email5, code2, context2);
     unchanged3();
     target.unchanged();
     return client2;
   } };
 }
+function preparePrivatePublicationSession(requested) {
+  return preparePrivateSession(requested, "Manage private publications", (auth, email5, code2, context2) => auth.openPrivatePublications(email5, code2, context2));
+}
+function preparePrivateSkillHistorySession(requested) {
+  return preparePrivateSession(requested, "Read private version history", (auth, email5, code2, context2) => auth.openPrivateSkillHistory(email5, code2, context2));
+}
 async function privatePublicationSession(email5, code2, requested) {
   return preparePrivatePublicationSession(requested).verify(email5, code2);
 }
@@ -117201,7 +117313,7 @@ var exports_runtime_mcp = {};
 __export(exports_runtime_mcp, {
   handleMcp: () => handleMcp
 });
-import { existsSync as existsSync33, lstatSync as lstatSync40, mkdirSync as mkdirSync26, readFileSync as readFileSync43, renameSync as renameSync14, rmdirSync as rmdirSync4, statSync as statSync22, writeFileSync as writeFileSync23 } from "fs";
+import { closeSync as closeSync29, constants as constants28, existsSync as existsSync33, fstatSync as fstatSync29, lstatSync as lstatSync40, mkdirSync as mkdirSync26, openSync as openSync29, readFileSync as readFileSync43, readSync as readSync21, renameSync as renameSync14, rmdirSync as rmdirSync4, statSync as statSync22, writeFileSync as writeFileSync23 } from "fs";
 import { randomUUID as randomUUID10 } from "crypto";
 import { homedir as homedir10 } from "os";
 import { dirname as dirname40, isAbsolute as isAbsolute38, join as join66 } from "path";
@@ -117270,10 +117382,14 @@ async function registerClaudeMcp(command, server2, environment) {
   const desired = { type: "stdio", ...server2, env: environment };
   try {
     const path = claudeUserConfigPath();
+    const firstRun = lstatSync40(path, { throwIfNoEntry: false }) === undefined ? claudeFirstRunPathWitness(path) : undefined;
     const before2 = withClaudeConfigLock(path, () => {
       if (claudeUserConfigPath() !== path)
         throw new Error;
+      firstRun?.();
       const bytes = readClaudeConfig(path);
+      if (firstRun && bytes !== null)
+        throw new Error;
       if (bytes !== null) {
         const backup = `${path}.skills-mcp-${randomUUID10()}.backup`;
         writeFileSync23(backup, bytes, { flag: "wx", mode: 384 });
@@ -117308,11 +117424,11 @@ async function registerClaudeMcp(command, server2, environment) {
     return withClaudeConfigLock(path, () => {
       if (claudeUserConfigPath() !== path)
         throw new Error;
-      const current = readClaudeConfig(path);
+      const current = firstRun ? readClaudeFirstRunConfig(path, firstRun) : readClaudeConfig(path);
       const previous = parseClaudeConfig(before2), data = parseClaudeConfig(current);
       if (exitCode === 0) {
         const actual = isPlainObject4(data.mcpServers) ? data.mcpServers[MCP_SERVER_NAME] : undefined;
-        if (!claudeNativeConfigPreserved(previous, data) || !isPlainObject4(actual) || !isDeepStrictEqual17({ ...actual, env: actual.env ?? {} }, desired))
+        if (!claudeNativeConfigPreserved(previous, data, firstRun !== undefined && before2 === null) || !isPlainObject4(actual) || !isDeepStrictEqual17({ ...actual, env: actual.env ?? {} }, desired))
           throw new Error;
       } else {
         if (!cliUnavailable && (!duplicateAccepted || !isPlainObject4(previous.mcpServers) || !previous.mcpServers[MCP_SERVER_NAME]))
@@ -117326,7 +117442,7 @@ async function registerClaudeMcp(command, server2, environment) {
         writeFileSync23(temporary, next, { flag: "wx", mode: 384 });
         if (!readFileSync43(temporary).equals(next))
           throw new Error;
-        const latest = readClaudeConfig(path);
+        const latest = firstRun ? readClaudeFirstRunConfig(path, firstRun) : readClaudeConfig(path);
         if (claudeUserConfigPath() !== path || (before2 === null ? latest !== null : latest === null || !latest.equals(before2)))
           throw new Error;
         renameSync14(temporary, path);
@@ -117360,27 +117476,92 @@ function claudeUserConfigPath() {
   return modern;
 }
 function readClaudeConfig(path) {
-  if (!existsSync33(path))
+  const info = lstatSync40(path, { throwIfNoEntry: false });
+  if (info === undefined)
     return null;
-  const info = lstatSync40(path);
   if (!info.isFile() || info.size > 16777216)
     throw new Error;
   const bytes = readFileSync43(path);
   parseClaudeConfig(bytes);
   return bytes;
 }
+function claudeFirstRunPathWitness(path) {
+  if (!process.getuid || constants28.O_NOFOLLOW === undefined)
+    throw new Error;
+  const uid2 = BigInt(process.getuid()), canonical9 = canonicalSystemPath(path);
+  const identity6 = (info) => `${info.dev}:${info.ino}:${info.uid}:${info.gid}:${info.mode}`;
+  const directories = [];
+  for (let cursor2 = dirname40(canonical9);; cursor2 = dirname40(cursor2)) {
+    directories.unshift({ path: cursor2, identity: "" });
+    if (dirname40(cursor2) === cursor2)
+      break;
+  }
+  const verify = () => {
+    if (canonicalSystemPath(path) !== canonical9)
+      throw new Error;
+    for (const directory3 of directories) {
+      const info = lstatSync40(directory3.path, { bigint: true });
+      if (!info.isDirectory() || identity6(info) !== directory3.identity)
+        throw new Error;
+    }
+  };
+  for (const directory3 of directories) {
+    let info = lstatSync40(directory3.path, { bigint: true, throwIfNoEntry: false });
+    if (!info) {
+      mkdirSync26(directory3.path, { mode: 448 });
+      info = lstatSync40(directory3.path, { bigint: true });
+    }
+    if (!info.isDirectory() || info.uid !== 0n && info.uid !== uid2 || (info.mode & 0o022n) !== 0n && !(info.uid === 0n && (info.mode & 0o1000n) !== 0n))
+      throw new Error;
+    directory3.identity = identity6(info);
+  }
+  verify();
+  if (lstatSync40(path, { throwIfNoEntry: false }) !== undefined)
+    throw new Error;
+  return verify;
+}
+function readClaudeFirstRunConfig(path, verifyPath) {
+  verifyPath();
+  const before2 = lstatSync40(path, { bigint: true, throwIfNoEntry: false });
+  if (!before2)
+    return null;
+  const identity6 = (info) => `${info.dev}:${info.ino}:${info.uid}:${info.gid}:${info.mode}:${info.nlink}:${info.size}:${info.mtimeNs}:${info.ctimeNs}`;
+  if (!before2.isFile() || before2.nlink !== 1n || before2.uid !== BigInt(process.getuid()) || (before2.mode & 0o022n) !== 0n || before2.size > 16n * 1024n * 1024n)
+    throw new Error;
+  const fd = openSync29(path, constants28.O_RDONLY | constants28.O_NOFOLLOW | constants28.O_NONBLOCK);
+  try {
+    if (identity6(fstatSync29(fd, { bigint: true })) !== identity6(before2))
+      throw new Error;
+    const bytes = Buffer.alloc(Number(before2.size) + 1);
+    let length = 0;
+    while (length < bytes.length) {
+      const count = readSync21(fd, bytes, length, bytes.length - length, null);
+      if (!count)
+        break;
+      length += count;
+    }
+    if (BigInt(length) !== before2.size || identity6(fstatSync29(fd, { bigint: true })) !== identity6(before2) || identity6(lstatSync40(path, { bigint: true })) !== identity6(before2))
+      throw new Error;
+    const content = bytes.subarray(0, length);
+    verifyPath();
+    parseClaudeConfig(content);
+    return content;
+  } finally {
+    closeSync29(fd);
+  }
+}
 function parseClaudeConfig(bytes) {
   const data = bytes === null ? {} : JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
   if (!isPlainObject4(data) || data.mcpServers !== undefined && !isPlainObject4(data.mcpServers))
     throw new Error;
   return data;
 }
-function claudeNativeConfigPreserved(before2, after2) {
+function claudeNativeConfigPreserved(before2, after2, firstRun = false) {
   const previous = withoutClaudeSkills(before2), current = withoutClaudeSkills(after2);
   for (const key2 of Object.keys(current)) {
     if (Object.hasOwn(previous, key2))
       continue;
-    if (!isClaudeBootstrapAddition(key2, current[key2]))
+    if (!(firstRun && key2 === "userID" && typeof current[key2] === "string" && /^[0-9a-f]{64}$/i.test(current[key2])) && !isClaudeBootstrapAddition(key2, current[key2]))
       return false;
     delete current[key2];
   }
@@ -117562,6 +117743,7 @@ var MCP_SERVER_NAME = "skills", MCP_COMMAND_NAME = "skills-mcp";
 var init_runtime_mcp = __esm(() => {
   init_source();
   init_installer();
+  init_agent_integration();
   init_credential_profile_command();
   init_mcp_registration_environment();
 });
@@ -120456,30 +120638,30 @@ var exports_recurring = {};
 __export(exports_recurring, {
   registerRecurringCommands: () => registerRecurringCommands
 });
-import { constants as constants28, closeSync as closeSync29, fstatSync as fstatSync29, lstatSync as lstatSync43, openSync as openSync29, readSync as readSync21 } from "fs";
+import { constants as constants29, closeSync as closeSync30, fstatSync as fstatSync30, lstatSync as lstatSync43, openSync as openSync30, readSync as readSync22 } from "fs";
 import { createInterface as createInterface2 } from "readline";
 function readRequest(path) {
-  const fd = openSync29(path, constants28.O_RDONLY | constants28.O_NOFOLLOW | constants28.O_NONBLOCK);
+  const fd = openSync30(path, constants29.O_RDONLY | constants29.O_NOFOLLOW | constants29.O_NONBLOCK);
   try {
-    const before2 = fstatSync29(fd);
+    const before2 = fstatSync30(fd);
     if (!before2.isFile() || before2.size > 1048576 || before2.size < 1)
       throw new RecurringInputError;
     const bytes = Buffer.alloc(before2.size + 1);
     let length = 0;
     while (length < bytes.length) {
-      const n2 = readSync21(fd, bytes, length, bytes.length - length, length);
+      const n2 = readSync22(fd, bytes, length, bytes.length - length, length);
       if (!n2)
         break;
       length += n2;
     }
-    const after2 = fstatSync29(fd), current = lstatSync43(path);
+    const after2 = fstatSync30(fd), current = lstatSync43(path);
     if (length !== before2.size || after2.size !== before2.size || before2.mtimeMs !== after2.mtimeMs || before2.ctimeMs !== after2.ctimeMs || current.dev !== before2.dev || current.ino !== before2.ino || !current.isFile() || current.isSymbolicLink())
       throw new RecurringInputError;
     return JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes.subarray(0, length)));
   } catch {
     throw new RecurringInputError;
   } finally {
-    closeSync29(fd);
+    closeSync30(fd);
   }
 }
 async function acceptAtTerminal(draft) {
@@ -123119,7 +123301,7 @@ var init_claude_installer_binding = __esm(() => {
 });
 
 // src/cli/commands/claude-installer-capture.ts
-import { closeSync as closeSync30, constants as constants29, fstatSync as fstatSync30, lstatSync as lstatSync48, openSync as openSync30, readSync as readSync22 } from "fs";
+import { closeSync as closeSync31, constants as constants30, fstatSync as fstatSync31, lstatSync as lstatSync48, openSync as openSync31, readSync as readSync23 } from "fs";
 import { isAbsolute as isAbsolute46, resolve as resolve44 } from "path";
 function need11(condition, code2) {
   if (!condition)
@@ -123141,19 +123323,19 @@ function readRequest2(path) {
   const before2 = lstatSync48(path, { throwIfNoEntry: false });
   if (!before2?.isFile() || before2.isSymbolicLink() || before2.size > MAX_REQUEST_BYTES)
     throw new CaptureRefusal("INVALID_REQUEST_FILE: --request must name a regular non-symlink JSON file no larger than 64 KiB");
-  const fd = openSync30(path, constants29.O_RDONLY | (constants29.O_NOFOLLOW ?? 0) | constants29.O_NONBLOCK);
+  const fd = openSync31(path, constants30.O_RDONLY | (constants30.O_NOFOLLOW ?? 0) | constants30.O_NONBLOCK);
   try {
-    const opened = fstatSync30(fd);
+    const opened = fstatSync31(fd);
     need11(opened.isFile() && opened.dev === before2.dev && opened.ino === before2.ino && opened.size === before2.size, "INVALID_REQUEST_FILE: --request must remain the same regular file while read");
     const bytes = Buffer.alloc(MAX_REQUEST_BYTES + 1);
     let length = 0;
     while (length < bytes.length) {
-      const count = readSync22(fd, bytes, length, bytes.length - length, null);
+      const count = readSync23(fd, bytes, length, bytes.length - length, null);
       if (!count)
         break;
       length += count;
     }
-    const after2 = fstatSync30(fd), current = lstatSync48(path);
+    const after2 = fstatSync31(fd), current = lstatSync48(path);
     need11(length <= MAX_REQUEST_BYTES && length === opened.size && after2.size === opened.size && after2.mtimeMs === opened.mtimeMs && after2.ctimeMs === opened.ctimeMs && current.dev === opened.dev && current.ino === opened.ino && current.mtimeMs === opened.mtimeMs && current.ctimeMs === opened.ctimeMs, "INVALID_REQUEST_FILE: --request must remain unchanged while read");
     try {
       return JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes.subarray(0, length)));
@@ -123161,7 +123343,7 @@ function readRequest2(path) {
       throw new CaptureRefusal("INVALID_REQUEST_JSON: --request must contain one valid UTF-8 JSON object");
     }
   } finally {
-    closeSync30(fd);
+    closeSync31(fd);
   }
 }
 function paths(value) {
@@ -123305,7 +123487,7 @@ var exports_agent_integration = {};
 __export(exports_agent_integration, {
   registerAgentIntegration: () => registerAgentIntegration
 });
-import { existsSync as existsSync36, lstatSync as lstatSync49, readFileSync as readFileSync50, readSync as readSync23, writeFileSync as writeFileSync27 } from "fs";
+import { existsSync as existsSync36, lstatSync as lstatSync49, readFileSync as readFileSync50, readSync as readSync24, writeFileSync as writeFileSync27 } from "fs";
 import { createHash as createHash48 } from "crypto";
 import { homedir as homedir14 } from "os";
 import { basename as basename25, isAbsolute as isAbsolute47, resolve as resolve45 } from "path";
@@ -123420,7 +123602,7 @@ function registerAgentIntegration(parent) {
       const bytes = Buffer.alloc(1024 * 1024 + 1);
       let length = 0;
       while (length < bytes.length) {
-        const count = readSync23(0, bytes, length, bytes.length - length, null);
+        const count = readSync24(0, bytes, length, bytes.length - length, null);
         if (!count)
           break;
         length += count;
@@ -123976,17 +124158,17 @@ var exports_profiles = {};
 __export(exports_profiles, {
   registerProfiles: () => registerProfiles
 });
-import { closeSync as closeSync31, constants as constants30, fstatSync as fstatSync31, openSync as openSync31, readSync as readSync24, writeFileSync as writeFileSync28 } from "fs";
+import { closeSync as closeSync32, constants as constants31, fstatSync as fstatSync32, openSync as openSync32, readSync as readSync25, writeFileSync as writeFileSync28 } from "fs";
 function readProfileInput(path) {
-  const fd = openSync31(path, constants30.O_RDONLY | constants30.O_NONBLOCK);
+  const fd = openSync32(path, constants31.O_RDONLY | constants31.O_NONBLOCK);
   try {
-    const stat3 = fstatSync31(fd);
+    const stat3 = fstatSync32(fd);
     if (!stat3.isFile() || stat3.size > MAX_PROFILE_DOCUMENT_BYTES)
       throw new Error("Profile input exceeds the size limit or is not a regular file");
     const bytes = Buffer.alloc(MAX_PROFILE_DOCUMENT_BYTES + 1);
     let size2 = 0;
     while (size2 < bytes.length) {
-      const read3 = readSync24(fd, bytes, size2, bytes.length - size2, null);
+      const read3 = readSync25(fd, bytes, size2, bytes.length - size2, null);
       if (!read3)
         break;
       size2 += read3;
@@ -123995,7 +124177,7 @@ function readProfileInput(path) {
       throw new Error("Profile input exceeds the size limit");
     return new TextDecoder("utf-8", { fatal: true }).decode(bytes.subarray(0, size2));
   } finally {
-    closeSync31(fd);
+    closeSync32(fd);
   }
 }
 function registerProfiles(parent) {
@@ -124409,23 +124591,23 @@ __export(exports_grants, {
   registerGrants: () => registerGrants
 });
 import {
-  constants as constants31,
-  closeSync as closeSync32,
-  fstatSync as fstatSync32,
-  openSync as openSync32,
-  readSync as readSync25,
+  constants as constants32,
+  closeSync as closeSync33,
+  fstatSync as fstatSync33,
+  openSync as openSync33,
+  readSync as readSync26,
   writeFileSync as writeFileSync29
 } from "fs";
 function readInput(path) {
-  const fd = openSync32(path, constants31.O_RDONLY | constants31.O_NONBLOCK);
+  const fd = openSync33(path, constants32.O_RDONLY | constants32.O_NONBLOCK);
   try {
-    const stat3 = fstatSync32(fd);
+    const stat3 = fstatSync33(fd);
     if (!stat3.isFile() || stat3.size > MAX_EXECUTION_GRANT_BYTES)
       throw new Error("Grant input must be a regular file within the policy size limit.");
     const bytes = Buffer.alloc(MAX_EXECUTION_GRANT_BYTES + 1);
     let size2 = 0;
     while (size2 < bytes.length) {
-      const count = readSync25(fd, bytes, size2, bytes.length - size2, null);
+      const count = readSync26(fd, bytes, size2, bytes.length - size2, null);
       if (!count)
         break;
       size2 += count;
@@ -124438,7 +124620,7 @@ function readInput(path) {
       throw new Error("Grant input must be a JSON document containing a grants array.");
     }
   } finally {
-    closeSync32(fd);
+    closeSync33(fd);
   }
 }
 function registerGrants(parent) {
@@ -125221,17 +125403,17 @@ var exports_metadata = {};
 __export(exports_metadata, {
   registerMetadata: () => registerMetadata
 });
-import { closeSync as closeSync33, constants as constants32, fstatSync as fstatSync33, openSync as openSync33, readFileSync as readFileSync53, readSync as readSync26, writeFileSync as writeFileSync32 } from "fs";
+import { closeSync as closeSync34, constants as constants33, fstatSync as fstatSync34, openSync as openSync34, readFileSync as readFileSync53, readSync as readSync27, writeFileSync as writeFileSync32 } from "fs";
 function readPlan(path) {
-  const fd = openSync33(path, constants32.O_RDONLY | constants32.O_NONBLOCK | constants32.O_NOFOLLOW);
+  const fd = openSync34(path, constants33.O_RDONLY | constants33.O_NONBLOCK | constants33.O_NOFOLLOW);
   try {
-    const stat3 = fstatSync33(fd);
+    const stat3 = fstatSync34(fd);
     if (!stat3.isFile() || stat3.size > 8 * 1024 * 1024)
       throw new SkillMetadataUpdateError("INVALID_METADATA_PLAN");
     const bytes = Buffer.alloc(stat3.size + 1);
     let size2 = 0;
     while (size2 < bytes.length) {
-      const count = readSync26(fd, bytes, size2, bytes.length - size2, null);
+      const count = readSync27(fd, bytes, size2, bytes.length - size2, null);
       if (!count)
         break;
       size2 += count;
@@ -125240,7 +125422,7 @@ function readPlan(path) {
       throw new SkillMetadataUpdateError("INVALID_METADATA_PLAN");
     return metadataPlan(JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes.subarray(0, size2))));
   } finally {
-    closeSync33(fd);
+    closeSync34(fd);
   }
 }
 function failure(error61) {
@@ -125606,7 +125788,7 @@ var init_registry_sync = __esm(() => {
 });
 
 // src/lib/review-export.ts
-import { constants as constants33, closeSync as closeSync34, existsSync as existsSync38, fstatSync as fstatSync34, fsyncSync as fsyncSync10, lstatSync as lstatSync51, openSync as openSync34, realpathSync as realpathSync25, statSync as statSync27, writeFileSync as writeFileSync34 } from "fs";
+import { constants as constants34, closeSync as closeSync35, existsSync as existsSync38, fstatSync as fstatSync35, fsyncSync as fsyncSync10, lstatSync as lstatSync51, openSync as openSync35, realpathSync as realpathSync25, statSync as statSync27, writeFileSync as writeFileSync34 } from "fs";
 import { basename as basename26, dirname as dirname52, isAbsolute as isAbsolute49, join as join80, parse as parse13, resolve as resolve48, sep as sep25 } from "path";
 function exactVersion(spec) {
   const at2 = spec.indexOf("@");
@@ -125670,16 +125852,16 @@ async function exportSkillVersionForReview(spec, output2, client2) {
   if (bytes.byteLength !== metadata2.bundleByteSize || sha256Hex(bytes) !== metadata2.bundleSha256.toLowerCase()) {
     throw new Error("Published bundle bytes do not match the exact version metadata.");
   }
-  const fd = openSync34(target, constants33.O_WRONLY | constants33.O_CREAT | constants33.O_EXCL | constants33.O_NOFOLLOW, 384);
+  const fd = openSync35(target, constants34.O_WRONLY | constants34.O_CREAT | constants34.O_EXCL | constants34.O_NOFOLLOW, 384);
   try {
     writeFileSync34(fd, bytes);
     fsyncSync10(fd);
-    if (fstatSync34(fd).size !== bytes.byteLength)
+    if (fstatSync35(fd).size !== bytes.byteLength)
       throw new Error("Incomplete review output write.");
   } catch (error61) {
     throw new Error(`Review output write failed. A private partial file may remain at ${target}; use Trash to remove it before reusing this path.`, { cause: error61 });
   } finally {
-    closeSync34(fd);
+    closeSync35(fd);
   }
   return { slug: slug2, version: version2, bundleSha256: metadata2.bundleSha256.toLowerCase(), bundleByteSize: bytes.byteLength, output: target };
 }
@@ -126217,7 +126399,7 @@ function verifySessionOptions(options) {
   if (options.userId === undefined !== (options.membershipId === undefined) || options.userId !== undefined && (!publicationUuid(options.userId) || !publicationUuid(options.membershipId)))
     throw new PrivatePublicationError("PUBLICATION_CONTEXT_REQUIRED", "Provide both observed --user-id and --membership-id UUIDs.");
   if (!options.codeStdin && (options.json || !process.stdin.isTTY || !process.stderr.isTTY))
-    throw new PrivatePublicationError("PUBLICATION_CODE_REQUIRED", "Use --code-stdin with a fresh code for noninteractive publishing.");
+    throw new PrivatePublicationError("PUBLICATION_CODE_REQUIRED", "Use --code-stdin with a fresh code for noninteractive private-skill commands.");
 }
 function verifyOptions(options, action) {
   verifySessionOptions(options);
@@ -126273,6 +126455,45 @@ function registerPrivatePublications(parent) {
       process.exitCode = 1;
     }
   });
+  group.command("versions").allowExcessArguments(false).description("Read one page of a private skill's versions and current version using fresh interactive sign-in").argument("<skill-id>", "Private or team skill UUID from the workspace catalog or create result").requiredOption("--email <email>", "Account email for fresh interactive verification").option("--user-id <uuid>", "Observed account UUID (required without an enrolled named profile)").option("--membership-id <uuid>", "Observed workspace membership UUID").option("--code-stdin", "Read a fresh six-digit verification code from stdin").option("--limit <count>", "Page size from 1 to 50", "20").option("--cursor <uuid>", "Read the next page using its returned cursor").option("--json", "Output validated history metadata without credentials or source content").action(async (skillId, options) => {
+    try {
+      if (!publicationUuid(skillId) || !/^[1-9]\d?$/.test(options.limit) || Number(options.limit) > 50 || options.cursor !== undefined && !publicationUuid(options.cursor))
+        throw new PrivatePublicationError("INVALID_PRIVATE_HISTORY_INPUT", "Provide a private skill UUID, --limit from 1 to 50, and an optional UUID --cursor.");
+      verifySessionOptions(options);
+      const context2 = options.userId ? { userId: options.userId, membershipId: options.membershipId } : undefined;
+      const pending = preparePrivateSkillHistorySession(context2);
+      let code2;
+      if (options.codeStdin)
+        code2 = await readCode();
+      else {
+        await new RemoteSkillsAuthClient(pending.origin).requestCode(options.email);
+        code2 = await promptCode();
+      }
+      if (code2 === null)
+        return;
+      const client2 = await pending.verify(options.email, code2);
+      const history = await client2.listVersions(skillId, { limit: Number(options.limit), cursor: options.cursor });
+      if (options.json)
+        console.log(JSON.stringify(history));
+      else {
+        console.log(`Private versions of ${history.slug} (${history.skillId})`);
+        console.log(`Current version: ${history.currentVersion ?? "Not published yet"}`);
+        if (!history.versions.length)
+          console.log("No versions on this page.");
+        for (const version2 of history.versions)
+          console.log(`  ${version2.version}${version2.id === history.currentVersionId ? " (current)" : ""}  published: ${version2.releasedAt ?? "Not released"}  created: ${version2.createdAt}`);
+        if (history.nextCursor)
+          console.log(`More versions: repeat this command with --cursor ${history.nextCursor} and fresh verification.`);
+      }
+    } catch (error61) {
+      const result2 = error61 instanceof PrivatePublicationError ? privatePublicationCustomerError(error61) : { error: "Unable to read private version history. Check the selected account, workspace and fresh verification; no skill or credential was changed.", code: "PRIVATE_HISTORY_UNAVAILABLE", uncertain: false };
+      if (options.json)
+        console.log(JSON.stringify(result2));
+      else
+        console.error(result2.error);
+      process.exitCode = 1;
+    }
+  });
   const publishCommand = group.command("publish").allowExcessArguments(false).description("Publish private source with explicit current-version comparison").requiredOption("--recovery-dir <directory>", "New recovery directory for publish; existing directory for other actions").requiredOption("--email <email>", "Account email for fresh interactive verification").option("--user-id <uuid>", "Observed account UUID (required without an enrolled named profile)").option("--membership-id <uuid>", "Observed workspace membership UUID").option("--code-stdin", "Read a fresh six-digit verification code from stdin").option("--json", "Output a safe result without session credentials or upload URLs").option("--confirm", "Explicitly approve this action").argument("<directory>", "Validated local skill directory").requiredOption("--skill-id <uuid>", "Existing private/team skill UUID").option("--expected-current-version <uuid>", "Compare against the observed current version UUID").option("--expect-empty", "Require the skill to have no current version").option("--idempotency-key <uuid>", "Stable intent key; generated and saved before begin when omitted").option("--wait-seconds <seconds>", "Bounded status wait from 0 to 300", "60");
   const statusCommand = group.command("status").allowExcessArguments(false).description("Inspect the exact saved publication").requiredOption("--recovery-dir <directory>", "New recovery directory for publish; existing directory for other actions").requiredOption("--email <email>", "Account email for fresh interactive verification").option("--user-id <uuid>", "Observed account UUID (required without an enrolled named profile)").option("--membership-id <uuid>", "Observed workspace membership UUID").option("--code-stdin", "Read a fresh six-digit verification code from stdin").option("--json", "Output a safe result without session credentials or upload URLs");
   const resumeCommand = group.command("resume").allowExcessArguments(false).description("Reconcile the saved intent without creating a replacement").requiredOption("--recovery-dir <directory>", "New recovery directory for publish; existing directory for other actions").requiredOption("--email <email>", "Account email for fresh interactive verification").option("--user-id <uuid>", "Observed account UUID (required without an enrolled named profile)").option("--membership-id <uuid>", "Observed workspace membership UUID").option("--code-stdin", "Read a fresh six-digit verification code from stdin").option("--json", "Output a safe result without session credentials or upload URLs").option("--confirm", "Explicitly approve this action").option("--wait-seconds <seconds>", "Bounded status wait from 0 to 300", "60");