@iowarp/clio-coder 0.4.6 → 0.4.8

package/dist/chunk-GJBJHJNY.js

@@ -0,0 +1,2120 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  loadPromptTemplates,
+  validateLibraryPackage
+} from "./chunk-OEMFEL26.js";
+import {
+  fetchPluginSource,
+  loadSkills,
+  parseAgentRecipeSchema,
+  parsePluginGithubSource,
+  pluginLocalPath
+} from "./chunk-EXKUF426.js";
+import {
+  normalizedSkillHash
+} from "./chunk-DNCE23JJ.js";
+import {
+  PLUGIN_EXTENSION_KEY,
+  PLUGIN_SCHEMA,
+  installLibraryPackage,
+  isPluginId,
+  listInstalledPlugins,
+  pluginBaseDir,
+  readPluginInstallRecord,
+  readPluginManifest
+} from "./chunk-6UJ7RDI7.js";
+import {
+  isSemanticVersion
+} from "./chunk-XW2UZICE.js";
+import {
+  readSettings,
+  updateSettings
+} from "./chunk-PGEFOTJB.js";
+import {
+  INTEROP_AGENT_KINDS,
+  interopAgentKind
+} from "./chunk-5EQO5NWP.js";
+import {
+  require_dist
+} from "./chunk-B5GGDIHT.js";
+import {
+  runCommandVector
+} from "./chunk-GJ24ODAX.js";
+import {
+  withStateFileLockSync
+} from "./chunk-DVJL77SO.js";
+import {
+  clioConfigDir,
+  clioStateDir
+} from "./chunk-CTTI7G3T.js";
+import {
+  safeResourceWrite
+} from "./chunk-ZZFWWYLX.js";
+import {
+  __toESM,
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/domains/interop/inventory.ts
+init_esm_shims();
+var import_yaml = __toESM(require_dist(), 1);
+import { lstatSync, readdirSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { parse as parseToml } from "smol-toml";
+var MAX_FILES = 4096;
+var MAX_BYTES = 2 * 1024 * 1024;
+function inventoryText(file) {
+  const stat = lstatSync(file);
+  if (!stat.isFile() || stat.isSymbolicLink() || stat.size > MAX_BYTES) throw new Error("not a bounded regular file");
+  return readFileSync(file, "utf8");
+}
+function object(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function discoverInteropInventory(kind, home, cwd, env = {}) {
+  const layout = kind.inventory;
+  const result = { status: "known", items: [], diagnostics: [], listing: "unknown" };
+  if (!layout) return { ...result, status: "unknown", diagnostics: ["Inventory is not extended for this host."] };
+  const seen = /* @__PURE__ */ new Set();
+  let visited = 0;
+  const unknown = (message) => {
+    result.status = "unknown";
+    result.diagnostics.push(message);
+  };
+  const entries = (dir) => {
+    try {
+      if (lstatSync(dir).isSymbolicLink()) {
+        unknown(`Symbolic-link root was not traversed: ${dir}`);
+        return [];
+      }
+      return readdirSync(dir).sort();
+    } catch (error) {
+      if (error.code !== "ENOENT") unknown(`Cannot inspect ${dir}`);
+      return [];
+    }
+  };
+  const json = (file) => {
+    try {
+      const value = JSON.parse(inventoryText(file));
+      if (!object(value)) throw new Error("not object");
+      return value;
+    } catch (error) {
+      if (error.code !== "ENOENT") unknown(`Cannot parse ${file}`);
+      return void 0;
+    }
+  };
+  const add = (file, resourceKind, scope, plugin2, metadata = {}) => {
+    const key = `${scope}:${resourceKind}:${file}:${metadata.name ?? ""}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    let declaredName;
+    if (["skill", "agent", "prompt"].includes(resourceKind)) {
+      try {
+        const raw = inventoryText(file);
+        const frontmatter = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/.exec(raw);
+        const data = file.endsWith(".toml") ? parseToml(raw) : frontmatter ? (0, import_yaml.parse)(frontmatter[1] ?? "") : void 0;
+        if (object(data) && typeof data.name === "string") declaredName = data.name;
+      } catch {
+        unknown(`Resource metadata is unknown: ${file}`);
+      }
+    }
+    result.items.push({
+      kind: resourceKind,
+      name: declaredName ?? (resourceKind === "skill" ? path.basename(path.dirname(file)) : path.basename(file, path.extname(file))),
+      path: file,
+      scope,
+      ...plugin2 ? { plugin: plugin2 } : {},
+      ...metadata
+    });
+  };
+  const walk = (dir, visit, depth = 0) => {
+    if (depth > 12) {
+      unknown(`Depth limit reached: ${dir}`);
+      return;
+    }
+    for (const name of entries(dir)) {
+      if (++visited > MAX_FILES) {
+        unknown("Inventory file limit reached.");
+        return;
+      }
+      const file = path.join(dir, name);
+      try {
+        const stat = lstatSync(file);
+        if (stat.isSymbolicLink()) {
+          unknown(`Symbolic link was not traversed: ${file}`);
+          continue;
+        }
+        if (stat.isDirectory()) walk(file, visit, depth + 1);
+        else if (stat.isFile()) visit(file);
+      } catch {
+        unknown(`Cannot inspect ${file}`);
+      }
+    }
+  };
+  const scan = (root, scope, plugin2, declarations = layout.declarations, resourceRoots = layout.roots) => {
+    for (const entry of resourceRoots) {
+      walk(path.join(root, entry.path), (file) => {
+        if (entry.kind === "skill" ? path.basename(file) === "SKILL.md" : entry.extensions.some((ext) => file.endsWith(ext)))
+          add(file, entry.kind, scope, plugin2);
+      });
+    }
+    for (const entry of declarations) {
+      const file = path.join(root, entry.path);
+      if (entry.path.endsWith(".toml")) {
+        try {
+          const data = parseToml(inventoryText(file));
+          if (object(data.mcp_servers))
+            for (const name of Object.keys(data.mcp_servers)) add(file, "mcp", scope, plugin2, { name });
+        } catch (error) {
+          if (error.code !== "ENOENT") unknown(`Cannot read ${file}`);
+        }
+      } else {
+        const data = json(file);
+        if (!data) continue;
+        const value = entry.key ? data[entry.key] : data;
+        if (value === void 0) continue;
+        if (object(value))
+          for (const name of Object.keys(value)) {
+            const key = `${scope}:${entry.kind}:${file}:${name}`;
+            if (!seen.has(key)) {
+              seen.add(key);
+              result.items.push({ kind: entry.kind, name, path: file, scope, ...plugin2 ? { plugin: plugin2 } : {} });
+            }
+          }
+        else unknown(`Unsupported declaration shape in ${file}`);
+      }
+    }
+  };
+  scan(home, "user", void 0, layout.userDeclarations ?? [], []);
+  scan(cwd, "project", void 0, layout.projectDeclarations ?? [], []);
+  if (layout.projectModuleConfig) {
+    const file = path.join(cwd, layout.projectModuleConfig);
+    const data = json(file);
+    if (Array.isArray(data?.plugin))
+      for (const value of data.plugin) {
+        const name = typeof value === "string" ? value : Array.isArray(value) && typeof value[0] === "string" ? value[0] : void 0;
+        if (name)
+          add(file, "executable", "project", void 0, {
+            name: name.startsWith("file:") || path.isAbsolute(name) ? path.basename(name) : name
+          });
+        else unknown("Unsupported project executable plugin declaration.");
+      }
+  }
+  const userRoot = env[layout.homeEnv ?? ""] ?? (layout.xdgConfigSubdir && env.XDG_CONFIG_HOME ? path.join(env.XDG_CONFIG_HOME, layout.xdgConfigSubdir) : path.join(home, layout.userRoot));
+  const roots = [
+    { root: userRoot, scope: "user" },
+    ...(layout.additionalUserRoots ?? []).map((root) => ({ root: path.join(home, root), scope: "user" })),
+    ...layout.projectRoots.map((root) => ({ root: path.join(cwd, root), scope: "project" }))
+  ];
+  const pluginRoots = /* @__PURE__ */ new Set();
+  const plugin = (root, scope, metadata = {}) => {
+    if (pluginRoots.has(`${scope}:${root}`)) return;
+    pluginRoots.add(`${scope}:${root}`);
+    let manifest;
+    for (const manifestPath of layout.pluginManifests) {
+      manifest = json(path.join(root, manifestPath));
+      if (manifest) break;
+    }
+    add(root, "plugin", scope, void 0, {
+      name: typeof manifest?.name === "string" ? manifest.name : path.basename(root),
+      version: typeof manifest?.version === "string" ? manifest.version : "unknown",
+      marketplace: "unknown",
+      installation: "unknown",
+      ...metadata
+    });
+    scan(root, scope, root);
+    for (const directory of ["scripts", "tools"])
+      walk(path.join(root, directory), (file) => add(file, "executable", scope, root));
+  };
+  for (const { root, scope } of roots) {
+    scan(root, scope);
+    if (layout.moduleConfig) {
+      const data = json(path.join(root, layout.moduleConfig));
+      if (Array.isArray(data?.plugin))
+        for (const name of data.plugin) {
+          const source = typeof name === "string" ? name : Array.isArray(name) && typeof name[0] === "string" ? name[0] : void 0;
+          if (source)
+            add(path.join(root, layout.moduleConfig), "executable", scope, void 0, {
+              name: path.isAbsolute(source) ? path.basename(source) : source.startsWith("file:") ? path.basename(source) : source
+            });
+          else unknown("Unsupported executable plugin declaration.");
+        }
+    }
+    if (layout.settingsRegistry === "copilot") {
+      const settings = json(path.join(root, "settings.json"));
+      if (object(settings?.enabledPlugins))
+        for (const [id, enabled] of Object.entries(settings.enabledPlugins)) {
+          const [name, market] = id.split("@");
+          const markets = settings.extraKnownMarketplaces;
+          const entry = object(markets) && market ? markets[market] : void 0;
+          const source = object(entry) ? entry.source : void 0;
+          if (!name || !object(source) || source.source !== "directory" || typeof source.path !== "string") {
+            unknown(`Plugin source path is unknown: ${id}`);
+            add(path.join(root, "settings.json"), "plugin", scope, void 0, {
+              name: id,
+              installation: "installed",
+              marketplace: market ?? "unknown",
+              version: "unknown"
+            });
+            continue;
+          }
+          const marketManifest = json(path.join(source.path, ".claude-plugin/marketplace.json")) ?? json(path.join(source.path, "marketplace.json"));
+          const declaration = Array.isArray(marketManifest?.plugins) ? marketManifest.plugins.find((entry2) => object(entry2) && entry2.name === name) : void 0;
+          if (!object(declaration) || typeof declaration.source !== "string" || !declaration.source.startsWith(".")) {
+            unknown(`Plugin local source is unknown: ${id}`);
+            continue;
+          }
+          plugin(path.resolve(source.path, declaration.source), scope, {
+            name,
+            marketplace: market ?? "unknown",
+            installation: "installed",
+            ...typeof enabled === "boolean" ? { enabled } : {}
+          });
+        }
+    }
+    if (layout.installedRegistry) {
+      const data = json(path.join(root, layout.installedRegistry));
+      if (object(data?.plugins)) {
+        for (const [id, records] of Object.entries(data.plugins)) {
+          if (!Array.isArray(records)) {
+            unknown("Unsupported installed plugin registry record.");
+            continue;
+          }
+          for (const record2 of records) {
+            if (!object(record2) || typeof record2.installPath !== "string") {
+              unknown("Plugin install path is unknown.");
+              continue;
+            }
+            if (record2.scope !== "user" && record2.scope !== "project" && record2.scope !== "local") {
+              unknown("Plugin scope is unknown.");
+              continue;
+            }
+            if (record2.scope !== "user" && record2.projectPath !== cwd) continue;
+            plugin(record2.installPath, record2.scope === "user" ? "user" : "project", {
+              name: id.split("@")[0] ?? id,
+              marketplace: id.split("@")[1] ?? "unknown",
+              version: typeof record2.version === "string" ? record2.version : "unknown",
+              installation: "installed"
+            });
+          }
+        }
+      }
+    }
+    for (const directory of layout.pluginDirs) {
+      const search = (dir, depth) => {
+        if (depth > 4) {
+          unknown(`Plugin search depth reached: ${dir}`);
+          return;
+        }
+        const names = entries(dir);
+        if (layout.pluginManifests.some((name) => {
+          try {
+            return lstatSync(path.join(dir, name)).isFile();
+          } catch {
+            return false;
+          }
+        })) {
+          const relative = path.relative(path.join(root, directory), dir).split(path.sep);
+          plugin(dir, scope, layout.cacheMarketplace ? { marketplace: relative[0] ?? "unknown" } : {});
+          return;
+        }
+        for (const name of names) {
+          if (++visited > MAX_FILES) {
+            unknown("Inventory file limit reached.");
+            return;
+          }
+          try {
+            if (lstatSync(path.join(dir, name)).isDirectory()) search(path.join(dir, name), depth + 1);
+          } catch {
+            unknown(`Cannot inspect ${dir}`);
+          }
+        }
+      };
+      search(path.join(root, directory), 0);
+    }
+  }
+  if (layout.settingsRegistry === "codex") {
+    try {
+      const data = parseToml(inventoryText(path.join(userRoot, "config.toml")));
+      if (object(data.plugins))
+        for (const item of result.items.filter((item2) => item2.kind === "plugin" && item2.scope === "user")) {
+          const state = data.plugins[`${item.name}@${item.marketplace}`];
+          if (object(state) && typeof state.enabled === "boolean") {
+            item.enabled = state.enabled;
+            item.installation = "installed";
+          }
+        }
+    } catch (error) {
+      if (error.code !== "ENOENT") unknown("Cannot parse Codex plugin settings.");
+    }
+  }
+  if (layout.settingsRegistry === "antigravity") {
+    const manifest = json(path.join(userRoot, "import_manifest.json"));
+    if (Array.isArray(manifest?.imports))
+      for (const item of result.items.filter((item2) => item2.kind === "plugin")) {
+        if (manifest.imports.some((entry) => object(entry) && entry.name === item.name)) item.installation = "installed";
+      }
+  }
+  return result;
+}
+
+// src/domains/interop/detect.ts
+init_esm_shims();
+import { createHash } from "node:crypto";
+import { accessSync, constants, existsSync as existsSync2, mkdirSync, mkdtempSync, rmSync, statSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import path3 from "node:path";
+
+// src/domains/interop/state.ts
+init_esm_shims();
+import { existsSync, readFileSync as readFileSync2 } from "node:fs";
+import path2 from "node:path";
+var KNOWN_IDS = new Set(INTEROP_AGENT_KINDS.map((kind) => kind.id));
+var PRESENCES = /* @__PURE__ */ new Set(["present", "absent", "unknown"]);
+function interopStatePath() {
+  return path2.join(clioStateDir(), "interop.json");
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringField(raw, key) {
+  const value = raw[key];
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function countField(raw, key) {
+  const value = raw[key];
+  return typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : 0;
+}
+function presenceField(raw, key) {
+  const value = raw[key];
+  return typeof value === "string" && PRESENCES.has(value) ? value : void 0;
+}
+function parseAgent(raw) {
+  if (!isRecord(raw)) return null;
+  const kind = stringField(raw, "kind");
+  const fingerprint = stringField(raw, "fingerprint");
+  const presence = presenceField(raw, "presence");
+  if (kind === void 0 || !KNOWN_IDS.has(kind) || fingerprint === void 0 || presence === void 0) return null;
+  const decision = stringField(raw, "decision");
+  const adapter = presenceField(raw, "adapter");
+  const binary = stringField(raw, "binary");
+  const version = stringField(raw, "version");
+  const installDir = stringField(raw, "installDir");
+  const decidedAt = stringField(raw, "decidedAt");
+  const decidedFingerprint = stringField(raw, "decidedFingerprint");
+  const hintedFingerprint = stringField(raw, "hintedFingerprint");
+  return {
+    kind,
+    presence,
+    fingerprint,
+    skillCount: countField(raw, "skillCount"),
+    projectArtifacts: countField(raw, "projectArtifacts"),
+    ...binary !== void 0 ? { binary } : {},
+    ...version !== void 0 ? { version } : {},
+    ...installDir !== void 0 ? { installDir } : {},
+    ...adapter !== void 0 ? { adapter } : {},
+    ...decision === "accepted" || decision === "declined" ? { decision } : {},
+    ...decidedAt !== void 0 ? { decidedAt } : {},
+    ...decidedFingerprint !== void 0 ? { decidedFingerprint } : {},
+    ...hintedFingerprint !== void 0 ? { hintedFingerprint } : {}
+  };
+}
+function readInteropReport() {
+  let filePath;
+  try {
+    filePath = interopStatePath();
+  } catch {
+    return null;
+  }
+  if (!existsSync(filePath)) return null;
+  try {
+    const parsed = JSON.parse(readFileSync2(filePath, "utf8"));
+    if (!isRecord(parsed) || parsed.version !== 1) return null;
+    const detectedAt = stringField(parsed, "detectedAt");
+    if (detectedAt === void 0 || !Array.isArray(parsed.agents)) return null;
+    const agents = parsed.agents.map(parseAgent).filter((agent) => agent !== null);
+    return { version: 1, detectedAt, agents };
+  } catch {
+    return null;
+  }
+}
+function writeInteropReport(report) {
+  safeResourceWrite(interopStatePath(), `${JSON.stringify(report, null, 2)}
+`, { encoding: "utf8" });
+}
+
+// src/domains/interop/detect.ts
+var VERSION_PROBE_TIMEOUT_MS = 2e3;
+var VERSION_PROBE_MAX_OUTPUT_BYTES = 4096;
+function resolveOnPath(binaryNames) {
+  if (binaryNames.length === 0) return { presence: "absent" };
+  const rawPath = process.env.PATH;
+  if (rawPath === void 0 || rawPath.length === 0) return { presence: "unknown" };
+  let unreadable = false;
+  try {
+    for (const dir of rawPath.split(path3.delimiter)) {
+      if (dir.length === 0) continue;
+      for (const name of binaryNames) {
+        const candidate = path3.join(dir, name);
+        try {
+          accessSync(candidate, constants.X_OK);
+          if (statSync(candidate).isFile()) return { presence: "present", binary: candidate };
+        } catch (error) {
+          if (["EACCES", "EPERM"].includes(error.code ?? "")) unreadable = true;
+        }
+      }
+    }
+  } catch {
+    return { presence: "unknown" };
+  }
+  return { presence: unreadable ? "unknown" : "absent" };
+}
+function adapterPresence(kind, cwd, binaryPresence) {
+  const recipe = kind.acp;
+  if (recipe === void 0) return "absent";
+  if (recipe.npmPackage === void 0) return binaryPresence;
+  try {
+    if (existsSync2(path3.join(cwd, "node_modules", recipe.npmPackage))) return "present";
+  } catch {
+    return "unknown";
+  }
+  if (recipe.npmPackageBin === void 0) return "absent";
+  return resolveOnPath([recipe.npmPackageBin]).presence;
+}
+function installDirOf(kind, home) {
+  const dir = path3.join(home, kind.userDir);
+  try {
+    return existsSync2(dir) ? dir : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function parseVersion(output) {
+  return /\b\d+\.\d+(?:\.\d+)?(?:[-+][0-9A-Za-z.-]+)?\b/.exec(output)?.[0];
+}
+async function probeVersion(binary) {
+  let scratch;
+  try {
+    scratch = mkdtempSync(path3.join(tmpdir(), "clio-coder-interop-version-"));
+    const env = { HOME: scratch, USERPROFILE: scratch };
+    for (const key of [
+      "XDG_CONFIG_HOME",
+      "XDG_CACHE_HOME",
+      "XDG_STATE_HOME",
+      "XDG_DATA_HOME",
+      "APPDATA",
+      "LOCALAPPDATA",
+      "CLAUDE_CONFIG_DIR",
+      "CODEX_HOME",
+      "ANTIGRAVITY_HOME",
+      "OPENCODE_CONFIG_DIR",
+      "COPILOT_HOME",
+      "GEMINI_CLI_HOME"
+    ]) {
+      const directory = path3.join(scratch, key.toLowerCase());
+      mkdirSync(directory);
+      env[key] = directory;
+    }
+    const result = await runCommandVector(binary, ["--version"], {
+      cwd: scratch,
+      workspaceRoot: scratch,
+      env,
+      timeoutMs: VERSION_PROBE_TIMEOUT_MS,
+      maxOutputBytes: VERSION_PROBE_MAX_OUTPUT_BYTES
+    });
+    if (result.timedOut || result.outputCapped || result.exitCode !== 0) return void 0;
+    return parseVersion(`${result.stdout}
+${result.stderr}`);
+  } catch {
+    return void 0;
+  } finally {
+    if (scratch) rmSync(scratch, { recursive: true, force: true });
+  }
+}
+function interopFingerprint(kind, facts) {
+  const recipe = kind.acp;
+  const parts = [
+    kind.id,
+    facts.binary ?? "",
+    facts.version ?? "",
+    recipe === void 0 ? "" : `${recipe.command} ${recipe.args.join(" ")}`
+  ];
+  return `sha256:${createHash("sha256").update(parts.join("\0")).digest("hex")}`;
+}
+function countBy(values, match) {
+  if (values === void 0 || match === void 0) return 0;
+  return values.filter((value) => value === match).length;
+}
+function detected(facts) {
+  return facts.presence === "present" || facts.installDir !== void 0 || facts.skillCount > 0 || facts.projectArtifacts > 0;
+}
+async function detectInteropAgents(input = {}, previous) {
+  const cwd = path3.resolve(input.cwd ?? process.cwd());
+  const home = input.home ?? homedir();
+  const priorByKind = new Map((previous ?? readInteropReport()?.agents ?? []).map((record2) => [record2.kind, record2]));
+  const agents = [];
+  for (const kind of INTEROP_AGENT_KINDS) {
+    const resolved = resolveOnPath(kind.binaryNames);
+    const prior = priorByKind.get(kind.id);
+    const inventoryRoot = input.inventory && kind.inventory ? (input.home === void 0 ? process.env[kind.inventory.homeEnv ?? ""] : void 0) ?? path3.join(home, kind.inventory.userRoot) : void 0;
+    const installDir = inventoryRoot && existsSync2(inventoryRoot) ? inventoryRoot : installDirOf(kind, home);
+    const facts = {
+      kind: kind.id,
+      presence: resolved.presence,
+      ...resolved.binary !== void 0 ? { binary: resolved.binary } : {},
+      ...installDir !== void 0 ? { installDir } : {},
+      ...kind.acp !== void 0 ? { adapter: adapterPresence(kind, cwd, resolved.presence) } : {},
+      skillCount: countBy(input.skillSources, kind.skillSource),
+      projectArtifacts: countBy(input.artifactProviders, kind.adoptionProvider)
+    };
+    if (resolved.binary !== void 0) {
+      const version = input.probeVersion === true ? await probeVersion(resolved.binary) : (
+        // A run that did not probe keeps the last version seen for the same
+        // binary, so the fingerprint does not flip between probing callers.
+        prior?.binary === resolved.binary ? prior.version : void 0
+      );
+      if (version !== void 0) facts.version = version;
+    }
+    if (input.inventory === true && kind.inventory) {
+      facts.inventory = discoverInteropInventory(kind, home, cwd, input.home === void 0 ? process.env : {});
+      facts.skillCount = facts.inventory.items.filter((item) => item.kind === "skill").length;
+      facts.projectArtifacts = facts.inventory.items.filter((item) => item.scope === "project").length;
+    }
+    if (!detected(facts) && !(input.inventory && kind.inventory)) continue;
+    agents.push({
+      ...facts,
+      fingerprint: interopFingerprint(kind, facts),
+      ...prior?.decision !== void 0 ? { decision: prior.decision } : {},
+      ...prior?.decidedAt !== void 0 ? { decidedAt: prior.decidedAt } : {},
+      ...prior?.decidedFingerprint !== void 0 ? { decidedFingerprint: prior.decidedFingerprint } : {},
+      ...prior?.hintedFingerprint !== void 0 ? { hintedFingerprint: prior.hintedFingerprint } : {}
+    });
+  }
+  return { version: 1, detectedAt: (/* @__PURE__ */ new Date()).toISOString(), agents };
+}
+
+// src/domains/interop/adopt.ts
+init_esm_shims();
+import { mkdirSync as mkdirSync2, mkdtempSync as mkdtempSync2, rmSync as rmSync2, writeFileSync } from "node:fs";
+import { tmpdir as tmpdir2 } from "node:os";
+import path6 from "node:path";
+
+// src/domains/interop/foreign.ts
+init_esm_shims();
+import { existsSync as existsSync3, lstatSync as lstatSync3, readdirSync as readdirSync3 } from "node:fs";
+import path5 from "node:path";
+
+// src/domains/interop/projection.ts
+init_esm_shims();
+var import_yaml2 = __toESM(require_dist(), 1);
+import { createHash as createHash2 } from "node:crypto";
+import { lstatSync as lstatSync2, readdirSync as readdirSync2, readFileSync as readFileSync3, readlinkSync } from "node:fs";
+import path4 from "node:path";
+import { parse as parseToml2 } from "smol-toml";
+var DATA_EXTENSIONS = /* @__PURE__ */ new Set([".md", ".txt", ".rst", ".csv", ".bib"]);
+var FORBIDDEN_PARTS = /* @__PURE__ */ new Set([
+  "hooks",
+  "output-styles",
+  "scripts",
+  "tools",
+  "node_modules",
+  ".git",
+  ".claude-plugin",
+  ".codex-plugin"
+]);
+var HOST_SKILL_KEYS = [
+  "audit",
+  "installed-hash",
+  "source-url",
+  "installed-by",
+  "hooks",
+  "mcpServers",
+  "allowed-tools",
+  "tools",
+  "context",
+  "agent",
+  "model",
+  "effort",
+  "user-invocable",
+  "disable-model-invocation",
+  "argument-hint",
+  "paths",
+  "when_to_use"
+];
+var PROMPT_KEYS = /* @__PURE__ */ new Set(["description", "argument-hint", "argumentHint"]);
+function safeName(name) {
+  const value = name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 45).replace(/-$/u, "");
+  if (!value) throw new Error("No safe resource identifier.");
+  return value;
+}
+function safeData(file) {
+  return !file.split("/").some((part) => FORBIDDEN_PARTS.has(part)) && DATA_EXTENSIONS.has(path4.extname(file));
+}
+function listFiles(root, dir, out, depth = 0) {
+  if (depth > 12 || out.length > 4096) return;
+  let names;
+  try {
+    names = readdirSync2(dir).sort();
+  } catch {
+    return;
+  }
+  for (const name of names) {
+    const file = path4.join(dir, name);
+    const relative = path4.relative(root, file).split(path4.sep).join("/");
+    try {
+      const stat = lstatSync2(file);
+      if (stat.isDirectory()) listFiles(root, file, out, depth + 1);
+      else out.push(relative);
+    } catch {
+      out.push(relative);
+    }
+  }
+}
+function tree(root, dataOnly = false, omitted = []) {
+  const files = {};
+  let bytes = 0;
+  const visit = (dir, depth) => {
+    if (depth > 12) throw new Error("Source tree exceeds depth limit.");
+    if (lstatSync2(dir).isSymbolicLink()) throw new Error("Symbolic links are not adoptable.");
+    for (const name of readdirSync2(dir).sort()) {
+      const file = path4.join(dir, name);
+      const relative = path4.relative(root, file).split(path4.sep).join("/");
+      if (dataOnly && relative.split("/").some((part) => FORBIDDEN_PARTS.has(part) || part === "fleets")) {
+        let isDirectory = false;
+        try {
+          isDirectory = lstatSync2(file).isDirectory();
+        } catch {
+        }
+        if (isDirectory) listFiles(root, file, omitted);
+        else omitted.push(relative);
+        continue;
+      }
+      const stat = lstatSync2(file);
+      if (stat.isSymbolicLink() || !stat.isDirectory() && !stat.isFile())
+        throw new Error("Symbolic links and special files are not adoptable.");
+      if (stat.isDirectory()) visit(file, depth + 1);
+      else {
+        if (dataOnly && relative !== "plugin.json" && (!safeData(relative) || (stat.mode & 73) !== 0)) {
+          omitted.push(relative);
+          continue;
+        }
+        if ((stat.mode & 73) !== 0) throw new Error(`Executable file is not adoptable: ${path4.relative(root, file)}`);
+        const text = inventoryText(file);
+        bytes += Buffer.byteLength(text);
+        if (bytes > 16 * 1024 * 1024 || Object.keys(files).length >= 2048)
+          throw new Error("Source tree exceeds adoption limits.");
+        files[relative] = text;
+      }
+    }
+  };
+  visit(root, 0);
+  return files;
+}
+function reviewFingerprint(root) {
+  const hash = createHash2("sha256");
+  let budget = 64 * 1024 * 1024;
+  let count = 0;
+  const visit = (dir, depth) => {
+    if (depth > 12) throw new Error("Source tree exceeds depth limit.");
+    for (const name of readdirSync2(dir).sort()) {
+      if (++count > 8192) throw new Error("Source tree exceeds review limits.");
+      const file = path4.join(dir, name);
+      const relative = path4.relative(root, file).split(path4.sep).join("/");
+      const stat = lstatSync2(file);
+      hash.update(relative).update("\0");
+      if (stat.isSymbolicLink()) hash.update(`symlink:${readlinkSync(file)}`);
+      else if (stat.isDirectory()) {
+        hash.update("dir");
+        visit(file, depth + 1);
+      } else if (stat.isFile()) {
+        hash.update(`file:${stat.mode & 511}:${stat.size}:`);
+        budget -= stat.size;
+        if (budget < 0) throw new Error("Source tree exceeds review limits.");
+        hash.update(readFileSync3(file));
+      } else hash.update("special");
+      hash.update("\0");
+    }
+  };
+  visit(root, 0);
+  return hash.digest("hex");
+}
+function digest(files) {
+  const hash = createHash2("sha256");
+  for (const key of Object.keys(files).sort())
+    hash.update(key).update("\0").update(files[key] ?? "").update("\0");
+  return hash.digest("hex");
+}
+function prose(text) {
+  const match = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)([\s\S]*)$/.exec(text);
+  if (!match) return { metadata: {}, body: text };
+  const metadata = (0, import_yaml2.parse)(match[1] ?? "");
+  if (!metadata || typeof metadata !== "object" || Array.isArray(metadata))
+    throw new Error("Invalid resource frontmatter.");
+  return { metadata, body: match[2] ?? "" };
+}
+function projectSkill(input) {
+  const rawOmitted = [];
+  const rawSource = input.lenient ? tree(input.skillDir, true, rawOmitted) : tree(input.skillDir);
+  const foreign = (file) => input.excludeTopLevel?.has(file.split("/")[0] ?? "") === true;
+  const source = Object.fromEntries(Object.entries(rawSource).filter(([file]) => !foreign(file)));
+  const omittedFiles = rawOmitted.filter((file) => !foreign(file));
+  delete source["plugin.json"];
+  if (!input.lenient && Object.keys(source).some((file) => !safeData(file)))
+    throw new Error("Not adoptable: skill contains executable or non-text companion files.");
+  const raw = source["SKILL.md"];
+  if (raw === void 0) throw new Error("Skill directory has no SKILL.md.");
+  const skill = prose(raw);
+  const name = typeof skill.metadata.name === "string" && skill.metadata.name.trim() ? skill.metadata.name.trim() : "";
+  if (!input.lenient && (!name || typeof skill.metadata.description !== "string"))
+    throw new Error("Skill requires name and description frontmatter.");
+  if (typeof skill.metadata.description !== "string" || !skill.metadata.description.trim())
+    throw new Error("Skill requires description frontmatter.");
+  const actualName = name || input.fallbackName;
+  const omittedFields = [];
+  for (const key of ["clio-coder", "clio"]) if (key in skill.metadata) delete skill.metadata[key];
+  for (const key of HOST_SKILL_KEYS)
+    if (key in skill.metadata) {
+      omittedFields.push(key);
+      delete skill.metadata[key];
+    }
+  const id = safeName(actualName);
+  const body = skill.body;
+  const retained = [
+    body,
+    ...Object.entries(source).filter(([file]) => file !== "SKILL.md").map(([, text]) => text)
+  ];
+  const requiredOmissions = omittedFiles.filter((file) => {
+    const base = path4.basename(file);
+    return retained.some((text) => text.includes(file) || base.includes(".") && text.includes(base));
+  });
+  source["SKILL.md"] = `---
+${(0, import_yaml2.stringify)({ ...skill.metadata, name: actualName, "clio-coder": { audit: "unknown" } })}---
+${body}`;
+  return {
+    id,
+    name: actualName,
+    files: Object.fromEntries(Object.entries(source).map(([file, text]) => [`skills/${id}/${file}`, text])),
+    componentPath: `skills/${id}/SKILL.md`,
+    omittedFields,
+    omittedFiles,
+    requiredOmissions,
+    bindings: []
+  };
+}
+function projectAgent(input) {
+  if (input.text === void 0 && (lstatSync2(input.file).mode & 73) !== 0)
+    throw new Error("Executable files are not adoptable.");
+  const raw = input.text ?? inventoryText(input.file);
+  const parsed = input.file.endsWith(".toml") ? (() => {
+    const data = parseToml2(raw);
+    if (typeof data.developer_instructions !== "string") throw new Error("Agent developer_instructions is unknown.");
+    return { metadata: data, body: data.developer_instructions };
+  })() : prose(raw);
+  if (!parsed.body.trim()) throw new Error("Empty resource body.");
+  const name = typeof parsed.metadata.name === "string" && parsed.metadata.name.trim() ? parsed.metadata.name.trim() : input.name;
+  const id = safeName(name);
+  const omittedFields = Object.keys(parsed.metadata).filter(
+    (key) => !["name", "description", "developer_instructions", ...input.bindSkills ? ["skills"] : []].includes(key)
+  );
+  const metadata = {
+    description: typeof parsed.metadata.description === "string" ? parsed.metadata.description : `Adopted agent ${name}`,
+    version: 1,
+    name,
+    tools: { required: ["read"], optional: ["grep", "find", "ls"] },
+    skills: [...input.bindSkills ?? []],
+    audience: "custom",
+    category: "research",
+    capabilityClass: "read-only",
+    latencyClass: "balanced",
+    projectContextTier: "bounded",
+    budget: { toolCalls: 24, readReserve: 4, synthesis: true },
+    resultContract: { kind: "artifact-report" },
+    tags: ["interop"]
+  };
+  parseAgentRecipeSchema({
+    id,
+    source: "plugin",
+    filepath: input.file,
+    body: parsed.body,
+    frontmatter: metadata
+  });
+  const componentPath = `agents/${id}.md`;
+  const declaredSkills = parsed.metadata.skills;
+  const bindings = Array.isArray(declaredSkills) ? declaredSkills.filter((skill) => typeof skill === "string") : typeof declaredSkills === "string" ? declaredSkills.split(",").map((skill) => skill.trim()).filter(Boolean) : [];
+  return {
+    id,
+    name,
+    files: { [componentPath]: `---
+${(0, import_yaml2.stringify)(metadata)}---
+${parsed.body}` },
+    componentPath,
+    omittedFields,
+    omittedFiles: [],
+    requiredOmissions: [],
+    bindings
+  };
+}
+function projectPrompt(input) {
+  if (input.text === void 0 && (lstatSync2(input.file).mode & 73) !== 0)
+    throw new Error("Executable files are not adoptable.");
+  const parsed = prose(input.text ?? inventoryText(input.file));
+  if (!parsed.body.trim()) throw new Error("Empty resource body.");
+  const name = input.name;
+  const id = safeName(name);
+  const omittedFields = Object.keys(parsed.metadata).filter((key) => !PROMPT_KEYS.has(key));
+  const metadata = {
+    description: typeof parsed.metadata.description === "string" ? parsed.metadata.description : `Adopted prompt ${name}`
+  };
+  const hint = parsed.metadata["argument-hint"] ?? parsed.metadata.argumentHint;
+  if (typeof hint === "string") metadata["argument-hint"] = hint;
+  const componentPath = `prompts/${id}.md`;
+  return {
+    id,
+    name,
+    files: { [componentPath]: `---
+${(0, import_yaml2.stringify)(metadata)}---
+${parsed.body}` },
+    componentPath,
+    omittedFields,
+    omittedFiles: [],
+    requiredOmissions: [],
+    bindings: []
+  };
+}
+
+// src/domains/interop/foreign.ts
+var FOREIGN_MANIFESTS = [
+  { format: "portable", path: "plugin.json" },
+  { format: "claude-code", path: ".claude-plugin/plugin.json" },
+  { format: "codex", path: ".codex-plugin/plugin.json" }
+];
+function detectForeignPlugin(root, explicit) {
+  const present = (relative) => {
+    try {
+      lstatSync3(path5.join(root, relative));
+      return true;
+    } catch {
+      return false;
+    }
+  };
+  const candidates = FOREIGN_MANIFESTS.filter(({ path: relative }) => present(relative));
+  const diagnostics = [];
+  const portable = candidates.find((candidate) => candidate.format === "portable");
+  if (portable) {
+    if (!lstatSync3(path5.join(root, "plugin.json")).isFile())
+      diagnostics.push("Root plugin.json exists but is not a regular file; the portable manifest is invalid.");
+    if (explicit)
+      diagnostics.push(`Root plugin.json is portable; --format ${explicit} is ignored and no foreign fallback runs.`);
+    for (const other of candidates.filter((candidate) => candidate.format !== "portable"))
+      diagnostics.push(`Ignoring ${other.path}: the portable root plugin.json takes precedence.`);
+    return { format: "portable", manifestPath: portable.path, candidates, ambiguous: false, diagnostics };
+  }
+  const hidden = candidates.filter((candidate) => candidate.format !== "portable");
+  if (hidden.length === 0)
+    return {
+      format: "none",
+      candidates,
+      ambiguous: false,
+      diagnostics: [
+        "No plugin manifest found: expected plugin.json, .claude-plugin/plugin.json or .codex-plugin/plugin.json."
+      ]
+    };
+  if (explicit) {
+    const chosen = hidden.find((candidate) => candidate.format === explicit);
+    if (!chosen)
+      return {
+        format: "none",
+        candidates,
+        ambiguous: false,
+        diagnostics: [`No ${explicit} manifest present; found ${hidden.map((item) => item.path).join(", ")}.`]
+      };
+    return { format: chosen.format, manifestPath: chosen.path, candidates, ambiguous: false, diagnostics };
+  }
+  if (hidden.length > 1)
+    return {
+      format: "none",
+      candidates,
+      ambiguous: true,
+      diagnostics: [
+        `Both ${hidden.map((item) => item.path).join(" and ")} are present; choose --format claude or --format codex.`
+      ]
+    };
+  const only = hidden[0];
+  return { format: only.format, manifestPath: only.path, candidates, ambiguous: false, diagnostics };
+}
+function record(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function pathList(value, field, problems) {
+  if (value === void 0) return [];
+  const items = typeof value === "string" ? [value] : Array.isArray(value) ? value : void 0;
+  if (!items || items.some((item) => typeof item !== "string")) {
+    problems.push(`Manifest ${field} must be a path or list of paths; ignored.`);
+    return [];
+  }
+  return items;
+}
+function contained(root, relative) {
+  if (relative.includes("\\") || relative.includes("\0") || path5.isAbsolute(relative))
+    throw new Error(`Manifest path is not relative: ${relative}`);
+  const full = path5.resolve(root, relative);
+  const rel = path5.relative(root, full);
+  if (rel === ".." || rel.startsWith(`..${path5.sep}`)) throw new Error(`Manifest path escapes the package: ${relative}`);
+  let cursor = root;
+  for (const part of rel.split(path5.sep).filter(Boolean)) {
+    cursor = path5.join(cursor, part);
+    if (lstatSync3(cursor).isSymbolicLink()) throw new Error(`Manifest path crosses a symbolic link: ${relative}`);
+  }
+  return full;
+}
+function relativeTo(root, file) {
+  return path5.relative(root, file).split(path5.sep).join("/");
+}
+function isDir(file) {
+  try {
+    return lstatSync3(file).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function isFile(file) {
+  try {
+    return lstatSync3(file).isFile();
+  } catch {
+    return false;
+  }
+}
+function skillDirectories(root, declared) {
+  const base = contained(root, declared);
+  if (!isDir(base)) return [];
+  if (isFile(path5.join(base, "SKILL.md"))) return [base];
+  return readdirSync3(base).sort().map((name) => path5.join(base, name)).filter((dir) => !lstatSync3(dir).isSymbolicLink() && isDir(dir) && isFile(path5.join(dir, "SKILL.md")));
+}
+function markdownFiles(root, declared, extensions) {
+  const base = contained(root, declared);
+  if (isFile(base)) return extensions.some((ext) => base.endsWith(ext)) ? [base] : [];
+  if (!isDir(base)) return [];
+  const found = [];
+  const walk = (dir, depth) => {
+    if (depth > 6) return;
+    for (const name of readdirSync3(dir).sort()) {
+      const file = path5.join(dir, name);
+      const stat = lstatSync3(file);
+      if (stat.isSymbolicLink()) continue;
+      if (stat.isDirectory()) walk(file, depth + 1);
+      else if (extensions.some((ext) => name.endsWith(ext))) found.push(file);
+    }
+  };
+  walk(base, 0);
+  return found;
+}
+var CLAUDE_UNSUPPORTED_FIELDS = [
+  "hooks",
+  "mcpServers",
+  "lspServers",
+  "outputStyles",
+  "workflows",
+  "experimental",
+  "userConfig",
+  "channels",
+  "defaultEnabled"
+];
+var CODEX_UNSUPPORTED_FIELDS = ["apps", "hooks", "mcpServers", "interface"];
+var UNSUPPORTED_FILES = [
+  "hooks/hooks.json",
+  ".mcp.json",
+  "mcp.json",
+  ".lsp.json",
+  ".app.json",
+  "monitors/monitors.json",
+  "output-styles",
+  "scripts",
+  "tools"
+];
+function projectForeignPlugin(input) {
+  const root = path5.resolve(input.root);
+  const manifestPath = input.manifestPath ?? (input.format === "claude-code" ? ".claude-plugin/plugin.json" : ".codex-plugin/plugin.json");
+  const manifestFile = contained(root, manifestPath);
+  if (!isFile(manifestFile)) throw new Error(`Missing ${manifestPath}.`);
+  const parsed = JSON.parse(inventoryText(manifestFile));
+  if (!record(parsed)) throw new Error(`${manifestPath} must be a JSON object.`);
+  const notes = [];
+  const unsupported = [];
+  const outcomes = [];
+  const rawName = typeof parsed.name === "string" && parsed.name.trim() ? parsed.name.trim() : "";
+  if (!rawName) throw new Error(`${manifestPath} requires a name.`);
+  const id = isPluginId(rawName) ? rawName : safeName(rawName);
+  if (id !== rawName) notes.push(`Package name "${rawName}" normalized to Clio id "${id}".`);
+  let version = "0.0.0";
+  if (parsed.version === void 0) notes.push("Vendor manifest declares no version; projected as 0.0.0.");
+  else if (isSemanticVersion(parsed.version)) version = parsed.version;
+  else throw new Error(`${manifestPath} version ${JSON.stringify(parsed.version)} is not a Semantic Version.`);
+  notes.push(
+    `Vendor identity: ${manifestPath} name ${JSON.stringify(rawName)}, version ${parsed.version === void 0 ? "absent" : JSON.stringify(parsed.version)}.`
+  );
+  const description = typeof parsed.description === "string" ? parsed.description : `Imported ${input.format === "claude-code" ? "Claude Code" : "Codex"} plugin ${rawName}`;
+  const fieldList = input.format === "claude-code" ? CLAUDE_UNSUPPORTED_FIELDS : CODEX_UNSUPPORTED_FIELDS;
+  for (const field of fieldList)
+    if (parsed[field] !== void 0) unsupported.push(`${manifestPath}#${field}: never activated by Clio import.`);
+  const requirements = [];
+  if (parsed.dependencies !== void 0) {
+    if (!Array.isArray(parsed.dependencies)) throw new Error(`${manifestPath} dependencies must be an array.`);
+    for (const dependency of parsed.dependencies) {
+      const name = typeof dependency === "string" ? dependency : record(dependency) ? dependency.name : void 0;
+      if (typeof name !== "string" || !name.trim())
+        throw new Error(`${manifestPath} declares a dependency without a name; the package cannot be imported.`);
+      if (record(dependency) && dependency.version !== void 0)
+        throw new Error(
+          `${manifestPath} dependency ${name} declares version constraint ${JSON.stringify(dependency.version)}; version-constrained vendor dependencies are not supported. Import ${name} first and remove the constraint in a reviewed copy, or skip this package.`
+        );
+      if (record(dependency)) {
+        const unknown = Object.keys(dependency).filter((key) => !["name", "version"].includes(key));
+        if (unknown.length)
+          throw new Error(
+            `${manifestPath} dependency ${name} declares unsupported fields ${unknown.join(", ")}; source or marketplace constrained dependencies cannot be imported.`
+          );
+      }
+      if (!isPluginId(name))
+        throw new Error(
+          `${manifestPath} dependency ${JSON.stringify(name)} is not a portable identifier; it cannot be matched to an imported package.`
+        );
+      requirements.push(`plugin:${name}`);
+      notes.push(
+        `Vendor dependency ${name} requires plugin:${name} imported from the same ${input.format} format; native packages with that id do not satisfy it.`
+      );
+    }
+  }
+  for (const file of UNSUPPORTED_FILES)
+    if (existsSync3(path5.join(root, file))) unsupported.push(`${file}: host runtime content is not imported.`);
+  const omittedTree = [];
+  const sourceFiles = tree(root, true, omittedTree);
+  const projected = /* @__PURE__ */ new Set();
+  const files = {};
+  const components = [];
+  const resources = {};
+  const usedIds = /* @__PURE__ */ new Map();
+  const claim = (resource, kind, source) => {
+    const key = `${kind}:${resource.id}`;
+    const previous = usedIds.get(key);
+    if (previous) {
+      outcomes.push({
+        kind,
+        name: resource.name,
+        source,
+        status: "unsupported",
+        reason: `Resource id ${resource.id} already provided by ${previous}.`
+      });
+      return false;
+    }
+    usedIds.set(key, source);
+    return true;
+  };
+  const declaredSkills = [];
+  const declaredCommands = [];
+  const declaredAgents = [];
+  const problems = [];
+  const skillsField = pathList(parsed.skills, "skills", problems);
+  if (input.format === "claude-code") {
+    declaredSkills.push("skills", ...skillsField);
+    const commands = pathList(parsed.commands, "commands", problems);
+    declaredCommands.push(...commands.length ? commands : ["commands"]);
+    if (commands.length && isDir(path5.join(root, "commands")) && !commands.some((c) => path5.resolve(root, c) === path5.join(root, "commands")))
+      notes.push("Manifest commands replaces the default commands/ directory; the default folder is not scanned.");
+    const agents = pathList(parsed.agents, "agents", problems);
+    declaredAgents.push(...agents.length ? agents : ["agents"]);
+    if (agents.length && isDir(path5.join(root, "agents")) && !agents.some((a) => path5.resolve(root, a) === path5.join(root, "agents")))
+      notes.push("Manifest agents replaces the default agents/ directory; the default folder is not scanned.");
+  } else {
+    declaredSkills.push(...skillsField.length ? skillsField : ["skills"]);
+    if (isDir(path5.join(root, "commands")) || isDir(path5.join(root, "agents")))
+      notes.push("commands/ and agents/ are not Codex plugin components and were not imported.");
+  }
+  notes.push(...problems);
+  const seenSkillDirs = /* @__PURE__ */ new Set();
+  const skillDirs = [];
+  for (const declared of declaredSkills) {
+    try {
+      for (const dir of skillDirectories(root, declared))
+        if (!seenSkillDirs.has(dir)) {
+          seenSkillDirs.add(dir);
+          skillDirs.push(dir);
+        }
+    } catch (error) {
+      unsupported.push(`skills path ${declared}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  if (input.format === "claude-code" && skillDirs.length === 0 && !isDir(path5.join(root, "skills")) && skillsField.length === 0 && isFile(path5.join(root, "SKILL.md"))) {
+    skillDirs.push(root);
+    notes.push("Root SKILL.md loaded as the plugin's single skill (documented Claude Code fallback).");
+  }
+  const siblingRoots = new Set(
+    [
+      ".claude-plugin",
+      ".codex-plugin",
+      "skills",
+      "commands",
+      "agents",
+      ...declaredCommands,
+      ...declaredAgents,
+      ...skillsField
+    ].map((entry) => entry.replace(/^\.\//u, "").split("/")[0] ?? "").filter((entry) => entry && entry !== ".")
+  );
+  for (const dir of skillDirs) {
+    const source = dir === root ? "SKILL.md" : `${relativeTo(root, dir)}/SKILL.md`;
+    const fallbackName = dir === root ? rawName : path5.basename(dir);
+    const prefix = dir === root ? "" : `${relativeTo(root, dir)}/`;
+    try {
+      const resource = projectSkill({
+        skillDir: dir,
+        fallbackName,
+        lenient: true,
+        ...dir === root ? { excludeTopLevel: siblingRoots } : {}
+      });
+      const omittedFiles = resource.omittedFiles.map((file) => `${prefix}${file}`);
+      if (resource.requiredOmissions.length) {
+        outcomes.push({
+          kind: "skill",
+          name: resource.name,
+          source,
+          status: "unsupported",
+          reason: `Instructions reference omitted companions: ${resource.requiredOmissions.join(", ")}.`,
+          omittedFields: resource.omittedFields,
+          omittedFiles
+        });
+        continue;
+      }
+      if (!claim(resource, "skill", source)) continue;
+      Object.assign(files, resource.files);
+      components.push({ kind: "skill", id: resource.id, path: resource.componentPath });
+      resources.skills = "skills";
+      for (const file of Object.keys(resource.files))
+        projected.add(`${prefix}${file.slice(`skills/${resource.id}/`.length)}`);
+      outcomes.push({
+        kind: "skill",
+        name: resource.name,
+        source,
+        status: "converted",
+        id: resource.id,
+        destination: resource.componentPath,
+        ...resource.omittedFields.length ? { omittedFields: resource.omittedFields } : {},
+        ...omittedFiles.length ? { omittedFiles } : {}
+      });
+    } catch (error) {
+      outcomes.push({
+        kind: "skill",
+        name: fallbackName,
+        source,
+        status: "unsupported",
+        reason: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  const collect = (declared, kind, extensions, convert) => {
+    const seen = /* @__PURE__ */ new Set();
+    for (const entry of declared) {
+      let found;
+      try {
+        found = markdownFiles(root, entry, extensions);
+      } catch (error) {
+        unsupported.push(`${kind} path ${entry}: ${error instanceof Error ? error.message : String(error)}`);
+        continue;
+      }
+      for (const file of found) {
+        if (seen.has(file)) continue;
+        seen.add(file);
+        const source = relativeTo(root, file);
+        const name = path5.basename(file, path5.extname(file));
+        try {
+          const resource = convert(file, name);
+          if (!claim(resource, kind, source)) continue;
+          Object.assign(files, resource.files);
+          components.push({ kind, id: resource.id, path: resource.componentPath });
+          resources[`${kind}s`] = `${kind}s`;
+          projected.add(source);
+          outcomes.push({
+            kind,
+            name: resource.name,
+            source,
+            status: "converted",
+            id: resource.id,
+            destination: resource.componentPath,
+            ...resource.omittedFields.length ? { omittedFields: resource.omittedFields } : {}
+          });
+        } catch (error) {
+          outcomes.push({
+            kind,
+            name,
+            source,
+            status: "unsupported",
+            reason: error instanceof Error ? error.message : String(error)
+          });
+        }
+      }
+    }
+  };
+  if (input.format === "claude-code") {
+    collect(declaredCommands, "prompt", [".md"], (file, name) => projectPrompt({ file, name }));
+    const convertedSkills = new Set(
+      outcomes.filter((o) => o.kind === "skill" && o.status === "converted").map((o) => o.name)
+    );
+    collect(declaredAgents, "agent", [".md"], (file, name) => {
+      const declared = projectAgent({ file, name }).bindings;
+      const bound = declared.filter((skill) => !convertedSkills.has(skill));
+      if (bound.length)
+        throw new Error(`Agent binds skills that were not converted: ${bound.join(", ")}; Clio cannot honor the binding.`);
+      return projectAgent({ file, name, bindSkills: declared });
+    });
+  }
+  const omitted = [
+    ...omittedTree,
+    ...Object.keys(sourceFiles).filter((file) => !projected.has(file) && file !== manifestPath)
+  ].sort();
+  files["plugin.json"] = `${JSON.stringify(
+    {
+      $schema: PLUGIN_SCHEMA,
+      name: id,
+      version,
+      description,
+      ...record(parsed.author) && Object.values(parsed.author).every((v) => typeof v === "string") ? {
+        author: Object.fromEntries(
+          Object.entries(parsed.author).filter(([key]) => ["name", "email", "url"].includes(key))
+        )
+      } : {},
+      ...typeof parsed.homepage === "string" ? { homepage: parsed.homepage } : {},
+      ...typeof parsed.repository === "string" ? { repository: parsed.repository } : {},
+      ...typeof parsed.license === "string" ? { license: parsed.license } : {},
+      ...Array.isArray(parsed.keywords) && parsed.keywords.every((k) => typeof k === "string") ? { keywords: parsed.keywords } : {},
+      extensions: {
+        [PLUGIN_EXTENSION_KEY]: {
+          manifestVersion: 1,
+          ...requirements.length ? { requires: requirements } : {},
+          resources,
+          components
+        }
+      }
+    },
+    null,
+    2
+  )}
+`;
+  return {
+    format: input.format,
+    manifestPath,
+    id,
+    version,
+    description,
+    files,
+    requirements,
+    outcomes,
+    unsupported: [...new Set(unsupported)],
+    omitted: [...new Set(omitted)],
+    notes
+  };
+}
+
+// src/domains/interop/install.ts
+init_esm_shims();
+function installInteropPackage(input) {
+  return installLibraryPackage(input);
+}
+
+// src/domains/interop/adopt.ts
+function preparePortablePackage(root) {
+  const candidate = readPluginManifest(root);
+  if (!candidate.valid || !candidate.manifest)
+    throw new Error(
+      `Not adoptable: invalid portable root plugin.json (${candidate.diagnostics.map((d) => d.message).join("; ")}).`
+    );
+  const manifest = candidate.manifest;
+  const omitted = [];
+  const files = tree(root, true, omitted);
+  const raw = JSON.parse(files["plugin.json"] ?? "{}");
+  const resources = Object.fromEntries(
+    Object.entries(manifest.clio.resources).filter(([key]) => ["skills", "agents", "prompts"].includes(key))
+  );
+  const components = manifest.clio.components.filter(
+    (component) => ["skill", "agent", "prompt", "resource"].includes(component.kind) && files[component.path] !== void 0
+  );
+  const retained = new Set(components.map((component) => `${component.kind}:${component.id}`));
+  if (components.some((component) => component.requires?.some((ref) => !retained.has(ref))))
+    throw new Error("Not adoptable: retained resources require omitted executable components.");
+  const kind = manifest.clio.kind ?? "plugin";
+  if (!["plugin", "skill", "agent", "prompt"].includes(kind))
+    throw new Error(
+      `Not adoptable: ${kind} packages have no data-only projection; install them through the library instead.`
+    );
+  if (kind !== "plugin" && !components.some((component) => component.kind === kind))
+    throw new Error(`Not adoptable: the ${kind} package's public ${kind} component is not projectable.`);
+  const validation = validateLibraryPackage(root);
+  if (!validation.valid)
+    throw new Error(
+      `Not adoptable: invalid recipe content (${validation.validation.diagnostics.filter((item) => item.severity === "error").map((item) => item.message).join("; ")}).`
+    );
+  const recipes = validation.validation.resources.filter(
+    (resource) => ["skill", "agent", "prompt"].includes(resource.kind) && files[resource.path] !== void 0
+  );
+  if (recipes.length === 0) throw new Error("Not adoptable: the portable package has no supported data-only recipes.");
+  const outcomes = [];
+  for (const resource of recipes) {
+    const component = components.find((item) => item.kind === resource.kind && item.path === resource.path);
+    const skillDir = resource.kind === "skill" ? path6.posix.dirname(resource.path) : void 0;
+    const dir = skillDir === void 0 ? void 0 : skillDir === "." ? "" : `${skillDir}/`;
+    const texts = Object.entries(files).filter(([file]) => file !== "plugin.json" && (dir === void 0 ? file === resource.path : file.startsWith(dir))).map(([, text]) => text);
+    const needed = omitted.filter((file) => {
+      const own = dir !== void 0 && file.startsWith(dir);
+      const base = path6.posix.basename(file);
+      return texts.some((text) => text.includes(file) || own && base.includes(".") && text.includes(base));
+    });
+    if (needed.length)
+      throw new Error(
+        `Not adoptable: ${resource.kind} ${resource.name} references omitted companions (${needed.join(", ")}); the data-only import cannot claim it works. Use library install for script-bearing packages.`
+      );
+    outcomes.push({
+      kind: resource.kind,
+      name: resource.name,
+      source: resource.path,
+      status: "converted",
+      ...component ? { id: component.id } : {},
+      destination: resource.path
+    });
+  }
+  raw.extensions = {
+    [PLUGIN_EXTENSION_KEY]: {
+      manifestVersion: 1,
+      ...kind !== "plugin" ? { kind } : {},
+      ...manifest.clio.requires ? { requires: manifest.clio.requires } : {},
+      resources,
+      components,
+      ...manifest.clio.compatibility ? { compatibility: manifest.clio.compatibility } : {}
+    }
+  };
+  files["plugin.json"] = JSON.stringify(raw, null, 2);
+  return {
+    id: manifest.name,
+    version: manifest.version ?? "0.0.0",
+    files,
+    note: "Data-only portable projection; hooks, MCP, scripts, tools, fleets and host settings are skipped. References to omitted files are unavailable.",
+    omitted,
+    requirements: [...manifest.clio.requires ?? []],
+    format: "portable",
+    outcomes
+  };
+}
+function prepareForeignPackage(root, format) {
+  const detection = detectForeignPlugin(root, format);
+  if (detection.format === "portable") throw new Error("Portable root plugin.json present; use the portable route.");
+  if (detection.format === "none") throw new Error(`Not adoptable: ${detection.diagnostics.join(" ")}`);
+  const projection = projectForeignPlugin({
+    root,
+    format: detection.format,
+    ...detection.manifestPath ? { manifestPath: detection.manifestPath } : {}
+  });
+  if (!projection.outcomes.some((outcome) => outcome.status === "converted"))
+    throw new Error(
+      `Not adoptable: no supported recipe converted from ${detection.manifestPath}${projection.outcomes.length ? ` (${projection.outcomes.map((o) => `${o.kind} ${o.name}: ${o.reason ?? "unsupported"}`).join("; ")})` : ""}.`
+    );
+  return {
+    id: projection.id,
+    version: projection.version,
+    files: projection.files,
+    note: `${detection.format === "claude-code" ? "Claude Code" : "Codex"} plugin normalized to a portable Clio package; hooks, MCP, LSP, scripts and host settings are never activated.${projection.notes.length ? ` ${projection.notes.join(" ")}` : ""}`,
+    omitted: projection.omitted,
+    requirements: projection.requirements,
+    format: detection.format,
+    outcomes: projection.outcomes,
+    unsupported: projection.unsupported
+  };
+}
+function prepared(item, host) {
+  let value;
+  if (item.kind === "plugin") {
+    const detection = detectForeignPlugin(item.path);
+    value = detection.format === "portable" || detection.format === "none" ? preparePortablePackage(item.path) : prepareForeignPackage(item.path, detection.format);
+  } else {
+    const id = safeName(`${host}-${item.kind}-${item.name}`);
+    const plural = `${item.kind}s`;
+    let note = "Text only; foreign execution settings are not imported.";
+    const resource = item.kind === "skill" ? projectSkill({ skillDir: path6.dirname(item.path), fallbackName: item.name }) : item.kind === "agent" ? projectAgent({ file: item.path, name: item.name }) : projectPrompt({ file: item.path, name: item.name });
+    if (item.kind === "agent")
+      note = "Persona copied into a read-only Clio recipe; host tools, permissions, model, hooks and skill bindings are omitted.";
+    const files = { ...resource.files };
+    files["plugin.json"] = JSON.stringify(
+      {
+        $schema: PLUGIN_SCHEMA,
+        name: id,
+        version: "0.0.0",
+        description: `Adopted ${item.kind} from ${host}`,
+        extensions: {
+          [PLUGIN_EXTENSION_KEY]: {
+            manifestVersion: 1,
+            kind: item.kind,
+            resources: { [plural]: plural },
+            components: [{ kind: item.kind, id: resource.id, path: resource.componentPath }]
+          }
+        }
+      },
+      null,
+      2
+    );
+    value = {
+      id,
+      version: "0.0.0",
+      files,
+      note,
+      omitted: [],
+      requirements: [],
+      ...resource.omittedFields.length ? {
+        outcomes: [
+          {
+            kind: item.kind,
+            name: resource.name,
+            source: item.path,
+            status: "converted",
+            id: resource.id,
+            destination: resource.componentPath,
+            omittedFields: resource.omittedFields
+          }
+        ]
+      } : {}
+    };
+  }
+  const manifest = JSON.parse(value.files["plugin.json"] ?? "{}");
+  manifest.extensions = {
+    ...manifest.extensions,
+    "ai.iowarp.clio.interop": {
+      host,
+      source: item.path,
+      sourceScope: item.scope,
+      untrusted: true,
+      ...value.format ? { format: value.format } : {}
+    }
+  };
+  value.files["plugin.json"] = `${JSON.stringify(manifest, null, 2)}
+`;
+  return value;
+}
+function vendorOf(format) {
+  return format === "claude-code" || format === "codex" ? format : void 0;
+}
+function unmetRequirements(requirements, cwd, scope, vendor) {
+  if (requirements.length === 0) return [];
+  const available = new Map(
+    listInstalledPlugins(cwd, { all: true, ...scope === "user" ? { scope } : {} }).filter((pkg) => pkg.loadable).map((pkg) => [`${pkg.kind ?? "plugin"}:${pkg.id}`, pkg])
+  );
+  const problems = /* @__PURE__ */ new Set();
+  if (vendor)
+    for (const ref of requirements) {
+      const pkg = available.get(ref);
+      if (!pkg) continue;
+      const origin = readPluginInstallRecord(pkg.id, { cwd, scope: pkg.scope })?.origin;
+      const provenance = typeof origin === "object" && (origin.kind === "import" || origin.kind === "interop") ? origin.format : void 0;
+      if (provenance !== vendor)
+        problems.add(
+          `${ref} (installed package is not an imported ${vendor} plugin; a same-named native package does not satisfy a vendor dependency)`
+        );
+    }
+  const visiting = /* @__PURE__ */ new Set();
+  const checked = /* @__PURE__ */ new Set();
+  const visit = (ref) => {
+    if (visiting.has(ref)) {
+      problems.add(`${ref} (dependency cycle)`);
+      return;
+    }
+    if (checked.has(ref)) return;
+    const dependency = available.get(ref);
+    if (!dependency) {
+      problems.add(`${ref} (missing, inactive, or unavailable in ${scope} scope)`);
+      return;
+    }
+    visiting.add(ref);
+    for (const nested of dependency.manifest?.clio.requires ?? []) visit(nested);
+    visiting.delete(ref);
+    checked.add(ref);
+  };
+  for (const ref of requirements) visit(ref);
+  return [...problems];
+}
+function planInteropAdoption(input) {
+  const cwd = path6.resolve(input.cwd ?? process.cwd());
+  const scope = input.scope ?? "user";
+  const installed = listInstalledPlugins(cwd, { all: true });
+  const installedSkills = loadSkills({
+    cwd,
+    roots: [
+      { path: path6.join(clioConfigDir(), "skills"), scope: "user" },
+      { path: path6.join(cwd, ".clio-coder/skills"), scope: "project" },
+      ...installed.flatMap(
+        (pkg) => pkg.resources.skills ? [{ path: path6.join(pkg.rootPath, pkg.resources.skills), rootPath: pkg.rootPath, scope: "package" }] : []
+      )
+    ]
+  }).items;
+  const installedPrompts = loadPromptTemplates({
+    cwd,
+    roots: [
+      { path: path6.join(clioConfigDir(), "prompts"), scope: "user" },
+      { path: path6.join(cwd, ".clio-coder/prompts"), scope: "project" },
+      ...installed.flatMap(
+        (pkg) => pkg.resources.prompts ? [{ path: path6.join(pkg.rootPath, pkg.resources.prompts), rootPath: pkg.rootPath, scope: "package" }] : []
+      )
+    ]
+  }).items;
+  const promptBodies = new Set(
+    installedPrompts.flatMap((prompt) => {
+      try {
+        return [prose(inventoryText(prompt.filePath)).body];
+      } catch {
+        return [];
+      }
+    })
+  );
+  const installedContent = new Set(
+    installed.flatMap((pkg) => {
+      try {
+        const files = tree(pkg.rootPath);
+        delete files["plugin.json"];
+        return [digest(files)];
+      } catch {
+        return [];
+      }
+    })
+  );
+  const planned = /* @__PURE__ */ new Set();
+  const plan = { host: input.host, cwd, scope, entries: [] };
+  for (const item of input.inventory.items) {
+    const skip = (reason) => {
+      plan.entries.push({ item, action: "skip", reason });
+    };
+    if (!["skill", "agent", "prompt", "plugin"].includes(item.kind)) {
+      skip(`Not adoptable: ${item.kind} is executable configuration or unsupported presentation data.`);
+      continue;
+    }
+    if (input.kind && item.kind !== input.kind) {
+      skip(`Excluded by --kind ${input.kind}.`);
+      continue;
+    }
+    if (item.plugin && !input.kind && planned.has(item.plugin)) {
+      skip("Provided by an installed or planned portable plugin.");
+      continue;
+    }
+    try {
+      if (item.kind === "skill" && installedSkills.some((skill) => skill.normalizedHash === normalizedSkillHash(inventoryText(item.path)))) {
+        skip("Already installed: same skill content digest.");
+        continue;
+      }
+      if (item.kind === "prompt" && promptBodies.has(prose(inventoryText(item.path)).body)) {
+        skip("Already installed: same prompt content digest.");
+        continue;
+      }
+      const value = prepared(item, input.host);
+      const missing = unmetRequirements(value.requirements, cwd, scope, vendorOf(value.format));
+      if (missing.length) {
+        skip(
+          `Unsatisfied package requirements: ${missing.join(", ")}. Install dependencies through the library and review a new plan; no extra resources are imported.`
+        );
+        continue;
+      }
+      const hash = digest(value.files);
+      if (item.kind === "plugin" && installed.some((pkg) => pkg.id === value.id && pkg.version === value.version)) {
+        planned.add(item.path);
+        skip("Already installed: same package id and version.");
+        continue;
+      }
+      const resourceFiles = { ...value.files };
+      delete resourceFiles["plugin.json"];
+      if (Object.keys(resourceFiles).length > 0 && installedContent.has(digest(resourceFiles))) {
+        skip("Already installed: same content digest.");
+        continue;
+      }
+      if (installed.some((pkg) => pkg.id === value.id && pkg.scope === scope) || planned.has(value.id)) {
+        skip("Package identifier collision; existing content will not be replaced.");
+        continue;
+      }
+      planned.add(value.id);
+      if (item.kind === "plugin") planned.add(item.path);
+      plan.entries.push({
+        item,
+        action: "install",
+        id: value.id,
+        destination: path6.join(pluginBaseDir(scope, cwd), value.id),
+        files: value.files,
+        digest: hash,
+        reason: value.note,
+        omitted: value.omitted,
+        requirements: value.requirements,
+        ...value.format ? { format: value.format } : {},
+        ...value.outcomes?.length ? { outcomes: value.outcomes } : {},
+        ...value.unsupported?.length ? { unsupported: value.unsupported } : {}
+      });
+    } catch (error) {
+      skip(error instanceof Error ? error.message : String(error));
+    }
+  }
+  return plan;
+}
+function renderOutcomes(outcomes) {
+  return (outcomes ?? []).map((outcome) => {
+    const detail = [
+      ...outcome.omittedFields?.length ? [`omitted frontmatter: ${outcome.omittedFields.join(", ")}`] : [],
+      ...outcome.omittedFiles?.length ? [`omitted files: ${outcome.omittedFiles.join(", ")}`] : [],
+      ...outcome.reason ? [outcome.reason] : []
+    ];
+    return outcome.status === "converted" ? `  CONVERT ${outcome.kind} ${outcome.name} -> ${outcome.destination}${detail.length ? ` (${detail.join("; ")})` : ""}` : `  UNSUPPORTED ${outcome.kind} ${outcome.name} (${outcome.source}): ${detail.join("; ")}`;
+  });
+}
+function renderInteropAdoptionPlan(plan) {
+  return [
+    `Adopt resources from ${plan.host} into Clio (${plan.scope})?`,
+    ...plan.entries.flatMap((entry) => [
+      `${entry.action.toUpperCase()} ${entry.item.kind} ${entry.item.name} (${entry.item.scope})`,
+      `  Source: ${entry.item.path}`,
+      ...entry.destination ? [`  Destination: ${entry.destination}`, `  SHA-256: ${entry.digest}`] : [],
+      `  ${entry.reason}`,
+      ...entry.format && entry.format !== "portable" ? [`  Format: ${entry.format} (normalized to a portable Clio package)`] : [],
+      ...entry.requirements?.length ? [`  Requires installed packages: ${entry.requirements.join(", ")}`] : [],
+      ...renderOutcomes(entry.outcomes),
+      ...(entry.unsupported ?? []).map((feature) => `  UNSUPPORTED ${feature}`),
+      ...(entry.omitted ?? []).map((file) => `  SKIP ${file}: executable, host-specific, or non-text data.`)
+    ]),
+    "Foreign resources remain untrusted until the project-import trust setting is enabled.",
+    "Host files are never changed. Approval applies only to the displayed content."
+  ].join("\n");
+}
+function interopOrigin(host, entry) {
+  const marketplace = entry.item.marketplace && entry.item.marketplace !== "unknown" ? entry.item.marketplace : void 0;
+  return {
+    kind: "interop",
+    host,
+    source: path6.resolve(entry.item.path),
+    ...entry.format ? { format: entry.format } : {},
+    ...marketplace ? { marketplace } : {}
+  };
+}
+function applyInteropAdoption(plan, approved) {
+  const result = { installed: [], diagnostics: [] };
+  if (!approved) {
+    result.diagnostics.push("Approval required; nothing installed.");
+    return result;
+  }
+  for (const entry of plan.entries) {
+    if (entry.action !== "install" || !entry.files || !entry.id) continue;
+    let staging;
+    try {
+      const current = prepared(entry.item, plan.host);
+      if (digest(entry.files) !== entry.digest || digest(current.files) !== entry.digest)
+        throw new Error("Source or plan changed after review; inspect a new plan.");
+      const missing = unmetRequirements(current.requirements, plan.cwd, plan.scope, vendorOf(current.format));
+      if (missing.length)
+        throw new Error(
+          `Unsatisfied package requirements after review: ${missing.join(", ")}. No extra resources are imported.`
+        );
+      staging = mkdtempSync2(path6.join(tmpdir2(), "clio-coder-interop-adopt-"));
+      for (const [file, text] of Object.entries(entry.files)) {
+        const target = path6.join(staging, file);
+        mkdirSync2(path6.dirname(target), { recursive: true });
+        writeFileSync(target, text, { mode: 420 });
+      }
+      const candidate = readPluginManifest(staging);
+      if (!candidate.valid || !candidate.contentDigest)
+        throw new Error(candidate.diagnostics.map((d) => d.message).join("; "));
+      const installed = installInteropPackage({
+        sourcePath: staging,
+        kind: entry.item.kind,
+        trust: "foreign",
+        cwd: plan.cwd,
+        scope: plan.scope,
+        expectedId: entry.id,
+        expectedDigest: candidate.contentDigest,
+        origin: interopOrigin(plan.host, entry)
+      });
+      if (installed.plugin) result.installed.push(installed.plugin.id);
+      result.diagnostics.push(...installed.diagnostics.map((d) => d.message));
+    } catch (error) {
+      result.diagnostics.push(`${entry.item.name}: ${error instanceof Error ? error.message : String(error)}`);
+    } finally {
+      if (staging) rmSync2(staging, { recursive: true, force: true });
+    }
+  }
+  return result;
+}
+
+// src/domains/interop/import.ts
+init_esm_shims();
+import { mkdirSync as mkdirSync3, mkdtempSync as mkdtempSync3, rmSync as rmSync3, writeFileSync as writeFileSync2 } from "node:fs";
+import { tmpdir as tmpdir3 } from "node:os";
+import path7 from "node:path";
+function prepare(root, format) {
+  const detection = detectForeignPlugin(root, format);
+  if (detection.format === "portable") return { detection, value: preparePortablePackage(root) };
+  if (detection.format === "none") throw new Error(detection.diagnostics.join(" "));
+  return { detection, value: prepareForeignPackage(root, detection.format) };
+}
+function planLibraryImport(input, options = {}) {
+  const cwd = path7.resolve(options.cwd ?? process.cwd());
+  const scope = options.scope ?? "user";
+  const remote = parsePluginGithubSource(input);
+  const local = pluginLocalPath(input, cwd);
+  const fetched = fetchPluginSource(input, cwd);
+  const source = remote ? { input, transport: "github", root: fetched.root, url: input } : { input, transport: "local", root: fetched.root, path: local };
+  const originSource = remote ? input : path7.resolve(local);
+  try {
+    const raw = reviewFingerprint(fetched.root);
+    let detection;
+    let value;
+    const reasons = [];
+    try {
+      ({ detection, value } = prepare(fetched.root, options.format));
+    } catch (error) {
+      detection = detectForeignPlugin(fetched.root, options.format);
+      reasons.push(error instanceof Error ? error.message : String(error));
+    }
+    reasons.push(...detection.diagnostics);
+    const format = value?.format ?? (detection.format === "none" ? void 0 : detection.format);
+    const origin = {
+      kind: "import",
+      source: originSource,
+      transport: remote ? "github" : "local",
+      format: format ?? "portable",
+      ...options.host ? { host: options.host } : {},
+      ...options.marketplace ? { marketplace: options.marketplace } : {}
+    };
+    const base = {
+      source,
+      detection,
+      ...format ? { format } : {},
+      scope,
+      cwd,
+      outcomes: value?.outcomes ?? [],
+      unsupported: value?.unsupported ?? [],
+      omitted: value?.omitted ?? [],
+      requirements: value?.requirements ?? [],
+      origin,
+      reviewFingerprint: raw,
+      cleanup: fetched.cleanup
+    };
+    if (!value) return { ...base, action: "blocked", reasons };
+    const missing = unmetRequirements(value.requirements, cwd, scope, vendorOf(value.format));
+    if (missing.length)
+      reasons.push(
+        `Unsatisfied package requirements: ${missing.join(", ")}. Install or import those packages first; no extra resources are imported.`
+      );
+    const installed = listInstalledPlugins(cwd, { all: true });
+    if (installed.some((pkg) => pkg.id === value.id && pkg.scope === scope))
+      reasons.push(`Package ${value.id} is already installed in ${scope} scope; remove it before importing again.`);
+    const blocked = missing.length > 0 || installed.some((pkg) => pkg.id === value.id && pkg.scope === scope);
+    return {
+      ...base,
+      action: blocked ? "blocked" : "install",
+      reasons: [value.note, ...reasons],
+      id: value.id,
+      version: value.version,
+      destination: path7.join(pluginBaseDir(scope, cwd), value.id),
+      digest: digest(value.files),
+      files: value.files
+    };
+  } catch (error) {
+    fetched.cleanup();
+    throw error;
+  }
+}
+function releaseLibraryImport(plan) {
+  plan.cleanup();
+}
+function applyLibraryImport(plan, approved, options = {}) {
+  const admission = {
+    trust: "foreign",
+    gate: "integrations.projectResources.trustProjectImports",
+    gateEnabled: options.trustProjectImports === void 0 ? "unknown" : options.trustProjectImports
+  };
+  const result = { published: false, admission, diagnostics: [] };
+  let staging;
+  try {
+    if (!approved) {
+      result.diagnostics.push("Approval required; nothing installed.");
+      return result;
+    }
+    if (plan.action !== "install" || !plan.files || !plan.id || !plan.digest) {
+      result.diagnostics.push(...plan.reasons.length ? plan.reasons : ["Plan is not installable."]);
+      return result;
+    }
+    if (reviewFingerprint(plan.source.root) !== plan.reviewFingerprint)
+      throw new Error("Source changed after review; inspect a new plan.");
+    const current = prepare(plan.source.root, plan.format === "portable" ? void 0 : plan.format).value;
+    if (digest(plan.files) !== plan.digest || digest(current.files) !== plan.digest)
+      throw new Error("Plan changed after review; inspect a new plan.");
+    const missing = unmetRequirements(current.requirements, plan.cwd, plan.scope, vendorOf(current.format));
+    if (missing.length)
+      throw new Error(
+        `Unsatisfied package requirements after review: ${missing.join(", ")}. No extra resources are imported.`
+      );
+    staging = mkdtempSync3(path7.join(tmpdir3(), "clio-coder-library-import-"));
+    for (const [file, text] of Object.entries(plan.files)) {
+      const target = path7.join(staging, file);
+      mkdirSync3(path7.dirname(target), { recursive: true });
+      writeFileSync2(target, text, { mode: 420 });
+    }
+    const candidate = readPluginManifest(staging);
+    if (!candidate.valid || !candidate.contentDigest)
+      throw new Error(candidate.diagnostics.map((d) => d.message).join("; "));
+    const installed = installInteropPackage({
+      sourcePath: staging,
+      kind: candidate.manifest?.clio.kind ?? "plugin",
+      trust: "foreign",
+      cwd: plan.cwd,
+      scope: plan.scope,
+      expectedId: plan.id,
+      expectedDigest: candidate.contentDigest,
+      origin: plan.origin
+    });
+    result.diagnostics.push(...installed.diagnostics.map((d) => d.message));
+    if (installed.plugin) {
+      result.published = true;
+      result.installed = installed.plugin.id;
+      result.destination = installed.plugin.rootPath;
+      result.validation = validateLibraryPackage(installed.plugin.rootPath, { cwd: plan.cwd });
+    }
+    return result;
+  } catch (error) {
+    result.diagnostics.push(error instanceof Error ? error.message : String(error));
+    return result;
+  } finally {
+    if (staging) rmSync3(staging, { recursive: true, force: true });
+    releaseLibraryImport(plan);
+  }
+}
+function libraryImportPlanSummary(plan) {
+  const { files: _files, cleanup: _cleanup, ...summary } = plan;
+  return summary;
+}
+function renderLibraryImportPlan(plan) {
+  const lines = [
+    `Import ${plan.source.transport === "github" ? plan.source.url : plan.source.path} into Clio (${plan.scope})?`,
+    `  Format: ${plan.format ?? "unknown"}${plan.detection.manifestPath ? ` (${plan.detection.manifestPath})` : ""}`,
+    ...plan.action === "install" ? [`  Package: ${plan.id} ${plan.version}`, `  Destination: ${plan.destination}`, `  SHA-256: ${plan.digest}`] : ["  BLOCKED"],
+    ...plan.reasons.map((reason) => `  ${reason}`),
+    ...plan.requirements.length ? [`  Requires installed packages: ${plan.requirements.join(", ")}`] : [],
+    ...plan.outcomes.map((outcome) => {
+      const detail = [
+        ...outcome.omittedFields?.length ? [`omitted frontmatter: ${outcome.omittedFields.join(", ")}`] : [],
+        ...outcome.omittedFiles?.length ? [`omitted files: ${outcome.omittedFiles.join(", ")}`] : [],
+        ...outcome.reason ? [outcome.reason] : []
+      ];
+      return outcome.status === "converted" ? `  CONVERT ${outcome.kind} ${outcome.name} -> ${outcome.destination}${detail.length ? ` (${detail.join("; ")})` : ""}` : `  UNSUPPORTED ${outcome.kind} ${outcome.name} (${outcome.source}): ${detail.join("; ")}`;
+    }),
+    ...plan.unsupported.map((feature) => `  UNSUPPORTED ${feature}`),
+    ...plan.omitted.map((file) => `  SKIP ${file}: executable, host-specific, or non-text data.`),
+    "Imported resources keep foreign trust and stay behind the project-import trust setting.",
+    "Source files are never changed. Approval applies only to the displayed content."
+  ];
+  return lines.join("\n");
+}
+
+// src/domains/interop/index.ts
+init_esm_shims();
+
+// src/domains/interop/extension.ts
+init_esm_shims();
+
+// src/domains/interop/consent.ts
+init_esm_shims();
+var import_yaml3 = __toESM(require_dist(), 1);
+var INHERITED_PROJECT_CONTEXT = "none";
+function delegationEntryForKind(kind, defaults) {
+  const recipe = kind.acp;
+  if (recipe === void 0) throw new Error(`interop kind ${kind.id} has no ACP recipe`);
+  return {
+    id: kind.id,
+    command: recipe.command,
+    args: [...recipe.args],
+    connectTimeoutMs: defaults.connectTimeoutMs,
+    turnTimeoutMs: defaults.turnTimeoutMs,
+    permissionTimeoutMs: defaults.permissionTimeoutMs,
+    toolGovernance: "clio-coder-policy"
+  };
+}
+function interopProposals(report, settings) {
+  const configured = new Set(settings.integrations.externalAgents.entries.map((agent) => agent.id));
+  const proposals = [];
+  for (const record2 of report.agents) {
+    const kind = interopAgentKind(record2.kind);
+    if (kind?.acp === void 0) continue;
+    if (record2.presence !== "present") continue;
+    if (configured.has(kind.id)) continue;
+    if (record2.decision !== void 0 && record2.decidedFingerprint === record2.fingerprint) continue;
+    proposals.push({
+      kind: kind.id,
+      label: kind.label,
+      fingerprint: record2.fingerprint,
+      entry: delegationEntryForKind(kind, settings.integrations.externalAgents.defaults),
+      needsNetworkInstall: record2.adapter !== "present"
+    });
+  }
+  return proposals;
+}
+function renderProposalEntry(proposal) {
+  return (0, import_yaml3.stringify)([proposal.entry]).trimEnd();
+}
+function withStoredDecision(stored, fresh) {
+  if (stored === void 0) return fresh;
+  return {
+    ...fresh,
+    ...stored.decision !== void 0 ? { decision: stored.decision } : {},
+    ...stored.decidedAt !== void 0 ? { decidedAt: stored.decidedAt } : {},
+    ...stored.decidedFingerprint !== void 0 ? { decidedFingerprint: stored.decidedFingerprint } : {},
+    ...stored.hintedFingerprint !== void 0 ? { hintedFingerprint: stored.hintedFingerprint } : {}
+  };
+}
+function updateRecords(ids, report, patch) {
+  const wanted = new Set(ids);
+  const touched = [];
+  withStateFileLockSync(interopStatePath(), () => {
+    const stored = readInteropReport();
+    const storedByKind = new Map(
+      (stored?.agents ?? []).map((record2) => [record2.kind, record2])
+    );
+    const byKind = new Map(storedByKind);
+    for (const record2 of report.agents) {
+      byKind.set(record2.kind, withStoredDecision(storedByKind.get(record2.kind), record2));
+    }
+    for (const id of wanted) {
+      const record2 = byKind.get(id);
+      if (record2 === void 0) continue;
+      byKind.set(id, patch(record2));
+      touched.push(id);
+    }
+    writeInteropReport({ version: 1, detectedAt: report.detectedAt, agents: [...byKind.values()] });
+  });
+  return touched;
+}
+function recordDecisions(ids, report, decision) {
+  const decidedAt = (/* @__PURE__ */ new Date()).toISOString();
+  return updateRecords(ids, report, (record2) => ({
+    ...record2,
+    decision,
+    decidedAt,
+    decidedFingerprint: record2.fingerprint
+  }));
+}
+function interopBootHint(report, settings) {
+  const fresh = interopProposals(report, settings).filter(
+    (proposal) => report.agents.find((agent) => agent.kind === proposal.kind)?.hintedFingerprint !== proposal.fingerprint
+  );
+  if (fresh.length === 0) return null;
+  updateRecords(
+    fresh.map((proposal) => proposal.kind),
+    report,
+    (record2) => ({ ...record2, hintedFingerprint: record2.fingerprint })
+  );
+  const names = fresh.map((proposal) => proposal.entry.id).join(", ");
+  return `clio-coder: ${names} detected on PATH and not configured. Run /interop to review.`;
+}
+function acceptInteropAgents(ids, report) {
+  const proposals = interopProposals(report, readSettings()).filter((proposal) => ids.includes(proposal.kind));
+  const diagnostics = [];
+  for (const id of ids) {
+    if (!proposals.some((proposal) => proposal.kind === id)) diagnostics.push(`${id} is not a pending proposal`);
+  }
+  if (proposals.length === 0) return { decided: [], wired: [], diagnostics };
+  const wired = [];
+  updateSettings((settings) => {
+    for (const proposal of proposals) {
+      if (settings.integrations.externalAgents.entries.some((agent) => agent.id === proposal.entry.id)) continue;
+      settings.integrations.externalAgents.entries.push({ ...proposal.entry, args: [...proposal.entry.args] });
+      wired.push(proposal.entry.id);
+    }
+  });
+  const decided = recordDecisions(
+    proposals.map((proposal) => proposal.kind),
+    report,
+    "accepted"
+  );
+  return { decided, wired, diagnostics };
+}
+function declineInteropAgents(ids, report) {
+  return { decided: recordDecisions(ids, report, "declined"), wired: [], diagnostics: [] };
+}
+
+// src/domains/interop/extension.ts
+var EMPTY_REPORT = { version: 1, detectedAt: (/* @__PURE__ */ new Date(0)).toISOString(), agents: [] };
+function createInteropBundle(_context) {
+  let detected2 = null;
+  const extension = {
+    start() {
+      return void 0;
+    }
+  };
+  const contract = {
+    kinds() {
+      return INTEROP_AGENT_KINDS;
+    },
+    async detect(input = {}) {
+      detected2 = await detectInteropAgents(input, detected2?.agents);
+      return detected2;
+    },
+    // A decision is written and read back, so the report an overlay rebuilds
+    // from carries it: a declined row leaves the proposal list on the
+    // keystroke rather than on the next detection.
+    lastReport() {
+      return detected2 ?? readInteropReport();
+    },
+    proposals(report) {
+      return interopProposals(report, readSettings());
+    },
+    // Read here, not from the hot settings snapshot the TUI holds: that one is
+    // refreshed by the config watcher a tick after the write, and the overlay
+    // rebuilds its rows the moment accept returns. An accepted peer was gone
+    // from the proposals, which read the file, and not yet in the configured
+    // list, which read the snapshot, so it was in neither until a reopen.
+    configured() {
+      return readSettings().integrations.externalAgents.entries;
+    },
+    accept(ids) {
+      const result = acceptInteropAgents(ids, detected2 ?? readInteropReport() ?? EMPTY_REPORT);
+      detected2 = readInteropReport() ?? detected2;
+      return result;
+    },
+    decline(ids) {
+      const result = declineInteropAgents(ids, detected2 ?? readInteropReport() ?? EMPTY_REPORT);
+      detected2 = readInteropReport() ?? detected2;
+      return result;
+    },
+    bootHint(report) {
+      return interopBootHint(report, readSettings());
+    }
+  };
+  return { extension, contract };
+}
+
+// src/domains/interop/manifest.ts
+init_esm_shims();
+var InteropManifest = {
+  name: "interop",
+  dependsOn: ["config"]
+};
+
+// src/domains/interop/index.ts
+var InteropDomainModule = {
+  manifest: InteropManifest,
+  createExtension: createInteropBundle
+};
+
+export {
+  INHERITED_PROJECT_CONTEXT,
+  delegationEntryForKind,
+  interopProposals,
+  renderProposalEntry,
+  acceptInteropAgents,
+  declineInteropAgents,
+  discoverInteropInventory,
+  resolveOnPath,
+  detectInteropAgents,
+  planInteropAdoption,
+  renderInteropAdoptionPlan,
+  applyInteropAdoption,
+  planLibraryImport,
+  releaseLibraryImport,
+  applyLibraryImport,
+  libraryImportPlanSummary,
+  renderLibraryImportPlan,
+  InteropDomainModule
+};
+//# sourceMappingURL=chunk-GJBJHJNY.js.map