@iowarp/clio-coder 0.4.9 → 0.5.0

package/dist/chunk-T2MDZES3.js

@@ -0,0 +1,1577 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  detectInteropAgents,
+  interopStatePath,
+  inventoryText,
+  readInteropReport,
+  writeInteropReport
+} from "./chunk-4A6YRGV4.js";
+import {
+  loadPromptTemplates,
+  validateLibraryPackage
+} from "./chunk-UX2L5CUD.js";
+import {
+  fetchPluginSource,
+  loadSkills,
+  parseAgentRecipeSchema,
+  parsePluginGithubSource,
+  pluginLocalPath
+} from "./chunk-LAR7DX5E.js";
+import {
+  normalizedSkillHash
+} from "./chunk-DNCE23JJ.js";
+import {
+  PLUGIN_EXTENSION_KEY,
+  PLUGIN_SCHEMA,
+  installLibraryPackage,
+  isPluginId,
+  listInstalledPlugins,
+  pluginBaseDir,
+  readPluginInstallRecord,
+  readPluginManifest
+} from "./chunk-NVPXXW2H.js";
+import {
+  isSemanticVersion
+} from "./chunk-BJH6WFIB.js";
+import {
+  INTEROP_AGENT_KINDS,
+  interopAgentKind
+} from "./chunk-5EQO5NWP.js";
+import {
+  readSettings,
+  updateSettings
+} from "./chunk-56XP4FJU.js";
+import {
+  require_dist
+} from "./chunk-B5GGDIHT.js";
+import {
+  withStateFileLockSync
+} from "./chunk-DVJL77SO.js";
+import {
+  clioConfigDir
+} from "./chunk-CTTI7G3T.js";
+import {
+  __toESM,
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/domains/interop/consent.ts
+init_esm_shims();
+var import_yaml = __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_yaml.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/adopt.ts
+init_esm_shims();
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path3 from "node:path";
+
+// src/domains/interop/foreign.ts
+init_esm_shims();
+import { existsSync, lstatSync as lstatSync2, readdirSync as readdirSync2 } from "node:fs";
+import path2 from "node:path";
+
+// src/domains/interop/projection.ts
+init_esm_shims();
+var import_yaml2 = __toESM(require_dist(), 1);
+import { createHash } from "node:crypto";
+import { lstatSync, readdirSync, readFileSync, readlinkSync } from "node:fs";
+import path from "node:path";
+import { parse as parseToml } 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(path.extname(file));
+}
+function listFiles(root, dir, out, depth = 0) {
+  if (depth > 12 || out.length > 4096) return;
+  let names;
+  try {
+    names = readdirSync(dir).sort();
+  } catch {
+    return;
+  }
+  for (const name of names) {
+    const file = path.join(dir, name);
+    const relative = path.relative(root, file).split(path.sep).join("/");
+    try {
+      const stat = lstatSync(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 (lstatSync(dir).isSymbolicLink()) throw new Error("Symbolic links are not adoptable.");
+    for (const name of readdirSync(dir).sort()) {
+      const file = path.join(dir, name);
+      const relative = path.relative(root, file).split(path.sep).join("/");
+      if (dataOnly && relative.split("/").some((part) => FORBIDDEN_PARTS.has(part) || part === "fleets")) {
+        let isDirectory = false;
+        try {
+          isDirectory = lstatSync(file).isDirectory();
+        } catch {
+        }
+        if (isDirectory) listFiles(root, file, omitted);
+        else omitted.push(relative);
+        continue;
+      }
+      const stat = lstatSync(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: ${path.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 = createHash("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 readdirSync(dir).sort()) {
+      if (++count > 8192) throw new Error("Source tree exceeds review limits.");
+      const file = path.join(dir, name);
+      const relative = path.relative(root, file).split(path.sep).join("/");
+      const stat = lstatSync(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(readFileSync(file));
+      } else hash.update("special");
+      hash.update("\0");
+    }
+  };
+  visit(root, 0);
+  return hash.digest("hex");
+}
+function digest(files) {
+  const hash = createHash("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 = path.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 && (lstatSync(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 = parseToml(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 && (lstatSync(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 {
+      lstatSync2(path2.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 (!lstatSync2(path2.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") || path2.isAbsolute(relative))
+    throw new Error(`Manifest path is not relative: ${relative}`);
+  const full = path2.resolve(root, relative);
+  const rel = path2.relative(root, full);
+  if (rel === ".." || rel.startsWith(`..${path2.sep}`)) throw new Error(`Manifest path escapes the package: ${relative}`);
+  let cursor = root;
+  for (const part of rel.split(path2.sep).filter(Boolean)) {
+    cursor = path2.join(cursor, part);
+    if (lstatSync2(cursor).isSymbolicLink()) throw new Error(`Manifest path crosses a symbolic link: ${relative}`);
+  }
+  return full;
+}
+function relativeTo(root, file) {
+  return path2.relative(root, file).split(path2.sep).join("/");
+}
+function isDir(file) {
+  try {
+    return lstatSync2(file).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function isFile(file) {
+  try {
+    return lstatSync2(file).isFile();
+  } catch {
+    return false;
+  }
+}
+function skillDirectories(root, declared) {
+  const base = contained(root, declared);
+  if (!isDir(base)) return [];
+  if (isFile(path2.join(base, "SKILL.md"))) return [base];
+  return readdirSync2(base).sort().map((name) => path2.join(base, name)).filter((dir) => !lstatSync2(dir).isSymbolicLink() && isDir(dir) && isFile(path2.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 readdirSync2(dir).sort()) {
+      const file = path2.join(dir, name);
+      const stat = lstatSync2(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 = path2.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 (existsSync(path2.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(path2.join(root, "commands")) && !commands.some((c) => path2.resolve(root, c) === path2.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(path2.join(root, "agents")) && !agents.some((a) => path2.resolve(root, a) === path2.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(path2.join(root, "commands")) || isDir(path2.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(path2.join(root, "skills")) && skillsField.length === 0 && isFile(path2.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 : path2.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 = path2.basename(file, path2.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" ? path3.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 = path3.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: path3.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 = path3.resolve(input.cwd ?? process.cwd());
+  const scope = input.scope ?? "user";
+  const installed = listInstalledPlugins(cwd, { all: true });
+  const installedSkills = loadSkills({
+    cwd,
+    roots: [
+      { path: path3.join(clioConfigDir(), "skills"), scope: "user" },
+      { path: path3.join(cwd, ".clio-coder/skills"), scope: "project" },
+      ...installed.flatMap(
+        (pkg) => pkg.resources.skills ? [{ path: path3.join(pkg.rootPath, pkg.resources.skills), rootPath: pkg.rootPath, scope: "package" }] : []
+      )
+    ]
+  }).items;
+  const installedPrompts = loadPromptTemplates({
+    cwd,
+    roots: [
+      { path: path3.join(clioConfigDir(), "prompts"), scope: "user" },
+      { path: path3.join(cwd, ".clio-coder/prompts"), scope: "project" },
+      ...installed.flatMap(
+        (pkg) => pkg.resources.prompts ? [{ path: path3.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: path3.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: path3.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 = mkdtempSync(path3.join(tmpdir(), "clio-coder-interop-adopt-"));
+      for (const [file, text] of Object.entries(entry.files)) {
+        const target = path3.join(staging, file);
+        mkdirSync(path3.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) rmSync(staging, { recursive: true, force: true });
+    }
+  }
+  return result;
+}
+
+// src/domains/interop/import.ts
+init_esm_shims();
+import { mkdirSync as mkdirSync2, mkdtempSync as mkdtempSync2, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { tmpdir as tmpdir2 } from "node:os";
+import path4 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 = path4.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 : path4.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: path4.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 = mkdtempSync2(path4.join(tmpdir2(), "clio-coder-library-import-"));
+    for (const [file, text] of Object.entries(plan.files)) {
+      const target = path4.join(staging, file);
+      mkdirSync2(path4.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) rmSync2(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();
+var EMPTY_REPORT = { version: 1, detectedAt: (/* @__PURE__ */ new Date(0)).toISOString(), agents: [] };
+function createInteropBundle(_context) {
+  let detected = null;
+  const extension = {
+    start() {
+      return void 0;
+    }
+  };
+  const contract = {
+    kinds() {
+      return INTEROP_AGENT_KINDS;
+    },
+    async detect(input = {}) {
+      detected = await detectInteropAgents(input, detected?.agents);
+      return detected;
+    },
+    // 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 detected ?? 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, detected ?? readInteropReport() ?? EMPTY_REPORT);
+      detected = readInteropReport() ?? detected;
+      return result;
+    },
+    decline(ids) {
+      const result = declineInteropAgents(ids, detected ?? readInteropReport() ?? EMPTY_REPORT);
+      detected = readInteropReport() ?? detected;
+      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,
+  planInteropAdoption,
+  renderInteropAdoptionPlan,
+  applyInteropAdoption,
+  planLibraryImport,
+  releaseLibraryImport,
+  applyLibraryImport,
+  libraryImportPlanSummary,
+  renderLibraryImportPlan,
+  InteropDomainModule
+};
+//# sourceMappingURL=chunk-T2MDZES3.js.map