@iowarp/clio-coder 0.3.6 → 0.3.8

package/dist/chunk-NUGM5KR6.js

@@ -0,0 +1,165 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/domains/providers/registry.ts
+init_esm_shims();
+import { readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+var RUNTIME_KINDS = ["http", "sdk", "subprocess"];
+var RUNTIME_AUTHS = ["api-key", "oauth", "aws-sdk", "vertex-adc", "claude-cli", "none"];
+function createRuntimeRegistry() {
+  const byId = /* @__PURE__ */ new Map();
+  const canonical = /* @__PURE__ */ new Set();
+  const register = (desc) => {
+    const ids = [desc.id, ...desc.aliases ?? []];
+    const conflict = ids.find((id) => byId.has(id));
+    if (conflict) {
+      throw new Error(`runtime id '${conflict}' already registered`);
+    }
+    for (const id of ids) byId.set(id, desc);
+    canonical.add(desc.id);
+  };
+  const get = (id) => byId.get(id) ?? null;
+  const list = () => Array.from(canonical, (id) => byId.get(id)).filter((entry) => entry !== void 0);
+  const clear = () => {
+    byId.clear();
+    canonical.clear();
+  };
+  const loadFromDir = async (dir, beforeImport) => {
+    let entries;
+    try {
+      const stat = statSync(dir);
+      if (!stat.isDirectory()) return [];
+      entries = readdirSync(dir);
+    } catch {
+      return [];
+    }
+    const loaded = [];
+    for (const name of entries) {
+      if (!name.endsWith(".js")) continue;
+      const full = join(dir, name);
+      const desc = await importDescriptor(full, pathToFileURL(full).href, beforeImport);
+      if (desc === null) continue;
+      try {
+        register(desc);
+        loaded.push(desc.id);
+      } catch (err) {
+        process.stderr.write(`[providers] runtime plugin ${full} rejected: ${describeError(err)}
+`);
+      }
+    }
+    return loaded;
+  };
+  const loadFromPackage = async (packageName, beforeImport) => {
+    let mod;
+    try {
+      await beforeImport?.();
+      mod = await import(packageName);
+    } catch (err) {
+      process.stderr.write(`[providers] runtime package ${packageName} failed to import: ${describeError(err)}
+`);
+      return [];
+    }
+    const exported = mod.clioRuntimes;
+    if (!Array.isArray(exported)) {
+      process.stderr.write(`[providers] runtime package ${packageName} has no 'clioRuntimes' array export
+`);
+      return [];
+    }
+    const loaded = [];
+    for (const candidate of exported) {
+      const validation = validateRuntimeDescriptor(candidate);
+      if (!validation.ok) {
+        process.stderr.write(
+          `[providers] runtime package ${packageName} exported an invalid descriptor: ${validation.reason}
+`
+        );
+        continue;
+      }
+      try {
+        register(validation.descriptor);
+        loaded.push(validation.descriptor.id);
+      } catch (err) {
+        process.stderr.write(`[providers] runtime package ${packageName} id conflict: ${describeError(err)}
+`);
+      }
+    }
+    return loaded;
+  };
+  return { register, get, list, clear, loadFromDir, loadFromPackage };
+}
+var singleton = null;
+function getRuntimeRegistry() {
+  if (singleton === null) singleton = createRuntimeRegistry();
+  return singleton;
+}
+async function importDescriptor(file, href, beforeImport) {
+  let mod;
+  try {
+    await beforeImport?.();
+    mod = await import(href);
+  } catch (err) {
+    process.stderr.write(`[providers] runtime plugin ${file} failed to import: ${describeError(err)}
+`);
+    return null;
+  }
+  const candidate = mod.default;
+  const validation = validateRuntimeDescriptor(candidate);
+  if (!validation.ok) {
+    process.stderr.write(
+      `[providers] runtime plugin ${file} has invalid default-export RuntimeDescriptor: ${validation.reason}
+`
+    );
+    return null;
+  }
+  return validation.descriptor;
+}
+function validateRuntimeDescriptor(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return { ok: false, reason: "descriptor must be an object" };
+  }
+  const v = value;
+  if (typeof v.id !== "string" || v.id.trim().length === 0) {
+    return { ok: false, reason: "id must be a non-empty string" };
+  }
+  if (v.aliases !== void 0 && (!Array.isArray(v.aliases) || v.aliases.some((alias) => typeof alias !== "string" || alias.trim().length === 0))) {
+    return { ok: false, reason: "aliases must be non-empty strings when present" };
+  }
+  if (typeof v.displayName !== "string" || v.displayName.trim().length === 0) {
+    return { ok: false, reason: "displayName must be a non-empty string" };
+  }
+  if (typeof v.kind !== "string" || !RUNTIME_KINDS.includes(v.kind)) {
+    return { ok: false, reason: `kind must be one of: ${RUNTIME_KINDS.join(", ")}` };
+  }
+  if (typeof v.apiFamily !== "string" || v.apiFamily.trim().length === 0) {
+    return { ok: false, reason: "apiFamily must be a non-empty string" };
+  }
+  if (typeof v.auth !== "string" || !RUNTIME_AUTHS.includes(v.auth)) {
+    return { ok: false, reason: `auth must be one of: ${RUNTIME_AUTHS.join(", ")}` };
+  }
+  if (typeof v.defaultCapabilities !== "object" || v.defaultCapabilities === null || Array.isArray(v.defaultCapabilities)) {
+    return { ok: false, reason: "defaultCapabilities must be an object" };
+  }
+  if (typeof v.synthesizeModel !== "function") {
+    return { ok: false, reason: "synthesizeModel must be a function" };
+  }
+  for (const field of ["probe", "probeModels", "complete", "infill", "embed", "rerank"]) {
+    if (v[field] !== void 0 && typeof v[field] !== "function") {
+      return { ok: false, reason: `${field} must be a function when present` };
+    }
+  }
+  return { ok: true, descriptor: value };
+}
+function describeError(err) {
+  if (err instanceof Error) return err.message;
+  return String(err);
+}
+
+export {
+  createRuntimeRegistry,
+  getRuntimeRegistry
+};
+//# sourceMappingURL=chunk-NUGM5KR6.js.map

