@hasna/skills 0.10.77 → 0.10.79

package/bin/index.js

@@ -36888,7 +36888,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@hasna/skills",
-    version: "0.10.77",
+    version: "0.10.79",
     description: "Skills library for AI coding agents",
     type: "module",
     bin: {
@@ -40398,7 +40398,8 @@ var init_codex_native_compatibility = __esm(() => {
     "codex-cli 0.160.1": ["hooks", "qualified-skill-catalog", "installed-plugin-review"],
     "codex-cli 0.161.0": ["hooks", "qualified-skill-catalog", "installed-plugin-review"],
     "codex-cli 0.162.0": ["hooks", "qualified-skill-catalog", "installed-plugin-review"],
-    "codex-cli 0.162.1": ["hooks", "qualified-skill-catalog", "installed-plugin-review"]
+    "codex-cli 0.162.1": ["hooks", "qualified-skill-catalog", "installed-plugin-review"],
+    "codex-cli 0.163.0": ["hooks", "qualified-skill-catalog", "installed-plugin-review"]
   };
   SUPPORTED_CODEX_HOOK_VERSIONS = Object.freeze(Object.keys(MEASURED_CODEX_CAPABILITIES).filter((version) => supportsCodexNativeCapability(version, "hooks")));
 });
@@ -66746,6 +66747,24 @@ var init_remote_workspace_selection = __esm(() => {
 
 // src/lib/remote-private-publications.ts
 import { createHash as createHash30 } from "crypto";
+function checkedPrivateSkillCreate(value) {
+  const refuse6 = (field3, accepted) => {
+    throw new PrivatePublicationError("INVALID_SKILL_CREATE_INPUT", `Invalid ${field3}. ${accepted}`);
+  };
+  if (!record7(value) || !Object.keys(value).every((key2) => ["slug", "displayName", "description", "visibility", "confirm"].includes(key2)))
+    return refuse6("create input", "Provide only slug, displayName, description, visibility and confirm.");
+  if (value.confirm !== true)
+    throw new PrivatePublicationError("SKILL_CREATE_CONFIRM_REQUIRED", "Explicit confirmation is required to create this skill.");
+  if (typeof value.slug !== "string" || value.slug.length > 128 || !/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(value.slug))
+    return refuse6("slug", "Use lowercase kebab-case, at most 128 characters.");
+  if (typeof value.displayName !== "string" || !value.displayName.trim() || value.displayName.length > 256 || /[\p{Cc}\p{Cs}\u2028\u2029]/u.test(value.displayName))
+    return refuse6("displayName", "Use nonempty text, at most 256 characters, without control characters.");
+  if (value.description !== undefined && (typeof value.description !== "string" || Buffer.byteLength(value.description) > 8192 || /[\p{Cc}\p{Cs}]/u.test(value.description.replace(/[\r\n\t]/g, ""))))
+    return refuse6("description", "Use text of at most 8192 UTF-8 bytes, without control characters other than tabs and newlines.");
+  if (value.visibility !== undefined && value.visibility !== "private" && value.visibility !== "team")
+    return refuse6("visibility", "Use private or team.");
+  return Object.freeze({ slug: value.slug, displayName: value.displayName.trim(), description: value.description ?? "", visibility: value.visibility ?? "private" });
+}
 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 || !hash4(value.archiveSha256) || !Number.isSafeInteger(value.archiveByteSize) || Number(value.archiveByteSize) < 1 || Number(value.archiveByteSize) > PRIVATE_PUBLICATION_MAX_BYTES)
     return bad();
@@ -66765,11 +66784,11 @@ function checkedPublicationView(value, skillId, intentId, declaration) {
     return invalid3();
   return Object.freeze({ ...value });
 }
-async function boundedJson(url, init, token, mutation, budget2 = 15000, signal) {
+async function boundedJson(url, init, token, mutation, budget2 = 15000, signal, create3 = false) {
   const controller = new AbortController;
   let reader;
   let response;
-  const timeout = new PrivatePublicationError("PUBLICATION_UNCONFIRMED", "No confirmed publication result. Inspect the saved intent before retrying.", mutation);
+  const timeout = new PrivatePublicationError(create3 ? "SKILL_CREATE_UNCONFIRMED" : "PUBLICATION_UNCONFIRMED", create3 ? "Skill creation could not be confirmed. Inspect the workspace for this slug before another create; do not retry automatically." : "No confirmed publication result. Inspect the saved intent before retrying.", mutation);
   let timer;
   let abort;
   try {
@@ -66809,11 +66828,19 @@ async function boundedJson(url, init, token, mutation, budget2 = 15000, signal)
         return invalid3();
       }
       if (!response.ok) {
-        const code = record7(body) && typeof body.code === "string" && Object.hasOwn(failures, body.code) ? body.code : null;
-        if (code && failures[code][0] === response.status)
-          throw new PrivatePublicationError(code, failures[code][1], mutation && code === "PUBLICATION_UNCERTAIN", response.status);
+        const known = create3 ? skillCreateFailures : failures;
+        const code = record7(body) && typeof body.code === "string" && Object.hasOwn(known, body.code) ? body.code : null;
+        if (code && known[code][0] === response.status)
+          throw new PrivatePublicationError(code, known[code][1], mutation && code === "PUBLICATION_UNCERTAIN", response.status);
+        if (create3) {
+          if (response.status >= 500)
+            throw timeout;
+          throw new PrivatePublicationError("SKILL_CREATE_REQUEST_FAILED", "The server refused skill creation.", false, response.status);
+        }
         throw new PrivatePublicationError("PUBLICATION_REQUEST_FAILED", "The publication request was refused. Inspect its status before retrying.", mutation && response.status >= 500, response.status);
       }
+      if (create3 && response.status !== 201)
+        return invalid3();
       return body;
     })(), new Promise((_, reject2) => {
       abort = () => {
@@ -66860,6 +66887,15 @@ class RemotePrivatePublicationsClient {
     this.membershipId = checked.user.membershipId;
     Object.freeze(this);
   }
+  async createSkill(input, options = {}) {
+    const body = checkedPrivateSkillCreate(input);
+    if (options.timeoutMs !== undefined && (!Number.isSafeInteger(options.timeoutMs) || options.timeoutMs < 1 || options.timeoutMs > 15000))
+      throw new PrivatePublicationError("INVALID_SKILL_CREATE_INPUT", "Invalid timeoutMs. Use an integer from 1 to 15000.");
+    const value = await boundedJson(skillsApiRequestUrl(this.apiOrigin, "/api/v1/skills"), { method: "POST", body: JSON.stringify(body) }, this.#token, true, options.timeoutMs, options.signal, true);
+    if (!record7(value) || !publicationUuid(value.id) || value.slug !== body.slug || value.displayName !== body.displayName || value.description !== body.description || value.visibility !== body.visibility || value.sourceType !== "private_hosted" || !record7(value.metadata) || value.metadata.ownerOrganizationId !== this.organizationId)
+      throw new PrivatePublicationError("SKILL_CREATE_UNCONFIRMED", "Skill creation returned an unbound result. Inspect the workspace for this slug before another create; do not retry automatically.", true);
+    return Object.freeze({ id: value.id, slug: body.slug, visibility: body.visibility, sourceType: "private_hosted", ownerOrganizationId: this.organizationId });
+  }
   async getCapability(options = {}) {
     if (options.timeoutMs !== undefined && (!Number.isSafeInteger(options.timeoutMs) || options.timeoutMs < 1 || options.timeoutMs > 15000))
       return bad();
@@ -67002,7 +67038,7 @@ class RemotePrivatePublicationsClient {
     }
   }
 }
-var PRIVATE_PUBLICATION_MAX_BYTES, failures, PrivatePublicationError, bad = () => {
+var PRIVATE_PUBLICATION_MAX_BYTES, skillCreateFailures, failures, PrivatePublicationError, bad = () => {
   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.");
@@ -67012,6 +67048,16 @@ var init_remote_private_publications = __esm(() => {
   init_remote_workspace_selection();
   init_skill_contract();
   PRIVATE_PUBLICATION_MAX_BYTES = 16 * 1024 * 1024;
+  skillCreateFailures = {
+    INVALID_SLUG: [400, "Provide a lowercase kebab-case skill slug."],
+    INVALID_DISPLAY_NAME: [400, "Provide a nonempty skill display name."],
+    INVALID_VISIBILITY: [400, "Use private or team visibility for source publication."],
+    SESSION_EXPIRED: [401, "Sign in again before creating a private skill."],
+    INTERACTIVE_SESSION_REQUIRED: [403, "An interactive account session is required to create a private skill."],
+    ACCOUNT_UNAVAILABLE: [403, "The current account membership cannot create a private skill."],
+    PLAN_REQUIRED: [403, "Private and team skills require the Pro plan."],
+    SLUG_CONFLICT: [409, "This skill slug already exists. Inspect the existing skill before publishing."]
+  };
   failures = {
     INVALID_REQUEST: [400, "The publication request is invalid."],
     SESSION_EXPIRED: [401, "Sign in again to manage this publication."],
@@ -88997,6 +89043,7 @@ function normalizeRemoteSkill(skill) {
   if (!name)
     throw new Error("Remote skill requires name or slug");
   return {
+    ...skill.id !== undefined ? { id: skill.id } : {},
     name,
     displayName: skill.displayName || titleize(name),
     description: skill.description || "",
@@ -89115,11 +89162,12 @@ var init_remote_registry = __esm(() => {
     details: exports_external.array(exports_external.string()).optional()
   }).passthrough();
   remoteSkillSchema = exports_external.object({
+    id: exports_external.string().regex(/^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/).optional(),
     name: exports_external.string().min(1).optional(),
     slug: exports_external.string().min(1).optional(),
     displayName: exports_external.string().optional(),
     description: exports_external.string().optional(),
-    category: exports_external.string().optional(),
+    category: exports_external.string().nullable().optional(),
     tags: exports_external.array(exports_external.string()).optional(),
     dependencies: exports_external.array(exports_external.string()).optional(),
     version: exports_external.string().optional(),
@@ -99568,6 +99616,43 @@ var init_run_state = __esm(() => {
   init_project_state();
 });
 
+// src/lib/mcp-registration-environment.ts
+import { isAbsolute as isAbsolute33 } from "path";
+function skillsMcpRegistrationEnvironment(env3 = process.env, origin) {
+  const result2 = {};
+  const profile = selectedSkillsProfile(env3);
+  if (profile)
+    result2[CREDENTIAL_PROFILE_ENV_KEY] = profile;
+  for (const key2 of ["HASNA_HOME", "HASNA_CONFIG_HOME"]) {
+    const value = env3[key2];
+    if (value === undefined)
+      continue;
+    if (!isAbsolute33(value) || /[\x00-\x1f\x7f]/.test(value))
+      throw new Error(`Invalid ${key2}; expected an absolute configuration path`);
+    result2[key2] = value;
+  }
+  if (origin !== undefined || urlKeys2.some((key2) => env3[key2] !== undefined)) {
+    try {
+      const source = origin === undefined ? env3 : { ...env3, ...Object.fromEntries(urlKeys2.map((key2) => [key2, origin])) };
+      const configured = configuredSkillsApiUrl(source);
+      if (!configured)
+        throw new Error;
+      for (const key2 of urlKeys2)
+        result2[key2] = configured.value;
+    } catch {
+      throw new Error("Invalid Skills MCP API URL; expected matching HTTPS or loopback HTTP origins without credentials, query or fragment");
+    }
+  }
+  return Object.freeze(result2);
+}
+var urlKeys2;
+var init_mcp_registration_environment = __esm(() => {
+  init_transport();
+  init_instance_credentials();
+  init_fleet_credentials();
+  urlKeys2 = clientTransportEnvKeys("skills").apiUrlKeys;
+});
+
 // node_modules/@modelcontextprotocol/sdk/dist/esm/types.js
 function assertCompleteRequestPrompt(request2) {
   if (request2.params.ref.type !== "ref/prompt") {
@@ -111906,7 +111991,7 @@ var init_recurring_customer = __esm(() => {
 
 // src/lib/recurring-recovery.ts
 import { constants as constants26, closeSync as closeSync27, fsyncSync as fsyncSync8, fstatSync as fstatSync27, lstatSync as lstatSync37, mkdirSync as mkdirSync21, openSync as openSync27, readSync as readSync19, realpathSync as realpathSync17, renameSync as renameSync12, unlinkSync as unlinkSync8, writeFileSync as writeFileSync19 } from "fs";
-import { dirname as dirname35, isAbsolute as isAbsolute33, join as join59, resolve as resolve34 } from "path";
+import { dirname as dirname35, isAbsolute as isAbsolute34, join as join59, resolve as resolve34 } from "path";
 import { randomUUID as randomUUID8 } from "crypto";
 
 class RecoveryOwner {
@@ -111914,7 +111999,7 @@ class RecoveryOwner {
   parents = [];
   constructor(directory2) {
     this.directory = directory2;
-    if (!isAbsolute33(directory2) || resolve34(directory2) !== directory2 || realpathSync17(directory2) !== directory2)
+    if (!isAbsolute34(directory2) || resolve34(directory2) !== directory2 || realpathSync17(directory2) !== directory2)
       invalid6();
     for (let path = directory2;; path = dirname35(path)) {
       const stat3 = lstatSync37(path);
@@ -112049,7 +112134,7 @@ function base2(customer, organizationId) {
   };
 }
 function create3(directory2, intent) {
-  if (!isAbsolute33(directory2) || resolve34(directory2) !== directory2 || realpathSync17(dirname35(directory2)) !== dirname35(directory2))
+  if (!isAbsolute34(directory2) || resolve34(directory2) !== directory2 || realpathSync17(dirname35(directory2)) !== dirname35(directory2))
     invalid6();
   mkdirSync21(directory2, { mode: 448 });
   const owner2 = new RecoveryOwner(directory2), checked = intentSchema.parse(intent), intentSha256 = canonicalJsonSha256(checked);
@@ -112212,7 +112297,7 @@ var init_recurring_recovery = __esm(() => {
 });
 
 // src/lib/recurring-surface.ts
-import { isAbsolute as isAbsolute34 } from "path";
+import { isAbsolute as isAbsolute35 } from "path";
 function recurringMcpSchema(action) {
   return action === "activate" ? recurringSurfaceSchemas.activate.extend({ code, confirm: exports_external.literal(true) }) : recurringSurfaceSchemas[action];
 }
@@ -112317,7 +112402,7 @@ var init_recurring_surface = __esm(() => {
   uuid12 = exports_external.string().regex(/^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/);
   context = { userId: uuid12.optional(), membershipId: uuid12.optional() };
   page2 = { limit: exports_external.number().int().min(1).max(100).optional(), cursor: exports_external.string().min(1).max(2048).optional() };
-  directory2 = exports_external.string().max(4096).refine(isAbsolute34, "Use an absolute recovery directory");
+  directory2 = exports_external.string().max(4096).refine(isAbsolute35, "Use an absolute recovery directory");
   email4 = exports_external.string().trim().toLowerCase().email().max(254);
   code = exports_external.string().regex(/^\d{6}$/);
   recurringSurfaceSchemas = {
@@ -115103,15 +115188,42 @@ var init_remote_invitation_tools = __esm(() => {
 });
 
 // src/lib/private-publication-customer.ts
+function preparePrivatePublicationSession(requested) {
+  const selectors = [
+    "HASNA_PROFILE",
+    "HASNA_HOME",
+    "HASNA_CONFIG_HOME",
+    "HASNA_STATION",
+    "HASNA_SKILLS_API_URL",
+    "SKILLS_API_URL",
+    "HASNA_SKILLS_API_KEY_OVERRIDE",
+    "HASNA_SKILLS_API_KEY_REF",
+    "HASNA_SKILLS_API_KEY",
+    "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 captured = requested ? { ...requested } : undefined;
+  const unchanged3 = () => {
+    if (selectors.some((key2) => process.env[key2] !== before2.get(key2)) || selectedSkillsProfile(process.env) !== profile)
+      throw new PrivatePublicationError("PUBLICATION_TARGET_CHANGED", "The selected profile or server changed during verification. Start again with a stable target; no skill action was sent.");
+  };
+  return { origin: pending.origin, async verify(email5, code2) {
+    unchanged3();
+    const target = await pending.resolve();
+    const context2 = captured ?? target.context;
+    if (!context2 || !publicationUuid(context2.userId) || !publicationUuid(context2.membershipId) || target.context && (context2.userId !== target.context.userId || context2.membershipId !== target.context.membershipId))
+      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);
+    unchanged3();
+    target.unchanged();
+    return client2;
+  } };
+}
 async function privatePublicationSession(email5, code2, requested) {
-  const target = await captureProfileWorkspace("Manage private publications");
-  const context2 = requested ?? target.context;
-  if (!context2 || !publicationUuid(context2.userId) || !publicationUuid(context2.membershipId) || target.context && (context2.userId !== target.context.userId || context2.membershipId !== target.context.membershipId))
-    throw new PrivatePublicationError("PUBLICATION_CONTEXT_REQUIRED", "Provide the observed user and membership IDs, or select an enrolled workspace profile.");
-  target.unchanged();
-  const client2 = await new RemoteSkillsAuthClient(target.origin).openPrivatePublications(email5, code2, context2);
-  target.unchanged();
-  return client2;
+  return preparePrivatePublicationSession(requested).verify(email5, code2);
 }
 function privatePublicationCustomerError(error61) {
   return error61 instanceof PrivatePublicationError ? { error: error61.message, code: error61.code, uncertain: error61.uncertain } : { error: "The publication action could not be confirmed. Preserve the recovery directory and inspect the same intent; credentials were not changed.", code: "PUBLICATION_ACTION_UNCONFIRMED", uncertain: true };
@@ -115120,14 +115232,15 @@ var init_private_publication_customer = __esm(() => {
   init_remote_auth();
   init_remote_private_publications();
   init_workspace_profile();
+  init_instance_credentials();
 });
 
 // src/lib/private-publication-recovery.ts
 import { constants as constants27, closeSync as closeSync28, fsyncSync as fsyncSync9, fstatSync as fstatSync28, lstatSync as lstatSync38, mkdirSync as mkdirSync25, openSync as openSync28, readSync as readSync20, realpathSync as realpathSync18, renameSync as renameSync13, unlinkSync as unlinkSync9, writeFileSync as writeFileSync22 } from "fs";
-import { dirname as dirname38, isAbsolute as isAbsolute35, join as join64, resolve as resolve35 } from "path";
+import { dirname as dirname38, isAbsolute as isAbsolute36, join as join64, resolve as resolve35 } from "path";
 import { randomUUID as randomUUID9 } from "crypto";
 function safeDirectory(directory3) {
-  if (!isAbsolute35(directory3) || directory3 !== resolve35(directory3) || realpathSync18(directory3) !== directory3)
+  if (!isAbsolute36(directory3) || directory3 !== resolve35(directory3) || realpathSync18(directory3) !== directory3)
     return fail5();
   for (let path = directory3;; path = dirname38(path)) {
     const stat3 = lstatSync38(path);
@@ -115265,7 +115378,7 @@ async function preparePrivatePublication(client2, sourceDirectory, recoveryDirec
     phase: "prepared",
     intent: null
   };
-  if (!isAbsolute35(recoveryDirectory) || resolve35(recoveryDirectory) !== recoveryDirectory || realpathSync18(dirname38(recoveryDirectory)) !== dirname38(recoveryDirectory))
+  if (!isAbsolute36(recoveryDirectory) || resolve35(recoveryDirectory) !== recoveryDirectory || realpathSync18(dirname38(recoveryDirectory)) !== dirname38(recoveryDirectory))
     return fail5();
   mkdirSync25(recoveryDirectory, { mode: 448 });
   safeDirectory(recoveryDirectory);
@@ -115366,10 +115479,10 @@ var init_private_publication_recovery = __esm(() => {
 });
 
 // src/mcp/private-publication-tools.ts
-import { isAbsolute as isAbsolute36 } from "path";
+import { isAbsolute as isAbsolute37 } from "path";
 function registerPrivatePublicationTools(server) {
   const uuid9 = exports_external.string().regex(/^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/);
-  const directory3 = exports_external.string().max(4096).refine(isAbsolute36, "Use an absolute local directory");
+  const directory3 = exports_external.string().max(4096).refine(isAbsolute37, "Use an absolute local directory");
   const verification2 = { email: exports_external.string().email().max(254), code: exports_external.string().regex(/^\d{6}$/), userId: uuid9, membershipId: uuid9, recoveryDirectory: directory3 };
   const description = "Manage a private source publication using fresh workspace-bound verification and a host-local recovery directory. Publishing requires explicit UUID current-version comparison and upload consent. Resume reuses immutable saved bytes and intent; an uncertain PUT is finalized for server verification, never uploaded twice. Sessions and signed URLs are not returned or persisted. Private execution is unavailable. Host request history may contain the supplied verification code.";
   const handler = (action) => async (value) => {
@@ -115830,14 +115943,18 @@ var exports_runtime_mcp = {};
 __export(exports_runtime_mcp, {
   handleMcp: () => handleMcp
 });
-import { existsSync as existsSync33, mkdirSync as mkdirSync26, readFileSync as readFileSync42, writeFileSync as writeFileSync23 } from "fs";
+import { existsSync as existsSync33, lstatSync as lstatSync39, mkdirSync as mkdirSync26, readFileSync as readFileSync42, 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 dirname39, join as join65 } from "path";
+import { dirname as dirname39, isAbsolute as isAbsolute38, join as join65 } from "path";
+import { isDeepStrictEqual as isDeepStrictEqual16, stripVTControlCharacters } from "util";
 async function handleMcp(options) {
   if (options.register) {
     let agents;
+    let environment;
     try {
       agents = resolveAgents(options.register);
+      environment = skillsMcpRegistrationEnvironment(process.env, options.apiUrl);
     } catch (err) {
       const error61 = err.message;
       if (options.json) {
@@ -115851,7 +115968,7 @@ async function handleMcp(options) {
     const command = findCommandOnPath(MCP_COMMAND_NAME);
     const results2 = [];
     for (const agent of agents) {
-      const result2 = await registerMcpForAgent(agent, command);
+      const result2 = await registerMcpForAgent(agent, command, environment);
       results2.push(result2);
       if (!options.json) {
         const label = result2.path ? `${agent} (${result2.path})` : agent;
@@ -115868,96 +115985,193 @@ async function handleMcp(options) {
   const { startMcpStdio: startMcpStdio2 } = await Promise.resolve().then(() => (init_mcp2(), exports_mcp));
   await startMcpStdio2();
 }
-async function registerMcpForAgent(agent, command) {
+async function registerMcpForAgent(agent, command, environment) {
+  const server2 = { command, args: ["--stdio"], ...Object.keys(environment).length ? { env: environment } : {} };
   switch (agent) {
     case "claude":
-      return registerClaudeMcp(command);
+      return registerClaudeMcp(command, server2, environment);
     case "codex":
-      return registerCodexMcp(command);
+      return registerCodexMcp(command, environment);
     case "gemini":
-      return registerJsonMcpServer(agent, join65(homedir10(), ".gemini", "settings.json"), "mcpServers", {
-        command,
-        args: []
-      });
+      return registerJsonMcpServer(agent, join65(homedir10(), ".gemini", "settings.json"), "mcpServers", server2);
     case "pi":
-      return registerJsonMcpServer(agent, join65(homedir10(), ".pi", "agent", "mcp.json"), "mcpServers", {
-        command,
-        args: []
-      });
+      return registerJsonMcpServer(agent, join65(homedir10(), ".pi", "agent", "mcp.json"), "mcpServers", server2);
     case "opencode":
-      return registerOpenCodeMcp(command);
+      return registerOpenCodeMcp(command, environment);
     case "cursor":
-      return registerJsonMcpServer(agent, join65(homedir10(), ".cursor", "mcp.json"), "mcpServers", {
-        command,
-        args: []
-      });
+      return registerJsonMcpServer(agent, join65(homedir10(), ".cursor", "mcp.json"), "mcpServers", server2);
     case "windsurf":
-      return registerJsonMcpServer(agent, join65(homedir10(), ".windsurf", "mcp.json"), "mcpServers", {
-        command,
-        args: []
-      });
+      return registerJsonMcpServer(agent, join65(homedir10(), ".windsurf", "mcp.json"), "mcpServers", server2);
     default:
       return { agent, success: false, error: `Unknown agent: ${agent}. Available: ${AGENT_TARGETS.join(", ")}, all` };
   }
 }
-async function registerClaudeMcp(command) {
-  const cliCommand = `claude mcp add -s user ${MCP_SERVER_NAME} -- ${command}`;
+async function registerClaudeMcp(command, server2, environment) {
+  const args2 = ["claude", "mcp", "add", "-s", "user", ...Object.entries(environment).flatMap(([key2, value]) => ["--env", `${key2}=${value}`]), "--transport", "stdio", MCP_SERVER_NAME, "--", command, "--stdio"];
+  const cliCommand = args2.map(skillsShellArgument).join(" ");
+  const desired = { type: "stdio", ...server2, env: environment };
   try {
-    const proc = Bun.spawn(["claude", "mcp", "add", "-s", "user", MCP_SERVER_NAME, "--", command], {
-      stdout: "pipe",
-      stderr: "pipe"
+    const path = claudeUserConfigPath();
+    const before2 = withClaudeConfigLock(path, () => {
+      if (claudeUserConfigPath() !== path)
+        throw new Error;
+      const bytes = readClaudeConfig(path);
+      if (bytes !== null) {
+        const backup = `${path}.skills-mcp-${randomUUID10()}.backup`;
+        writeFileSync23(backup, bytes, { flag: "wx", mode: 384 });
+        if (!readFileSync42(backup).equals(bytes))
+          throw new Error;
+      }
+      return bytes;
     });
-    const [stdout, stderr, exitCode] = await Promise.all([
-      new Response(proc.stdout).text(),
-      new Response(proc.stderr).text(),
-      proc.exited
-    ]);
-    if (exitCode === 0) {
-      return { agent: "claude", success: true, command: cliCommand };
+    let exitCode, duplicateAccepted = false, cliUnavailable = false;
+    const proc = (() => {
+      try {
+        return Bun.spawn(args2, { stdout: "pipe", stderr: "pipe" });
+      } catch (error61) {
+        if (!isPlainObject4(error61) || error61.code !== "ENOENT")
+          throw new Error;
+        cliUnavailable = true;
+        return;
+      }
+    })();
+    if (proc) {
+      const [stdout, stderr, status] = await Promise.all([
+        new Response(proc.stdout).text(),
+        new Response(proc.stderr).text(),
+        proc.exited
+      ]);
+      exitCode = status;
+      const diagnostic = stripVTControlCharacters(stderr).trim();
+      duplicateAccepted = exitCode === 1 && stdout.trim() === "" && (diagnostic === `MCP server ${MCP_SERVER_NAME} already exists in user config` || diagnostic === `Error: MCP server ${MCP_SERVER_NAME} already exists in user config`);
+      if (exitCode !== 0 && !duplicateAccepted)
+        throw new Error;
     }
-    const fallback = registerJsonMcpServer("claude", join65(homedir10(), ".claude", ".mcp.json"), "mcpServers", {
-      command,
-      args: []
-    });
-    return {
-      ...fallback,
-      command: cliCommand,
-      error: fallback.success ? undefined : `claude exited with ${exitCode}: ${(stderr || stdout).trim()}`
-    };
-  } catch (err) {
-    const fallback = registerJsonMcpServer("claude", join65(homedir10(), ".claude", ".mcp.json"), "mcpServers", {
-      command,
-      args: []
+    return withClaudeConfigLock(path, () => {
+      if (claudeUserConfigPath() !== path)
+        throw new Error;
+      const current = readClaudeConfig(path);
+      const previous = parseClaudeConfig(before2), data = parseClaudeConfig(current);
+      if (exitCode === 0) {
+        const actual = isPlainObject4(data.mcpServers) ? data.mcpServers[MCP_SERVER_NAME] : undefined;
+        if (!isDeepStrictEqual16(withoutClaudeSkills(previous), withoutClaudeSkills(data)) || !isPlainObject4(actual) || !isDeepStrictEqual16({ ...actual, env: actual.env ?? {} }, desired))
+          throw new Error;
+      } else {
+        if (!cliUnavailable && (!duplicateAccepted || !isPlainObject4(previous.mcpServers) || !previous.mcpServers[MCP_SERVER_NAME]))
+          throw new Error;
+        if (before2 === null ? current !== null : current === null || !current.equals(before2))
+          throw new Error;
+        data.mcpServers = { ...data.mcpServers, [MCP_SERVER_NAME]: desired };
+        const next = Buffer.from(`${JSON.stringify(data, null, 2)}
+`);
+        const temporary = `${path}.skills-mcp-${randomUUID10()}.tmp`;
+        writeFileSync23(temporary, next, { flag: "wx", mode: 384 });
+        if (!readFileSync42(temporary).equals(next))
+          throw new Error;
+        const latest = readClaudeConfig(path);
+        if (claudeUserConfigPath() !== path || (before2 === null ? latest !== null : latest === null || !latest.equals(before2)))
+          throw new Error;
+        renameSync14(temporary, path);
+        if (!readFileSync42(path).equals(next))
+          throw new Error;
+      }
+      return { agent: "claude", success: true, path, command: cliCommand };
     });
+  } catch {
     return {
-      ...fallback,
+      agent: "claude",
+      success: false,
       command: cliCommand,
-      error: fallback.success ? undefined : err.message
+      error: "Could not safely update the Claude user MCP configuration; native admission or config checks refused the update"
     };
   }
 }
-function registerCodexMcp(command) {
+function claudeUserConfigPath() {
+  const override = process.env.CLAUDE_CONFIG_DIR;
+  if (override !== undefined && (!override || !isAbsolute38(override) || /[\x00-\x1f\x7f]/.test(override)))
+    throw new Error;
+  const modern = join65(override || homedir10(), process.env.CLAUDE_CODE_CUSTOM_OAUTH_URL ? ".claude-custom-oauth.json" : ".claude.json");
+  const legacy = join65(override ?? join65(homedir10(), ".claude"), ".config.json");
+  if (existsSync33(legacy)) {
+    const info = lstatSync39(legacy);
+    if (!info.isFile())
+      throw new Error;
+    if (info.size > 0 || (info.mode & 146) !== 0 && !existsSync33(modern))
+      return legacy;
+  }
+  return modern;
+}
+function readClaudeConfig(path) {
+  if (!existsSync33(path))
+    return null;
+  const info = lstatSync39(path);
+  if (!info.isFile() || info.size > 16777216)
+    throw new Error;
+  const bytes = readFileSync42(path);
+  parseClaudeConfig(bytes);
+  return bytes;
+}
+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 withoutClaudeSkills(data) {
+  const rest2 = { ...data }, servers = { ...data.mcpServers };
+  delete servers[MCP_SERVER_NAME];
+  if (Object.keys(servers).length)
+    rest2.mcpServers = servers;
+  else
+    delete rest2.mcpServers;
+  return rest2;
+}
+function withClaudeConfigLock(path, action) {
+  mkdirSync26(dirname39(path), { recursive: true });
+  const lock = `${path}.lock`;
+  mkdirSync26(lock, { mode: 448 });
+  const owned = statSync22(lock);
+  try {
+    return action();
+  } finally {
+    const current = lstatSync39(lock);
+    if (current.isDirectory() && current.dev === owned.dev && current.ino === owned.ino) {
+      rmdirSync4(lock);
+    }
+  }
+}
+function registerCodexMcp(command, environment) {
   const path = join65(homedir10(), ".codex", "config.toml");
+  const body = `command = ${JSON.stringify(command)}
+args = ["--stdio"]${Object.keys(environment).length ? `
+env = { ${Object.entries(environment).map(([key2, value]) => `${JSON.stringify(key2)} = ${JSON.stringify(value)}`).join(", ")} }` : ""}`;
   const config2 = `[mcp_servers.${MCP_SERVER_NAME}]
-command = ${JSON.stringify(command)}`;
+${body}`;
   try {
     const current = existsSync33(path) ? readFileSync42(path, "utf-8") : "";
-    writeTextFile(path, upsertTomlSection(current, `[mcp_servers.${MCP_SERVER_NAME}]`, `command = ${JSON.stringify(command)}`));
+    const before2 = Bun.TOML.parse(current);
+    const next = upsertTomlSection(current, `[mcp_servers.${MCP_SERVER_NAME}]`, body);
+    const after2 = Bun.TOML.parse(next);
+    if (!isDeepStrictEqual16(withoutSkillsMcp(before2), withoutSkillsMcp(after2)))
+      throw new Error;
+    writeTextFile(path, next);
     return { agent: "codex", success: true, path, config: config2 };
   } catch (err) {
-    return { agent: "codex", success: false, path, config: config2, error: err.message };
+    return { agent: "codex", success: false, path, config: config2, error: "Could not update the Codex MCP configuration" };
   }
 }
-function registerOpenCodeMcp(command) {
+function registerOpenCodeMcp(command, environment) {
   const path = join65(homedir10(), ".config", "opencode", "opencode.json");
+  const server2 = {
+    type: "local",
+    command: [command, "--stdio"],
+    enabled: true,
+    ...Object.keys(environment).length ? { environment } : {}
+  };
   const config2 = JSON.stringify({
     $schema: "https://opencode.ai/config.json",
     mcp: {
-      [MCP_SERVER_NAME]: {
-        type: "local",
-        command: [command],
-        enabled: true
-      }
+      [MCP_SERVER_NAME]: server2
     }
   }, null, 2);
   try {
@@ -115965,16 +116179,12 @@ function registerOpenCodeMcp(command) {
     if (!data.$schema)
       data.$schema = "https://opencode.ai/config.json";
     const mcp = isPlainObject4(data.mcp) ? data.mcp : {};
-    mcp[MCP_SERVER_NAME] = {
-      type: "local",
-      command: [command],
-      enabled: true
-    };
+    mcp[MCP_SERVER_NAME] = server2;
     data.mcp = mcp;
     writeJsonObject(path, data);
     return { agent: "opencode", success: true, path, config: config2 };
   } catch (err) {
-    return { agent: "opencode", success: false, path, config: config2, error: err.message };
+    return { agent: "opencode", success: false, path, config: config2, error: "Could not update the OpenCode MCP configuration" };
   }
 }
 function registerJsonMcpServer(agent, path, containerKey, server2) {
@@ -115987,7 +116197,7 @@ function registerJsonMcpServer(agent, path, containerKey, server2) {
     writeJsonObject(path, data);
     return { agent, success: true, path, config: config2 };
   } catch (err) {
-    return { agent, success: false, path, config: config2, error: err.message };
+    return { agent, success: false, path, config: config2, error: "Could not update the agent MCP configuration" };
   }
 }
 function readJsonObject2(path) {
@@ -116014,24 +116224,37 @@ function writeTextFile(path, content) {
 function upsertTomlSection(content, header, body) {
   const sectionLines = [header, ...body.trim().split(/\r?\n/)];
   const lines = content.trimEnd() ? content.trimEnd().split(/\r?\n/) : [];
-  const start = lines.findIndex((line) => line.trim() === header);
-  if (start === -1) {
-    const prefix = lines.length ? [...lines, ""] : [];
-    return [...prefix, ...sectionLines, ""].join(`
-`);
-  }
-  let end = lines.length;
-  for (let i = start + 1;i < lines.length; i++) {
-    if (/^\s*\[[^\]]+\]\s*$/.test(lines[i])) {
-      end = i;
-      break;
+  const result2 = [];
+  let owned = false, inserted = false;
+  for (const line of lines) {
+    if (/^\s*\[/.test(line)) {
+      owned = /^\s*\[\s*(?:mcp_servers|"mcp_servers"|'mcp_servers')\s*\.\s*(?:skills|"skills"|'skills')\s*(?:\.|\])/.test(line);
+      if (owned && !inserted) {
+        result2.push(...sectionLines, "");
+        inserted = true;
+      }
     }
+    if (!owned)
+      result2.push(line);
   }
-  lines.splice(start, end - start, ...sectionLines);
-  return `${lines.join(`
+  if (!inserted)
+    result2.push(...result2.length ? [""] : [], ...sectionLines);
+  return `${result2.join(`
 `)}
 `;
 }
+function withoutSkillsMcp(config2) {
+  const preserved = { ...config2 };
+  if (isPlainObject4(preserved.mcp_servers)) {
+    const servers = { ...preserved.mcp_servers };
+    delete servers[MCP_SERVER_NAME];
+    if (Object.keys(servers).length)
+      preserved.mcp_servers = servers;
+    else
+      delete preserved.mcp_servers;
+  }
+  return preserved;
+}
 function findCommandOnPath(command) {
   const pathValue = process.env.PATH || "";
   for (const dir of pathValue.split(":")) {
@@ -116050,6 +116273,8 @@ var MCP_SERVER_NAME = "skills", MCP_COMMAND_NAME = "skills-mcp";
 var init_runtime_mcp = __esm(() => {
   init_source();
   init_installer();
+  init_credential_profile_command();
+  init_mcp_registration_environment();
 });
 
 // src/cli/commands/remote-account.ts
@@ -116243,7 +116468,7 @@ var init_reviewed_runtime_lock = __esm(() => {
 });
 
 // src/cli/commands/runtime-copyfile.ts
-import { createHash as createHash40, randomUUID as randomUUID10 } from "crypto";
+import { createHash as createHash40, randomUUID as randomUUID11 } from "crypto";
 import { Readable } from "stream";
 import { createGunzip as createGunzip2 } from "zlib";
 import { spawnSync as spawnSync6 } from "child_process";
@@ -116251,16 +116476,16 @@ import {
   chmodSync as chmodSync4,
   copyFileSync,
   existsSync as existsSync34,
-  lstatSync as lstatSync39,
+  lstatSync as lstatSync40,
   mkdirSync as mkdirSync27,
   readFileSync as readFileSync43,
   readdirSync as readdirSync24,
   readlinkSync as readlinkSync8,
   realpathSync as realpathSync19,
-  renameSync as renameSync14,
+  renameSync as renameSync15,
   writeFileSync as writeFileSync24
 } from "fs";
-import { basename as basename21, delimiter as delimiter3, dirname as dirname40, isAbsolute as isAbsolute37, join as join66, relative as relative13, resolve as resolve36, sep as sep18 } from "path";
+import { basename as basename21, delimiter as delimiter3, dirname as dirname40, isAbsolute as isAbsolute39, join as join66, relative as relative13, resolve as resolve36, sep as sep18 } from "path";
 function oldLauncherState(item) {
   if (item.oldShape === "pinned")
     return { shape: "pinned", runtime: item.oldRuntime, cwd: item.oldCwd, target: item.oldTarget, sha256: item.oldSha256, format: item.oldFormat, profile: item.oldProfile };
@@ -116286,7 +116511,7 @@ function assertLauncherRecordShapes(item, expectedProfile) {
         throw new Error("RECEIPT_LAUNCHER_SHAPE_INVALID");
       continue;
     }
-    if (shape !== "pinned" || typeof runtime !== "string" || !isAbsolute37(runtime) || typeof cwd2 !== "string" || !isAbsolute37(cwd2) || typeof sha7 !== "string" || !hex4.test(sha7)) {
+    if (shape !== "pinned" || typeof runtime !== "string" || !isAbsolute39(runtime) || typeof cwd2 !== "string" || !isAbsolute39(cwd2) || typeof sha7 !== "string" || !hex4.test(sha7)) {
       throw new Error("RECEIPT_LAUNCHER_SHAPE_INVALID");
     }
     const target = side === "old" ? item.oldTarget : item.newTarget;
@@ -116314,7 +116539,7 @@ function verifyTargetPrerequisites(manifest, packageRoot, home, cwd2, pathValue)
     throw new Error("RUNTIME_PREREQUISITE_CONTRACT_INVALID");
   }
   const entry = join66(packageRoot, contract.entry);
-  if (!entryExists(entry) || !lstatSync39(entry).isFile() || lstatSync39(entry).isSymbolicLink())
+  if (!entryExists(entry) || !lstatSync40(entry).isFile() || lstatSync40(entry).isSymbolicLink())
     throw new Error("RUNTIME_PREREQUISITE_ENTRY_MISSING");
   const entrySha256 = hash6(readFileSync43(entry));
   const env3 = { HOME: home, PATH: pathValue, BUN_RUNTIME_TRANSPILER_CACHE_PATH: "0" };
@@ -116373,11 +116598,11 @@ function hash6(bytes) {
 }
 function isWithin(parent, child2) {
   const rel = relative13(parent, child2);
-  return rel === "" || !rel.startsWith(`..${sep18}`) && rel !== ".." && !isAbsolute37(rel);
+  return rel === "" || !rel.startsWith(`..${sep18}`) && rel !== ".." && !isAbsolute39(rel);
 }
 function entryExists(path) {
   try {
-    lstatSync39(path);
+    lstatSync40(path);
     return true;
   } catch {
     return false;
@@ -116389,7 +116614,7 @@ function assertNoSymlinkAncestors(path) {
   let current = sep18;
   for (const part of parts) {
     current = join66(current, part);
-    const stat3 = lstatSync39(current);
+    const stat3 = lstatSync40(current);
     if (stat3.isSymbolicLink())
       throw new Error("PATH_ANCESTOR_SYMLINK_UNSUPPORTED");
     if (!stat3.isDirectory())
@@ -116404,17 +116629,17 @@ function acquireRuntimeLock(runtimeRoot) {
     throw new Error("RUNTIME_UPDATE_LOCKED");
   }
   try {
-    writeJsonPrivate(join66(lockPath, "lock.json"), { operationId: randomUUID10(), pid: process.pid, startedAt: new Date().toISOString() });
+    writeJsonPrivate(join66(lockPath, "lock.json"), { operationId: randomUUID11(), pid: process.pid, startedAt: new Date().toISOString() });
   } catch {
     try {
-      renameSync14(lockPath, join66(runtimeRoot, `.copyfile-update-lock-incomplete-${randomUUID10()}`));
+      renameSync15(lockPath, join66(runtimeRoot, `.copyfile-update-lock-incomplete-${randomUUID11()}`));
     } catch {}
     throw new Error("RUNTIME_LOCK_INITIALIZATION_FAILED");
   }
   return () => {
-    const released = join66(runtimeRoot, `.copyfile-update-lock-released-${randomUUID10()}`);
+    const released = join66(runtimeRoot, `.copyfile-update-lock-released-${randomUUID11()}`);
     writeJsonPrivate(join66(lockPath, "released.json"), { completedAt: new Date().toISOString() });
-    renameSync14(lockPath, released);
+    renameSync15(lockPath, released);
   };
 }
 function packageBins(pkg) {
@@ -116422,7 +116647,7 @@ function packageBins(pkg) {
   const entries = typeof raw === "string" ? [[PACKAGE_NAME.slice(PACKAGE_NAME.lastIndexOf("/") + 1), raw]] : raw && typeof raw === "object" && !Array.isArray(raw) ? Object.entries(raw) : [];
   const output2 = {};
   for (const [name, value] of entries) {
-    if (!/^[a-zA-Z0-9._-]+$/.test(name) || typeof value !== "string" || !value || isAbsolute37(value)) {
+    if (!/^[a-zA-Z0-9._-]+$/.test(name) || typeof value !== "string" || !value || isAbsolute39(value)) {
       throw new Error("PACKAGE_BIN_INVALID");
     }
     const normalized2 = value.replaceAll("\\", "/");
@@ -116450,7 +116675,7 @@ function resolveRuntimeLayout(homeInput, pathInput) {
   const home = realpathSync19(homeInput);
   const runtimeRoot = join66(home, ".hasna", "skills", "runtime");
   assertNoSymlinkAncestors(runtimeRoot);
-  const runtimeRootStat = lstatSync39(runtimeRoot);
+  const runtimeRootStat = lstatSync40(runtimeRoot);
   if (!runtimeRootStat.isDirectory() || runtimeRootStat.isSymbolicLink() || (runtimeRootStat.mode & 63) !== 0) {
     throw new Error("RUNTIME_ROOT_NOT_PRIVATE");
   }
@@ -116509,7 +116734,7 @@ function resolveRuntimeLayout(homeInput, pathInput) {
       if (actual !== join66(currentPackageRoot, target))
         continue;
       const newTarget = join66(runtimeRoot, "__target__", "node_modules", "@hasna", "skills", target);
-      const backupPath = `${path}.skills-prev-${randomUUID10()}`;
+      const backupPath = `${path}.skills-prev-${randomUUID11()}`;
       if (launcher.kind === "symlink") {
         if (resolve36(dirname40(path), launcher.linkTarget) !== actual)
           throw new Error("LAUNCHER_SYMLINK_CHAIN_UNSUPPORTED");
@@ -116722,7 +116947,7 @@ function readTree(root2, includeModes, excludeNpmDependencies = false) {
     for (const item of readdirSync24(dir).sort()) {
       const path = join66(dir, item);
       const rel = prefix ? `${prefix}/${item}` : item;
-      const stat3 = lstatSync39(path);
+      const stat3 = lstatSync40(path);
       if (excludeNpmDependencies && !prefix && item === "node_modules") {
         if (!stat3.isDirectory() || stat3.isSymbolicLink())
           throw new Error("INSTALLED_DEPENDENCY_DIRECTORY_UNSAFE");
@@ -116758,14 +116983,14 @@ function readTree(root2, includeModes, excludeNpmDependencies = false) {
   return { entries, digest: hash6(new TextEncoder().encode(JSON.stringify(entries))) };
 }
 function normalizeModes(root2) {
-  const rootStat = lstatSync39(root2);
+  const rootStat = lstatSync40(root2);
   if (!rootStat.isDirectory() || rootStat.isSymbolicLink())
     throw new Error("RUNTIME_ENTRY_TYPE_UNSUPPORTED");
   chmodSync4(root2, rootStat.mode & 493);
   const walk2 = (dir) => {
     for (const item of readdirSync24(dir)) {
       const path = join66(dir, item);
-      const stat3 = lstatSync39(path);
+      const stat3 = lstatSync40(path);
       if (stat3.isSymbolicLink())
         continue;
       if (stat3.isDirectory()) {
@@ -116815,7 +117040,7 @@ function verifyPreimageManifest(runtimePath, receipt, home) {
       throw new Error("PREIMAGE_CONFIG_BINDING_INVALID");
     if (config2.present) {
       const backup = join66(runtimePath, "preimage", "configs", relativePath);
-      const stat3 = lstatSync39(backup);
+      const stat3 = lstatSync40(backup);
       const saved = readFileSync43(backup);
       if (!stat3.isFile() || stat3.isSymbolicLink() || hash6(saved) !== config2.sha256 || saved.byteLength !== config2.byteSize)
         throw new Error("PREIMAGE_CONFIG_DRIFT");
@@ -116829,7 +117054,7 @@ function captureConfigPreimages(home, stage) {
     const sourcePath = join66(home, relativePath);
     if (!entryExists(sourcePath))
       return { sourcePath, relativePath, present: false };
-    const stat3 = lstatSync39(sourcePath);
+    const stat3 = lstatSync40(sourcePath);
     if (!stat3.isFile() || stat3.isSymbolicLink())
       throw new Error("CONFIG_PREIMAGE_NOT_REGULAR_FILE");
     const bytes = readFileSync43(sourcePath);
@@ -116849,7 +117074,7 @@ function assertConfigUnchanged(configs) {
     if (present2 !== config2.present)
       throw new Error("CONFIG_DRIFT_DURING_UPDATE");
     if (present2) {
-      const stat3 = lstatSync39(config2.sourcePath);
+      const stat3 = lstatSync40(config2.sourcePath);
       if (!stat3.isFile() || stat3.isSymbolicLink() || hash6(readFileSync43(config2.sourcePath)) !== config2.sha256) {
         throw new Error("CONFIG_DRIFT_DURING_UPDATE");
       }
@@ -116948,7 +117173,7 @@ function replaceLauncher(item) {
   const oldState = oldLauncherState(item), newState = newLauncherState(item);
   if (!launcherIs(item.path, oldState) || entryExists(item.backupPath))
     throw new Error("LAUNCHER_PREIMAGE_DRIFT");
-  const temp = `${item.path}.skills-next-${randomUUID10()}`;
+  const temp = `${item.path}.skills-next-${randomUUID11()}`;
   try {
     materializeLauncher(item.backupPath, oldState);
   } catch {
@@ -116963,15 +117188,15 @@ function replaceLauncher(item) {
   }
   if (!launcherIs(temp, newState))
     throw new Error("LAUNCHER_NEW_LINK_READBACK_MISMATCH");
-  renameSync14(temp, item.path);
+  renameSync15(temp, item.path);
 }
 function atomicJson(path, value) {
-  const temp = `${path}.next-${randomUUID10()}`;
+  const temp = `${path}.next-${randomUUID11()}`;
   const bytes = Buffer.from(`${JSON.stringify(value, null, 2)}
 `);
   writeFileSync24(temp, bytes, { flag: "wx", mode: 384 });
   chmodSync4(temp, 384);
-  renameSync14(temp, path);
+  renameSync15(temp, path);
   if (!readFileSync43(path).equals(bytes))
     throw new Error("RECEIPT_READBACK_MISMATCH");
 }
@@ -116988,10 +117213,10 @@ function persistReceipt(path, value) {
     const historyRoot = join66(dirname40(path), "receipt-history");
     if (!entryExists(historyRoot))
       mkdirSync27(historyRoot, { mode: 448 });
-    const historyStat = lstatSync39(historyRoot);
+    const historyStat = lstatSync40(historyRoot);
     if (!historyStat.isDirectory() || historyStat.isSymbolicLink() || (historyStat.mode & 63) !== 0)
       throw new Error("RECEIPT_HISTORY_NOT_PRIVATE");
-    const historyPath = join66(historyRoot, `${value.id}-${String(prior.state)}-${randomUUID10()}.json`);
+    const historyPath = join66(historyRoot, `${value.id}-${String(prior.state)}-${randomUUID11()}.json`);
     writeFileSync24(historyPath, priorBytes, { flag: "wx", mode: 256 });
     chmodSync4(historyPath, 256);
     if (!readFileSync43(historyPath).equals(priorBytes))
@@ -117012,10 +117237,10 @@ function persistAliasReceipt(path, value) {
     const history = join66(dirname40(path), "history");
     if (!entryExists(history))
       mkdirSync27(history, { mode: 448 });
-    const historyStat = lstatSync39(history);
+    const historyStat = lstatSync40(history);
     if (!historyStat.isDirectory() || historyStat.isSymbolicLink() || (historyStat.mode & 63) !== 0)
       throw new Error("ALIAS_RECEIPT_HISTORY_UNSAFE");
-    const saved = join66(history, `${value.id}-${String(prior.state)}-${randomUUID10()}.json`);
+    const saved = join66(history, `${value.id}-${String(prior.state)}-${randomUUID11()}.json`);
     writeFileSync24(saved, priorBytes, { flag: "wx", mode: 256 });
     chmodSync4(saved, 256);
     if (!readFileSync43(saved).equals(priorBytes))
@@ -117026,7 +117251,7 @@ function persistAliasReceipt(path, value) {
 function assertOwnedSafePath(path, home, requireWritable = false) {
   assertNoSymlinkAncestors(path);
   for (let current = path;; current = dirname40(current)) {
-    const stat3 = lstatSync39(current);
+    const stat3 = lstatSync40(current);
     if (!stat3.isDirectory() || ![0, process.getuid?.() ?? -1].includes(stat3.uid) || stat3.mode & 18)
       throw new Error("ALIAS_PATH_UNSAFE");
     if (current === path && requireWritable && (stat3.uid !== (process.getuid?.() ?? -1) || (stat3.mode & 128) === 0))
@@ -117074,7 +117299,7 @@ function inspectAliasPackageChain(home, aliasPath, oldLinkTarget, oldTarget, bin
   assertOwnedSafePath(dirname40(packageLinkPath), home);
   let stat3, packageLinkTarget, resolved;
   try {
-    stat3 = lstatSync39(packageLinkPath);
+    stat3 = lstatSync40(packageLinkPath);
     packageLinkTarget = readlinkSync8(packageLinkPath);
     resolved = realpathSync19(packageLinkPath);
   } catch {
@@ -117097,7 +117322,7 @@ function validateAliasSource(home, name, actual) {
   }
   assertOwnedSafePath(packageRoot, home);
   const manifestPath = join66(packageRoot, "package.json");
-  const manifestStat = lstatSync39(manifestPath), binaryStat = lstatSync39(actual);
+  const manifestStat = lstatSync40(manifestPath), binaryStat = lstatSync40(actual);
   if (!manifestStat.isFile() || manifestStat.isSymbolicLink() || !binaryStat.isFile() || binaryStat.isSymbolicLink() || ![0, process.getuid?.() ?? -1].includes(manifestStat.uid) || ![0, process.getuid?.() ?? -1].includes(binaryStat.uid) || manifestStat.mode & 18)
     throw new Error("ALIAS_SOURCE_UNSAFE");
   const pkg = readPackage(manifestPath);
@@ -117113,7 +117338,7 @@ function adoptCopyfileAliases(options = {}) {
   const launcherRuntime = pinnedLauncherRuntime();
   pinnedLauncherState(launcherRuntime, currentRuntime, join66(layout.currentPackageRoot, layout.bin.skills ?? "bin/index.js"));
   const releaseLock = acquireRuntimeLock(layout.runtimeRoot);
-  const id2 = randomUUID10();
+  const id2 = randomUUID11();
   const aliases = [];
   const receiptDir = join66(currentRuntime, "alias-adoptions");
   const receiptPath = join66(receiptDir, `${id2}.json`);
@@ -117130,7 +117355,7 @@ function adoptCopyfileAliases(options = {}) {
         if (!entryExists(path))
           continue;
         assertOwnedSafePath(dir, home, true);
-        const stat3 = lstatSync39(path);
+        const stat3 = lstatSync40(path);
         if (stat3.uid !== (process.getuid?.() ?? -1))
           throw new Error("ALIAS_LINK_NOT_OWNED");
         let launcher;
@@ -117169,7 +117394,7 @@ function adoptCopyfileAliases(options = {}) {
     if (!aliases.length)
       return { adopted: true, version: layout.currentVersion, aliasCount: 0 };
     mkdirSync27(receiptDir, { recursive: true, mode: 448 });
-    const receiptDirStat = lstatSync39(receiptDir);
+    const receiptDirStat = lstatSync40(receiptDir);
     if (!receiptDirStat.isDirectory() || receiptDirStat.isSymbolicLink() || receiptDirStat.mode & 63)
       throw new Error("ALIAS_RECEIPT_DIRECTORY_UNSAFE");
     receipt = {
@@ -117234,9 +117459,9 @@ function adoptCopyfileAliases(options = {}) {
           if (entryExists(after2))
             throw new Error("ALIAS_AFTER_COLLISION");
           materializeLauncher(after2, newLauncherState(item));
-          const temp = `${item.path}.skills-alias-rollback-${randomUUID10()}`;
+          const temp = `${item.path}.skills-alias-rollback-${randomUUID11()}`;
           materializeLauncher(temp, oldLauncherState(item));
-          renameSync14(temp, item.path);
+          renameSync15(temp, item.path);
           if (!launcherIs(item.path, oldLauncherState(item)))
             throw new Error("ALIAS_ROLLBACK_READBACK_MISMATCH");
           receipt.rollbackCompletedAliases = [...receipt.rollbackCompletedAliases, item.path];
@@ -117287,7 +117512,7 @@ function rollbackCopyfileAliases(receiptId, options = {}) {
       const source = validateAliasSource(home, name, item.oldTarget);
       if (source.version !== item.oldVersion || source.binarySha256 !== item.oldBinarySha256)
         throw new Error("ALIAS_PREIMAGE_DRIFT");
-      const stat3 = lstatSync39(item.path);
+      const stat3 = lstatSync40(item.path);
       if (stat3.uid !== (process.getuid?.() ?? -1))
         throw new Error("ALIAS_LINK_DRIFT");
       let current;
@@ -117322,9 +117547,9 @@ function rollbackCopyfileAliases(receiptId, options = {}) {
         throw new Error("ALIAS_AFTER_DRIFT");
       if (launcherTarget(item.path) !== item.newTarget)
         throw new Error("ALIAS_TARGET_DRIFT");
-      const temp = `${item.path}.skills-alias-rollback-${randomUUID10()}`;
+      const temp = `${item.path}.skills-alias-rollback-${randomUUID11()}`;
       materializeLauncher(temp, oldLauncherState(item));
-      renameSync14(temp, item.path);
+      renameSync15(temp, item.path);
       if (!launcherIs(item.path, oldLauncherState(item)))
         throw new Error("ALIAS_ROLLBACK_READBACK_MISMATCH");
       receipt.rollbackCompletedAliases = [...new Set([...receipt.rollbackCompletedAliases, item.path])];
@@ -117353,10 +117578,10 @@ async function updateCopyfileRuntime(version2, options = {}) {
       throw new Error("REVIEWED_LOCK_INPUT_PAIR_REQUIRED");
     if (!policy)
       throw new Error("REVIEWED_LOCK_RELEASE_AGE_REQUIRED");
-    if (!isAbsolute37(options.reviewedLock))
+    if (!isAbsolute39(options.reviewedLock))
       throw new Error("REVIEWED_LOCK_ABSOLUTE_PATH_REQUIRED");
     assertNoSymlinkAncestors(dirname40(options.reviewedLock));
-    const stat3 = lstatSync39(options.reviewedLock);
+    const stat3 = lstatSync40(options.reviewedLock);
     if (!stat3.isFile() || stat3.isSymbolicLink() || stat3.nlink !== 1 || stat3.uid !== process.getuid?.() || stat3.mode & 63 || stat3.size > 8 * 1024 * 1024)
       throw new Error("REVIEWED_LOCK_FILE_UNSAFE");
     reviewedLockBytes = readFileSync43(options.reviewedLock);
@@ -117377,10 +117602,10 @@ async function updateCopyfileRuntime(version2, options = {}) {
     throw new Error("REGISTRY_ORIGIN_INVALID");
   if (origin.username || origin.password || origin.search || origin.hash)
     throw new Error("REGISTRY_ORIGIN_INVALID");
-  const runtimeRootStat = lstatSync39(layout.runtimeRoot);
+  const runtimeRootStat = lstatSync40(layout.runtimeRoot);
   if ((runtimeRootStat.mode & 63) !== 0)
     throw new Error("RUNTIME_ROOT_NOT_PRIVATE");
-  const id2 = randomUUID10();
+  const id2 = randomUUID11();
   const stagePath = join66(layout.runtimeRoot, `.stage-${version2}-${id2}`);
   const finalPath = join66(layout.runtimeRoot, `${version2}-copyfile`);
   const launcherRuntime = pinnedLauncherRuntime();
@@ -117493,7 +117718,7 @@ async function updateCopyfileRuntime(version2, options = {}) {
     persistReceipt(join66(stagePath, "rollout-receipt.json"), receipt);
     const finalNodeModules = join66(stagePackage, "node_modules");
     const stagedNodeModules = join66(stagePath, "node_modules");
-    renameSync14(finalNodeModules, stagedNodeModules);
+    renameSync15(finalNodeModules, stagedNodeModules);
     copyFileSync(join66(stagePackage, "package-lock.json"), join66(stagePath, "install-lock.json"));
     chmodSync4(join66(stagePath, "install-lock.json"), 384);
     const stagedTree = readTree(stagedNodeModules, true);
@@ -117502,7 +117727,7 @@ async function updateCopyfileRuntime(version2, options = {}) {
     receipt.targetPackageRoot = join66(finalPath, "node_modules", "@hasna", "skills");
     receipt.runtimeTreeSha256 = stagedTree.digest;
     persistReceipt(join66(stagePath, "rollout-receipt.json"), receipt);
-    renameSync14(stagePath, finalPath);
+    renameSync15(stagePath, finalPath);
     moved = true;
     const finalReceiptBytes = Buffer.from(`${JSON.stringify(receipt, null, 2)}
 `);
@@ -117540,7 +117765,7 @@ async function updateCopyfileRuntime(version2, options = {}) {
             throw new Error("ROLLBACK_PRESERVATION_PATH_EXISTS");
           materializeLauncher(afterPath, newLauncherState(item));
           materializeLauncher(temp, oldLauncherState(item));
-          renameSync14(temp, item.path);
+          renameSync15(temp, item.path);
         } catch {
           rollbackFailed = true;
         }
@@ -117568,7 +117793,7 @@ function rollbackCopyfileRuntime(receiptId, options = {}) {
     throw new Error("HOME_NOT_FOUND");
   const runtimeRoot = join66(realpathSync19(home), ".hasna", "skills", "runtime");
   assertNoSymlinkAncestors(runtimeRoot);
-  const rootStat = lstatSync39(runtimeRoot);
+  const rootStat = lstatSync40(runtimeRoot);
   if (!rootStat.isDirectory() || rootStat.isSymbolicLink() || (rootStat.mode & 63) !== 0)
     throw new Error("RUNTIME_ROOT_NOT_PRIVATE");
   const releaseLock = acquireRuntimeLock(runtimeRoot);
@@ -117609,7 +117834,7 @@ function rollbackCopyfileRuntime(receiptId, options = {}) {
     const seen = new Set;
     for (const item of receipt.launchers) {
       const bin = oldBins[basename21(item.path)];
-      if (!bin || !isAbsolute37(item.path) || seen.has(item.path) || item.oldTarget !== join66(receipt.currentPackageRoot, bin) || item.newTarget !== join66(receipt.targetPackageRoot, bin) || !/^.+\.skills-prev-[0-9a-f-]{36}$/.test(item.backupPath) || !item.backupPath.startsWith(`${item.path}.skills-prev-`) || typeof item.oldLinkTarget !== "string" || resolve36(dirname40(item.path), item.oldLinkTarget) !== item.oldTarget)
+      if (!bin || !isAbsolute39(item.path) || seen.has(item.path) || item.oldTarget !== join66(receipt.currentPackageRoot, bin) || item.newTarget !== join66(receipt.targetPackageRoot, bin) || !/^.+\.skills-prev-[0-9a-f-]{36}$/.test(item.backupPath) || !item.backupPath.startsWith(`${item.path}.skills-prev-`) || typeof item.oldLinkTarget !== "string" || resolve36(dirname40(item.path), item.oldLinkTarget) !== item.oldTarget)
         throw new Error("RECEIPT_LAUNCHER_BINDING_INVALID");
       assertNoSymlinkAncestors(dirname40(item.path));
       assertLauncherRecordShapes(item, launcherProfileForBin(basename21(item.path), bin));
@@ -117641,9 +117866,9 @@ function rollbackCopyfileRuntime(receiptId, options = {}) {
       const afterPath = `${item.path}.skills-after-${receiptId}`;
       if (!entryExists(afterPath))
         materializeLauncher(afterPath, newLauncherState(item));
-      const temp = `${item.path}.skills-rollback-${receiptId}-${randomUUID10()}`;
+      const temp = `${item.path}.skills-rollback-${receiptId}-${randomUUID11()}`;
       materializeLauncher(temp, oldLauncherState(item));
-      renameSync14(temp, item.path);
+      renameSync15(temp, item.path);
       receipt.rollbackCompletedLaunchers = [...new Set([...receipt.rollbackCompletedLaunchers, item.path])];
       persistReceipt(receiptPath, receipt);
     }
@@ -117676,9 +117901,9 @@ __export(exports_runtime, {
   selectedSkillsCommand: () => selectedSkillsCommand,
   registerRuntime: () => registerRuntime
 });
-import { createHash as createHash41, randomUUID as randomUUID11 } from "crypto";
-import { lstatSync as lstatSync40, mkdirSync as mkdirSync28, readFileSync as readFileSync44, writeFileSync as writeFileSync25 } from "fs";
-import { basename as basename22, isAbsolute as isAbsolute38, join as join67 } from "path";
+import { createHash as createHash41, randomUUID as randomUUID12 } from "crypto";
+import { lstatSync as lstatSync41, mkdirSync as mkdirSync28, readFileSync as readFileSync44, writeFileSync as writeFileSync25 } from "fs";
+import { basename as basename22, isAbsolute as isAbsolute40, join as join67 } from "path";
 import { createInterface } from "readline";
 function registerRuntime(parent) {
   parent.command("run").argument("<skill>", "Skill name").argument("[args...]", "Arguments to pass to the skill; use -- to end Skills options").allowUnknownOption(true).passThroughOptions(true).option("--json", "Output result as JSON", false).option("--remote", "Run on the configured server, using its catalog and quote", false).option("--target <target>", "Execution target: local or cloud").option("--secret-bindings <path>", "Reviewed, exact-selection local execution vault bindings (JSON file)").option("--secret-bindings-template", "Print a scoped bindings template without resolving secrets or running the skill", false).option("--input <json>", "Structured cloud execution input").option("--skill-version <version>", "Exact selected skill version").option("--selection-profile <id>", "Selected Skills profile").option("--session <id>", "Pinned Skills session").option("--cached", "Use the explicit verified selected cache", false).option("--yes", "Approve the server's quoted credit cost for this run", false).option("--idempotency-key <key>", "Reuse this key when retrying the same remote submission").option("--file <path>", "Attach a local input file to a remote run (repeatable)", (value, prior) => [...prior, value], []).option("--wait", "Poll remote runs until a terminal status", false).option("--poll-interval-ms <ms>", "Remote polling interval in milliseconds", "1000").option("--poll-timeout-ms <ms>", "Maximum time to wait for a remote run", "300000").description("Run a skill directly").action(async (name, args2, options, command) => {
@@ -117746,7 +117971,11 @@ function registerRuntime(parent) {
     await handleMcp(options);
   }));
   const setup = parent.command("setup").description("Point this CLI at a Skills API server, or register agent integrations").option("--api-url <url>", "Skills API origin to send remote work to").option("--global", "Accepted for compatibility; the API origin is always per-user", false).option("--json", "Output setup result as JSON", false).action(async (options) => handleSetup(options));
-  setup.command("agents").option("--json", "Output registration result as JSON", false).description("Register the Skills MCP server with all supported agents").action(async (options) => handleMcp({ register: "all", json: options.json }));
+  setup.command("agents").option("--json", "Output registration result as JSON", false).description("Register the Skills MCP server with all supported agents").action(async (options, command) => handleMcp({
+    register: "all",
+    json: options.json,
+    apiUrl: command.parent?.opts().apiUrl
+  }));
   parent.command("self-update").description("Update @hasna/skills to the latest version").option("--json", "Output result as JSON", false).option("--version <version>", "Install this exact @hasna/skills version as a staged copyfile runtime").option("--min-release-age <days>", "Require a positive integer dependency release age in days for an exact-version update").option("--min-release-age-exclude <pattern>", "Exclude matching package identities from the release-age policy (repeatable)", (pattern, prior) => [...prior, pattern], []).option("--reviewed-lock <path>", "Install from this private absolute package-lock.json path without resolving dependency ranges").option("--reviewed-lock-sha256 <sha256>", "Exact reviewed SHA-256 of the supplied package-lock.json").option("--rollback <receipt-id>", "Restore launcher links from an exact copyfile rollout receipt").option("--adopt-aliases", "Switch verified legacy @hasna/skills aliases to the active copyfile runtime").option("--rollback-aliases <receipt-id>", "Restore aliases from an exact adoption receipt").action(async (options) => {
     if ((options.reviewedLock !== undefined || options.reviewedLockSha256 !== undefined) && (!options.version || options.rollback || options.adoptAliases || options.rollbackAliases)) {
       console.error(JSON.stringify({ error: "REVIEWED_LOCK_REQUIRES_EXACT_VERSION" }));
@@ -117877,7 +118106,7 @@ Updating ${name}...
 async function readUpdatedVersion(bunExecutable) {
   const output2 = await readUpdateCommand([bunExecutable, "pm", "bin", "-g"]);
   const globalBin = output2.replace(/\r?\n$/, "");
-  if (!globalBin || !isAbsolute38(globalBin) || /[\r\n\0]/.test(globalBin))
+  if (!globalBin || !isAbsolute40(globalBin) || /[\r\n\0]/.test(globalBin))
     throw new Error("Update bin discovery failed");
   const installed = Bun.which("skills", { PATH: globalBin, cwd: globalBin });
   const selected = Bun.which("skills");
@@ -118156,7 +118385,7 @@ async function handleRun(name, args2, options, separatorBeforeSkill) {
       if (!Number.isFinite(timeoutMs) || timeoutMs < 1 || timeoutMs > 1200000 || !Number.isFinite(intervalMs) || intervalMs < 100 || intervalMs > 60000)
         throw new Error("Invalid cloud polling bounds");
       const client3 = await CloudExecutionClient.configured();
-      const admitted = await client3.submit(slug2, version2, input2, options.idempotencyKey ?? randomUUID11(), selected?.selection);
+      const admitted = await client3.submit(slug2, version2, input2, options.idempotencyKey ?? randomUUID12(), selected?.selection);
       if (options.wait)
         console.error(JSON.stringify({ executionId: admitted.id, status: admitted.status }));
       const result3 = options.wait ? await client3.wait(admitted.id, { timeoutMs, intervalMs }) : admitted;
@@ -118213,7 +118442,7 @@ async function handleRun(name, args2, options, separatorBeforeSkill) {
     try {
       parsePollingOptions(options);
       inputFiles = (options.file ?? []).map((path) => {
-        const info = lstatSync40(path);
+        const info = lstatSync41(path);
         if (!info.isFile() || info.size > 20 * 1024 * 1024)
           throw new Error("Input must be a regular file no larger than 20 MiB");
         return { name: basename22(path), bytes: new Uint8Array(readFileSync44(path)) };
@@ -118643,7 +118872,7 @@ function ensureSafeExportParent(root2, relativePath) {
     if (part)
       parent = join67(parent, part);
     try {
-      if (!lstatSync40(parent).isDirectory() || lstatSync40(parent).isSymbolicLink())
+      if (!lstatSync41(parent).isDirectory() || lstatSync41(parent).isSymbolicLink())
         throw new Error("Unsafe artifact directory");
     } catch (error61) {
       if (error61.code !== "ENOENT")
@@ -118938,7 +119167,7 @@ var exports_recurring = {};
 __export(exports_recurring, {
   registerRecurringCommands: () => registerRecurringCommands
 });
-import { constants as constants28, closeSync as closeSync29, fstatSync as fstatSync29, lstatSync as lstatSync41, openSync as openSync29, readSync as readSync21 } from "fs";
+import { constants as constants28, closeSync as closeSync29, fstatSync as fstatSync29, lstatSync as lstatSync42, openSync as openSync29, readSync as readSync21 } from "fs";
 import { createInterface as createInterface2 } from "readline";
 function readRequest(path) {
   const fd = openSync29(path, constants28.O_RDONLY | constants28.O_NOFOLLOW | constants28.O_NONBLOCK);
@@ -118954,7 +119183,7 @@ function readRequest(path) {
         break;
       length += n2;
     }
-    const after2 = fstatSync29(fd), current = lstatSync41(path);
+    const after2 = fstatSync29(fd), current = lstatSync42(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)));
@@ -119238,7 +119467,7 @@ var init_completion = __esm(() => {
 });
 
 // src/lib/portable-snapshot-filter.ts
-import { readdirSync as readdirSync25, statSync as statSync22 } from "fs";
+import { readdirSync as readdirSync25, statSync as statSync23 } from "fs";
 import { homedir as homedir11 } from "os";
 import { join as join68, sep as sep19 } from "path";
 function isExcludedSkillFileName(fileName) {
@@ -119306,7 +119535,7 @@ function walkEntries(absoluteRoot) {
 }
 function isRegularFile(filePath) {
   try {
-    return statSync22(filePath).isFile();
+    return statSync23(filePath).isFile();
   } catch {
     return false;
   }
@@ -119392,10 +119621,10 @@ import {
   copyFileSync as copyFileSync2,
   mkdirSync as mkdirSync29,
   readFileSync as readFileSync45,
-  statSync as statSync23,
+  statSync as statSync24,
   writeFileSync as writeFileSync26
 } from "fs";
-import { dirname as dirname42, isAbsolute as isAbsolute39, relative as relative14, resolve as resolve37, sep as sep20 } from "path";
+import { dirname as dirname42, isAbsolute as isAbsolute41, relative as relative14, resolve as resolve37, sep as sep20 } from "path";
 function validateStationId(stationId) {
   if (!/^[a-z0-9-]+$/.test(stationId)) {
     throw new StationSnapshotError("INVALID_STATION", `station id must be a slug, got: ${stationId}`);
@@ -119432,7 +119661,7 @@ function scanHome(definition, homesRoot) {
       skipped.push({ relativePath: entry.relativePath, reason: "not-regular-file" });
       continue;
     }
-    const info = statSync23(entry.fullPath);
+    const info = statSync24(entry.fullPath);
     portable.push({
       relativePath: entry.relativePath,
       fullPath: entry.fullPath,
@@ -119501,7 +119730,7 @@ function writeStationSnapshot(options) {
   for (const plan of plans) {
     const destination = resolve37(repoRoot, plan.destination);
     const destinationRelative = relative14(repoRoot, destination);
-    if (destinationRelative.startsWith("..") || destinationRelative.startsWith(sep20) || isAbsolute39(destinationRelative)) {
+    if (destinationRelative.startsWith("..") || destinationRelative.startsWith(sep20) || isAbsolute41(destinationRelative)) {
       throw new StationSnapshotError("DESTINATION_ESCAPE", `destination escapes repo root: ${plan.destination}`);
     }
     let existingDigest = null;
@@ -119974,7 +120203,7 @@ var init_create_sync_config = __esm(() => {
 });
 
 // src/lib/agent-install-selection.ts
-import { lstatSync as lstatSync42 } from "fs";
+import { lstatSync as lstatSync43 } from "fs";
 import { dirname as dirname43, join as join70, resolve as resolve38 } from "path";
 import { homedir as homedir12 } from "os";
 function detectedIntegrationAgents(options = {}) {
@@ -119988,7 +120217,7 @@ function detectedIntegrationAgents(options = {}) {
     throw new Error("Invalid existing bridge agent inventory");
   const present2 = (path) => {
     try {
-      return lstatSync42(path, { throwIfNoEntry: false }) !== undefined;
+      return lstatSync43(path, { throwIfNoEntry: false }) !== undefined;
     } catch {
       throw new Error("Agent presence cannot be inspected; review native configuration before hook installation");
     }
@@ -120018,7 +120247,7 @@ var init_agent_install_selection = __esm(() => {
 });
 
 // src/lib/codex-native-config.ts
-import { isDeepStrictEqual as isDeepStrictEqual16 } from "util";
+import { isDeepStrictEqual as isDeepStrictEqual17 } from "util";
 function isRecord8(value) {
   if (!value || typeof value !== "object")
     return false;
@@ -120040,7 +120269,7 @@ function decimalIdentity(text4) {
   return `${match[1]}${coefficient}e${exponent}`;
 }
 function codexNativeConfigEqual(native, expected) {
-  if (isDeepStrictEqual16(native, expected))
+  if (isDeepStrictEqual17(native, expected))
     return true;
   if (typeof expected === "number") {
     if (!Number.isFinite(expected) || !isRecord8(native))
@@ -120064,11 +120293,11 @@ var NUMBER_TAG = "$serde_json::private::Number";
 var init_codex_native_config = () => {};
 
 // src/lib/codex-hook-trust-identity.ts
-import { lstatSync as lstatSync43, realpathSync as realpathSync20 } from "fs";
-import { dirname as dirname44, isAbsolute as isAbsolute40, join as join71, resolve as resolve39 } from "path";
-import { isDeepStrictEqual as isDeepStrictEqual17 } from "util";
+import { lstatSync as lstatSync44, realpathSync as realpathSync20 } from "fs";
+import { dirname as dirname44, isAbsolute as isAbsolute42, join as join71, resolve as resolve39 } from "path";
+import { isDeepStrictEqual as isDeepStrictEqual18 } from "util";
 function commandPhysical(command) {
-  need8(typeof command === "string" && isAbsolute40(command) && !command.includes("\x00") && resolve39(command) === command, COMMAND_NOT_CANONICAL);
+  need8(typeof command === "string" && isAbsolute42(command) && !command.includes("\x00") && resolve39(command) === command, COMMAND_NOT_CANONICAL);
   const physical = realpathSync20(command);
   let spelled;
   try {
@@ -120079,7 +120308,7 @@ function commandPhysical(command) {
   safeParents(spelled);
   let direct = false;
   try {
-    const leaf = lstatSync43(spelled);
+    const leaf = lstatSync44(spelled);
     direct = leaf.isSymbolicLink() ? trustedAncestorOwner(leaf.uid) && directAliasTarget(spelled) === physical : spelled === physical;
   } catch {}
   need8(direct, COMMAND_ALIAS_UNSAFE);
@@ -120123,7 +120352,7 @@ function targetUnchanged(command, target) {
     assertPinnedRuntime(target.runtime);
 }
 function inspectRecordedSkillsCli(command, expected) {
-  need8(isAbsolute40(command) && !command.includes("\x00"), "RECONCILE_RECORDED_COMMAND_REQUIRED");
+  need8(isAbsolute42(command) && !command.includes("\x00"), "RECONCILE_RECORDED_COMMAND_REQUIRED");
   const target = skillsCommandTarget(command), resolved = target.entry;
   const cli = snapshot(resolved, false, { readOnlyPackage: true });
   const manifest = snapshot(join71(dirname44(dirname44(resolved)), "package.json"), false, { readOnlyPackage: true });
@@ -120131,7 +120360,7 @@ function inspectRecordedSkillsCli(command, expected) {
   need8(pkg.name === "@hasna/skills" && /^\d+\.\d+\.\d+$/.test(pkg.version) && pkg.bin?.skills === "bin/index.js" && resolved === join71(dirname44(manifest.file), "bin/index.js"), "SKILLS_PACKAGE_MISMATCH");
   need8((cli.stat.mode & 0o100n) !== 0n, "SKILLS_COMMAND_NOT_EXECUTABLE");
   const receipt = { path: resolved, version: pkg.version, sha256: cli.sha256, manifestSha256: manifest.sha256 };
-  need8(isDeepStrictEqual17(receipt, expected), "RECONCILE_SKILLS_BINDING_CHANGED");
+  need8(isDeepStrictEqual18(receipt, expected), "RECONCILE_SKILLS_BINDING_CHANGED");
   return { receipt, recheck() {
     targetUnchanged(command, target);
     unchanged2(cli);
@@ -120142,7 +120371,7 @@ function bindSkillsCli(command, reviewed) {
   const normal = Bun.which("skills", { PATH: process.env.PATH });
   need8(normal, "SKILLS_COMMAND_UNAVAILABLE");
   const normalTarget = skillsCommandTarget(normal), resolved = normalTarget.entry;
-  const bound = isAbsolute40(command) ? command : command === "skills" ? normal : undefined;
+  const bound = isAbsolute42(command) ? command : command === "skills" ? normal : undefined;
   need8(bound, "SKILLS_COMMAND_MISMATCH");
   const boundTarget = skillsCommandTarget(bound);
   need8(boundTarget.entry === resolved, "SKILLS_COMMAND_MISMATCH");
@@ -120201,19 +120430,19 @@ var init_codex_hook_trust_identity = __esm(() => {
 });
 
 // src/lib/codex-hook-policy-recovery.ts
-import { isDeepStrictEqual as isDeepStrictEqual18 } from "util";
+import { isDeepStrictEqual as isDeepStrictEqual19 } from "util";
 function reviewedClaudeDiscoveryChange(beforeText, currentText, options) {
   need8(typeof options.reason === "string" && options.reason.trim().length > 0 && options.reason.length <= 512 && !/[\x00-\x1f\x7f]/.test(options.reason), "RECONCILE_RECOVERY_REASON_REQUIRED");
   need8(options.reviewedPlanDigest === undefined || /^[a-f0-9]{64}$/.test(options.reviewedPlanDigest), "RECONCILE_RECOVERY_PLAN_CHANGED");
   const before2 = parseManagedSkillPolicy(beforeText), current = parseManagedSkillPolicy(currentText);
   const oldDiscovery = before2.bridge?.discovery?.claude, newDiscovery = current.bridge?.discovery?.claude;
   need8(oldDiscovery?.agent === "claude" && newDiscovery?.agent === "claude" && oldDiscovery.method === "reviewed" && newDiscovery.method === "reviewed", "RECONCILE_POLICY_CHANGED");
-  const changes = ["roots", "sources"].filter((key2) => !isDeepStrictEqual18(oldDiscovery[key2], newDiscovery[key2])).map((key2) => ({ path: `bridge.discovery.claude.${key2}`, before: oldDiscovery[key2], after: newDiscovery[key2] }));
+  const changes = ["roots", "sources"].filter((key2) => !isDeepStrictEqual19(oldDiscovery[key2], newDiscovery[key2])).map((key2) => ({ path: `bridge.discovery.claude.${key2}`, before: oldDiscovery[key2], after: newDiscovery[key2] }));
   need8(changes.length > 0, "RECONCILE_POLICY_CHANGED");
   const compared = structuredClone(current);
   compared.bridge.discovery.claude.roots = oldDiscovery.roots;
   compared.bridge.discovery.claude.sources = oldDiscovery.sources;
-  need8(isDeepStrictEqual18(before2, compared), "RECONCILE_POLICY_CHANGED");
+  need8(isDeepStrictEqual19(before2, compared), "RECONCILE_POLICY_CHANGED");
   verifyAgentDiscovery(newDiscovery);
   return { reason: options.reason, changes };
 }
@@ -120224,16 +120453,16 @@ var init_codex_hook_policy_recovery = __esm(() => {
 });
 
 // src/lib/agent-codex-trust.ts
-import { lstatSync as lstatSync44, mkdirSync as mkdirSync30, readdirSync as readdirSync26, readFileSync as readFileSync46, realpathSync as realpathSync21, statSync as statSync24 } from "fs";
-import { createHash as createHash43, randomUUID as randomUUID12 } from "crypto";
+import { lstatSync as lstatSync45, mkdirSync as mkdirSync30, readdirSync as readdirSync26, readFileSync as readFileSync46, realpathSync as realpathSync21, statSync as statSync25 } from "fs";
+import { createHash as createHash43, randomUUID as randomUUID13 } from "crypto";
 import { execFileSync as execFileSync2 } from "child_process";
-import { dirname as dirname45, isAbsolute as isAbsolute41, join as join72, resolve as resolve40 } from "path";
+import { dirname as dirname45, isAbsolute as isAbsolute43, join as join72, resolve as resolve40 } from "path";
 import { homedir as homedir13 } from "os";
-import { isDeepStrictEqual as isDeepStrictEqual19 } from "util";
+import { isDeepStrictEqual as isDeepStrictEqual20 } from "util";
 function verifyReleaseArtifact(proof, skillsCli) {
-  need8(isAbsolute41(proof.packageTarPath) && !proof.packageTarPath.includes("\x00"), "RECONCILE_RELEASE_PROVENANCE_PATH");
+  need8(isAbsolute43(proof.packageTarPath) && !proof.packageTarPath.includes("\x00"), "RECONCILE_RELEASE_PROVENANCE_PATH");
   const tarPath = realpathSync21(proof.packageTarPath);
-  need8(statSync24(tarPath).isFile(), "RECONCILE_RELEASE_PROVENANCE_PATH");
+  need8(statSync25(tarPath).isFile(), "RECONCILE_RELEASE_PROVENANCE_PATH");
   const tarBytes = readFileSync46(tarPath);
   need8(tarBytes.byteLength === proof.packageTarBytes && createHash43("sha256").update(tarBytes).digest("hex") === proof.packageTarSha256, "RECONCILE_RELEASE_ARTIFACT_CHANGED");
   const packageRoot = dirname45(dirname45(realpathSync21(skillsCli.receipt.path)));
@@ -120257,10 +120486,10 @@ async function reconcileCodexNativeHooks(options, connect = connectCodexHookRpc)
     const home = resolve40(options.home ?? homedir13()), dataDir3 = resolve40(options.dataDir ?? getDataDirReadOnly());
     const parent = resolve40(join72(dataDir3, "native-hook-trust")), journal = resolve40(options.journal);
     need8(journal.startsWith(parent + "/") && /^[a-f0-9-]{36}$/.test(journal.slice(parent.length + 1)), "RECONCILE_JOURNAL_PATH");
-    const dir = lstatSync44(journal, { throwIfNoEntry: false });
+    const dir = lstatSync45(journal, { throwIfNoEntry: false });
     need8(!!dir && dir.isDirectory() && !dir.isSymbolicLink() && dir.uid === process.getuid() && (dir.mode & 511) === 448, "UNSAFE_JOURNAL");
-    need8(!lstatSync44(join72(journal, "receipt.json"), { throwIfNoEntry: false }), "RECONCILE_ALREADY_COMPLETE");
-    need8(lstatSync44(join72(journal, "stopped.json"), { throwIfNoEntry: false })?.isFile(), "RECONCILE_JOURNAL_INCOMPLETE");
+    need8(!lstatSync45(join72(journal, "receipt.json"), { throwIfNoEntry: false }), "RECONCILE_ALREADY_COMPLETE");
+    need8(lstatSync45(join72(journal, "stopped.json"), { throwIfNoEntry: false })?.isFile(), "RECONCILE_JOURNAL_INCOMPLETE");
     const stoppedFile = snapshot(join72(journal, "stopped.json"), true);
     const intentFile = snapshot(join72(journal, "intent.json"), true), intent = JSON.parse(intentFile.text);
     const configBefore = snapshot(join72(journal, "config.before.toml"), true), hooksBefore = snapshot(join72(journal, "hooks.before.json"), true), policyBefore = snapshot(join72(journal, "policy.before.json"), true);
@@ -120271,7 +120500,7 @@ async function reconcileCodexNativeHooks(options, connect = connectCodexHookRpc)
     const configSha256 = intent.configSha256 ?? configBefore.sha256, configVersion = intent.configVersion ?? intent.expectedVersion;
     const digestInput = { version: 1, home: intent.home ?? home, configPath: intent.configPath, ...intent.nativeConfigPath !== undefined ? { nativeConfigPath: intent.nativeConfigPath } : {}, configSha256, configVersion, policySha256: intent.policySha256, hooksSha256: intent.hooksSha256, skillsCli: intent.skillsCli, nativeVersion: intent.nativeVersion, declarations, admitted };
     need8(makePlanDigest(digestInput) === intent.planDigest, "RECONCILE_PLAN_CHANGED");
-    need8(isDeepStrictEqual19(intent.hooks, admitted.filter((hook) => !hook.enabled || hook.trustStatus !== "trusted")), "RECONCILE_INTENT_HOOKS_CHANGED");
+    need8(isDeepStrictEqual20(intent.hooks, admitted.filter((hook) => !hook.enabled || hook.trustStatus !== "trusted")), "RECONCILE_INTENT_HOOKS_CHANGED");
     need8(configBefore.sha256 === (intent.beforeSha256 ?? intent.configSha256) && hooksBefore.sha256 === intent.hooksSha256 && policyBefore.sha256 === intent.policySha256, "RECONCILE_JOURNAL_CHANGED");
     const policyCurrent = snapshot(join72(dataDir3, "agent-policy.json"), true);
     const { claudeDiscoveryRecovery: claudeRecovery, nativeHookAdditionsRecovery: additionsRecovery } = options;
@@ -120284,13 +120513,13 @@ async function reconcileCodexNativeHooks(options, connect = connectCodexHookRpc)
     if (policyCurrent.sha256 !== policyBefore.sha256 && !claudeRecovery) {
       need8(options.supersedeBinding === true, "RECONCILE_POLICY_CHANGED");
       const oldPolicy = JSON.parse(policyBefore.text), currentPolicy = JSON.parse(policyCurrent.text);
-      need8(isDeepStrictEqual19(withoutCodexCommand(oldPolicy), withoutCodexCommand(currentPolicy)), "RECONCILE_POLICY_CHANGED");
+      need8(isDeepStrictEqual20(withoutCodexCommand(oldPolicy), withoutCodexCommand(currentPolicy)), "RECONCILE_POLICY_CHANGED");
       supersededBinding = true;
     }
     if (supersededBinding || recovery) {
       need8(Array.isArray(intent.nativeHooks) && intent.nativeHooks.length > 0, "RECONCILE_NATIVE_INVENTORY_REQUIRED");
       const proof = options.releaseProof;
-      need8(!!proof && isAbsolute41(proof.packageTarPath) && /^[a-f0-9]{64}$/.test(proof.packageTarSha256) && Number.isInteger(proof.packageTarBytes) && proof.packageTarBytes > 0 && /^[a-f0-9]{64}$/.test(proof.manifestSha256) && /^[a-f0-9]{64}$/.test(proof.executableSha256), "RECONCILE_RELEASE_PROVENANCE_REQUIRED");
+      need8(!!proof && isAbsolute43(proof.packageTarPath) && /^[a-f0-9]{64}$/.test(proof.packageTarSha256) && Number.isInteger(proof.packageTarBytes) && proof.packageTarBytes > 0 && /^[a-f0-9]{64}$/.test(proof.manifestSha256) && /^[a-f0-9]{64}$/.test(proof.executableSha256), "RECONCILE_RELEASE_PROVENANCE_REQUIRED");
     }
     const currentConfig = snapshot(intent.configPath, true);
     const policy = parseManagedSkillPolicy(policyCurrent.text), binding = policy.bridge;
@@ -120320,7 +120549,7 @@ async function reconcileCodexNativeHooks(options, connect = connectCodexHookRpc)
         need8(state?.enabled === true && typeof state.trusted_hash === "string" && /^sha256:[a-f0-9]{64}$/.test(state.trusted_hash), "RECONCILE_CONFIG_DRIFT");
       }
     } else
-      need8(isDeepStrictEqual19(expectedConfig, current), "RECONCILE_CONFIG_DRIFT");
+      need8(isDeepStrictEqual20(expectedConfig, current), "RECONCILE_CONFIG_DRIFT");
     const configDiscoveryRecovery = recovery && binding.discovery?.codex ? createCodexHookDiscoveryRecovery(binding.discovery.codex, configBefore, currentConfig, intent.hooks, additions?.trustProof) : undefined;
     assertManagedAgentBridge("codex", { home, dataDir: dataDir3, projectDir: home, codexDiscoveryRecovery: configDiscoveryRecovery });
     const recoveryCli = recovery ? bindSkillsCli("skills", options.reviewedSkillsCli) : undefined;
@@ -120329,14 +120558,14 @@ async function reconcileCodexNativeHooks(options, connect = connectCodexHookRpc)
     const skillsCli = recovery ? inspectRecordedSkillsCli(binding.commands.codex, intent.skillsCli) : bindSkillsCli(binding.commands.codex, options.reviewedSkillsCli);
     if (supersededBinding)
       verifyReleaseArtifact(options.releaseProof, skillsCli);
-    const skillsBindingChanged = !isDeepStrictEqual19(skillsCli.receipt, intent.skillsCli);
+    const skillsBindingChanged = !isDeepStrictEqual20(skillsCli.receipt, intent.skillsCli);
     need8(!skillsBindingChanged || supersededBinding, "RECONCILE_SKILLS_BINDING_CHANGED");
     if (!additions && hooksCurrent.sha256 !== intent.hooksSha256 && hooksCurrent.sha256 !== hooksBefore.sha256) {
       need8(supersededBinding, "RECONCILE_HOOKS_CHANGED");
       const currentDeclarations = JSON.parse(hooksCurrent.text).hooks;
       for (const [event, [nativeEvent]] of Object.entries(eventNames)) {
         const command = renderAgentHookCommand(binding.commands.codex, "codex", binding.profiles.codex, event);
-        need8(isDeepStrictEqual19(currentDeclarations?.[event], [{ hooks: [{ type: "command", command, timeout: 15 }] }]), "RECONCILE_BINDING_HOOK_CHANGED");
+        need8(isDeepStrictEqual20(currentDeclarations?.[event], [{ hooks: [{ type: "command", command, timeout: 15 }] }]), "RECONCILE_BINDING_HOOK_CHANGED");
       }
     }
     rpc = await connect({ command: options.codexCommand ?? "codex", home, codexHome });
@@ -120359,9 +120588,9 @@ async function reconcileCodexNativeHooks(options, connect = connectCodexHookRpc)
           delete identity6.command;
         return identity6;
       };
-      need8(isDeepStrictEqual19(stable(actual), stable(expected)), "RECONCILE_NATIVE_IDENTITY_CHANGED");
+      need8(isDeepStrictEqual20(stable(actual), stable(expected)), "RECONCILE_NATIVE_IDENTITY_CHANGED");
       if (!plannedKeys.has(expected.key))
-        need8(isDeepStrictEqual19(actual, expected), "RECONCILE_UNRELATED_HOOK_CHANGED");
+        need8(isDeepStrictEqual20(actual, expected), "RECONCILE_UNRELATED_HOOK_CHANGED");
     }
     for (const wanted of intent.hooks) {
       const matches2 = nativeHooks.filter((h2) => h2.key === wanted.key || h2.key === wanted.key.replace(join72(home, ".codex/hooks.json"), hooksPath));
@@ -120380,7 +120609,7 @@ async function reconcileCodexNativeHooks(options, connect = connectCodexHookRpc)
     const layers = config2?.layers?.filter((layer) => layer.name?.type === "user" && layer.name.file === nativeConfigPath && !layer.name.profile);
     need8(layers?.length === 1 && !layers[0].disabledReason && codexNativeConfigEqual(layers[0].config, current), "RECONCILE_NATIVE_CONFIG_MISMATCH");
     const finalDiscovery = await rpc.request("hooks/list", { cwds: [home] });
-    need8(Array.isArray(finalDiscovery?.data) && finalDiscovery.data.length === 1 && finalDiscovery.data[0].cwd === home && !finalDiscovery.data[0].errors?.length && !finalDiscovery.data[0].warnings?.length && (!recordedNativeHooks || isDeepStrictEqual19(finalDiscovery.data[0].hooks.map(safeNativeHook), nativeHooks.map(safeNativeHook))), "RECONCILE_NATIVE_STATE_CHANGED");
+    need8(Array.isArray(finalDiscovery?.data) && finalDiscovery.data.length === 1 && finalDiscovery.data[0].cwd === home && !finalDiscovery.data[0].errors?.length && !finalDiscovery.data[0].warnings?.length && (!recordedNativeHooks || isDeepStrictEqual20(finalDiscovery.data[0].hooks.map(safeNativeHook), nativeHooks.map(safeNativeHook))), "RECONCILE_NATIVE_STATE_CHANGED");
     const finalConfig = await rpc.request("config/read", { includeLayers: true, cwd: home });
     const finalLayers = finalConfig?.layers?.filter((layer) => layer.name?.type === "user" && layer.name.file === nativeConfigPath && !layer.name.profile);
     need8(finalLayers?.length === 1 && !finalLayers[0].disabledReason && codexNativeConfigEqual(finalLayers[0].config, current), "RECONCILE_NATIVE_CONFIG_CHANGED");
@@ -120435,7 +120664,7 @@ async function enrollCodexNativeHooksUnlocked(options, connect, admission) {
     const binding = policy.bridge, alias = binding.rootAliases?.find((item) => item.agent === "codex");
     const skillsCli = bindSkillsCli(binding.commands.codex, options.reviewedSkillsCli);
     const physicalRoot = alias?.target ?? join72(home, ".codex"), hooksPath = join72(physicalRoot, "hooks.json"), configPath = join72(physicalRoot, "config.toml");
-    need8(options.codexHome === undefined || isAbsolute41(options.codexHome) && [join72(home, ".codex"), physicalRoot].includes(options.codexHome), "NATIVE_HOME_NOT_ADMITTED");
+    need8(options.codexHome === undefined || isAbsolute43(options.codexHome) && [join72(home, ".codex"), physicalRoot].includes(options.codexHome), "NATIVE_HOME_NOT_ADMITTED");
     const codexHome = options.codexHome === undefined ? undefined : physicalRoot;
     const nativeConfigPath = join72(codexHome ?? join72(home, ".codex"), "config.toml");
     const hooksFile = snapshot(hooksPath), configFile = snapshot(configPath, true), original = structure3(configFile.text);
@@ -120445,7 +120674,7 @@ async function enrollCodexNativeHooksUnlocked(options, connect, admission) {
       const groups = declarations[event];
       need8(Array.isArray(groups), "DECLARATION_CHANGED");
       const matches2 = groups.flatMap((group, gi) => (group.hooks ?? []).flatMap((entry, hi) => entry.command === command ? [{ group, entry, gi, hi }] : []));
-      need8(matches2.length === 1 && isDeepStrictEqual19(matches2[0].group, { hooks: [{ type: "command", command, timeout: 15 }] }), "DECLARATION_CHANGED");
+      need8(matches2.length === 1 && isDeepStrictEqual20(matches2[0].group, { hooks: [{ type: "command", command, timeout: 15 }] }), "DECLARATION_CHANGED");
       expected.push({ event: nativeEvent, key: `${join72(home, ".codex/hooks.json")}:${label}:${matches2[0].gi}:${matches2[0].hi}`, command });
     }
     codexTrustTextWitness(configFile.text, expected.map((h) => h.key));
@@ -120491,27 +120720,27 @@ async function enrollCodexNativeHooksUnlocked(options, connect, admission) {
     if (options.apply)
       need8(options.reviewedPlanDigest === planDigest, "PLAN_CHANGED: run the dry-run again and pass its reviewed --plan-digest with --apply");
     const parent = join72(dataDir3, "native-hook-trust");
-    const st = lstatSync44(parent, { throwIfNoEntry: false });
+    const st = lstatSync45(parent, { throwIfNoEntry: false });
     if (st) {
       need8(st.isDirectory() && !st.isSymbolicLink() && st.uid === process.getuid() && (st.mode & 511) === 448, "UNSAFE_JOURNAL");
       const priorJournals = readdirSync26(parent);
       need8(priorJournals.length < 1000, "JOURNAL_BOUND");
       for (const name of priorJournals) {
         need8(/^[a-f0-9-]{36}$/.test(name), "UNSAFE_JOURNAL");
-        need8(lstatSync44(join72(parent, name, "receipt.json"), { throwIfNoEntry: false })?.isFile(), "RECONCILE_REQUIRED: inspect the incomplete private journal before applying again");
+        need8(lstatSync45(join72(parent, name, "receipt.json"), { throwIfNoEntry: false })?.isFile(), "RECONCILE_REQUIRED: inspect the incomplete private journal before applying again");
       }
     }
     if (!options.apply || !planned.length)
       return baseReceipt;
     if (!st)
       mkdirSync30(parent, { mode: 448 });
-    journal = join72(parent, randomUUID12());
+    journal = join72(parent, randomUUID13());
     mkdirSync30(journal, { mode: 448 });
     save(join72(journal, "config.before.toml"), configFile.bytes);
     save(join72(journal, "hooks.before.json"), hooksFile.bytes);
     save(join72(journal, "policy.before.json"), policyFile.bytes);
     save(join72(journal, "intent.json"), json2({ ...digestInput, planDigest, hooks: planned, nativeHooks: discovered.map(safeNativeHook), ...codexAdmissionReceipt(admission) }));
-    need8(isDeepStrictEqual19(admit(await list2()), admitted), "NATIVE_DISCOVERY_CHANGED");
+    need8(isDeepStrictEqual20(admit(await list2()), admitted), "NATIVE_DISCOVERY_CHANGED");
     checkInputs();
     let result2;
     try {
@@ -120525,7 +120754,7 @@ async function enrollCodexNativeHooksUnlocked(options, connect, admission) {
     expectedConfig.hooks.state ??= {};
     for (const h of planned)
       expectedConfig.hooks.state[h.key] = { ...expectedConfig.hooks.state[h.key], enabled: true, trusted_hash: h.currentHash };
-    need8(isDeepStrictEqual19(structure3(after2.text), expectedConfig) && codexTrustTextWitness(after2.text, keys4) === preservationText, "PRESERVATION_FAILED");
+    need8(isDeepStrictEqual20(structure3(after2.text), expectedConfig) && codexTrustTextWitness(after2.text, keys4) === preservationText, "PRESERVATION_FAILED");
     const savedConfig = snapshot(join72(journal, "config.before.toml"), true);
     need8(savedConfig.sha256 === configFile.sha256, "JOURNAL_CHANGED");
     const discoveryTransition = binding.discovery?.codex ? createCodexHookDiscoveryRecovery(binding.discovery.codex, savedConfig, after2, planned) : undefined;
@@ -120533,8 +120762,8 @@ async function enrollCodexNativeHooksUnlocked(options, connect, admission) {
     unchanged2(hooksFile);
     assertManagedAgentBridge("codex", { home, dataDir: dataDir3, projectDir: home, codexDiscoveryRecovery: discoveryTransition });
     const current = await list2(), confirmed = admit(current);
-    need8(confirmed.every((h) => h.enabled && h.trustStatus === "trusted") && isDeepStrictEqual19(confirmed.map((h) => [h.key, h.currentHash]), admitted.map((h) => [h.key, h.currentHash])), "NATIVE_NOT_ELIGIBLE");
-    need8(isDeepStrictEqual19(current.filter((h) => !keys4.includes(h.key)), discovered.filter((h) => !keys4.includes(h.key))), "UNRELATED_HOOK_CHANGED");
+    need8(confirmed.every((h) => h.enabled && h.trustStatus === "trusted") && isDeepStrictEqual20(confirmed.map((h) => [h.key, h.currentHash]), admitted.map((h) => [h.key, h.currentHash])), "NATIVE_NOT_ELIGIBLE");
+    need8(isDeepStrictEqual20(current.filter((h) => !keys4.includes(h.key)), discovered.filter((h) => !keys4.includes(h.key))), "UNRELATED_HOOK_CHANGED");
     unchanged2(after2);
     unchanged2(savedConfig);
     unchanged2(hooksFile);
@@ -120667,9 +120896,9 @@ var init_codex_native_trust = __esm(() => {
 
 // src/lib/claude-prospective-review.ts
 import { createHash as createHash45 } from "crypto";
-import { lstatSync as lstatSync45, readFileSync as readFileSync48, readdirSync as readdirSync27, realpathSync as realpathSync22 } from "fs";
-import { basename as basename23, dirname as dirname46, isAbsolute as isAbsolute42, join as join74, relative as relative15, resolve as resolve42, sep as sep21 } from "path";
-import { isDeepStrictEqual as isDeepStrictEqual20 } from "util";
+import { lstatSync as lstatSync46, readFileSync as readFileSync48, readdirSync as readdirSync27, realpathSync as realpathSync22 } from "fs";
+import { basename as basename23, dirname as dirname46, isAbsolute as isAbsolute44, join as join74, relative as relative15, resolve as resolve42, sep as sep21 } from "path";
+import { isDeepStrictEqual as isDeepStrictEqual21 } from "util";
 function hashClaudeDiscoveryBinding(binding) {
   return sha8(JSON.stringify(binding));
 }
@@ -120719,7 +120948,7 @@ function keys4(value, expected, name) {
     refuse8(`${name} has an unsupported shape`);
 }
 function abs(path, name) {
-  if (typeof path !== "string" || !path || path.length > 4096 || /[\x00-\x1f\x7f]/.test(path) || !isAbsolute42(path) || resolve42(path) !== path)
+  if (typeof path !== "string" || !path || path.length > 4096 || /[\x00-\x1f\x7f]/.test(path) || !isAbsolute44(path) || resolve42(path) !== path)
     refuse8(`${name} must be a normalized absolute path`);
 }
 function validUtcTimestamp(value) {
@@ -120728,23 +120957,23 @@ function validUtcTimestamp(value) {
 function safeFile(path, name) {
   abs(path, name);
   for (let at2 = dirname46(path);; at2 = dirname46(at2)) {
-    const stat4 = lstatSync45(at2, { throwIfNoEntry: false });
+    const stat4 = lstatSync46(at2, { throwIfNoEntry: false });
     if (!stat4?.isDirectory() || stat4.isSymbolicLink())
       refuse8(`${name} traverses a symlink or non-directory`);
     if (at2 === dirname46(at2))
       break;
   }
-  const stat3 = lstatSync45(path, { throwIfNoEntry: false });
+  const stat3 = lstatSync46(path, { throwIfNoEntry: false });
   if (!stat3?.isFile() || stat3.isSymbolicLink() || stat3.size > MAX_CANDIDATE_BYTES)
     refuse8(`${name} is not a bounded regular file`);
   return readFileSync48(path);
 }
 function canonicalDir(path, name) {
   abs(path, name);
-  if (realpathSync22(path) !== path || !lstatSync45(path).isDirectory())
+  if (realpathSync22(path) !== path || !lstatSync46(path).isDirectory())
     refuse8(`${name} is not a canonical directory`);
   for (let at2 = path;; at2 = dirname46(at2)) {
-    const stat3 = lstatSync45(at2);
+    const stat3 = lstatSync46(at2);
     if (!stat3.isDirectory() || stat3.isSymbolicLink())
       refuse8(`${name} traverses a symlink`);
     if (at2 === dirname46(at2))
@@ -120756,7 +120985,7 @@ function captureClaudeProspectiveCandidateClosure(root2) {
   const entries = [];
   let bytes = 0;
   const walk2 = (directory3) => {
-    const beforeDirectory = lstatSync45(directory3);
+    const beforeDirectory = lstatSync46(directory3);
     const names = readdirSync27(directory3).sort();
     if (new Set(names).size !== names.length)
       refuse8("candidate contains ambiguous directory entries");
@@ -120766,7 +120995,7 @@ function captureClaudeProspectiveCandidateClosure(root2) {
       const path = join74(directory3, name), rel = relative15(root2, path).split(sep21).join("/");
       if (entries.length >= MAX_CANDIDATE_FILES)
         refuse8("candidate closure exceeds its member limit");
-      const stat3 = lstatSync45(path);
+      const stat3 = lstatSync46(path);
       if (stat3.isSymbolicLink())
         refuse8("candidate closure contains a symlink");
       if (stat3.isDirectory()) {
@@ -120776,14 +121005,14 @@ function captureClaudeProspectiveCandidateClosure(root2) {
         bytes += stat3.size;
         if (bytes > MAX_CANDIDATE_BYTES)
           refuse8("candidate closure exceeds its byte limit");
-        const content = safeFile(path, "candidate member"), after2 = lstatSync45(path);
+        const content = safeFile(path, "candidate member"), after2 = lstatSync46(path);
         if (!after2.isFile() || after2.dev !== stat3.dev || after2.ino !== stat3.ino || after2.size !== stat3.size || after2.mtimeMs !== stat3.mtimeMs || after2.ctimeMs !== stat3.ctimeMs)
           refuse8("candidate member changed while being read");
         entries.push([rel, "file", sha8(content)]);
       } else
         refuse8("candidate closure contains a special file");
     }
-    const afterDirectory = lstatSync45(directory3);
+    const afterDirectory = lstatSync46(directory3);
     if (!afterDirectory.isDirectory() || afterDirectory.dev !== beforeDirectory.dev || afterDirectory.ino !== beforeDirectory.ino || afterDirectory.mtimeMs !== beforeDirectory.mtimeMs || afterDirectory.ctimeMs !== beforeDirectory.ctimeMs)
       refuse8("candidate directory changed while being read");
   };
@@ -120807,11 +121036,11 @@ function captureClaudeInstallerCandidate(root2, policyPath) {
     if (names.has(row2.name))
       refuse8("candidate catalog repeats a plugin name");
     names.add(row2.name);
-    if (typeof row2.source !== "string" || isAbsolute42(row2.source) || /[\\\x00-\x1f\x7f]/.test(row2.source))
+    if (typeof row2.source !== "string" || isAbsolute44(row2.source) || /[\\\x00-\x1f\x7f]/.test(row2.source))
       refuse8("candidate catalog plugin source is invalid");
     const pluginRoot = resolve42(root2, row2.source);
     const relativeRoot = relative15(root2, pluginRoot);
-    if (!relativeRoot || relativeRoot === "." || relativeRoot === ".." || relativeRoot.startsWith(`..${sep21}`) || isAbsolute42(relativeRoot))
+    if (!relativeRoot || relativeRoot === "." || relativeRoot === ".." || relativeRoot.startsWith(`..${sep21}`) || isAbsolute44(relativeRoot))
       refuse8("candidate plugin source escapes the candidate root");
     const path = join74(pluginRoot, ".claude-plugin/plugin.json");
     return { plugin: row2.name, ...captureClaudePluginManifestFile(path) };
@@ -120830,7 +121059,7 @@ function captureClaudeInstallerCandidate(root2, policyPath) {
 }
 function readWitness(path, expected, name) {
   abs(path, `${name} path`);
-  const stat3 = lstatSync45(path, { throwIfNoEntry: false });
+  const stat3 = lstatSync46(path, { throwIfNoEntry: false });
   if (expected === null) {
     if (stat3)
       refuse8(`${name} was absent at review but is now present`);
@@ -120882,7 +121111,7 @@ function unreviewedProjectSettingsRefusal(path, expected, name) {
   return null;
 }
 function jsonFile(path, name) {
-  const stat3 = lstatSync45(path, { throwIfNoEntry: false });
+  const stat3 = lstatSync46(path, { throwIfNoEntry: false });
   if (!stat3)
     return null;
   let value;
@@ -120914,7 +121143,7 @@ function assertNoUnprojectedSkillPayload(root2, catalogPath, marketplace, plugin
   const walk2 = (directory3) => {
     for (const name of readdirSync27(directory3).sort()) {
       const path = join74(directory3, name), rel = relative15(root2, path).split(sep21).join("/");
-      const stat3 = lstatSync45(path);
+      const stat3 = lstatSync46(path);
       if (stat3.isDirectory())
         walk2(path);
       else if (stat3.isFile()) {
@@ -120980,7 +121209,7 @@ function reviewClaudeProspectiveCandidate(request2, requestFileSha256) {
     refuse8("CLAUDE_CODE_PLUGIN_CACHE_DIR overrides are unsupported by this prospective schema; bind and review the actual cache root first");
   if (request2.native.pluginRoot !== pluginRoot)
     refuse8("Claude plugin root differs from the supported standard plugins directory; Cowork and custom cache roots require a separately bound schema");
-  const pluginRootStat = lstatSync45(pluginRoot, { throwIfNoEntry: false });
+  const pluginRootStat = lstatSync46(pluginRoot, { throwIfNoEntry: false });
   if (pluginRootStat && (!pluginRootStat.isDirectory() || pluginRootStat.isSymbolicLink()))
     refuse8("Claude plugin root is not a regular directory");
   keys4(request2.candidate, ["marketplace", "root", "catalogPath", "catalogSha256", "closureSha256", "plugins", ...hasOwn2(request2.candidate, "releaseManifest") ? ["releaseManifest"] : [], ...hasOwn2(request2.candidate, "functionHooksEnv") ? ["functionHooksEnv"] : [], ...hasOwn2(request2.candidate, "settingsMarketplaceSource") ? ["settingsMarketplaceSource"] : []], "candidate");
@@ -120992,7 +121221,7 @@ function reviewClaudeProspectiveCandidate(request2, requestFileSha256) {
     refuse8("candidate must select between one and 32 plugins from one marketplace");
   if (candidate2.functionHooksEnv !== undefined && candidate2.functionHooksEnv !== "1")
     refuse8("function-hook environment mutation only supports the explicit value 1");
-  const settingsMarketplaceWriterVersions = ["2.1.276", "2.1.278", "2.1.282", "2.1.287", "2.1.293", "2.1.296", "2.1.299", "2.1.300"];
+  const settingsMarketplaceWriterVersions = ["2.1.276", "2.1.278", "2.1.282", "2.1.287", "2.1.293", "2.1.296", "2.1.299", "2.1.300", "2.1.301", "2.1.302"];
   const nativeVersion = request2.native.executable.version;
   const measuredSettingsWriter = settingsMarketplaceWriterVersions.some((version2) => nativeVersion === version2 || nativeVersion === `${version2} (Claude Code)`);
   if (hasOwn2(candidate2, "settingsMarketplaceSource") && (candidate2.settingsMarketplaceSource !== "directory" || request2.scope.kind !== "user" || !measuredSettingsWriter))
@@ -121046,7 +121275,7 @@ function reviewClaudeProspectiveCandidate(request2, requestFileSha256) {
       refuse8("plugin manifest must be under a plugin root inside the frozen marketplace closure");
     const pluginRoot2 = dirname46(dirname46(selected.manifestPath));
     const relativePluginRoot = relative15(candidate2.root, pluginRoot2);
-    if (!relativePluginRoot || relativePluginRoot === "." || relativePluginRoot === ".." || relativePluginRoot.startsWith(`..${sep21}`) || isAbsolute42(relativePluginRoot))
+    if (!relativePluginRoot || relativePluginRoot === "." || relativePluginRoot === ".." || relativePluginRoot.startsWith(`..${sep21}`) || isAbsolute44(relativePluginRoot))
       refuse8("plugin root must be a child of the frozen marketplace root");
     canonicalDir(pluginRoot2, "candidate plugin root");
     if (!SHA256.test(selected.manifestSha256))
@@ -121080,7 +121309,7 @@ function reviewClaudeProspectiveCandidate(request2, requestFileSha256) {
     const sourcePath = selectedEntry.source;
     const sourceRelativePath = relative15(candidate2.root, pluginRoot2).split(sep21).join("/");
     const expectedSourcePath = sourceRelativePath === "." ? "./" : `./${sourceRelativePath}`;
-    if (typeof sourcePath !== "string" || isAbsolute42(sourcePath) || sourcePath !== expectedSourcePath || resolve42(dirname46(dirname46(candidate2.catalogPath)), sourcePath) !== pluginRoot2)
+    if (typeof sourcePath !== "string" || isAbsolute44(sourcePath) || sourcePath !== expectedSourcePath || resolve42(dirname46(dirname46(candidate2.catalogPath)), sourcePath) !== pluginRoot2)
       refuse8("marketplace source does not resolve to the frozen plugin closure; external source mapping is not supported by this schema");
     const entry = captureClaudeMarketplaceEntry(candidate2.catalogPath, candidate2.marketplace, selected.plugin);
     if (entry.sha256.length !== 64)
@@ -121141,7 +121370,7 @@ function reviewClaudeProspectiveCandidate(request2, requestFileSha256) {
     refuse8("Skills discovery preimage differs from its reviewed binding");
   assertProjectDiscovery("claude", [request2.scope.projectPath], request2.native.home, canonical9, binding);
   const stored = snapshot2.value.bridge?.discovery?.claude;
-  if (!stored || !isDeepStrictEqual20(stored, binding) || snapshot2.value.bridge?.home !== request2.native.home)
+  if (!stored || !isDeepStrictEqual21(stored, binding) || snapshot2.value.bridge?.home !== request2.native.home)
     refuse8("Skills policy does not bind the reviewed current Claude discovery");
   assertExemptUnchanged();
   const delta = request2.delta;
@@ -121299,7 +121528,7 @@ function reviewClaudeProspectiveCandidate(request2, requestFileSha256) {
         refuse8("current known marketplace autoUpdate is not a boolean");
     }
   }
-  if (!isDeepStrictEqual20(delta.settingsAfter, settingsAfter))
+  if (!isDeepStrictEqual21(delta.settingsAfter, settingsAfter))
     refuse8("complete settings document differs from the exact selected plugin/options/environment/marketplace operations");
   const marketplaceRowBefore = marketplaces?.[candidate2.marketplace];
   if (marketplaceRowBefore !== undefined && !object11(marketplaceRowBefore))
@@ -121311,7 +121540,7 @@ function reviewClaudeProspectiveCandidate(request2, requestFileSha256) {
   if (marketplaceRowBefore?.lastUpdated !== undefined && !validUtcTimestamp(marketplaceRowBefore.lastUpdated))
     refuse8("current marketplace update timestamp is invalid");
   const targetMarketplaceLocation = candidate2.root;
-  const sameMarketplaceSource = isDeepStrictEqual20(marketplaceRowBefore?.source, { source: "directory", path: candidate2.root }) && marketplaceRowBefore?.installLocation === targetMarketplaceLocation;
+  const sameMarketplaceSource = isDeepStrictEqual21(marketplaceRowBefore?.source, { source: "directory", path: candidate2.root }) && marketplaceRowBefore?.installLocation === targetMarketplaceLocation;
   const afterMarketplace = {
     source: { source: "directory", path: candidate2.root },
     installLocation: targetMarketplaceLocation,
@@ -121320,7 +121549,7 @@ function reviewClaudeProspectiveCandidate(request2, requestFileSha256) {
   };
   const marketplacesAfter = marketplaces ? structuredClone(marketplaces) : {};
   marketplacesAfter[candidate2.marketplace] = afterMarketplace;
-  if (!isDeepStrictEqual20(delta.knownMarketplacesAfter, marketplacesAfter))
+  if (!isDeepStrictEqual21(delta.knownMarketplacesAfter, marketplacesAfter))
     refuse8("complete marketplace document differs from the exact selected-directory marketplace operation");
   const installedAfter = registrations ? structuredClone(registrations) : { version: 2, plugins: {} };
   if (installedAfter.plugins === undefined)
@@ -121340,7 +121569,7 @@ function reviewClaudeProspectiveCandidate(request2, requestFileSha256) {
       nextRows[index] = targetRegistration;
     installedAfter.plugins[pluginId2] = nextRows;
   }
-  if (!isDeepStrictEqual20(delta.installedPluginsAfter, installedAfter))
+  if (!isDeepStrictEqual21(delta.installedPluginsAfter, installedAfter))
     refuse8("complete installed plugin document changes an unrelated registration or has target rows not derived from every selected candidate");
   assertExemptUnchanged();
   const semanticDocumentsSha256 = sha8(canonicalJson3({ settings: settingsAfter, knownMarketplaces: marketplacesAfter, installedPlugins: installedAfter }));
@@ -121419,7 +121648,7 @@ var init_claude_prospective_review = __esm(() => {
 
 // src/lib/self-spawn.ts
 import { realpathSync as realpathSync23 } from "fs";
-import { dirname as dirname47, isAbsolute as isAbsolute43, sep as sep22 } from "path";
+import { dirname as dirname47, isAbsolute as isAbsolute45, sep as sep22 } from "path";
 function selfSpawnRoot(entry) {
   const index = entry.indexOf(INSTALLED_PACKAGE);
   const root2 = index > 0 ? entry.slice(0, index) : dirname47(entry);
@@ -121432,7 +121661,7 @@ function selfSpawnRoot(entry) {
 function selfSpawnCommand(args2, options = {}) {
   const runtime = options.runtime ?? process.execPath;
   const entry = options.entry ?? process.argv[1];
-  if (!runtime || !isAbsolute43(runtime) || !entry || !isAbsolute43(entry))
+  if (!runtime || !isAbsolute45(runtime) || !entry || !isAbsolute45(entry))
     throw new Error("SKILLS_SELF_SPAWN_ENTRY_UNRESOLVED");
   const root2 = selfSpawnRoot(entry);
   const env3 = pinnedLauncherEnvironment(options.env ?? process.env);
@@ -121538,8 +121767,8 @@ 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 lstatSync46, openSync as openSync30, readSync as readSync22 } from "fs";
-import { isAbsolute as isAbsolute44, resolve as resolve43 } from "path";
+import { closeSync as closeSync30, constants as constants29, fstatSync as fstatSync30, lstatSync as lstatSync47, openSync as openSync30, readSync as readSync22 } from "fs";
+import { isAbsolute as isAbsolute46, resolve as resolve43 } from "path";
 function need11(condition, code2) {
   if (!condition)
     throw new CaptureRefusal(code2);
@@ -121553,11 +121782,11 @@ function exactKeys5(value, expected, operation) {
   }
 }
 function canonicalPath2(value) {
-  need11(typeof value === "string" && isAbsolute44(value) && resolve43(value) === value && !/[\x00-\x1f\x7f]/.test(value), "INVALID_PATH: path fields must be normalized absolute paths without control characters");
+  need11(typeof value === "string" && isAbsolute46(value) && resolve43(value) === value && !/[\x00-\x1f\x7f]/.test(value), "INVALID_PATH: path fields must be normalized absolute paths without control characters");
 }
 function readRequest2(path) {
   canonicalPath2(path);
-  const before2 = lstatSync46(path, { throwIfNoEntry: false });
+  const before2 = lstatSync47(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);
@@ -121572,7 +121801,7 @@ function readRequest2(path) {
         break;
       length += count;
     }
-    const after2 = fstatSync30(fd), current = lstatSync46(path);
+    const after2 = fstatSync30(fd), current = lstatSync47(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)));
@@ -121724,10 +121953,10 @@ var exports_agent_integration = {};
 __export(exports_agent_integration, {
   registerAgentIntegration: () => registerAgentIntegration
 });
-import { existsSync as existsSync36, lstatSync as lstatSync47, readFileSync as readFileSync49, readSync as readSync23, writeFileSync as writeFileSync27 } from "fs";
+import { existsSync as existsSync36, lstatSync as lstatSync48, readFileSync as readFileSync49, readSync as readSync23, writeFileSync as writeFileSync27 } from "fs";
 import { createHash as createHash47 } from "crypto";
 import { homedir as homedir14 } from "os";
-import { basename as basename24, isAbsolute as isAbsolute45, resolve as resolve44 } from "path";
+import { basename as basename24, isAbsolute as isAbsolute47, resolve as resolve44 } from "path";
 function pinnedHookProfile(input3, configuredProfile) {
   try {
     const parsed = parseSkillContextInput(JSON.stringify(input3));
@@ -121862,7 +122091,7 @@ function registerAgentIntegration(parent) {
   });
   hook.command("native-catalog").requiredOption("--cwd <path>", "Absolute project directory observed by native Codex skills/list").requiredOption("--output <file>", "New private file for the projected native catalog").option("--codex-command <path>", "Installed Codex executable used by the native client", "codex").option("--json", "Output bounded capture metadata as JSON", false).description("Capture a reviewed Codex native skill catalog for exact hook enrollment").action(async (options) => {
     try {
-      if (!isAbsolute45(options.cwd) || !isAbsolute45(options.output))
+      if (!isAbsolute47(options.cwd) || !isAbsolute47(options.output))
         throw new Error("CODEX_NATIVE_SKILL_CATALOG_ABSOLUTE_PATH_REQUIRED");
       if (existsSync36(options.output))
         throw new Error("CODEX_NATIVE_SKILL_CATALOG_OUTPUT_EXISTS");
@@ -121886,7 +122115,7 @@ function registerAgentIntegration(parent) {
           throw new Error("CODEX_NATIVE_SKILL_CATALOG_OUTPUT_EXISTS");
         throw error61;
       }
-      const written = lstatSync47(options.output);
+      const written = lstatSync48(options.output);
       if (!written.isFile() || written.isSymbolicLink() || (written.mode & 63) !== 0 || readFileSync49(options.output, "utf8") !== bytes)
         throw new Error("CODEX_NATIVE_SKILL_CATALOG_READBACK_FAILED");
       const receipt = {
@@ -121953,9 +122182,9 @@ function registerAgentIntegration(parent) {
   });
   hook.command("review-claude-candidate").requiredOption("--request <file>", "Frozen skills.claude-plugin-prospective-review/v1 JSON request").option("--json", "Return the validation-only receipt as JSON", false).description("Validate a prospective Claude plugin candidate and current preimages without changing native state; Harnesses must compare native and Skills paths against installed package-owned resolvers before trusting the receipt").action(async (options) => {
     try {
-      if (!isAbsolute45(options.request))
+      if (!isAbsolute47(options.request))
         throw new Error("CLAUDE_CANDIDATE_REVIEW_REFUSED: --request must be an absolute path");
-      const stat3 = lstatSync47(options.request);
+      const stat3 = lstatSync48(options.request);
       if (!stat3.isFile() || stat3.isSymbolicLink() || stat3.size > 1024 * 1024)
         throw new Error("CLAUDE_CANDIDATE_REVIEW_REFUSED: request must be a regular file no larger than 1 MiB");
       const requestBytes = readFileSync49(options.request);
@@ -122091,12 +122320,12 @@ function registerAgentIntegration(parent) {
       input3.hook_event_name = event;
       const projects = [process.cwd()];
       if (input3.cwd !== undefined) {
-        if (typeof input3.cwd !== "string" || !isAbsolute45(input3.cwd) || input3.cwd.includes("\x00"))
+        if (typeof input3.cwd !== "string" || !isAbsolute47(input3.cwd) || input3.cwd.includes("\x00"))
           throw new Error("Invalid native hook working directory");
         projects.push(input3.cwd);
       }
       if (options.agent === "cursor") {
-        if (!Array.isArray(input3.workspace_roots) || input3.workspace_roots.length > 32 || input3.workspace_roots.some((path) => typeof path !== "string" || !isAbsolute45(path) || path.includes("\x00")))
+        if (!Array.isArray(input3.workspace_roots) || input3.workspace_roots.length > 32 || input3.workspace_roots.some((path) => typeof path !== "string" || !isAbsolute47(path) || path.includes("\x00")))
           throw new Error("Invalid Cursor workspace roots");
         projects.push(...input3.workspace_roots);
         input3.cwd ??= input3.workspace_roots[0] ?? process.cwd();
@@ -122887,7 +123116,7 @@ import {
   mkdirSync as mkdirSync31,
   readdirSync as readdirSync28,
   readFileSync as readFileSync50,
-  statSync as statSync25,
+  statSync as statSync26,
   writeFileSync as writeFileSync30
 } from "fs";
 import { dirname as dirname48, join as join76, resolve as resolve45, sep as sep23 } from "path";
@@ -122984,7 +123213,7 @@ function planStationHydration(stationId, repoRoot) {
           });
           continue;
         }
-        const info = statSync25(entry.fullPath);
+        const info = statSync26(entry.fullPath);
         const manifestHash = manifestHashes.get(`${agent}${MANIFEST_HASH_KEY_SEP}${homeRelative}`) ?? null;
         let verified = false;
         if (manifestHash !== null) {
@@ -123241,10 +123470,10 @@ var init_hydrate = __esm(() => {
 });
 
 // src/lib/prepare-skill.ts
-import { createHash as createHash49, randomUUID as randomUUID13 } from "crypto";
-import { chmodSync as chmodSync5, existsSync as existsSync37, lstatSync as lstatSync48, mkdirSync as mkdirSync32, mkdtempSync as mkdtempSync7, readFileSync as readFileSync51, readdirSync as readdirSync29, renameSync as renameSync15, rmSync as rmSync10, writeFileSync as writeFileSync31 } from "fs";
+import { createHash as createHash49, randomUUID as randomUUID14 } from "crypto";
+import { chmodSync as chmodSync5, existsSync as existsSync37, lstatSync as lstatSync49, mkdirSync as mkdirSync32, mkdtempSync as mkdtempSync7, readFileSync as readFileSync51, readdirSync as readdirSync29, renameSync as renameSync16, rmSync as rmSync10, writeFileSync as writeFileSync31 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
-import { dirname as dirname49, isAbsolute as isAbsolute46, join as join77, relative as relative16, resolve as resolve46, sep as sep24 } from "path";
+import { dirname as dirname49, isAbsolute as isAbsolute48, join as join77, relative as relative16, resolve as resolve46, sep as sep24 } from "path";
 function prepareSkill(name, options) {
   const normalized2 = normalizePortableSkillName(name);
   if (!new RegExp(SEMVER_PATTERN).test(options.version))
@@ -123316,11 +123545,11 @@ ${validation.issues.map((issue2) => `${issue2.code}: ${issue2.message}`).join(`
     if (snapshot2(path).identity !== before2.identity)
       throw new Error("Skill changed during preparation; review the draft and run prepare again.");
     if (changed3 && !options.dryRun) {
-      const temporary = join77(path, `.skill-prepare-${randomUUID13()}.tmp`);
+      const temporary = join77(path, `.skill-prepare-${randomUUID14()}.tmp`);
       try {
         writeFileSync31(temporary, candidateBytes, { flag: "wx", mode: manifestFile.mode });
         chmodSync5(temporary, manifestFile.mode);
-        renameSync15(temporary, join77(path, "skill.json"));
+        renameSync16(temporary, join77(path, "skill.json"));
       } finally {
         rmSync10(temporary, { force: true });
       }
@@ -123351,7 +123580,7 @@ function validateRuntimeEntrypoint(candidate2, root2) {
   if (typeof entry !== "string")
     return;
   const target = resolve46(root2, entry), rel = relative16(root2, target);
-  if (isAbsolute46(entry) || /^[a-zA-Z]:/.test(entry) || entry.includes("\\") || !rel || rel === ".." || rel.startsWith(`..${sep24}`) || isAbsolute46(rel) || !existsSync37(target) || !lstatSync48(target).isFile()) {
+  if (isAbsolute48(entry) || /^[a-zA-Z]:/.test(entry) || entry.includes("\\") || !rel || rel === ".." || rel.startsWith(`..${sep24}`) || isAbsolute48(rel) || !existsSync37(target) || !lstatSync49(target).isFile()) {
     throw new Error("Executable runtime.entrypoint must name an existing regular file inside the skill directory.");
   }
 }
@@ -123436,7 +123665,7 @@ function compareVersions(left, right) {
   return 0;
 }
 function snapshot2(root2) {
-  const rootStat = lstatSync48(root2);
+  const rootStat = lstatSync49(root2);
   if (rootStat.isSymbolicLink() || !rootStat.isDirectory())
     throw new Error("Skill root must be a real directory, not a symlink.");
   const files = [], directories = [];
@@ -123449,7 +123678,7 @@ function snapshot2(root2) {
       const path = relative17 ? `${relative17}/${name}` : name;
       if (++count > 20000)
         throw new Error("Skill exceeds the preparation entry limit (20000).");
-      const absolute = join77(root2, path), stat3 = lstatSync48(absolute);
+      const absolute = join77(root2, path), stat3 = lstatSync49(absolute);
       if (stat3.isSymbolicLink())
         throw new Error(`Skill contains a symlink: ${path}. No files were changed.`);
       if (stat3.isDirectory() && name === "node_modules")
@@ -123942,8 +124171,8 @@ var init_registry_sync = __esm(() => {
 });
 
 // src/lib/review-export.ts
-import { constants as constants32, closeSync as closeSync33, existsSync as existsSync38, fstatSync as fstatSync33, fsyncSync as fsyncSync10, lstatSync as lstatSync49, openSync as openSync33, realpathSync as realpathSync24, statSync as statSync26, writeFileSync as writeFileSync33 } from "fs";
-import { basename as basename25, dirname as dirname51, isAbsolute as isAbsolute47, join as join78, parse as parse13, resolve as resolve47, sep as sep25 } from "path";
+import { constants as constants32, closeSync as closeSync33, existsSync as existsSync38, fstatSync as fstatSync33, fsyncSync as fsyncSync10, lstatSync as lstatSync50, openSync as openSync33, realpathSync as realpathSync24, statSync as statSync27, writeFileSync as writeFileSync33 } from "fs";
+import { basename as basename25, dirname as dirname51, isAbsolute as isAbsolute49, join as join78, parse as parse13, resolve as resolve47, sep as sep25 } from "path";
 function exactVersion(spec) {
   const at2 = spec.indexOf("@");
   const slug2 = spec.slice(0, at2);
@@ -123954,14 +124183,14 @@ function exactVersion(spec) {
   return { slug: slug2, version: version2 };
 }
 function assertPrivateDestination(output2) {
-  if (!isAbsolute47(output2) || resolve47(output2) !== output2 || !basename25(output2).endsWith(".tar.gz")) {
+  if (!isAbsolute49(output2) || resolve47(output2) !== output2 || !basename25(output2).endsWith(".tar.gz")) {
     throw new Error("Review output must be an absolute, normalized .tar.gz path.");
   }
   const parent = dirname51(output2);
-  if (realpathSync24(parent) !== parent || lstatSync49(parent).isSymbolicLink()) {
+  if (realpathSync24(parent) !== parent || lstatSync50(parent).isSymbolicLink()) {
     throw new Error("Review output parent must be a real directory, not a symlink.");
   }
-  const parentStat = statSync26(parent);
+  const parentStat = statSync27(parent);
   if (!parentStat.isDirectory() || (parentStat.mode & 63) !== 0 || process.getuid && parentStat.uid !== process.getuid()) {
     throw new Error("Review output parent must be an owner-only directory (mode 0700).");
   }
@@ -124549,17 +124778,20 @@ __export(exports_private_publications, {
   registerPrivatePublications: () => registerPrivatePublications
 });
 import { resolve as resolve48 } from "path";
-function verifyOptions(options, action) {
+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.");
+}
+function verifyOptions(options, action) {
+  verifySessionOptions(options);
   if ((action === "publish" || action === "resume" || action === "cancel") && options.confirm !== true)
     throw new PrivatePublicationError("PUBLICATION_CONFIRM_REQUIRED", "Use --confirm to approve this publication action.");
   if (action === "publish" && (!publicationUuid(options.skillId) || Boolean(options.expectEmpty) === (options.expectedCurrentVersion !== undefined) || options.expectedCurrentVersion !== undefined && !publicationUuid(options.expectedCurrentVersion) || options.idempotencyKey !== undefined && !publicationUuid(options.idempotencyKey)))
     throw new PrivatePublicationError("INVALID_PUBLICATION_INPUT", "Provide --skill-id and exactly one of --expect-empty or --expected-current-version; optional --idempotency-key must be a UUID.");
   if (options.waitSeconds !== undefined && (!/^(?:0|[1-9]\d{0,2})$/.test(options.waitSeconds) || Number(options.waitSeconds) > 300))
     throw new PrivatePublicationError("INVALID_PUBLICATION_INPUT", "Use --wait-seconds from 0 to 300.");
-  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.");
 }
 function print2(result2, json3) {
   if (json3)
@@ -124573,7 +124805,39 @@ function print2(result2, json3) {
     process.exitCode = 2;
 }
 function registerPrivatePublications(parent) {
-  const group = parent.command("publication").description("Publish and reconcile private source versions on a compatible hosted server; execution is separate");
+  const group = parent.command("publication").description("Create private skills, publish and reconcile source versions on a compatible hosted server; execution is separate");
+  group.command("create").allowExcessArguments(false).description("Create a private or team skill using fresh session verification (requires Pro)").argument("<slug>", "Lowercase kebab-case skill slug").requiredOption("--display-name <name>", "Skill display name").option("--description <text>", "Skill description", "").option("--visibility <visibility>", "private or team", "private").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("--confirm", "Explicitly approve skill creation").option("--json", "Output validated skill identifiers without credentials or server free text").action(async (slug2, options) => {
+    try {
+      const body = checkedPrivateSkillCreate({ slug: slug2, displayName: options.displayName, description: options.description, visibility: options.visibility, confirm: options.confirm });
+      verifySessionOptions(options);
+      const context2 = options.userId ? { userId: options.userId, membershipId: options.membershipId } : undefined;
+      const pending = preparePrivatePublicationSession(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 result2 = await client2.createSkill({ ...body, confirm: true });
+      if (options.json)
+        console.log(JSON.stringify(result2));
+      else {
+        console.log(`Created ${result2.visibility} skill: ${result2.slug}`);
+        console.log(`Skill ID: ${result2.id}`);
+      }
+    } catch (error61) {
+      const result2 = error61 instanceof PrivatePublicationError ? privatePublicationCustomerError(error61) : { error: "Unable to verify the selected account and workspace for skill creation. Check the server, membership and fresh code; no credential was saved.", code: "SKILL_CREATE_SESSION_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");
@@ -124583,17 +124847,18 @@ function registerPrivatePublications(parent) {
       const options = action === "publish" ? args2[1] : args2[0];
       try {
         verifyOptions(options, action);
+        const context2 = options.userId ? { userId: options.userId, membershipId: options.membershipId } : undefined;
+        const pending = preparePrivatePublicationSession(context2);
         let code2;
         if (options.codeStdin)
           code2 = await readCode();
         else {
-          await new RemoteSkillsAuthClient(getApiUrl("Publish private skills")).requestCode(options.email);
+          await new RemoteSkillsAuthClient(pending.origin).requestCode(options.email);
           code2 = await promptCode();
         }
         if (code2 === null)
           return;
-        const context2 = options.userId ? { userId: options.userId, membershipId: options.membershipId } : undefined;
-        const client2 = await privatePublicationSession(options.email, code2, context2), directory3 = resolve48(options.recoveryDir);
+        const client2 = await pending.verify(options.email, code2), directory3 = resolve48(options.recoveryDir);
         if (action === "publish")
           await preparePrivatePublication(client2, resolve48(args2[0]), directory3, { skillId: options.skillId, expectedCurrentVersionId: options.expectedCurrentVersion ?? null, idempotencyKey: options.idempotencyKey });
         const result2 = action === "publish" || action === "resume" ? await continuePrivatePublication(client2, directory3, { confirm: true, waitMs: Number(options.waitSeconds) * 1000 }) : await inspectPrivatePublication(client2, directory3, action === "cancel");
@@ -124611,7 +124876,6 @@ function registerPrivatePublications(parent) {
 }
 var init_private_publications = __esm(() => {
   init_remote_auth();
-  init_auth_store();
   init_private_publication_customer();
   init_private_publication_recovery();
   init_remote_private_publications();
@@ -124890,7 +125154,7 @@ Skipped. Run it any time: ${skillsCommand("setup agents", target)}`));
     return;
   }
   const { handleMcp: handleMcp2 } = await Promise.resolve().then(() => (init_runtime_mcp(), exports_runtime_mcp));
-  await handleMcp2({ register: "all", json: false });
+  await handleMcp2({ register: "all", json: false, apiUrl: target.origin });
   process.exitCode = before2 ?? 0;
 }
 function promptHidden(question) {
@@ -126062,11 +126326,11 @@ var init_storage2 = __esm(() => {
 });
 
 // src/lib/registry-reconcile.ts
-import { existsSync as existsSync40, readFileSync as readFileSync53, statSync as statSync27, writeFileSync as writeFileSync34 } from "fs";
+import { existsSync as existsSync40, readFileSync as readFileSync53, statSync as statSync28, writeFileSync as writeFileSync34 } from "fs";
 import { join as join80 } from "path";
 function isDirectory2(path) {
   try {
-    return statSync27(path).isDirectory();
+    return statSync28(path).isDirectory();
   } catch {
     return false;
   }