@iowarp/clio-coder 0.4.6 → 0.4.7

package/dist/chunk-UWD3JD5X.js

@@ -0,0 +1,709 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  discoverAgentRecipes
+} from "./chunk-4UHVS5T7.js";
+import {
+  loadPromptTemplates,
+  validateLibraryPackage
+} from "./chunk-WB7POC6M.js";
+import {
+  bundledLibraryIndexPath,
+  discoverLibrary,
+  loadSkills,
+  parsePluginGithubSource
+} from "./chunk-MZNWZUJM.js";
+import {
+  listFleetContracts
+} from "./chunk-KKEYGFX4.js";
+import {
+  isLibraryKind,
+  isLibraryResourceKind,
+  listInstalledPlugins,
+  readPluginInstallRecord
+} from "./chunk-YKRJTYNP.js";
+import {
+  readSettings
+} from "./chunk-4QKAITQT.js";
+import {
+  INTEROP_AGENT_KINDS
+} from "./chunk-5EQO5NWP.js";
+import {
+  resolvePackageRoot
+} from "./chunk-E3LEPLQ2.js";
+import {
+  clioConfigDir
+} from "./chunk-CTTI7G3T.js";
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/domains/resources/library-inventory.ts
+init_esm_shims();
+import { existsSync, realpathSync } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+var LIBRARY_INVENTORY_LIMITS = {
+  packages: 512,
+  copies: 256,
+  resources: 1024,
+  diagnostics: 64,
+  copyDiagnostics: 16,
+  resourceDiagnostics: 8,
+  description: 512,
+  message: 512
+};
+function clip(value, limit = LIBRARY_INVENTORY_LIMITS.description) {
+  return value.length > limit ? `${value.slice(0, limit - 1)}\u2026` : value;
+}
+var Bounded = class {
+  constructor(limit) {
+    this.limit = limit;
+  }
+  limit;
+  items = [];
+  truncated = false;
+  push(item) {
+    if (this.items.length >= this.limit) {
+      this.truncated = true;
+      return false;
+    }
+    this.items.push(item);
+    return true;
+  }
+};
+function libraryResourceKey(kind, name, sourceId, relativePath) {
+  return `${kind}:${name}@${sourceId}#${relativePath}`;
+}
+function parseLibraryResourceKey(key) {
+  const hash = key.indexOf("#");
+  const head = hash >= 0 ? key.slice(0, hash) : key;
+  const at = head.lastIndexOf("@");
+  const colon = head.indexOf(":");
+  if (at <= 0 || colon <= 0 || colon > at) return void 0;
+  const kind = head.slice(0, colon);
+  const name = head.slice(colon + 1, at);
+  const sourceId = head.slice(at + 1);
+  if (!isLibraryResourceKind(kind) || !name || !sourceId) return void 0;
+  const relativePath = hash >= 0 ? key.slice(hash + 1) : void 0;
+  return { kind, name, sourceId, ...relativePath ? { relativePath } : {} };
+}
+function keyMatches(key, parts) {
+  const own = parseLibraryResourceKey(key);
+  if (!own) return false;
+  return own.kind === parts.kind && own.name === parts.name && own.sourceId === parts.sourceId && (parts.relativePath === void 0 || own.relativePath === parts.relativePath);
+}
+function relativeTo(anchor, filePath) {
+  if (!anchor) return void 0;
+  const relative = path.relative(canonical(anchor), canonical(filePath));
+  return contained(canonical(anchor), canonical(filePath)) ? relative.split(path.sep).join("/") : void 0;
+}
+function keyPath(anchors, sourceId, filePath, owner) {
+  const candidate = (owner ? relativeTo(owner.root, filePath) : void 0) ?? (sourceId === "core" ? relativeTo(anchors.packageRoot, filePath) : void 0) ?? (sourceId === "config" ? relativeTo(anchors.configDir, filePath) : void 0) ?? (sourceId === "project" || sourceId.endsWith("-project") ? relativeTo(anchors.cwd, filePath) : void 0) ?? relativeTo(anchors.home, filePath);
+  return candidate ?? path.basename(filePath);
+}
+function bundledLibraryDir() {
+  try {
+    return path.join(resolvePackageRoot(), "library");
+  } catch {
+    return void 0;
+  }
+}
+function contained(root, target) {
+  const relative = path.relative(root, target);
+  return relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
+}
+function canonical(value) {
+  try {
+    return realpathSync(value);
+  } catch {
+    return path.resolve(value);
+  }
+}
+function underBundledLibrary(candidate) {
+  const dir = bundledLibraryDir();
+  if (!dir || !path.isAbsolute(candidate)) return false;
+  return contained(canonical(dir), canonical(candidate));
+}
+function bundledIndex() {
+  try {
+    return bundledLibraryIndexPath();
+  } catch {
+    return void 0;
+  }
+}
+function compatHost(sourceId) {
+  const match = /^(.+)-(user|project)$/.exec(sourceId);
+  const host = match?.[1];
+  return host && host !== "unknown" ? host : void 0;
+}
+function formatForHost(host) {
+  if (host === "claude" || host === "claude-code") return "claude-code";
+  if (host === "codex") return "codex";
+  return void 0;
+}
+function classifyLibraryOrigin(evidence) {
+  if (evidence.kind === "catalog-row") {
+    const { entry } = evidence;
+    if (entry.origin === "installed") return { origin: { kind: "unknown", detail: "no catalog row" } };
+    const catalog = entry.index;
+    const bundled = bundledIndex();
+    if (catalog && bundled && canonical(catalog) === canonical(bundled))
+      return { origin: { kind: "bundled", catalog }, format: "portable" };
+    if (parsePluginGithubSource(entry.sourceUrl))
+      return { origin: { kind: "remote", url: entry.sourceUrl, ...catalog ? { catalog } : {} }, format: "portable" };
+    return { origin: { kind: "local", path: entry.sourceUrl, ...catalog ? { catalog } : {} }, format: "portable" };
+  }
+  if (evidence.kind === "install-record") {
+    const { record } = evidence;
+    if (!record) return { origin: { kind: "unknown", detail: "install record unavailable" } };
+    const origin = record.origin;
+    if (origin === void 0 || typeof origin === "string") {
+      const source = origin ?? record.source;
+      if (parsePluginGithubSource(source)) return { origin: { kind: "remote", url: source }, format: "portable" };
+      if (path.isAbsolute(source))
+        return underBundledLibrary(source) ? { origin: { kind: "bundled", catalog: bundledIndex() ?? source }, format: "portable" } : { origin: { kind: "local", path: source }, format: "portable" };
+      return { origin: { kind: "unknown", detail: `unclassified source: ${source}` } };
+    }
+    switch (origin.kind) {
+      case "catalog": {
+        if (parsePluginGithubSource(origin.source))
+          return { origin: { kind: "remote", url: origin.source }, format: "portable" };
+        if (underBundledLibrary(origin.source))
+          return { origin: { kind: "bundled", catalog: bundledIndex() ?? origin.source }, format: "portable" };
+        return { origin: { kind: "local", path: origin.source }, format: "portable" };
+      }
+      case "github":
+        return { origin: { kind: "remote", url: origin.source }, format: "portable" };
+      case "local":
+        return { origin: { kind: "local", path: origin.source }, format: "portable" };
+      case "interop":
+        return {
+          origin: {
+            kind: "imported",
+            agent: origin.host,
+            path: origin.source,
+            ...origin.marketplace ? { marketplace: origin.marketplace } : {}
+          },
+          format: origin.format ?? "portable"
+        };
+      case "import":
+        return {
+          origin: origin.transport === "github" ? { kind: "remote", url: origin.source, ...origin.host ? { host: origin.host } : {} } : { kind: "local", path: origin.source, ...origin.host ? { host: origin.host } : {} },
+          format: origin.format
+        };
+      default:
+        return { origin: { kind: "unknown", detail: "unrecognized origin record" } };
+    }
+  }
+  const { sourceId } = evidence;
+  if (sourceId === "core") return { origin: { kind: "core" } };
+  if (sourceId.startsWith("plugin:"))
+    return { origin: { kind: "unknown", detail: "package origin requires its installed copy record" } };
+  if (sourceId === "config" || sourceId === "project")
+    return { origin: { kind: "local", path: evidence.path }, format: "portable" };
+  const host = compatHost(sourceId);
+  const format = formatForHost(host);
+  return {
+    origin: { kind: "local", path: evidence.path, ...host ? { host } : {} },
+    ...format ? { format } : {}
+  };
+}
+function libraryCopyState(plugin) {
+  if (plugin.loadable) return "loadable";
+  if (!plugin.compatible) return "incompatible";
+  if (!plugin.manifest) return "invalid";
+  if (plugin.diagnostics.some((item) => item.message.includes("content drift"))) return "damaged";
+  if (!plugin.valid) return "invalid";
+  if (!plugin.enabled) return "disabled";
+  if (!plugin.effective) return "shadowed";
+  return "invalid";
+}
+function safeInstallRecord(plugin, cwd) {
+  try {
+    return readPluginInstallRecord(plugin.id, { cwd, scope: plugin.scope });
+  } catch {
+    return void 0;
+  }
+}
+function projectCopy(plugin, cwd) {
+  const kind = plugin.kind ?? "plugin";
+  const record = safeInstallRecord(plugin, cwd);
+  const classified = classifyLibraryOrigin({ kind: "install-record", record, rootPath: plugin.rootPath });
+  return {
+    ref: `${kind}:${plugin.id}`,
+    kind,
+    name: plugin.id,
+    scope: plugin.scope,
+    root: plugin.rootPath,
+    version: plugin.version,
+    state: libraryCopyState(plugin),
+    enabled: plugin.enabled,
+    valid: plugin.valid,
+    compatible: plugin.compatible,
+    effective: plugin.effective,
+    loadable: plugin.loadable,
+    trust: plugin.trust ?? "trusted",
+    ...plugin.overriddenBy ? { overriddenBy: plugin.overriddenBy } : {},
+    origin: classified.origin,
+    ...classified.format ? { format: classified.format } : {},
+    ...record?.contentDigest ? { recordedDigest: record.contentDigest } : {},
+    ...plugin.observedContentDigest ? { observedDigest: plugin.observedContentDigest } : {},
+    ...record?.installedAt ? { installedAt: record.installedAt } : {},
+    diagnostics: plugin.diagnostics.slice(0, LIBRARY_INVENTORY_LIMITS.copyDiagnostics).map((item) => clip(item.message, LIBRARY_INVENTORY_LIMITS.message))
+  };
+}
+function ownerIndex(copies, anchors) {
+  const bySourceId = /* @__PURE__ */ new Map();
+  const roots = [];
+  for (const copy of copies) {
+    bySourceId.set(`plugin:${copy.scope}:${copy.name}`, copy);
+    roots.push({ root: canonical(copy.root), copy });
+  }
+  roots.sort((a, b) => b.root.length - a.root.length);
+  return { bySourceId, roots, anchors };
+}
+function ownerByPath(index, filePath) {
+  const target = canonical(filePath);
+  return index.roots.find((item) => contained(item.root, target))?.copy;
+}
+function ownerOf(copy) {
+  return { ref: copy.ref, scope: copy.scope };
+}
+function sourceClassFor(sourceId) {
+  if (sourceId === "core") return "core";
+  if (sourceId.startsWith("plugin:")) return "package";
+  if (sourceId === "config") return "user";
+  if (sourceId === "project") return "project";
+  return "compat";
+}
+function resourceOrigin(sourceId, filePath, owner) {
+  if (owner) return { origin: owner.origin, ...owner.format ? { format: owner.format } : {} };
+  return classifyLibraryOrigin({ kind: "resource-root", sourceId, path: filePath });
+}
+function bounded(diagnostics) {
+  return diagnostics.slice(0, LIBRARY_INVENTORY_LIMITS.resourceDiagnostics).map((message) => clip(message, LIBRARY_INVENTORY_LIMITS.message));
+}
+function fromSkill(skill, index) {
+  const sourceId = skill.sourceInfo.source ?? `${skill.source}-${skill.scope}`;
+  const owner = index.bySourceId.get(sourceId) ?? (skill.scope === "package" ? ownerByPath(index, skill.filePath) : void 0);
+  const hard = skill.diagnostics.some((item) => item.type === "error" || item.type === "collision");
+  const availability = hard ? "invalid" : skill.trusted ? "available" : "untrusted";
+  const reason = hard ? skill.diagnostics.find((item) => item.type === "error" || item.type === "collision")?.message : !skill.trusted ? "root is not trusted; enable integrations.projectResources.trustProjectImports or install the package" : void 0;
+  const scope = skill.scope === "cli" ? "user" : skill.scope;
+  return {
+    key: libraryResourceKey("skill", skill.name, sourceId, keyPath(index.anchors, sourceId, skill.filePath, owner)),
+    kind: "skill",
+    name: skill.name,
+    description: clip(skill.description),
+    ...availability === "available" ? { invocation: `/skill ${skill.name}` } : {},
+    path: skill.filePath,
+    source: { class: sourceClassFor(sourceId), id: sourceId, scope },
+    ...owner ? { owner: ownerOf(owner) } : {},
+    ...resourceOrigin(sourceId, skill.filePath, owner),
+    availability,
+    ...reason ? { reason: clip(reason, LIBRARY_INVENTORY_LIMITS.message) } : {},
+    trusted: skill.trusted,
+    modelInvocable: skill.trusted && !skill.disableModelInvocation && !hard,
+    diagnostics: bounded(skill.diagnostics.map((item) => item.message))
+  };
+}
+function fromPrompt(template, index) {
+  const scope = template.sourceInfo.scope === "cli" ? "user" : template.sourceInfo.scope;
+  const sourceId = template.sourceInfo.source ?? scope;
+  const owner = index.bySourceId.get(sourceId) ?? (scope === "package" ? ownerByPath(index, template.filePath) : void 0);
+  const availability = template.unavailable ? "unavailable" : template.trusted ? "available" : "untrusted";
+  const reason = template.unavailable ? template.unavailable : !template.trusted ? "root is not trusted; enable integrations.projectResources.trustProjectImports or install the package" : void 0;
+  return {
+    key: libraryResourceKey(
+      "prompt",
+      template.name,
+      sourceId,
+      keyPath(index.anchors, sourceId, template.filePath, owner)
+    ),
+    kind: "prompt",
+    name: template.name,
+    description: clip(template.description),
+    ...availability === "available" ? { invocation: `/${template.name}` } : {},
+    path: template.filePath,
+    source: { class: sourceClassFor(sourceId), id: sourceId, scope },
+    ...owner ? { owner: ownerOf(owner) } : {},
+    ...resourceOrigin(sourceId, template.filePath, owner),
+    availability,
+    ...reason ? { reason: clip(reason, LIBRARY_INVENTORY_LIMITS.message) } : {},
+    trusted: template.trusted,
+    diagnostics: []
+  };
+}
+function agentSourceId(recipe, index) {
+  if (recipe.source === "builtin") return { sourceId: "core" };
+  if (recipe.source === "user") return { sourceId: "config" };
+  if (recipe.source === "project") return { sourceId: "project" };
+  const owner = ownerByPath(index, recipe.filepath);
+  return owner ? { sourceId: `plugin:${owner.scope}:${owner.name}`, owner } : { sourceId: "plugin:unknown" };
+}
+function agentScope(source) {
+  return source === "user" ? "user" : source === "project" ? "project" : "package";
+}
+function fromAgent(recipe, index) {
+  const { sourceId, owner } = agentSourceId(recipe, index);
+  const scope = agentScope(recipe.source);
+  return {
+    key: libraryResourceKey("agent", recipe.id, sourceId, keyPath(index.anchors, sourceId, recipe.filepath, owner)),
+    kind: "agent",
+    name: recipe.id,
+    description: clip(recipe.description),
+    invocation: `dispatch(agent="${recipe.id}")`,
+    path: recipe.filepath,
+    source: { class: sourceClassFor(sourceId), id: sourceId, scope },
+    ...owner ? { owner: ownerOf(owner) } : {},
+    ...resourceOrigin(sourceId, recipe.filepath, owner),
+    availability: "available",
+    trusted: true,
+    audience: recipe.audience,
+    diagnostics: []
+  };
+}
+function fromAgentDiagnostic(diagnostic, index) {
+  const { sourceId, owner } = agentSourceId({ source: diagnostic.source, filepath: diagnostic.filepath }, index);
+  const scope = agentScope(diagnostic.source);
+  const name = diagnostic.id ?? path.basename(diagnostic.filepath, ".md");
+  const availability = diagnostic.kind === "overridden" ? "shadowed" : diagnostic.kind === "ignored" ? "unavailable" : "invalid";
+  return {
+    key: libraryResourceKey("agent", name, sourceId, keyPath(index.anchors, sourceId, diagnostic.filepath, owner)),
+    kind: "agent",
+    name,
+    description: "",
+    path: diagnostic.filepath,
+    source: { class: sourceClassFor(sourceId), id: sourceId, scope },
+    ...owner ? { owner: ownerOf(owner) } : {},
+    ...resourceOrigin(sourceId, diagnostic.filepath, owner),
+    availability,
+    reason: clip(diagnostic.message, LIBRARY_INVENTORY_LIMITS.message),
+    trusted: true,
+    ...diagnostic.audience ? { audience: diagnostic.audience } : {},
+    diagnostics: bounded([diagnostic.message])
+  };
+}
+function fromFleet(listing, index) {
+  const { sourceId, owner } = agentSourceId({ source: listing.source, filepath: listing.path }, index);
+  const scope = agentScope(listing.source);
+  const name = listing.contract?.name ?? listing.name;
+  const availability = listing.contract ? "available" : listing.needsCommands ? "unavailable" : "invalid";
+  const reason = listing.error ?? void 0;
+  return {
+    key: libraryResourceKey("fleet", name, sourceId, keyPath(index.anchors, sourceId, listing.path, owner)),
+    kind: "fleet",
+    name,
+    description: clip(listing.contract?.description ?? ""),
+    ...availability === "available" ? { invocation: `/fleet run ${name}` } : {},
+    path: listing.path,
+    source: { class: sourceClassFor(sourceId), id: sourceId, scope },
+    ...owner ? { owner: ownerOf(owner) } : {},
+    ...resourceOrigin(sourceId, listing.path, owner),
+    availability,
+    ...reason ? { reason: clip(reason, LIBRARY_INVENTORY_LIMITS.message) } : {},
+    trusted: true,
+    diagnostics: reason ? bounded([reason]) : []
+  };
+}
+function fromCollisionLoser(kind, diagnostic, winners, index, sourceIdFor) {
+  const collision = diagnostic.collision;
+  if (!collision) return void 0;
+  if (winners.some((item) => item.path === collision.loserPath)) return void 0;
+  const scope = collision.loserScope === "cli" ? "user" : collision.loserScope;
+  const owner = scope === "package" ? ownerByPath(index, collision.loserPath) : void 0;
+  const sourceId = owner ? `plugin:${owner.scope}:${owner.name}` : sourceIdFor(collision.loserPath, scope);
+  return {
+    key: libraryResourceKey(kind, collision.name, sourceId, keyPath(index.anchors, sourceId, collision.loserPath, owner)),
+    kind,
+    name: collision.name,
+    description: "",
+    path: collision.loserPath,
+    source: { class: sourceClassFor(sourceId), id: sourceId, scope },
+    ...owner ? { owner: ownerOf(owner) } : {},
+    ...resourceOrigin(sourceId, collision.loserPath, owner),
+    availability: "shadowed",
+    reason: clip(diagnostic.message, LIBRARY_INVENTORY_LIMITS.message),
+    trusted: false,
+    diagnostics: bounded([diagnostic.message])
+  };
+}
+function looseSourceId(anchors, kind) {
+  return (filePath, scope) => {
+    if (scope === "package") return "plugin:unknown";
+    const target = canonical(filePath);
+    if (scope === "project" && contained(canonical(path.join(anchors.cwd, ".clio-coder")), target)) return "project";
+    if (scope === "user" && anchors.configDir && contained(canonical(anchors.configDir), target)) return "config";
+    const base = scope === "user" ? anchors.home : anchors.cwd;
+    for (const agent of INTEROP_AGENT_KINDS) {
+      const root = kind === "skill" ? scope === "user" ? agent.userSkillRoot : agent.projectSkillRoot : scope === "user" ? agent.userPromptRoot : agent.projectPromptRoot;
+      const id = kind === "skill" ? agent.skillSource : agent.id;
+      if (root && id && contained(canonical(path.join(base, root)), target)) return `${id}-${scope}`;
+    }
+    return `unknown-${scope}`;
+  };
+}
+function parseSelection(ref) {
+  if (!ref) return {};
+  const key = parseLibraryResourceKey(ref);
+  if (key) return { resourceKey: key };
+  const colon = ref.indexOf(":");
+  if (colon > 0 && isLibraryKind(ref.slice(0, colon))) return { packageRef: ref };
+  return { name: ref };
+}
+function matchesQuery(query, ...fields) {
+  if (!query) return true;
+  const needle = query.toLowerCase();
+  return fields.some((field) => field?.toLowerCase().includes(needle));
+}
+function packageMatches(record, options, selection) {
+  if (selection.packageRef && record.ref !== selection.packageRef) return false;
+  if (selection.name && record.name !== selection.name && !record.provides?.some((hint) => hint.name === selection.name))
+    return false;
+  if (selection.resourceKey) {
+    const key = selection.resourceKey;
+    if (!key.sourceId.startsWith("plugin:") || key.sourceId.split(":")[2] !== record.name) return false;
+  }
+  if (options.kinds?.length) {
+    const kinds = options.kinds;
+    if (!kinds.includes(record.kind) && !record.provides?.some((hint) => kinds.includes(hint.kind))) return false;
+  }
+  return matchesQuery(
+    options.query,
+    record.name,
+    record.description,
+    ...(record.provides ?? []).map((hint) => hint.name)
+  );
+}
+function copyMatches(copy, options, selection) {
+  if (selection.packageRef && copy.ref !== selection.packageRef) return false;
+  if (selection.name && copy.name !== selection.name) return false;
+  if (selection.resourceKey && selection.resourceKey.sourceId !== `plugin:${copy.scope}:${copy.name}`) return false;
+  if (options.kinds?.length && !options.kinds.includes(copy.kind)) return false;
+  return true;
+}
+function resourceMatches(resource, options, selection) {
+  if (selection.packageRef && resource.owner?.ref !== selection.packageRef) {
+    const [kind, name] = selection.packageRef.split(":", 2);
+    if (!(kind === resource.kind && name === resource.name)) return false;
+  }
+  if (selection.name && resource.name !== selection.name) return false;
+  if (selection.resourceKey && !keyMatches(resource.key, selection.resourceKey)) return false;
+  if (options.kinds?.length && !options.kinds.includes(resource.kind)) return false;
+  if (options.sources?.length && !options.sources.includes(resource.source.class)) return false;
+  return matchesQuery(options.query, resource.name, resource.description);
+}
+function audienceAdmits(resource, options) {
+  const model = options.audience === "model";
+  if (resource.kind === "agent" && (resource.audience === "shadow" || resource.audience === "internal"))
+    return !model && options.all === true;
+  if (model) return resource.availability === "available" && resource.modelInvocable !== false;
+  return true;
+}
+function trustSetting(explicit) {
+  if (explicit !== void 0) return explicit;
+  try {
+    return readSettings().integrations.projectResources.trustProjectImports;
+  } catch {
+    return false;
+  }
+}
+function sortResources(items) {
+  const order = { skill: 0, agent: 1, prompt: 2, fleet: 3 };
+  return items.sort(
+    (a, b) => order[a.kind] - order[b.kind] || a.name.localeCompare(b.name) || a.source.id.localeCompare(b.source.id) || a.key.localeCompare(b.key)
+  );
+}
+function readLibraryInventory(options = {}) {
+  const cwd = path.resolve(options.cwd ?? process.cwd());
+  const include = { packages: true, copies: true, resources: true, ...options.include ?? {} };
+  const selection = parseSelection(options.ref);
+  const diagnostics = new Bounded(LIBRARY_INVENTORY_LIMITS.diagnostics);
+  const note = (message) => {
+    const text = clip(message, LIBRARY_INVENTORY_LIMITS.message);
+    if (!diagnostics.items.includes(text)) diagnostics.push(text);
+  };
+  const wants = (kind) => !options.kinds?.length || options.kinds.includes(kind);
+  const installed = include.copies || include.packages || include.resources ? listInstalledPlugins(cwd, { all: true }) : [];
+  const copyRows = new Bounded(LIBRARY_INVENTORY_LIMITS.copies);
+  for (const plugin of installed) if (!copyRows.push(projectCopy(plugin, cwd))) break;
+  if (copyRows.truncated) note("installed copies truncated; later copies have no owner rows");
+  const copies = copyRows.items;
+  const copiesByRef = /* @__PURE__ */ new Map();
+  for (const copy of copies) copiesByRef.set(copy.ref, [...copiesByRef.get(copy.ref) ?? [], copy]);
+  const packages = new Bounded(LIBRARY_INVENTORY_LIMITS.packages);
+  if (include.packages) {
+    const discovery = discoverLibrary({ cwd, ...options.catalog ? { catalog: options.catalog } : {} });
+    for (const message of discovery.diagnostics) note(message);
+    for (const entry of discovery.entries) {
+      const ref = `${entry.kind}:${entry.name}`;
+      const own = copiesByRef.get(ref) ?? [];
+      const classified = entry.origin === "installed" && own[0] ? { origin: own[0].origin, ...own[0].format ? { format: own[0].format } : {} } : classifyLibraryOrigin({ kind: "catalog-row", entry });
+      const refusal = discovery.refusals[ref];
+      const record = {
+        ref,
+        kind: entry.kind,
+        name: entry.name,
+        description: clip(entry.description),
+        ...entry.version ? { version: entry.version } : {},
+        ...entry.sha256 ? { sha256: entry.sha256 } : {},
+        sourceUrl: entry.sourceUrl,
+        ...entry.requires ? { requires: entry.requires } : {},
+        origin: classified.origin,
+        ...classified.format ? { format: classified.format } : {},
+        ...entry.provides ? { provides: entry.provides } : {},
+        catalogOrigin: entry.origin,
+        copies: own.map((copy) => ({ scope: copy.scope, state: copy.state })),
+        ...refusal ? { refusal } : {}
+      };
+      if (packageMatches(record, options, selection) && !packages.push(record)) break;
+    }
+  }
+  const resources = new Bounded(LIBRARY_INVENTORY_LIMITS.resources);
+  if (include.resources) {
+    let configDir = options.configDir;
+    if (!configDir) {
+      try {
+        configDir = clioConfigDir();
+      } catch {
+        configDir = void 0;
+      }
+    }
+    let packageRoot;
+    try {
+      packageRoot = resolvePackageRoot();
+    } catch {
+      packageRoot = void 0;
+    }
+    const index = ownerIndex(copies, {
+      cwd,
+      home: options.home ?? homedir(),
+      ...configDir ? { configDir } : {},
+      ...packageRoot ? { packageRoot } : {}
+    });
+    const trustProjectCompatRoots = trustSetting(options.trustProjectCompatRoots);
+    const skillRows = [];
+    if (wants("skill")) {
+      const skills = loadSkills({
+        cwd,
+        trustProjectCompatRoots,
+        ...options.configDir ? { configDir: options.configDir } : {},
+        ...options.home ? { home: options.home } : {}
+      });
+      const loose = looseSourceId(index.anchors, "skill");
+      for (const skill of skills.items) skillRows.push(fromSkill(skill, index));
+      for (const diagnostic of skills.diagnostics) {
+        const loser = diagnostic.type === "collision" ? fromCollisionLoser("skill", diagnostic, skillRows, index, loose) : void 0;
+        if (loser) skillRows.push(loser);
+        else if (diagnostic.type !== "collision")
+          note(`skill: ${diagnostic.message}${diagnostic.path ? ` (${diagnostic.path})` : ""}`);
+      }
+    }
+    const promptRows = [];
+    if (wants("prompt")) {
+      const prompts = loadPromptTemplates({
+        cwd,
+        trustProjectCompatRoots,
+        ...options.home ? { home: options.home } : {}
+      });
+      const loose = looseSourceId(index.anchors, "prompt");
+      for (const template of prompts.items) promptRows.push(fromPrompt(template, index));
+      for (const diagnostic of prompts.diagnostics) {
+        const loser = diagnostic.type === "collision" ? fromCollisionLoser("prompt", diagnostic, promptRows, index, loose) : void 0;
+        if (loser) promptRows.push(loser);
+        else if (diagnostic.type !== "collision")
+          note(`prompt: ${diagnostic.message}${diagnostic.path ? ` (${diagnostic.path})` : ""}`);
+      }
+    }
+    const agentRows = [];
+    if (wants("agent")) {
+      const agentDiagnostics = [];
+      try {
+        for (const recipe of discoverAgentRecipes(cwd, agentDiagnostics)) agentRows.push(fromAgent(recipe, index));
+      } catch (error) {
+        note(`agent: discovery failed: ${error instanceof Error ? error.message : String(error)}`);
+      }
+      for (const diagnostic of agentDiagnostics) agentRows.push(fromAgentDiagnostic(diagnostic, index));
+    }
+    const fleetRows = [];
+    if (wants("fleet")) {
+      try {
+        for (const listing of listFleetContracts(cwd)) fleetRows.push(fromFleet(listing, index));
+      } catch (error) {
+        note(`fleet: discovery failed: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+    for (const row of sortResources([...skillRows, ...promptRows, ...agentRows, ...fleetRows])) {
+      if (!audienceAdmits(row, options) || !resourceMatches(row, options, selection)) continue;
+      if (!resources.push(row)) break;
+    }
+  }
+  const selectedCopies = include.copies ? copies.filter((copy) => copyMatches(copy, options, selection)).sort((a, b) => a.ref.localeCompare(b.ref) || a.scope.localeCompare(b.scope)) : [];
+  return {
+    version: 1,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    cwd,
+    audience: options.audience ?? "operator",
+    packages: packages.items,
+    copies: selectedCopies,
+    resources: resources.items,
+    diagnostics: diagnostics.items,
+    truncated: {
+      packages: packages.truncated,
+      // Copies also supply package status and resource ownership when omitted
+      // from the public copy list. Consumers must know when that evidence is partial.
+      copies: copyRows.truncated,
+      resources: resources.truncated
+    }
+  };
+}
+function inspectLibraryCopy(ref, options = {}) {
+  const cwd = path.resolve(options.cwd ?? process.cwd());
+  const candidates = listInstalledPlugins(cwd, { all: true }).filter((item) => !options.scope || item.scope === options.scope).filter((item) => ref.includes(":") ? `${item.kind ?? "plugin"}:${item.id}` === ref : item.id === ref).sort((a, b) => Number(b.scope === "project") - Number(a.scope === "project"));
+  const plugin = candidates[0];
+  if (!plugin) throw new Error(`package not installed: ${ref}`);
+  const copy = projectCopy(plugin, cwd);
+  if (!existsSync(plugin.rootPath))
+    return { copy, resources: [], ancillary: [], prerequisites: [], diagnostics: ["package root is missing"] };
+  const result = validateLibraryPackage(plugin.rootPath, { cwd });
+  const components = new Map(
+    (result.manifest?.clio.components ?? []).map((component) => [`${component.kind}:${component.id}`, component.id])
+  );
+  const resources = [];
+  const ancillary = [];
+  for (const record of result.validation.resources) {
+    if (isLibraryResourceKind(record.kind)) {
+      const componentId = record.componentRef ? components.get(record.componentRef) : void 0;
+      resources.push({
+        kind: record.kind,
+        name: record.name,
+        path: record.path,
+        ...componentId && componentId !== record.name ? { componentId } : {},
+        ...record.description !== void 0 ? { description: record.description } : {},
+        valid: record.valid,
+        diagnostics: bounded(record.diagnostics.map((item) => item.message))
+      });
+    } else ancillary.push({ kind: record.kind, id: record.name, path: record.path, valid: record.valid });
+  }
+  return {
+    copy,
+    resources,
+    ancillary,
+    prerequisites: result.validation.prerequisites,
+    diagnostics: [
+      ...result.diagnostics.map((item) => item.message),
+      ...result.validation.diagnostics.map((item) => `[${item.code}] ${item.message}`)
+    ].slice(0, LIBRARY_INVENTORY_LIMITS.copyDiagnostics)
+  };
+}
+
+export {
+  LIBRARY_INVENTORY_LIMITS,
+  libraryResourceKey,
+  parseLibraryResourceKey,
+  classifyLibraryOrigin,
+  libraryCopyState,
+  readLibraryInventory,
+  inspectLibraryCopy
+};
+//# sourceMappingURL=chunk-UWD3JD5X.js.map