package/dist/{chunk-22NAGB7X.js → chunk-P43ETTHK.js}

@@ -1,4 +1,8 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  gateRouteCorrelation,
+  isExecutionRole
+} from "./chunk-H7IXIC72.js";
 import {
   isAgentCapabilityClass
 } from "./chunk-AOCYTWAV.js";
@@ -6,90 +10,6 @@ import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
 
-// src/domains/dispatch/execution-role.ts
-init_esm_shims();
-var EXECUTION_ROLES = [
-  "builder",
-  "reviewer",
-  "judge",
-  "researcher",
-  "verifier",
-  "recovery"
-];
-function isExecutionRole(value) {
-  return typeof value === "string" && EXECUTION_ROLES.includes(value);
-}
-function deriveExecutionRole(input) {
-  if (input.attempt > 0) return "recovery";
-  if (input.gateRole === "reviewer") return "reviewer";
-  if (input.gateRole === "judge") return "judge";
-  if (input.gateRole === "builder" || input.gateRole === "candidate") return "builder";
-  if (input.resultContractKind === "verifier-report") return "verifier";
-  if (input.capabilityClass === "read-only") return "researcher";
-  return "builder";
-}
-function agentRoleFactsResolver(getSpec) {
-  return (agentId) => {
-    const spec = getSpec(agentId);
-    return spec === null ? null : { capabilityClass: spec.capabilityClass, resultContractKind: spec.resultContract.kind };
-  };
-}
-function requestExecutionRole(input) {
-  const facts = input.resolveFacts?.(input.agentId) ?? null;
-  return deriveExecutionRole({
-    attempt: 0,
-    ...input.gateRole !== void 0 ? { gateRole: input.gateRole } : {},
-    capabilityClass: facts?.capabilityClass ?? "workspace-edit",
-    resultContractKind: facts?.resultContractKind ?? null
-  });
-}
-function withAttemptRole(requestRole, attempt) {
-  return attempt > 0 ? "recovery" : requestRole;
-}
-var DEFAULT_GATE_DECIDER_AGENT_ID = "verifier";
-function gateDeciderAgentId(requested) {
-  const trimmed = requested?.trim() ?? "";
-  return trimmed.length > 0 ? trimmed : DEFAULT_GATE_DECIDER_AGENT_ID;
-}
-function appliesRecipeResultContract(gateRole) {
-  return gateRole !== "reviewer" && gateRole !== "judge";
-}
-function routeCorrelationFactsForRun(run) {
-  return {
-    agentId: run.agentId,
-    targetId: run.targetId,
-    wireModelId: run.wireModelId,
-    runtimeId: run.runtimeId,
-    nodeId: run.node?.id ?? "local"
-  };
-}
-function modelFamily(model) {
-  return model.trim().toLowerCase().replace(/[-_:]?\d{4}[-_]?\d{2}[-_]?\d{2}$/u, "");
-}
-function gateRouteCorrelation(subject, decider) {
-  const agent = subject.agentId === decider.agentId;
-  const target = subject.targetId === decider.targetId;
-  const sameModelFamily = modelFamily(subject.wireModelId) === modelFamily(decider.wireModelId);
-  const runtime = subject.runtimeId === decider.runtimeId;
-  const node = subject.nodeId === decider.nodeId;
-  const dimensions = [
-    ...agent ? ["agent"] : [],
-    ...target ? ["target"] : [],
-    ...sameModelFamily ? ["model-family"] : [],
-    ...runtime ? ["runtime"] : [],
-    ...node ? ["node"] : []
-  ].sort();
-  return {
-    agent,
-    target,
-    modelFamily: sameModelFamily,
-    runtime,
-    node,
-    independent: !agent && !sameModelFamily,
-    dimensions
-  };
-}
-
 // src/domains/dispatch/routing-intent.ts
 init_esm_shims();
 var KEYS = /* @__PURE__ */ new Set([
@@ -1053,15 +973,6 @@ function evaluateRouteDecision(decision, realized) {
 }
 
 export {
-  isExecutionRole,
-  deriveExecutionRole,
-  agentRoleFactsResolver,
-  requestExecutionRole,
-  withAttemptRole,
-  gateDeciderAgentId,
-  appliesRecipeResultContract,
-  routeCorrelationFactsForRun,
-  gateRouteCorrelation,
   ROUTE_POLICY_VERSION,
   routePriorForLatencyClass,
   routeObservationFromHistory,
@@ -1084,4 +995,4 @@ export {
   routingIntentRejection,
   explainRouteDecision
 };
-//# sourceMappingURL=chunk-22NAGB7X.js.map
+//# sourceMappingURL=chunk-P43ETTHK.js.map

package/dist/{chunk-NILBFAPG.js → chunk-PMDBGQSJ.js}

@@ -16,7 +16,7 @@ import {
   SAFE_EXEC_DEFAULT_TIMEOUT_MS,
   combineSafeOutput,
   runCommandVector
-} from "./chunk-VEZEGCGW.js";
+} from "./chunk-B5CSFE7B.js";
 import {
   StringEnum
 } from "./chunk-FCSXB6T2.js";
@@ -177,4 +177,4 @@ export {
   prepareVerifyArguments,
   verifyToolSurface
 };
-//# sourceMappingURL=chunk-NILBFAPG.js.map
+//# sourceMappingURL=chunk-PMDBGQSJ.js.map

package/dist/chunk-PT7HYKEM.js

@@ -0,0 +1,165 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  createEngineAi,
+  getEngineSupportedThinkingLevels
+} from "./chunk-FCSXB6T2.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/domains/providers/capabilities.ts
+init_esm_shims();
+function mergeCapabilities(base, kb, probe, userOverride) {
+  const merged = { ...base };
+  applyLayer(merged, probe);
+  applyLayer(merged, kb);
+  applyDeploymentLimits(merged, probe);
+  applyLayer(merged, userOverride);
+  return merged;
+}
+function applyDeploymentLimits(target, probe) {
+  if (!probe) return;
+  if (probe.contextWindow !== void 0) target.contextWindow = probe.contextWindow;
+  if (probe.maxTokens !== void 0) target.maxTokens = probe.maxTokens;
+}
+function supportsAgentRoleTools(capabilities) {
+  return capabilities.tools === true;
+}
+var AGENT_ROLE_TOOLS_REQUIRED_REASON = "reports no tool support; Clio drives every agent role through typed tools";
+function applyLayer(target, layer) {
+  if (!layer) return;
+  for (const key of Object.keys(layer)) {
+    const value = layer[key];
+    if (value !== void 0) target[key] = value;
+  }
+}
+
+// src/domains/providers/catalog.ts
+init_esm_shims();
+var engineAi = createEngineAi();
+var CATALOG_PROVIDER_BY_RUNTIME_ID = /* @__PURE__ */ new Map([
+  ["anthropic", "anthropic"],
+  ["anthropic-max", "anthropic"],
+  ["claude-code", "anthropic"],
+  ["claude-sdk", "anthropic"],
+  ["bedrock", "amazon-bedrock"],
+  ["deepseek", "deepseek"],
+  ["google", "google"],
+  ["groq", "groq"],
+  ["mistral", "mistral"],
+  ["openai", "openai"],
+  ["openai-codex", "openai-codex"],
+  ["openrouter", "openrouter"]
+]);
+function catalogProviderForRuntime(runtimeId) {
+  return CATALOG_PROVIDER_BY_RUNTIME_ID.get(runtimeId);
+}
+function listCatalogModelsForRuntime(runtimeId) {
+  const provider = catalogProviderForRuntime(runtimeId);
+  if (!provider) return [];
+  try {
+    return engineAi.listModels(provider);
+  } catch {
+    return [];
+  }
+}
+function resolveEffectivePricing(target, runtimeId, wireModelId) {
+  if (target.pricing) {
+    const rates = {
+      input: target.pricing.input,
+      output: target.pricing.output,
+      cacheRead: target.pricing.cacheRead ?? 0,
+      cacheWrite: target.pricing.cacheWrite ?? 0
+    };
+    return {
+      rates,
+      provenance: Object.values(rates).every((rate) => rate === 0) ? "known_free" : "known"
+    };
+  }
+  const catalogModel = getCatalogModelForRuntime(runtimeId, wireModelId);
+  if (!catalogModel) return { rates: null, provenance: "unknown" };
+  return {
+    rates: {
+      input: catalogModel.cost.input,
+      output: catalogModel.cost.output,
+      cacheRead: catalogModel.cost.cacheRead,
+      cacheWrite: catalogModel.cost.cacheWrite
+    },
+    provenance: "estimated"
+  };
+}
+function resolveCostProvenance(target, runtimeId, wireModelId) {
+  return resolveEffectivePricing(target, runtimeId, wireModelId).provenance;
+}
+function getCatalogModelForRuntime(runtimeId, wireModelId) {
+  const provider = catalogProviderForRuntime(runtimeId);
+  if (!provider) return void 0;
+  try {
+    return engineAi.getModel(provider, wireModelId);
+  } catch {
+    return void 0;
+  }
+}
+function capabilitiesFromCatalogModel(defaultCapabilities, model) {
+  if (!model) return defaultCapabilities;
+  return {
+    ...defaultCapabilities,
+    reasoning: model.reasoning,
+    vision: model.input.includes("image"),
+    contextWindow: model.contextWindow,
+    maxTokens: model.maxTokens
+  };
+}
+function catalogThinkingLevelsForRuntime(runtimeId, wireModelId) {
+  const model = getCatalogModelForRuntime(runtimeId, wireModelId);
+  return model ? getEngineSupportedThinkingLevels(model) : void 0;
+}
+function synthesizeCatalogBackedModel(input) {
+  const builtin = getCatalogModelForRuntime(input.runtimeId, input.wireModelId);
+  const caps = mergeCapabilities(
+    capabilitiesFromCatalogModel(input.defaultCapabilities, builtin),
+    input.kb?.entry.capabilities ?? null,
+    null,
+    input.target.capabilities ?? null
+  );
+  const pricing = input.target.pricing;
+  const targetHeaders = input.target.auth?.headers;
+  const model = {
+    ...builtin ?? {},
+    id: input.wireModelId,
+    name: `${input.wireModelId} (${input.target.id})`,
+    api: input.api,
+    provider: input.provider,
+    baseUrl: input.target.url ?? builtin?.baseUrl ?? input.defaultBaseUrl,
+    reasoning: caps.reasoning,
+    input: caps.vision ? builtin?.input.includes("image") ? builtin.input : ["text", "image"] : ["text"],
+    cost: {
+      input: pricing?.input ?? builtin?.cost.input ?? 0,
+      output: pricing?.output ?? builtin?.cost.output ?? 0,
+      cacheRead: pricing?.cacheRead ?? builtin?.cost.cacheRead ?? 0,
+      cacheWrite: pricing?.cacheWrite ?? builtin?.cost.cacheWrite ?? 0
+    },
+    contextWindow: caps.contextWindow,
+    maxTokens: caps.maxTokens
+  };
+  const headers = { ...input.defaultHeaders ?? {}, ...builtin?.headers ?? {}, ...targetHeaders ?? {} };
+  if (Object.keys(headers).length > 0) {
+    model.headers = headers;
+  }
+  return model;
+}
+
+export {
+  mergeCapabilities,
+  supportsAgentRoleTools,
+  AGENT_ROLE_TOOLS_REQUIRED_REASON,
+  catalogProviderForRuntime,
+  listCatalogModelsForRuntime,
+  resolveEffectivePricing,
+  resolveCostProvenance,
+  getCatalogModelForRuntime,
+  capabilitiesFromCatalogModel,
+  catalogThinkingLevelsForRuntime,
+  synthesizeCatalogBackedModel
+};
+//# sourceMappingURL=chunk-PT7HYKEM.js.map

package/dist/chunk-RVG5JXAL.js

@@ -0,0 +1,41 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/domains/safety/rigor.ts
+init_esm_shims();
+import { existsSync } from "node:fs";
+import path from "node:path";
+var VALIDATION_CONTRACT_FILES = [
+  path.join(".clio-coder", "validation.yaml"),
+  path.join(".clio-coder", "validation.yml"),
+  "validation.yaml",
+  "validation.yml",
+  "VALIDATION.md"
+];
+function resolveRigor(options) {
+  if (options.override === "high" || options.override === "normal") return options.override;
+  const cwd = options.cwd ?? process.cwd();
+  return hasValidationContract(cwd) ? "high" : "normal";
+}
+function parseRigorOverride(value) {
+  if (typeof value !== "string") return null;
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "high") return "high";
+  if (normalized === "normal") return "normal";
+  return null;
+}
+function hasValidationContract(cwd) {
+  try {
+    return VALIDATION_CONTRACT_FILES.some((relative) => existsSync(path.join(cwd, relative)));
+  } catch {
+    return false;
+  }
+}
+
+export {
+  resolveRigor,
+  parseRigorOverride
+};
+//# sourceMappingURL=chunk-RVG5JXAL.js.map

