@hasna/skills 0.10.73 → 0.10.74

package/bin/index.js

@@ -36888,7 +36888,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@hasna/skills",
-    version: "0.10.73",
+    version: "0.10.74",
     description: "Skills library for AI coding agents",
     type: "module",
     bin: {
@@ -39496,8 +39496,8 @@ function ensureInstructionSkillFiles(skillPath, manifest) {
     displayName: manifest.displayName ?? displayName(manifest.name),
     category: manifest.category ?? "Development Tools",
     tags: manifest.tags?.length ? manifest.tags : ["custom", manifest.name],
-    inputs: [],
-    commands: []
+    inputs: Array.isArray(manifest.inputs) ? manifest.inputs : [],
+    commands: Array.isArray(manifest.commands) ? manifest.commands : []
   };
   if (!existsSync10(join10(skillPath, "SKILL.md"))) {
     writeFileSync2(join10(skillPath, "SKILL.md"), renderSkillMd(next));
@@ -58192,11 +58192,19 @@ function planAgentIntegration(options) {
     const executable2 = discoveryExecutable(agent) ?? (prior ? recordedDiscoveryExecutable(agent, prior) : null);
     executables.set(agent, executable2);
     const retainedReview = options.discoveryInputs === undefined && policy.bridge?.discovery?.[agent]?.method === "reviewed" ? { ...policy.bridge.discovery[agent], ...agent === "codex" ? { codexDisabledPluginSkills: policy.bridge.codexPluginSkills ?? [] } : {} } : undefined;
-    if (retainedReview) {
-      assertManagedAgentBridge(agent, { home, dataDir: dataDir3, projectDir: options.projectDir ?? home });
-      retainedAgents.push(agent);
+    try {
+      if (retainedReview) {
+        assertRetainedReviewState(agent, { home, dataDir: dataDir3, projectDir: options.projectDir ?? home });
+        retainedAgents.push(agent);
+      }
+      return resolveAgentDiscovery({ home, agent, reviewed: options.discoveryInputs, retainedReview, canonical: (path) => canonicalAgentPath(path, aliases), executable: executable2 });
+    } catch (error) {
+      if (isDiscoveryRootUnresolved(error) || error instanceof SumiPathResolverError || error instanceof NativeSkillCopiesDriftError)
+        throw error;
+      if (!retainedReview)
+        throw error;
+      throw new Error(`NATIVE_SKILL_DRIFT: ${error.message.replace(/^NATIVE_SKILL_DRIFT: /, "")}. This agent reuses a saved discovery review and that review no longer verifies, so a fresh explicit review is required: skills hook install --agent ${agent} --discovery-inputs <review> --apply.`);
     }
-    return resolveAgentDiscovery({ home, agent, reviewed: options.discoveryInputs, retainedReview, canonical: (path) => canonicalAgentPath(path, aliases), executable: executable2 });
   });
   const codexConfigBefore = options.agents.includes("codex") ? readOptional(canonicalAgentPath(join34(home, ".codex", "config.toml"), aliases)) : null;
   const codexConfig = Bun.TOML.parse(codexConfigBefore ?? "");
@@ -58867,7 +58875,7 @@ function applyAgentIntegrationUnlocked(plan, options = {}, assertCurrent) {
   assertCurrent();
   recheckRootAliases(aliases);
   for (const agent of plan.retainedReviewChecks?.agents ?? [])
-    assertManagedAgentBridge(agent, { ...plan.retainedReviewChecks, dataDir: plan.dataDir });
+    assertRetainedReviewState(agent, { ...plan.retainedReviewChecks, dataDir: plan.dataDir });
   if (plan.reviewArtifactMigration) {
     const verified = planReviewedArtifactMigration(plan.reviewArtifactMigration);
     if (JSON.stringify(verified.changes) !== JSON.stringify(plan.changes) || JSON.stringify(verified.discoveryAfter) !== JSON.stringify(plan.discoveryAfter))
@@ -58910,6 +58918,8 @@ function applyAgentIntegrationUnlocked(plan, options = {}, assertCurrent) {
   if (!plan.changes.length) {
     assertCurrent();
     recheckRootAliases(aliases);
+    for (const agent of plan.retainedReviewChecks?.agents ?? [])
+      assertManagedAgentBridge(agent, { ...plan.retainedReviewChecks, dataDir: plan.dataDir });
     return { changed: [], backups, ...aliases.length ? { rootAliases: aliases } : {} };
   }
   assertSafePath(backupRoot);
@@ -58959,6 +58969,8 @@ function applyAgentIntegrationUnlocked(plan, options = {}, assertCurrent) {
     }
     for (const agent of plan.managedAgentChecks?.agents ?? [])
       assertManagedAgentBridge(agent, { home: plan.managedAgentChecks.home, dataDir: plan.dataDir, projectDir: plan.managedAgentChecks.projectDir ?? plan.managedAgentChecks.home });
+    for (const agent of plan.retainedReviewChecks?.agents ?? [])
+      assertManagedAgentBridge(agent, { ...plan.retainedReviewChecks, dataDir: plan.dataDir });
     atomicWrite2(join34(backupRoot, "receipt.json"), JSON.stringify({ version: 1, changes: written.map((change) => ({ path: change.path, beforeHash: change.before === null ? null : sha4(change.before), afterHash: sha4(change.after) })), backups, ...plan.cacheWitnessUpgrade ? { cacheWitnessUpgrade: plan.cacheWitnessUpgrade } : {}, ...plan.retainedReviewArtifacts?.length ? { retainedReviewArtifacts: plan.retainedReviewArtifacts.map((item) => ({ path: item.path, ...item.artifact })) } : {}, ...aliases.length ? { rootAliases: aliases } : {} }) + `
 `);
   } catch (error) {
@@ -59299,7 +59311,7 @@ function codexPromptDriftWarning(report) {
 function assertManagedAgentBridge(agent, options = {}) {
   return assertManagedAgentBridgeWithDiscovery(agent, options);
 }
-function assertManagedAgentBridgeWithDiscovery(agent, options = {}, provenDiscovery) {
+function assertManagedBridgeCustody(agent, options = {}, provenDiscovery) {
   const home = resolve24(options.home ?? homedir3()), dataDir3 = options.dataDir ?? getDataDirReadOnly();
   assertSafePath(join34(dataDir3, "agent-policy.json"));
   const snapshot2 = readManagedSkillPolicySnapshot(dataDir3);
@@ -59316,7 +59328,6 @@ function assertManagedAgentBridgeWithDiscovery(agent, options = {}, provenDiscov
   if (!isOwnedCliBridge(expected, [expected]))
     throw new Error("NATIVE_SKILL_DRIFT: the native Skills bridge is missing or modified; repair it before continuing");
   const roots = projectAncestorDirectories([options.projectDir ?? process.cwd(), ...options.projectDirs ?? [], ...agent === "hermes" && process.env.TERMINAL_CWD ? [process.cwd()] : []]);
-  const visible = (entry) => entry.agent === agent || ["codex", "gemini", "opencode", "hermes", "sumi"].includes(agent) && entry.path.includes(`${sep13}.agents${sep13}skills${sep13}`) || ["opencode", "sumi"].includes(agent) && entry.agent === "claude";
   const discovery = provenDiscovery ?? binding.discovery?.[agent];
   assertProjectDiscovery(agent, [...roots], home, (path) => canonicalAgentPath(path, aliases), discovery);
   for (const source of discovery?.sources ?? [])
@@ -59331,11 +59342,27 @@ function assertManagedAgentBridgeWithDiscovery(agent, options = {}, provenDiscov
     throw new Error("NATIVE_SKILL_DRIFT: the native hook command/profile binding is missing");
   if (options.profileId !== undefined && options.profileId !== profile)
     throw new Error("NATIVE_SKILL_DRIFT: the hook selection profile differs from its managed binding; restart the native client after reviewing skills hook install");
+  return { home, dataDir: dataDir3, binding, aliases, expected, roots, discovery, configPath, config, command, profile };
+}
+function assertUnrepairableBridgeProtection(custody, agent) {
+  if (agent !== "hermes")
+    return;
+  const { home, dataDir: dataDir3, binding, config, command, profile } = custody;
+  const supervisor = binding.supervisors?.hermes;
+  if (supervisor?.path !== join34(dataDir3, "agent-hooks", "hermes.js") || supervisor?.sha256 !== sha4(renderHermesSupervisor(command, profile)))
+    throw new Error("NATIVE_SKILL_DRIFT: Hermes supervisor binding changed; run skills hook install");
+  assertHermesProtection(home, config, command, profile, supervisor);
+}
+function assertRetainedReviewState(agent, options) {
+  const custody = assertManagedBridgeCustody(agent, options);
+  assertUnrepairableBridgeProtection(custody, agent);
+  assertManagedNativeDiscovery(custody, agent, options);
+}
+function assertManagedAgentBridgeWithDiscovery(agent, options = {}, provenDiscovery) {
+  const custody = assertManagedBridgeCustody(agent, options, provenDiscovery);
+  const { home, aliases, expected, discovery, config, command, profile } = custody;
   if (agent === "hermes") {
-    const supervisor = binding.supervisors?.hermes;
-    if (supervisor?.path !== join34(dataDir3, "agent-hooks", "hermes.js") || supervisor?.sha256 !== sha4(renderHermesSupervisor(command, profile)))
-      throw new Error("NATIVE_SKILL_DRIFT: Hermes supervisor binding changed; run skills hook install");
-    assertHermesProtection(home, config, command, profile, supervisor);
+    assertUnrepairableBridgeProtection(custody, agent);
   } else if (agent === "sumi") {
     if (JSON.stringify(config.permissions?.filter((rule) => rule.action === "skill")) !== JSON.stringify(SUMI_SKILL_PERMISSIONS) || !isManagedSumiPlugin(readOptional(join34(sumiConfigDirectory(home, process.env, options.projectDir ?? process.cwd()), "plugins", "skills-cli.js")), command, profile))
       throw new Error("NATIVE_SKILL_DRIFT: Sumi bridge protection changed; run skills hook install");
@@ -59357,6 +59384,21 @@ function assertManagedAgentBridgeWithDiscovery(agent, options = {}, provenDiscov
     if (agent === "gemini" && (config.hooksConfig?.enabled === false || config.skills?.enabled !== true || !["antigravity-support", "skill-creator"].every((name) => config.skills?.disabled?.includes(name)) || config.skills?.disabled?.includes(CLI_BRIDGE_NAME)))
       throw new Error("NATIVE_SKILL_DRIFT: Gemini bridge or bundled-skill protection changed; run skills hook install");
   }
+  if (agent === "codex") {
+    const codexConfig = Bun.TOML.parse(readOptional(canonicalAgentPath(join34(home, ".codex", "config.toml"), aliases)) ?? "");
+    if (codexConfig.skills?.bundled?.enabled !== false)
+      throw new Error("NATIVE_SKILL_DRIFT: Codex bundled skill reseeding is not disabled (skills.bundled.enabled); run skills hook install");
+    const setting = (path) => (codexConfig.skills?.config ?? []).filter((entry) => typeof entry.path === "string" && [path, join34(path, "SKILL.md")].includes(canonicalAgentPath(entry.path, aliases)));
+    if ([...setting(expected), ...(codexConfig.skills?.config ?? []).filter((entry) => typeof entry.name === "string" && entry.name.trim() === CLI_BRIDGE_NAME)].some((entry) => entry.enabled === false))
+      throw new Error("NATIVE_SKILL_DRIFT: the Codex CLI bridge is disabled; run skills hook install");
+  }
+  if (agent === "gemini" && discovery && !discovery.builtinNames?.every((name) => config.skills.disabled.includes(name)))
+    throw new Error("NATIVE_SKILL_DRIFT: an installed Gemini builtin is not disabled");
+  return assertManagedNativeDiscovery(custody, agent, options);
+}
+function assertManagedNativeDiscovery(custody, agent, options) {
+  const { home, dataDir: dataDir3, binding, aliases, expected, roots, discovery } = custody;
+  const visible = (entry) => entry.agent === agent || ["codex", "gemini", "opencode", "hermes", "sumi"].includes(agent) && entry.path.includes(`${sep13}.agents${sep13}skills${sep13}`) || ["opencode", "sumi"].includes(agent) && entry.agent === "claude";
   const codexPath = canonicalAgentPath(join34(home, ".codex", "config.toml"), aliases);
   const vendorCache = canonicalAgentPath(join34(home, ".codex", "plugins", "cache"), aliases);
   const witnessTolerance = agent === "codex" && options.codexPromptHook === true ? {
@@ -59367,11 +59409,6 @@ function assertManagedAgentBridgeWithDiscovery(agent, options = {}, provenDiscov
   if (options.codexDiscoveryRecovery && (agent !== "codex" || options.codexDiscoveryRecovery.configPath !== codexPath))
     throw new Error("NATIVE_SKILL_DRIFT: Codex trust recovery names a different configuration root");
   const codexConfig = agent === "codex" ? Bun.TOML.parse(readOptional(codexPath) ?? "") : {};
-  if (agent === "codex" && codexConfig.skills?.bundled?.enabled !== false)
-    throw new Error("NATIVE_SKILL_DRIFT: Codex bundled skill reseeding is not disabled (skills.bundled.enabled); run skills hook install");
-  const setting = (path) => (codexConfig.skills?.config ?? []).filter((entry) => typeof entry.path === "string" && [path, join34(path, "SKILL.md")].includes(canonicalAgentPath(entry.path, aliases)));
-  if (agent === "codex" && [...setting(expected), ...(codexConfig.skills?.config ?? []).filter((entry) => typeof entry.name === "string" && entry.name.trim() === CLI_BRIDGE_NAME)].some((entry) => entry.enabled === false))
-    throw new Error("NATIVE_SKILL_DRIFT: the Codex CLI bridge is disabled; run skills hook install");
   if (agent === "codex" && !reviewedCodexPluginCapabilitiesUnchanged(canonicalAgentPath(join34(home, ".codex/plugins/cache"), aliases), binding.codexPluginSkills ?? [], (path) => new TextDecoder("utf-8", { fatal: true }).decode(readNativeBytes(path, 1024 * 1024)), codexConfig.skills?.config ?? []))
     throw new Error("NATIVE_SKILL_DRIFT: reviewed native plugin capability controls changed; run skills hook install with a fresh discovery review");
   const disabledPlugin = (entry) => {
@@ -59408,8 +59445,6 @@ function assertManagedAgentBridgeWithDiscovery(agent, options = {}, provenDiscov
   };
   if (!discovery || discovery.agent !== agent)
     throw new Error("NATIVE_SKILL_DRIFT: native discovery coverage is missing; run skills hook install");
-  if (agent === "gemini" && !discovery.builtinNames?.every((name) => config.skills.disabled.includes(name)))
-    throw new Error("NATIVE_SKILL_DRIFT: an installed Gemini builtin is not disabled");
   try {
     verifyAgentDiscovery(agent === "codex" ? { ...discovery, codexDisabledPluginSkills: binding.codexPluginSkills ?? [] } : discovery, options.codexDiscoveryRecovery, aliases, witnessTolerance);
     if (agent === "sumi" && discovery.method === "reviewed")
@@ -59464,7 +59499,7 @@ function assertManagedAgentBridgeWithDiscovery(agent, options = {}, provenDiscov
         return false;
       }
     }, read: (path) => new TextDecoder("utf-8", { fatal: true }).decode(readNativeBytes(path, 1024 * 1024)) });
-    throw new Error(`NATIVE_SKILL_DRIFT: ${blocking.length} unexpected native skill copies were found: ${nativeSkillPathList(blocking.map((entry) => entry.path))}. ${remediation}${adapterRefusal ? ` Native policy adapter refused: ${adapterRefusal}` : ""}`);
+    throw new NativeSkillCopiesDriftError(`NATIVE_SKILL_DRIFT: ${blocking.length} unexpected native skill copies were found: ${nativeSkillPathList(blocking.map((entry) => entry.path))}. ${remediation}${adapterRefusal ? ` Native policy adapter refused: ${adapterRefusal}` : ""}`);
   }
   recheckRootAliases(aliases);
   const discoveryChanges = (witnessTolerance?.changes ?? []).filter((change, index, all) => all.findIndex((other) => other.kind === change.kind && other.path === change.path) === index);
@@ -59505,7 +59540,7 @@ function assertNativeExportAllowed(dataDir3 = getDataDirReadOnly()) {
   if (requiresCliSkillLoading(dataDir3))
     throw new Error("NATIVE_SKILL_EXPORT_DISABLED: this station loads skills through the Skills CLI; use skills sync --selection-profile <id>");
 }
-var sha4 = (data) => createHash26("sha256").update(data).digest("hex"), HOOK_EVENTS, ROOTS, SKILLS_LOADING_POLICY = "Skills loading policy: discover skills with `skills list` or `skills search`, and read selected instructions with `skills load <slug>`. Use `skills sync` to refresh the shared profile. The only native skill is the owned skills-cli bridge. Create and edit payload skills in the Skills authoring workspace; do not copy payload instructions into native discovery folders. Context loading does not authorize execution; use `skills run` only when the task calls for running a skill.";
+var sha4 = (data) => createHash26("sha256").update(data).digest("hex"), HOOK_EVENTS, ROOTS, NativeSkillCopiesDriftError, SKILLS_LOADING_POLICY = "Skills loading policy: discover skills with `skills list` or `skills search`, and read selected instructions with `skills load <slug>`. Use `skills sync` to refresh the shared profile. The only native skill is the owned skills-cli bridge. Create and edit payload skills in the Skills authoring workspace; do not copy payload instructions into native discovery folders. Context loading does not authorize execution; use `skills run` only when the task calls for running a skill.";
 var init_agent_integration = __esm(() => {
   init_sumi_settings_witness();
   init_codex_corpus_write();
@@ -59534,6 +59569,8 @@ var init_agent_integration = __esm(() => {
   init_retained_review_artifacts();
   HOOK_EVENTS = ["UserPromptSubmit", "SessionStart", "SubagentStart"];
   ROOTS = NATIVE_SKILL_ROOTS;
+  NativeSkillCopiesDriftError = class NativeSkillCopiesDriftError extends Error {
+  };
 });
 
 // src/lib/home-migration.ts
@@ -62715,6 +62752,9 @@ function verifyAgentDiscovery(binding, codexRecovery, reviewedRootAliases, witne
 function claudeControlSource(source) {
   return CLAUDE_CONTROL_WITNESS_MODES.has(source.hashMode ?? "") || CLAUDE_CONTROL_FILES.has(basename16(source.path)) && !source.path.includes(`${sep14}.claude${sep14}plugins${sep14}cache${sep14}`);
 }
+function retainedAbsentClaudeRoot(absentRoots, source) {
+  return claudeControlSource(source) ? undefined : retainedAbsentRoot(absentRoots, source);
+}
 function classifyClaudeDiscoverySources(binding) {
   if (!binding || binding.agent !== "claude" || !Array.isArray(binding.sources))
     throw new Error("Invalid Claude discovery binding");
@@ -62735,7 +62775,7 @@ function classifyClaudeDiscoverySources(binding) {
   };
   const budget2 = discoveryByteBudget();
   return binding.sources.map((source) => {
-    const root2 = claudeControlSource(source) ? undefined : retainedAbsentRoot(absentRoots, source);
+    const root2 = retainedAbsentClaudeRoot(absentRoots, source);
     if (root2 !== undefined)
       return { status: "retained-absent", root: root2, witness: retainableAbsentWitness(source) };
     let current;
@@ -63150,7 +63190,10 @@ function resolveAgentDiscovery(options) {
     if (!review.sources.some((source) => source.path === canonical9(configPath)))
       throw new Error("Discovery review must include the agent configuration source");
     const reviewedSources = supersedesSettingsProjection(agent, review.sources, canonical9(configPath)) ? sources.filter((source) => !isSupersededSettingsProjection(agent, canonical9(configPath), source)) : sources;
+    const absentRoots = absentRetiredClaudeRoots(supplied);
     const reviewedSourcesWithManifestProjection = review.sources.map((source) => {
+      if (retainedAbsentClaudeRoot(absentRoots, source) !== undefined)
+        return source;
       if (agent === "claude" && source.format === undefined && source.fields === undefined && source.managedPlugins === undefined && source.reviewArtifact === undefined && [undefined, "bytes", "path-bytes"].includes(source.hashMode) && isClaudePluginCacheOrphanMarker(source.path)) {
         return { path: source.path, hashMode: CLAUDE_ORPHAN_MARKER_MODE, sha256: hashClaudePluginCacheOrphanMarker(source.path) };
       }
@@ -63183,6 +63226,11 @@ function resolveAgentDiscovery(options) {
     });
     if (agent === "claude")
       assertReviewedClaudeCacheClosures(home, config, review, canonical9);
+    for (const root2 of absentRoots) {
+      safe6(root2);
+      if (lstatSync32(root2, { throwIfNoEntry: false }))
+        throw new Error("Retired native materialization changed during discovery review");
+    }
     const combined = [...reviewedSources, ...reviewedSourcesWithManifestProjection];
     const unique = combined.filter((source, index) => combined.findIndex((candidate2) => isDeepStrictEqual13(candidate2, source)) === index);
     return { ...supplied, roots: [...new Set([...roots, ...supplied.roots])].sort(), sources: unique, ...agent === "gemini" ? { builtinNames } : {} };
@@ -94457,7 +94505,11 @@ var exports_selected_run = {};
 __export(exports_selected_run, {
   resolveSelectedRun: () => resolveSelectedRun,
   prepareSelectedSecretBindings: () => prepareSelectedSecretBindings,
-  executeSelectedLocal: () => executeSelectedLocal
+  instructionRunRefusal: () => instructionRunRefusal,
+  instructionEntrypointMismatch: () => instructionEntrypointMismatch,
+  instructionCommandEntry: () => instructionCommandEntry,
+  executeSelectedLocal: () => executeSelectedLocal,
+  declaredOperation: () => declaredOperation
 });
 import { createHash as createHash36 } from "crypto";
 import { spawn as spawn3 } from "child_process";
@@ -94470,12 +94522,51 @@ async function resolveSelectedRun(spec, profileId, options = {}) {
   const entries = await readSelectedEntries(selection2, context, options);
   return { selection: selection2, profileId: context.receipt.profile.profileId, entries, ...describeEntries(entries), cacheDir: selectionCacheRoot(options) };
 }
+function declaredOperation(manifest) {
+  const entry = instructionCommandEntry(manifest);
+  if (!entry)
+    return null;
+  const runtime = manifest.runtime;
+  if (!runtime || typeof runtime !== "object" || Array.isArray(runtime))
+    return null;
+  if (runtime.runtime !== "bun" && runtime.runtime !== "node" && runtime.runtime !== "python3")
+    return null;
+  if (instructionEntrypointMismatch(manifest))
+    return null;
+  return { entry };
+}
+function instructionCommandEntry(manifest) {
+  const commands = Array.isArray(manifest.commands) ? manifest.commands : [];
+  const command = commands[0];
+  if (!command || typeof command !== "object" || typeof command.entry !== "string" || command.entry.length === 0)
+    return null;
+  return command.entry;
+}
+function instructionEntrypointMismatch(manifest) {
+  const entry = instructionCommandEntry(manifest);
+  const declared = manifest.runtime;
+  if (!entry || !declared || typeof declared !== "object" || Array.isArray(declared))
+    return null;
+  const runtimeEntrypoint = declared.entrypoint;
+  return typeof runtimeEntrypoint === "string" && runtimeEntrypoint !== entry ? runtimeEntrypoint : null;
+}
+function instructionRunRefusal(manifest, isBundledFile) {
+  const declaredEntry = instructionCommandEntry(manifest);
+  if (declaredEntry && !isBundledFile(declaredEntry))
+    return { code: "LOCAL_ENTRYPOINT_MISSING", message: `This selected instruction skill declares its operation entry as ${declaredEntry}, which is not a regular file in the selected bundle; a different runtime.entrypoint never substitutes for it.` };
+  const mismatch = instructionEntrypointMismatch(manifest);
+  if (mismatch)
+    return { code: "LOCAL_ENTRYPOINT_MISMATCH", message: `This selected instruction skill declares its operation entry as ${declaredEntry}, but its runtime.entrypoint is ${mismatch}; the two must agree.` };
+  if (!declaredOperation(manifest))
+    return { code: "INSTRUCTION_SKILL", message: "This selected skill contains instructions. Use skills load instead of skills run." };
+  return null;
+}
 async function prepareSelectedSecretBindings(selected, cwd2 = process.cwd()) {
   const entries = await readCachedSelection(selected.selection, { cacheDir: selected.cacheDir });
   if (!entries)
     throw new SkillSelectionError("CACHED_BUNDLE_MISSING", "The selected execution bundle is not cached.");
   const { kind, manifest } = describeEntries(entries);
-  if (kind !== "executable")
+  if (kind !== "executable" && !declaredOperation(manifest))
     throw new SkillSelectionError("INSTRUCTION_SKILL", "Instruction skills do not accept execution secret bindings.");
   const names = declaredSecretNames(manifest.runtime?.env);
   if (!names.length)
@@ -94488,8 +94579,12 @@ async function executeSelectedLocal(selected, options = {}) {
   if (!entries)
     throw new SkillSelectionError("CACHED_BUNDLE_MISSING", "The selected local execution bundle is not cached.");
   const { kind, manifest, packageJson } = describeEntries(entries);
-  if (kind === "instruction")
-    throw new SkillSelectionError("INSTRUCTION_SKILL", "This selected skill contains instructions. Use skills load instead of skills run.");
+  const operation = declaredOperation(manifest);
+  if (kind === "instruction") {
+    const refusal3 = instructionRunRefusal(manifest, (path) => entries.some((entry) => entry.path === path));
+    if (refusal3)
+      throw new SkillSelectionError(refusal3.code, refusal3.message);
+  }
   const runtime = manifest.runtime ?? {};
   if (!runtime || typeof runtime !== "object" || Array.isArray(runtime))
     throw new SkillSelectionError("INVALID_SKILL_MANIFEST", "The selected runtime declaration is invalid.");
@@ -94508,9 +94603,9 @@ async function executeSelectedLocal(selected, options = {}) {
   const executable2 = runtimeName === "bun" ? process.execPath : Bun.which(runtimeName);
   if (!executable2)
     throw new SkillSelectionError("LOCAL_RUNTIME_UNAVAILABLE", "The selected runtime is not installed on this station.");
-  const declaredEntry = runtime.entrypoint ?? (typeof packageJson.bin === "string" ? packageJson.bin : packageJson.bin && typeof packageJson.bin === "object" ? Object.values(packageJson.bin)[0] : undefined);
+  const declaredEntry = (kind === "instruction" ? operation?.entry : undefined) ?? runtime.entrypoint ?? (typeof packageJson.bin === "string" ? packageJson.bin : packageJson.bin && typeof packageJson.bin === "object" ? Object.values(packageJson.bin)[0] : undefined);
   if (typeof declaredEntry !== "string" || !entries.some((entry) => entry.path === declaredEntry))
-    throw new SkillSelectionError("LOCAL_ENTRYPOINT_MISSING", "The selected bundle must declare a regular-file entrypoint in its runtime manifest or package bin.");
+    throw new SkillSelectionError("LOCAL_ENTRYPOINT_MISSING", kind === "instruction" ? "The selected instruction skill must declare the operation entrypoint it ships in its manifest, and that declared entry must be a regular file in the selected bundle; a different runtime.entrypoint never substitutes for it." : "The selected bundle must declare a regular-file entrypoint in its runtime manifest or package bin.");
   const args = options.args ?? [];
   if (args.length > 128 || args.some((arg) => typeof arg !== "string" || arg.length > 16384 || arg.includes("\x00")))
     throw new SkillSelectionError("INVALID_RUN_INPUT", "Local skill arguments exceed their limits.");
@@ -94585,6 +94680,7 @@ async function executeSelectedLocal(selected, options = {}) {
     selection: selection2,
     target: "local",
     runtime: runtimeName,
+    entrypoint: declaredEntry,
     inputDigest: `sha256:${createHash36("sha256").update(input2).digest("hex")}`,
     runDirectory,
     ...executionGrant ? { executionGrant } : {},
@@ -113378,13 +113474,18 @@ function registerOperationTools(server) {
       return mcpError("CONFLICTING_EXECUTION_MODES", "Use remote for the configured server catalog and quote, or target for selected execution, not both.");
     if (managed && !remote) {
       try {
-        const { resolveSelectedRun: resolveSelectedRun2, executeSelectedLocal: executeSelectedLocal2 } = await Promise.resolve().then(() => (init_selected_run(), exports_selected_run));
+        const { resolveSelectedRun: resolveSelectedRun2, executeSelectedLocal: executeSelectedLocal2, instructionRunRefusal: instructionRunRefusal2 } = await Promise.resolve().then(() => (init_selected_run(), exports_selected_run));
         const resolved = await resolveSelectedRun2(name, selectedProfileId(), { projectDir: process.cwd() });
-        if (resolved.kind === "instruction")
-          return mcpError("INSTRUCTION_SKILL", "This selected skill contains instructions. Load it with skills load instead of running it.");
+        if (resolved.kind === "instruction") {
+          const refusal3 = instructionRunRefusal2(resolved.manifest, (path) => resolved.entries.some((entry) => entry.path === path));
+          if (refusal3)
+            return mcpError(refusal3.code, refusal3.message);
+        }
         if (files?.length)
           return mcpError("SELECTED_INPUT_REQUIRED", "Selected executions require their declared JSON input; use the CLI cloud execution input contract for files.");
         if (target === "cloud") {
+          if (resolved.kind === "instruction")
+            return mcpError("INSTRUCTION_SKILL", "Cloud execution requires an executable skill version; run the declared operation locally on a managed station, or load the instructions with skills load.");
           if (args?.length || quoteReceipt || maxCredits !== undefined || maxCostCents !== undefined)
             return mcpError("SELECTED_INPUT_REQUIRED", "The selected cloud execution contract accepts declared JSON input, not legacy run arguments or quote receipts.");
           const { CloudExecutionClient: CloudExecutionClient2 } = await Promise.resolve().then(() => (init_cloud_executions(), exports_cloud_executions));
@@ -117550,8 +117651,11 @@ async function handleRun(name, args2, options, separatorBeforeSkill) {
         projectDir: process.cwd(),
         sessionId: options.session
       }) : undefined;
-      if (selected?.kind === "instruction")
-        throw new Error("This selected skill contains instructions. Use skills load instead of skills run.");
+      if (selected?.kind === "instruction") {
+        const refusal3 = instructionRunRefusal(selected.manifest, (path) => selected.entries.some((entry) => entry.path === path));
+        if (refusal3)
+          throw new Error(refusal3.message);
+      }
       if (selected) {
         slug2 = selected.selection.slug;
         version2 = selected.selection.version;
@@ -117576,6 +117680,8 @@ async function handleRun(name, args2, options, separatorBeforeSkill) {
         process.exitCode = result4.exitCode;
         return;
       }
+      if (selected?.kind === "instruction")
+        throw new Error("Cloud execution requires an executable skill version; run the declared operation locally on a managed station, or use skills load for the instructions.");
       if (args2.length || options.remote || options.file?.length)
         throw new Error("Cloud execution accepts structured --input only");
       if (!version2 || options.input === undefined)
@@ -121866,6 +121972,369 @@ var init_profiles = __esm(() => {
   init_remote_permissions();
 });
 
+// src/lib/selection-provenance.ts
+function label(value) {
+  return value !== undefined && SAFE_LABEL2.test(value) ? value : "an unnamed value";
+}
+async function attempt2(read3) {
+  try {
+    return { ok: true, value: await read3() };
+  } catch {
+    return { ok: false, code: "READ_REFUSED" };
+  }
+}
+function sameRevision(observed, reference) {
+  return observed !== undefined && reference !== undefined && observed === reference;
+}
+function sameIdentity2(observed, reference) {
+  if (observed.profileId !== undefined && reference.profileId !== undefined && observed.profileId !== reference.profileId)
+    return false;
+  if (observed.authority !== undefined && reference.authority !== undefined && observed.authority !== reference.authority)
+    return false;
+  if (observed.workspaceId !== undefined && reference.workspaceId !== undefined && observed.workspaceId !== reference.workspaceId)
+    return false;
+  return true;
+}
+function supportedIdentityValue(value) {
+  return typeof value === "string" && value.trim() !== "";
+}
+function uncomparableFields(observed, reference, required2) {
+  return required2.filter((field3) => !supportedIdentityValue(observed[field3]) || !supportedIdentityValue(reference[field3]));
+}
+function supportedIdentityFields(source) {
+  const out = {};
+  for (const field3 of ["profileId", "profileRevision", "authority", "workspaceId"]) {
+    const value = source[field3];
+    if (supportedIdentityValue(value))
+      out[field3] = value;
+  }
+  return out;
+}
+function revisionReason(labelText, observed, reference, status) {
+  const seen = label(observed);
+  if (status === "current")
+    return `${labelText} revision ${seen} is the selected revision`;
+  return `${labelText} revision ${seen} is not the selected revision ${label(reference)}`;
+}
+async function resolveReference(input3, options) {
+  const fromSnapshot = (reasonCode, because) => {
+    let receipt;
+    try {
+      receipt = readSelectionProfile(input3.profileId, options);
+    } catch {
+      return { profileId: input3.profileId, source: "unavailable", reasonCode: "REFERENCE_UNAVAILABLE", reason: `${because} The locally synced snapshot is unreadable too.`, selections: noSelections };
+    }
+    if (!receipt)
+      return { profileId: input3.profileId, source: "unavailable", reasonCode: "REFERENCE_UNAVAILABLE", reason: `${because} Nothing is synced locally either, so no consumer can be compared.`, selections: noSelections };
+    return {
+      profileId: receipt.profile.profileId,
+      ...supportedIdentityFields({ profileRevision: receipt.profile.profileRevision, authority: receipt.profile.authority, workspaceId: receipt.profile.workspaceId }),
+      selectionCount: receipt.profile.selections.length,
+      observedAt: receipt.verifiedAt,
+      source: "synced-snapshot",
+      reasonCode,
+      reason: `${because} Comparisons use the locally synced snapshot (posted work is not proof of adoption), so every consumer below is reported unverified rather than current.`,
+      selections: receipt.profile.selections
+    };
+  };
+  if (input3.cached)
+    return fromSnapshot("REFERENCE_NOT_AUTHORITY", "--cached was requested, so the authority was not read.");
+  const read3 = options.readSelected ?? (async (profileId) => {
+    const client2 = await createProfileClient();
+    const profile2 = await client2.resolveProfile(profileId);
+    return { profileId: profile2.profileId, profileRevision: profile2.profileRevision, authority: profile2.authority, workspaceId: profile2.workspaceId, selections: profile2.selections };
+  });
+  const attempted = await attempt2(() => read3(input3.profileId));
+  if (!attempted.ok)
+    return fromSnapshot("READ_REFUSED", "The authority did not answer for the selected profile.");
+  const profile = attempted.value;
+  if (!profile?.profileId || !profile.profileRevision || !Array.isArray(profile.selections)) {
+    return { profileId: input3.profileId, source: "unavailable", reasonCode: "REFERENCE_UNAVAILABLE", reason: "The authority returned a selection profile this client does not recognise, so no consumer can be compared.", selections: noSelections };
+  }
+  return {
+    profileId: profile.profileId,
+    profileRevision: profile.profileRevision,
+    selectionCount: profile.selections.length,
+    ...profile.authority === undefined ? {} : { authority: profile.authority },
+    ...profile.workspaceId === undefined ? {} : { workspaceId: profile.workspaceId },
+    source: "authority",
+    reasonCode: "REFERENCE_FROM_AUTHORITY",
+    reason: `Read from the authority for profile ${label(profile.profileId)}.`,
+    selections: profile.selections
+  };
+}
+function activationConsumer(input3, reference, options) {
+  const base3 = {
+    kind: "station",
+    source: "local-receipt",
+    id: input3.localStationId,
+    idKind: "local-host",
+    status: "unverified",
+    reasonCode: "NO_LOCAL_RECEIPT",
+    reason: ""
+  };
+  const refuse10 = (reasonCode, reason2) => ({ consumer: { ...base3, reasonCode, reason: reason2 }, compared: noSelections });
+  let receipt;
+  try {
+    receipt = readSelectionProfile(input3.profileId, options);
+  } catch {
+    return refuse10("READ_REFUSED", `This machine's activated snapshot for profile ${label(input3.profileId)} could not be read.`);
+  }
+  if (!receipt)
+    return refuse10("NO_LOCAL_RECEIPT", `This machine holds no activated snapshot for profile ${label(input3.profileId)}.`);
+  const profile = receipt.profile;
+  const observed = {
+    ...base3,
+    ...supportedIdentityFields({ profileId: profile.profileId, profileRevision: profile.profileRevision, authority: profile.authority, workspaceId: profile.workspaceId }),
+    observedAt: receipt.verifiedAt,
+    selectionCount: profile.selections.length
+  };
+  if (!sameIdentity2(observed, reference)) {
+    return { consumer: { ...observed, status: "unverified", reasonCode: "IDENTITY_MISMATCH", reason: `This machine's activated snapshot is not the selected selection's identity: it differs in profile, authority or workspace, so it is not current whatever its revision.` }, compared: noSelections };
+  }
+  if (reference.source !== "authority") {
+    return { consumer: { ...observed, status: "unverified", reasonCode: reference.reasonCode, reason: `${reference.reason} This snapshot alone cannot say whether the machine is current.` }, compared: noSelections };
+  }
+  const missingActivation = uncomparableFields(observed, reference, REQUIRED_IDENTITY["local-receipt"]);
+  if (missingActivation.length > 0) {
+    return { consumer: { ...observed, status: "unverified", reasonCode: "INCOMPLETE_RECEIPT", reason: `This machine's activated snapshot does not record ${missingActivation.join(", ")}, so its identity and revision cannot be compared; it is reported unverified rather than current or behind.` }, compared: noSelections };
+  }
+  const status = sameRevision(profile.profileRevision, reference.profileRevision) ? "current" : "behind";
+  return {
+    consumer: {
+      ...observed,
+      status,
+      reasonCode: status === "current" ? "CURRENT_SCHEMA_MATCH" : "REVISION_BEHIND",
+      reason: status === "current" ? revisionReason("This machine's activated snapshot", profile.profileRevision, reference.profileRevision, "current") : `${revisionReason("This machine's activated snapshot", profile.profileRevision, reference.profileRevision, "behind")}. Run skills sync to activate the selected revision here.`
+    },
+    compared: profile.selections
+  };
+}
+async function stationConsumer(input3, reference, options) {
+  const base3 = {
+    kind: "station",
+    source: "authority-receipt",
+    id: input3.stationId,
+    idKind: "requested-station",
+    status: "unverified",
+    reasonCode: "NO_STATION_REPORTED",
+    reason: ""
+  };
+  const refuse10 = (reasonCode, reason2) => ({ consumer: { ...base3, reasonCode, reason: reason2 }, compared: noSelections });
+  if (reference.source !== "authority") {
+    return refuse10("REFERENCE_NOT_AUTHORITY", "The station receipt was not compared: this receipt has no authenticated selection to compare it with.");
+  }
+  const read3 = options.readStation ?? (async (stationId) => {
+    const state = await readStationSkillState(stationId);
+    return { profileId: state.profileId, profileRevision: state.profileRevision, appliedAt: state.appliedAt, workspaceId: state.workspaceId, selections: state.selections };
+  });
+  const attempted = await attempt2(() => read3(input3.stationId));
+  if (!attempted.ok)
+    return refuse10("READ_REFUSED", `The authority did not answer for station ${label(input3.stationId)}.`);
+  const station = attempted.value;
+  const observed = {
+    ...base3,
+    ...supportedIdentityFields({ profileId: station.profileId, profileRevision: station.profileRevision, workspaceId: station.workspaceId }),
+    observedAt: station.appliedAt,
+    selectionCount: station.selections.length
+  };
+  if (!sameIdentity2(observed, reference)) {
+    return { consumer: { ...observed, status: "unverified", reasonCode: "IDENTITY_MISMATCH", reason: `Station ${label(input3.stationId)} last applied a different selection identity: it differs in profile or workspace from the selected profile.` }, compared: noSelections };
+  }
+  const missing2 = uncomparableFields(observed, reference, REQUIRED_IDENTITY["authority-receipt"]);
+  if (missing2.length > 0) {
+    return { consumer: { ...observed, status: "unverified", reasonCode: "INCOMPLETE_RECEIPT", reason: `The receipt the authority holds for station ${label(input3.stationId)} does not record ${missing2.join(", ")}, so its identity and revision cannot be compared; it is reported unverified rather than current or behind.` }, compared: noSelections };
+  }
+  if (sameRevision(station.profileRevision, reference.profileRevision)) {
+    return { consumer: { ...observed, status: "current", reasonCode: "CURRENT_SCHEMA_MATCH", reason: revisionReason(`The receipt the authority holds for station ${label(input3.stationId)}`, station.profileRevision, reference.profileRevision, "current") }, compared: station.selections };
+  }
+  return {
+    consumer: {
+      ...observed,
+      status: "behind",
+      reasonCode: "REVISION_BEHIND",
+      reason: `${revisionReason(`The receipt the authority holds for station ${label(input3.stationId)}`, station.profileRevision, reference.profileRevision, "behind")}. Only an explicit skills sync writes this record, so report it before treating the machine as adrift.`
+    },
+    compared: station.selections
+  };
+}
+function sessionConsumer(input3, reference, options) {
+  const unnamed = {
+    kind: "session",
+    source: "session-receipt",
+    id: "unnamed",
+    idKind: "local-host",
+    status: "unverified",
+    reasonCode: "NO_SESSION_NAMED",
+    reason: "No session was named, so its pin and load receipts were not read; pass --session <id>."
+  };
+  if (!input3.sessionId)
+    return { consumer: unnamed, compared: noSelections };
+  const base3 = {
+    kind: "session",
+    source: "session-receipt",
+    id: input3.sessionId,
+    idKind: "local-host",
+    status: "unverified",
+    reasonCode: "NO_SESSION_RECEIPT",
+    reason: ""
+  };
+  const refuse10 = (reasonCode, reason2) => ({ consumer: { ...base3, reasonCode, reason: reason2 }, compared: noSelections });
+  let session;
+  try {
+    session = inspectSkillSession(input3.sessionId, options);
+  } catch {
+    return refuse10("READ_REFUSED", `The session receipt for the named session could not be read.`);
+  }
+  const consumed = session.selections.filter((selection2) => selection2.loaded).map((selection2) => ({ slug: selection2.slug, version: selection2.version, bundleDigest: selection2.bundleDigest }));
+  const observed = {
+    ...base3,
+    ...supportedIdentityFields({ profileId: session.profileId, profileRevision: session.profileRevision, authority: session.authority, workspaceId: session.workspaceId }),
+    observedAt: session.verifiedAt,
+    selectionCount: session.selectionCount,
+    loadedCount: session.loadedCount,
+    consumed
+  };
+  if (!sameIdentity2(observed, reference)) {
+    return { consumer: { ...observed, status: "unverified", reasonCode: "IDENTITY_MISMATCH", reason: "The session pin is not the selected selection's identity: it differs in profile, authority or workspace, so it is not current whatever its revision." }, compared: noSelections };
+  }
+  if (reference.source !== "authority") {
+    return { consumer: { ...observed, status: "unverified", reasonCode: reference.reasonCode, reason: `${reference.reason} This pin alone cannot say whether the session is current.` }, compared: noSelections };
+  }
+  const missingPin = uncomparableFields(observed, reference, REQUIRED_IDENTITY["session-receipt"]);
+  if (missingPin.length > 0) {
+    return { consumer: { ...observed, status: "unverified", reasonCode: "INCOMPLETE_RECEIPT", reason: `The session receipt does not record ${missingPin.join(", ")}, so its identity and revision cannot be compared; it is reported unverified rather than current, pinned or behind.` }, compared: noSelections };
+  }
+  if (sameRevision(session.profileRevision, reference.profileRevision)) {
+    return {
+      consumer: { ...observed, status: "current", reasonCode: "CURRENT_SCHEMA_MATCH", reason: `${revisionReason("The session pin", session.profileRevision, reference.profileRevision, "current")}; it loaded ${session.loadedCount} of ${session.selectionCount} selections.` },
+      compared: consumed
+    };
+  }
+  return {
+    consumer: {
+      ...observed,
+      status: "pinned",
+      reasonCode: "PINNED_BY_DESIGN",
+      reason: `${revisionReason("The session pin", session.profileRevision, reference.profileRevision, "pinned")}. A session keeps its revision when the profile moves on, so this is custody by design; skills sessions reconcile moves it intentionally.`
+    },
+    compared: consumed
+  };
+}
+function driftFor(result2, reference) {
+  if (reference.source !== "authority" || result2.compared.length === 0)
+    return [];
+  if (result2.consumer.status === "unverified" && result2.consumer.reasonCode === "IDENTITY_MISMATCH")
+    return [];
+  const selected = new Map(reference.selections.map((selection2) => [selection2.slug, selection2.version]));
+  return result2.compared.filter((selection2) => selected.has(selection2.slug) && selected.get(selection2.slug) !== selection2.version).map((selection2) => ({ source: result2.consumer.source, id: result2.consumer.id, slug: selection2.slug, selectedVersion: selected.get(selection2.slug), observedVersion: selection2.version })).sort((left, right) => left.slug.localeCompare(right.slug) || left.source.localeCompare(right.source));
+}
+async function readSelectionProvenance(input3, options = {}) {
+  if (!input3.profileId?.trim())
+    throw new Error("A selection profile id is required to read selection provenance.");
+  if (!input3.stationId?.trim() || input3.stationId.length > LABEL_MAX_CHARS)
+    throw new Error("A station id is required to read selection provenance.");
+  if (!input3.localStationId?.trim() || input3.localStationId.length > LABEL_MAX_CHARS)
+    throw new Error("The local host id is required to read selection provenance.");
+  const reference = await resolveReference(input3, options);
+  const results2 = [activationConsumer(input3, reference, options), await stationConsumer(input3, reference, options), sessionConsumer(input3, reference, options)];
+  const drift = results2.flatMap((result2) => driftFor(result2, reference));
+  return {
+    schemaVersion: 1,
+    readOnly: true,
+    selectionProfile: input3.profileId,
+    selected: {
+      profileId: reference.profileId,
+      ...supportedIdentityValue(reference.profileRevision) ? { profileRevision: reference.profileRevision, selectionCount: reference.selectionCount } : {},
+      ...supportedIdentityValue(reference.authority) ? { authority: reference.authority } : {},
+      ...supportedIdentityValue(reference.workspaceId) ? { workspaceId: reference.workspaceId } : {},
+      ...reference.observedAt === undefined ? {} : { observedAt: reference.observedAt },
+      source: reference.source,
+      reasonCode: reference.reasonCode,
+      reason: reference.reason
+    },
+    consumers: results2.map((result2) => result2.consumer),
+    drift: drift.slice(0, PROVENANCE_DRIFT_LIMIT),
+    driftTruncated: drift.length > PROVENANCE_DRIFT_LIMIT,
+    notAttested: [
+      "Published version and digest evidence for skill payloads: read it with skills versions and skills review-export.",
+      "Native discovery, native locks and project locks: read them with skills hook check and skills sessions recover-lock.",
+      "Live consumer adoption: a receipt shows what a session loaded, never that an agent honoured it."
+    ]
+  };
+}
+var PROVENANCE_DRIFT_LIMIT = 200, SAFE_LABEL2, LABEL_MAX_CHARS = 200, noSelections, REQUIRED_IDENTITY;
+var init_selection_provenance = __esm(() => {
+  init_session_reconciliation();
+  init_profile_admin();
+  init_profile_client();
+  init_selection_cache();
+  SAFE_LABEL2 = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/;
+  noSelections = [];
+  REQUIRED_IDENTITY = {
+    "local-receipt": ["profileId", "profileRevision", "authority", "workspaceId"],
+    "session-receipt": ["profileId", "profileRevision", "authority", "workspaceId"],
+    "authority-receipt": ["profileId", "profileRevision", "workspaceId"]
+  };
+});
+
+// src/cli/commands/provenance.ts
+var exports_provenance = {};
+__export(exports_provenance, {
+  registerProvenance: () => registerProvenance,
+  provenanceLines: () => provenanceLines
+});
+import { hostname as hostname5 } from "os";
+function provenanceLines(receipt) {
+  const selected = receipt.selected;
+  const lines = [
+    `Selection profile ${receipt.selectionProfile}`,
+    `Selected: ${selected.profileRevision ?? "unavailable"} (${selected.selectionCount ?? 0} selections, ${selected.source})`
+  ];
+  for (const consumer of receipt.consumers)
+    lines.push(...consumerLines(consumer));
+  if (receipt.drift.length > 0) {
+    lines.push(`Drift (${receipt.drift.length}${receipt.driftTruncated ? ", truncated" : ""}):`);
+    for (const row2 of receipt.drift)
+      lines.push(`- ${row2.source} ${row2.id}: ${row2.slug} ${row2.selectedVersion} -> ${row2.observedVersion}`);
+  }
+  return lines;
+}
+function consumerLines(consumer) {
+  const label2 = consumer.kind === "session" ? "Pinned" : consumer.source === "local-receipt" ? "Activated" : "Applied";
+  const identity6 = consumer.kind === "session" ? `session ${consumer.id}` : consumer.idKind === "local-host" ? `this machine (${consumer.id})` : `station ${consumer.id}`;
+  const lines = [`${label2}: ${identity6} ${consumer.profileRevision ?? "no receipt"} [${consumer.status}] ${consumer.reasonCode}`, `  ${consumer.reason}`];
+  if (consumer.kind === "session" && consumer.consumed) {
+    lines.push(`Consumed: ${consumer.loadedCount ?? 0} of ${consumer.selectionCount ?? 0} selections loaded`);
+    for (const selection2 of consumer.consumed)
+      lines.push(`- ${selection2.slug}@${selection2.version} ${selection2.bundleDigest}`);
+  }
+  return lines;
+}
+function registerProvenance(parent) {
+  parent.command("provenance").description("Read-only receipt of the selected, activated, applied, pinned and actually loaded skill versions").option("--selection-profile <id>", "Selection profile to read (default: the managed profile)").option("--station <id>", "Station whose sync receipt to read (default: HASNA_STATION, then this host)").option("--session <id>", "Also report one session's pin and the versions it actually loaded").option("--cached", "Read the reference from the locally synced snapshot and never ask the authority", false).option("--json", "Return the receipt as JSON", false).action(async (options) => {
+    try {
+      const localStationId = process.env.HASNA_STATION ?? hostname5();
+      const receipt = await readSelectionProvenance({
+        profileId: selectedProfileId(options.selectionProfile),
+        localStationId,
+        stationId: options.station ?? localStationId,
+        ...options.session === undefined ? {} : { sessionId: options.session },
+        ...options.cached ? { cached: true } : {}
+      });
+      await writeCliOutput(options.json ? JSON.stringify(receipt) : provenanceLines(receipt).join(`
+`));
+    } catch (error61) {
+      console.error(error61.message);
+      process.exitCode = 1;
+    }
+  });
+}
+var init_provenance = __esm(() => {
+  init_selection_provenance();
+  init_context();
+});
+
 // src/cli/commands/grants.ts
 var exports_grants = {};
 __export(exports_grants, {
@@ -123312,7 +123781,7 @@ __export(exports_publish, {
 });
 import { execFileSync as execFileSync3 } from "child_process";
 import { existsSync as existsSync39, readFileSync as readFileSync52 } from "fs";
-import { hostname as hostname5 } from "os";
+import { hostname as hostname6 } from "os";
 import { join as join79 } from "path";
 function registerPublish(parent) {
   parent.command("push").argument("<name>", "Name of a skill in the local corpus (~/.hasna/skills/installed or the migrated ~/.hasna/skills/skills)").option("--version <version>", "Override the version recorded on the instance").option("--force-new-version", "If name@version already exists with different content, publish as the next patch version", false).option("--dry-run", "Pack and validate without uploading", false).option("--json", "Output result as JSON", false).description("Publish a local skill to the configured skills instance").action(async (name, options) => {
@@ -123496,7 +123965,7 @@ function buildVersionManifest(skillDir, packed) {
     unpackedByteSize: packed.unpackedByteSize,
     bundleSha256: packed.sha256,
     provenance: {
-      machine: hostname5(),
+      machine: hostname6(),
       agent: process.env.SKILLS_AGENT_ID ?? process.env.HASNA_AGENT_ID ?? process.env.AGENT_ID ?? null,
       cliVersion: package_default.version,
       gitRemote: sanitizeGitRemote(gitValue(skillDir, ["remote", "get-url", "origin"])),
@@ -123875,9 +124344,9 @@ function printWhoami(payload) {
     console.log(source_default.dim(`Auth:   ${payload.authSource}`));
   const permissions = recordField(payload.permissions);
   if (permissions) {
-    const label = (value) => value === true ? "allowed" : value === false ? "denied" : "unknown";
-    console.log(`Publish: ${label(permissions.publish)}`);
-    console.log(`Profiles write: ${label(permissions.profilesWrite)}`);
+    const label2 = (value) => value === true ? "allowed" : value === false ? "denied" : "unknown";
+    console.log(`Publish: ${label2(permissions.publish)}`);
+    console.log(`Profiles write: ${label2(permissions.profilesWrite)}`);
   }
   if (payload.offline)
     console.log(source_default.dim("(offline \u2014 showing cached info)"));
@@ -124503,7 +124972,7 @@ function promptInvitationRecoveryCode() {
 }
 function promptInvitationProof(kind) {
   const length = kind === "token" ? 43 : 6;
-  const label = kind === "token" ? "invitation token" : "recovery code";
+  const label2 = kind === "token" ? "invitation token" : "recovery code";
   const character = kind === "token" ? /^[A-Za-z0-9_-]$/ : /^\d$/;
   const { stdin, stderr: output2 } = process, wasRaw = stdin.isRaw, wasFlowing = stdin.readableFlowing;
   return new Promise((resolve49) => {
@@ -124534,13 +125003,13 @@ function promptInvitationProof(kind) {
           value = "";
           overflow = false;
           output2.write(`
-Enter exactly ${length} ${label} characters: `);
+Enter exactly ${length} ${label2} characters: `);
           return;
         }
         if (value.length === length)
           return finish(value);
         output2.write(`
-Enter the complete ${label}: `);
+Enter the complete ${label2}: `);
         value = "";
         return;
       }
@@ -124555,7 +125024,7 @@ Enter the complete ${label}: `);
         if (value.length === length) {
           overflow = true;
           output2.write(`
-The ${label} is too long. Press Enter to start again.`);
+The ${label2} is too long. Press Enter to start again.`);
         } else {
           value += text4;
           output2.write("*");
@@ -124563,7 +125032,7 @@ The ${label} is too long. Press Enter to start again.`);
       } else if (text4 && !key2.ctrl && !key2.meta) {
         overflow = true;
         output2.write(`
-The ${label} contains invalid characters. Press Enter to start again.`);
+The ${label2} contains invalid characters. Press Enter to start again.`);
       }
     };
     const timer = setTimeout(cancel, 5 * 60 * 1000);
@@ -133712,6 +134181,8 @@ var { registerPluginAdmission: registerPluginAdmission2 } = await Promise.resolv
 registerPluginAdmission2(program2);
 var { registerProfiles: registerProfiles2 } = await Promise.resolve().then(() => (init_profiles(), exports_profiles));
 registerProfiles2(program2);
+var { registerProvenance: registerProvenance2 } = await Promise.resolve().then(() => (init_provenance(), exports_provenance));
+registerProvenance2(program2);
 var { registerGrants: registerGrants2 } = await Promise.resolve().then(() => (init_grants(), exports_grants));
 registerGrants2(program2);
 var { registerHydrate: registerHydrate2 } = await Promise.resolve().then(() => (init_hydrate(), exports_hydrate));