package/dist/{chunk-GEYXPTRF.js → chunk-RWSI4YD7.js}

@@ -2,7 +2,7 @@ import { createRequire as __clioCreateRequire } from "node:module"; const requir
 import {
   cwdHash,
   sessionPaths
-} from "./chunk-FO5ZOVUY.js";
+} from "./chunk-3BINW3FP.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -610,4 +610,4 @@ export {
   snapshotInputTokens,
   reconcileSnapshot
 };
-//# sourceMappingURL=chunk-GEYXPTRF.js.map
+//# sourceMappingURL=chunk-RWSI4YD7.js.map

package/dist/{chunk-4BPJXDWC.js → chunk-TANS5ZJS.js}

@@ -3,10 +3,10 @@ import {
   readRootEntries,
   splitYamlFrontmatter,
   stringField
-} from "./chunk-2SFS6XQE.js";
+} from "./chunk-DGSYXYMX.js";
 import {
   enabledExtensionResourceRoots
-} from "./chunk-ZWLZP4ZT.js";
+} from "./chunk-DYIM5TJT.js";
 import {
   ToolNames
 } from "./chunk-CGKSTWHD.js";
@@ -14,15 +14,15 @@ import {
   INTEROP_AGENT_KINDS,
   interopSourceRank
 } from "./chunk-IHXBNWMM.js";
+import {
+  resolvePackageRoot
+} from "./chunk-IWHMRKLL.js";
 import {
   clioConfigDir
 } from "./chunk-BNAZZHFG.js";
 import {
   fsyncDirectory
 } from "./chunk-WEPFGWHJ.js";
-import {
-  resolvePackageRoot
-} from "./chunk-IWHMRKLL.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -159,24 +159,38 @@ function optionalString(value) {
 function indexAudit(value) {
   return value === "pass" || value === "warn" || value === "fail" || value === "unknown" ? value : void 0;
 }
-function indexSkills(indexPath, diagnostics) {
+function parseMarketplaceIndex(indexPath, diagnostics = []) {
   try {
     const parsed = JSON.parse(readFileSync(indexPath, "utf8"));
     const rawSkills = Array.isArray(parsed) ? parsed : parsed && typeof parsed === "object" && Array.isArray(parsed.skills) ? parsed.skills : [];
-    return rawSkills.filter(isIndexSkill).map((skill) => {
+    return rawSkills.filter(isIndexSkill).flatMap((skill) => {
       const record = skill;
       const version = optionalString(record.version);
       const audit = indexAudit(record.audit);
       const category = optionalString(record.category);
-      return {
-        name: skill.name.trim(),
-        description: skill.description.trim(),
-        sourceUrl: skill.sourceUrl.trim(),
-        ...version ? { version } : {},
-        ...audit ? { audit } : {},
-        ...category ? { category } : {},
-        origin: "index"
-      };
+      if (record.kind !== void 0 && !["skill", "agent", "prompt", "fleet"].includes(String(record.kind))) {
+        diagnostics.push(`skill marketplace index entry has unsupported kind: ${skill.name}`);
+        return [];
+      }
+      if (record.requires !== void 0 && (!Array.isArray(record.requires) || record.requires.some((entry) => typeof entry !== "string"))) {
+        diagnostics.push(`library_requirement_malformed: ${skill.name}`);
+        return [];
+      }
+      const kind = record.kind === "agent" || record.kind === "prompt" || record.kind === "fleet" ? record.kind : "skill";
+      const requires = Array.isArray(record.requires) ? record.requires.filter((entry) => typeof entry === "string") : void 0;
+      return [
+        {
+          kind,
+          name: skill.name.trim(),
+          description: skill.description.trim(),
+          sourceUrl: skill.sourceUrl.trim(),
+          ...version ? { version } : {},
+          ...audit ? { audit } : {},
+          ...category ? { category } : {},
+          ...requires ? { requires } : {},
+          origin: "index"
+        }
+      ];
     });
   } catch (err) {
     diagnostics.push(`skill marketplace index unreadable: ${err instanceof Error ? err.message : String(err)}`);
@@ -228,7 +242,8 @@ function catalogEntry(skill, catalogDir) {
     ...version ? { version } : {},
     ...skill.provenance?.audit ? { audit: skill.provenance.audit } : {},
     ...category ? { category } : {},
-    origin: "catalog"
+    origin: "catalog",
+    kind: "skill"
   };
 }
 function catalogSkills(dir, diagnostics) {
@@ -253,7 +268,7 @@ function discoverMarketplaceSkills(options = {}) {
   const indexPath = options.indexPath === null ? null : options.indexPath ?? process.env.CLIO_CODER_SKILL_MARKETPLACE_INDEX ?? null;
   const resolvedIndexPath = indexPath ?? defaultIndexPath();
   if (options.indexPath !== null && resolvedIndexPath && existsSync(resolvedIndexPath)) {
-    for (const skill of indexSkills(resolvedIndexPath, diagnostics)) {
+    for (const skill of parseMarketplaceIndex(resolvedIndexPath, diagnostics)) {
       if (seen.has(skill.name)) continue;
       seen.add(skill.name);
       skills.push(skill);
@@ -1167,6 +1182,7 @@ function updateSkills(input = {}) {
 }
 
 export {
+  normalizedSkillHash,
   updateSkills,
   MARKETPLACE_UNCONFIGURED,
   discoverMarketplaceSkills,
@@ -1179,4 +1195,4 @@ export {
   expandSkillInvocationInput,
   parsePendingSkillRequests
 };
-//# sourceMappingURL=chunk-4BPJXDWC.js.map
+//# sourceMappingURL=chunk-TANS5ZJS.js.map