@cleocode/caamp 2026.4.3 → 2026.4.5

package/dist/{chunk-6NBM4CAF.js → chunk-43GULI6J.js}

@@ -1,8 +1,9 @@
 import {
   getAllProviders,
+  getPrimaryProvider,
   groupByInstructFile,
   injectAll
-} from "./chunk-CRU25LRL.js";
+} from "./chunk-KWYLZ46H.js";
 import {
   __export,
   getAgentsConfigPath,
@@ -14,7 +15,7 @@ import {
   getPlatformLocations,
   resolveProviderProjectPath,
   resolveProviderSkillsDirs
-} from "./chunk-XWQ5WPHC.js";
+} from "./chunk-364OHA2T.js";
 
 // src/core/logger.ts
 var verboseMode = false;
@@ -300,8 +301,8 @@ async function removeSkill(skillName, providers, isGlobal, projectDir) {
 }
 async function listCanonicalSkills() {
   if (!existsSync2(getCanonicalSkillsDir())) return [];
-  const { readdir: readdir2 } = await import("fs/promises");
-  const entries = await readdir2(getCanonicalSkillsDir(), { withFileTypes: true });
+  const { readdir: readdir3 } = await import("fs/promises");
+  const entries = await readdir3(getCanonicalSkillsDir(), { withFileTypes: true });
   return entries.filter((e) => e.isDirectory() || e.isSymbolicLink()).map((e) => e.name);
 }
 
@@ -321,6 +322,7 @@ var AGENTS_CONFIG_PATH = getAgentsConfigPath();
 
 // src/core/advanced/orchestration.ts
 var PRIORITY_ORDER = {
+  primary: -1,
   high: 0,
   medium: 1,
   low: 2
@@ -498,20 +500,430 @@ async function updateInstructionsSingleOperation(providers, content, scope = "pr
       file: filePath,
       action,
       providers: selected.map((provider) => provider.id),
-      configFormats: Array.from(new Set(selected.map((provider) => provider.configFormat)))
+      configFormats: Array.from(
+        new Set(
+          selected.map((provider) => provider.capabilities.mcp?.configFormat).filter((f) => f !== void 0)
+        )
+      )
     });
   }
   return summary;
 }
 
+// src/core/harness/pi.ts
+import { spawn } from "child_process";
+import { existsSync as existsSync4 } from "fs";
+import { cp as cp3, mkdir as mkdir3, readdir, readFile, rename, rm as rm3, writeFile } from "fs/promises";
+import { homedir } from "os";
+import { dirname as dirname2, join as join4 } from "path";
+var MARKER_START = "<!-- CAAMP:START -->";
+var MARKER_END = "<!-- CAAMP:END -->";
+var MARKER_PATTERN = /<!-- CAAMP:START -->[\s\S]*?<!-- CAAMP:END -->/;
+function getPiAgentDir() {
+  const env = process.env["PI_CODING_AGENT_DIR"];
+  if (env !== void 0 && env.length > 0) {
+    if (env === "~") return homedir();
+    if (env.startsWith("~/")) return join4(homedir(), env.slice(2));
+    return env;
+  }
+  return join4(homedir(), ".pi", "agent");
+}
+function isPlainObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function deepMerge(target, patch) {
+  const out = { ...target };
+  for (const [key, value] of Object.entries(patch)) {
+    const existing = out[key];
+    if (isPlainObject(value) && isPlainObject(existing)) {
+      out[key] = deepMerge(existing, value);
+    } else {
+      out[key] = value;
+    }
+  }
+  return out;
+}
+async function atomicWriteJson(filePath, data) {
+  await mkdir3(dirname2(filePath), { recursive: true });
+  const tmp = `${filePath}.tmp.${process.pid}`;
+  await writeFile(tmp, `${JSON.stringify(data, null, 2)}
+`, "utf8");
+  await rename(tmp, filePath);
+}
+var PiHarness = class {
+  /**
+   * Construct a harness bound to a resolved Pi provider.
+   *
+   * @param provider - The resolved provider entry for `"pi"`.
+   */
+  constructor(provider) {
+    this.provider = provider;
+  }
+  /** Provider id, always `"pi"`. */
+  id = "pi";
+  // ── Path helpers ────────────────────────────────────────────────────
+  /**
+   * Resolve the skills directory for a given scope.
+   */
+  skillsDir(scope) {
+    return scope.kind === "global" ? join4(getPiAgentDir(), "skills") : join4(scope.projectDir, ".pi", "skills");
+  }
+  /**
+   * Resolve the extensions directory for a given scope.
+   */
+  extensionsDir(scope) {
+    return scope.kind === "global" ? join4(getPiAgentDir(), "extensions") : join4(scope.projectDir, ".pi", "extensions");
+  }
+  /**
+   * Resolve the settings.json path for a given scope.
+   */
+  settingsPath(scope) {
+    return scope.kind === "global" ? join4(getPiAgentDir(), "settings.json") : join4(scope.projectDir, ".pi", "settings.json");
+  }
+  /**
+   * Resolve the AGENTS.md instruction file path for a given scope.
+   *
+   * @remarks
+   * Global scope lives under the Pi state root; project scope lives at
+   * the project root (NOT under `.pi/`), matching Pi's convention of
+   * auto-discovering `AGENTS.md` from the working directory upwards.
+   */
+  agentsMdPath(scope) {
+    return scope.kind === "global" ? join4(getPiAgentDir(), "AGENTS.md") : join4(scope.projectDir, "AGENTS.md");
+  }
+  // ── Skills ──────────────────────────────────────────────────────────
+  /** {@inheritDoc Harness.installSkill} */
+  async installSkill(sourcePath, skillName, scope) {
+    const targetDir = join4(this.skillsDir(scope), skillName);
+    await rm3(targetDir, { recursive: true, force: true });
+    await mkdir3(dirname2(targetDir), { recursive: true });
+    await cp3(sourcePath, targetDir, { recursive: true });
+  }
+  /** {@inheritDoc Harness.removeSkill} */
+  async removeSkill(skillName, scope) {
+    const targetDir = join4(this.skillsDir(scope), skillName);
+    await rm3(targetDir, { recursive: true, force: true });
+  }
+  /** {@inheritDoc Harness.listSkills} */
+  async listSkills(scope) {
+    const dir = this.skillsDir(scope);
+    if (!existsSync4(dir)) return [];
+    const entries = await readdir(dir, { withFileTypes: true });
+    return entries.filter((e) => e.isDirectory()).map((e) => e.name);
+  }
+  // ── Instructions ────────────────────────────────────────────────────
+  /** {@inheritDoc Harness.injectInstructions} */
+  async injectInstructions(content, scope) {
+    const filePath = this.agentsMdPath(scope);
+    await mkdir3(dirname2(filePath), { recursive: true });
+    const block = `${MARKER_START}
+${content.trim()}
+${MARKER_END}`;
+    let existing = "";
+    if (existsSync4(filePath)) {
+      existing = await readFile(filePath, "utf8");
+    }
+    let updated;
+    if (MARKER_PATTERN.test(existing)) {
+      updated = existing.replace(MARKER_PATTERN, block);
+    } else if (existing.length === 0) {
+      updated = `${block}
+`;
+    } else {
+      const separator = existing.endsWith("\n") ? "\n" : "\n\n";
+      updated = `${existing}${separator}${block}
+`;
+    }
+    await writeFile(filePath, updated, "utf8");
+  }
+  /** {@inheritDoc Harness.removeInstructions} */
+  async removeInstructions(scope) {
+    const filePath = this.agentsMdPath(scope);
+    if (!existsSync4(filePath)) return;
+    const existing = await readFile(filePath, "utf8");
+    if (!MARKER_PATTERN.test(existing)) return;
+    const stripped = existing.replace(MARKER_PATTERN, "").replace(/\n{3,}/g, "\n\n").trimEnd();
+    await writeFile(filePath, stripped.length === 0 ? "" : `${stripped}
+`, "utf8");
+  }
+  // ── MCP-as-extension scaffold ───────────────────────────────────────
+  /**
+   * {@inheritDoc Harness.installMcpAsExtension}
+   *
+   * @remarks
+   * Emits a SCAFFOLD Pi extension file under `extensions/mcp-<name>.ts`.
+   * The scaffold registers a Pi tool whose `execute` function currently
+   * returns an "isError" payload explaining that the MCP bridge runtime
+   * is not yet implemented. This preserves the public lifecycle surface
+   * (install/list/remove) so orchestration code can treat the bridge as
+   * a first-class asset while the concrete JSON-RPC runtime is built out
+   * in a later wave.
+   */
+  async installMcpAsExtension(server, scope) {
+    const dir = this.extensionsDir(scope);
+    await mkdir3(dir, { recursive: true });
+    const filePath = join4(dir, `mcp-${server.name}.ts`);
+    const launchConfig = JSON.stringify(
+      {
+        command: server.command,
+        args: server.args ?? [],
+        url: server.url,
+        env: server.env ?? {},
+        headers: server.headers ?? {}
+      },
+      null,
+      2
+    );
+    const src = `// AUTO-GENERATED by @cleocode/caamp \u2014 do not edit.
+// MCP-as-Pi-extension bridge scaffold for "${server.name}".
+// TODO: implement the MCP JSON-RPC bridge. Current behavior is a stub
+// that logs every tool invocation. The scaffold exists so that CAAMP
+// can manage the extension lifecycle (install/remove/list) without
+// blocking on a full MCP runtime bridge.
+
+const CONFIG = ${launchConfig};
+
+export default (pi: unknown) => {
+  const api = pi as {
+    registerTool: (def: {
+      name: string;
+      label: string;
+      description: string;
+      parameters: unknown;
+      execute: (...args: unknown[]) => Promise<{ type: 'text'; text: string; isError?: boolean }>;
+    }) => void;
+  };
+
+  api.registerTool({
+    name: ${JSON.stringify(`mcp_${server.name}`)},
+    label: ${JSON.stringify(`MCP: ${server.name}`)},
+    description: ${JSON.stringify(
+      `MCP server "${server.name}" \u2014 bridge scaffold, not yet implemented.`
+    )},
+    parameters: { type: 'object', properties: {} },
+    execute: async () => ({
+      type: 'text',
+      text: \`MCP bridge for "${server.name}" is a scaffold. Config: \${JSON.stringify(CONFIG)}\`,
+      isError: true,
+    }),
+  });
+};
+`;
+    await writeFile(filePath, src, "utf8");
+  }
+  // ── Subagent spawn ──────────────────────────────────────────────────
+  /**
+   * {@inheritDoc Harness.spawnSubagent}
+   *
+   * @remarks
+   * Invokes Pi's configured `spawnCommand` (e.g.
+   * `["pi", "--mode", "json", "-p", "--no-session"]`) with the task prompt
+   * appended as the trailing positional argument. The {@link SubagentTask.targetProviderId}
+   * is a routing hint carried in the prompt stream; Pi's own extension
+   * layer dispatches to the correct inner agent.
+   *
+   * Throws immediately when the provider entry is missing a `spawnCommand`
+   * so callers see configuration errors early rather than at child-exit time.
+   */
+  async spawnSubagent(task) {
+    const cmd = this.provider.capabilities.spawn.spawnCommand;
+    if (cmd === null || cmd.length === 0) {
+      throw new Error(
+        "PiHarness.spawnSubagent: provider has no spawn.spawnCommand in capabilities"
+      );
+    }
+    const program = cmd[0];
+    if (typeof program !== "string" || program.length === 0) {
+      throw new Error("PiHarness.spawnSubagent: invalid spawnCommand (missing program)");
+    }
+    const baseArgs = cmd.slice(1);
+    const args = [...baseArgs, task.prompt];
+    const child = spawn(program, args, {
+      cwd: task.cwd,
+      env: { ...process.env, ...task.env },
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString("utf8");
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk.toString("utf8");
+    });
+    const result = new Promise((resolve) => {
+      child.on("close", (exitCode) => {
+        let parsed;
+        try {
+          parsed = JSON.parse(stdout);
+        } catch {
+        }
+        resolve({ exitCode, stdout, stderr, parsed });
+      });
+    });
+    if (task.signal !== void 0) {
+      task.signal.addEventListener("abort", () => {
+        child.kill();
+      });
+    }
+    return {
+      pid: child.pid ?? null,
+      result,
+      abort: () => {
+        child.kill();
+      }
+    };
+  }
+  // ── Settings ────────────────────────────────────────────────────────
+  /** {@inheritDoc Harness.readSettings} */
+  async readSettings(scope) {
+    const filePath = this.settingsPath(scope);
+    if (!existsSync4(filePath)) return {};
+    const raw = await readFile(filePath, "utf8");
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return {};
+    }
+  }
+  /** {@inheritDoc Harness.writeSettings} */
+  async writeSettings(patch, scope) {
+    const filePath = this.settingsPath(scope);
+    const current = await this.readSettings(scope);
+    const currentObj = isPlainObject(current) ? current : {};
+    const merged = deepMerge(currentObj, patch);
+    await atomicWriteJson(filePath, merged);
+  }
+  /** {@inheritDoc Harness.configureModels} */
+  async configureModels(modelPatterns, scope) {
+    await this.writeSettings({ enabledModels: modelPatterns }, scope);
+  }
+};
+
+// src/core/harness/index.ts
+function getHarnessFor(provider) {
+  if (provider.id === "pi") return new PiHarness(provider);
+  return null;
+}
+function getPrimaryHarness() {
+  const primary = getPrimaryProvider();
+  if (primary === void 0) return null;
+  return getHarnessFor(primary);
+}
+function getAllHarnesses() {
+  const result = [];
+  for (const provider of getAllProviders()) {
+    const harness = getHarnessFor(provider);
+    if (harness !== null) result.push(harness);
+  }
+  return result;
+}
+function resolveDefaultTargetProviders() {
+  let primary = null;
+  try {
+    primary = getPrimaryHarness();
+  } catch {
+    primary = null;
+  }
+  const installed = getInstalledProviders();
+  if (primary !== null) {
+    const primaryId = primary.provider.id;
+    const primaryInstalled = installed.some((p) => p.id === primaryId);
+    if (primaryInstalled) {
+      return [primary.provider];
+    }
+  }
+  const highTier = installed.filter(
+    (provider) => provider.priority === "primary" || provider.priority === "high"
+  );
+  if (highTier.length > 0) {
+    return highTier;
+  }
+  return installed;
+}
+async function dispatchInstallSkillAcrossProviders(sourcePath, skillName, providers, isGlobal, projectDir) {
+  const harnessTargets = [];
+  const genericTargets = [];
+  for (const provider of providers) {
+    const harness = getHarnessFor(provider);
+    if (harness !== null) {
+      harnessTargets.push({ provider, harness });
+    } else {
+      genericTargets.push(provider);
+    }
+  }
+  const linkedAgents = [];
+  const errors = [];
+  const scope = isGlobal ? { kind: "global" } : { kind: "project", projectDir: projectDir ?? process.cwd() };
+  for (const { provider, harness } of harnessTargets) {
+    try {
+      await harness.installSkill(sourcePath, skillName, scope);
+      linkedAgents.push(provider.id);
+    } catch (err) {
+      errors.push(`${provider.id}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  let canonicalPath = "";
+  if (genericTargets.length > 0) {
+    const genericResult = projectDir !== void 0 ? await installSkill(sourcePath, skillName, genericTargets, isGlobal, projectDir) : await installSkill(sourcePath, skillName, genericTargets, isGlobal);
+    canonicalPath = genericResult.canonicalPath;
+    for (const id of genericResult.linkedAgents) {
+      linkedAgents.push(id);
+    }
+    for (const err of genericResult.errors) {
+      errors.push(err);
+    }
+  } else if (linkedAgents.length > 0) {
+    canonicalPath = sourcePath;
+  }
+  return {
+    name: skillName,
+    canonicalPath,
+    linkedAgents,
+    errors,
+    success: linkedAgents.length > 0
+  };
+}
+async function dispatchRemoveSkillAcrossProviders(skillName, providers, isGlobal, projectDir) {
+  const harnessTargets = [];
+  const genericTargets = [];
+  for (const provider of providers) {
+    const harness = getHarnessFor(provider);
+    if (harness !== null) {
+      harnessTargets.push({ provider, harness });
+    } else {
+      genericTargets.push(provider);
+    }
+  }
+  const removed = [];
+  const errors = [];
+  const scope = isGlobal ? { kind: "global" } : { kind: "project", projectDir: projectDir ?? process.cwd() };
+  for (const { provider, harness } of harnessTargets) {
+    try {
+      await harness.removeSkill(skillName, scope);
+      removed.push(provider.id);
+    } catch (err) {
+      errors.push(`${provider.id}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  const genericResult = projectDir !== void 0 ? await removeSkill(skillName, genericTargets, isGlobal, projectDir) : await removeSkill(skillName, genericTargets, isGlobal);
+  for (const id of genericResult.removed) {
+    removed.push(id);
+  }
+  for (const err of genericResult.errors) {
+    errors.push(err);
+  }
+  return { removed, errors };
+}
+
 // src/core/formats/utils.ts
-function deepMerge(target, source) {
+function deepMerge2(target, source) {
   const result = { ...target };
   for (const key of Object.keys(source)) {
     const sourceVal = source[key];
     const targetVal = target[key];
     if (sourceVal !== null && typeof sourceVal === "object" && !Array.isArray(sourceVal) && targetVal !== null && typeof targetVal === "object" && !Array.isArray(targetVal)) {
-      result[key] = deepMerge(
+      result[key] = deepMerge2(
         targetVal,
         sourceVal
       );
@@ -531,18 +943,18 @@ function getNestedValue(obj, keyPath) {
   return current;
 }
 async function ensureDir(filePath) {
-  const { mkdir: mkdir4 } = await import("fs/promises");
-  const { dirname: dirname3 } = await import("path");
-  await mkdir4(dirname3(filePath), { recursive: true });
+  const { mkdir: mkdir5 } = await import("fs/promises");
+  const { dirname: dirname4 } = await import("path");
+  await mkdir5(dirname4(filePath), { recursive: true });
 }
 
 // src/core/formats/json.ts
-import { existsSync as existsSync4 } from "fs";
-import { readFile, writeFile } from "fs/promises";
+import { existsSync as existsSync5 } from "fs";
+import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
 import * as jsonc from "jsonc-parser";
 async function readJsonConfig(filePath) {
-  if (!existsSync4(filePath)) return {};
-  const content = await readFile(filePath, "utf-8");
+  if (!existsSync5(filePath)) return {};
+  const content = await readFile2(filePath, "utf-8");
   if (!content.trim()) return {};
   const errors = [];
   const result = jsonc.parse(content, errors);
@@ -568,8 +980,8 @@ function detectIndent(content) {
 async function writeJsonConfig(filePath, configKey, serverName, serverConfig) {
   await ensureDir(filePath);
   let content;
-  if (existsSync4(filePath)) {
-    content = await readFile(filePath, "utf-8");
+  if (existsSync5(filePath)) {
+    content = await readFile2(filePath, "utf-8");
     if (!content.trim()) {
       content = "{}";
     }
@@ -591,11 +1003,11 @@ async function writeJsonConfig(filePath, configKey, serverName, serverConfig) {
   if (!content.endsWith("\n")) {
     content += "\n";
   }
-  await writeFile(filePath, content, "utf-8");
+  await writeFile2(filePath, content, "utf-8");
 }
 async function removeJsonConfig(filePath, configKey, serverName) {
-  if (!existsSync4(filePath)) return false;
-  let content = await readFile(filePath, "utf-8");
+  if (!existsSync5(filePath)) return false;
+  let content = await readFile2(filePath, "utf-8");
   if (!content.trim()) return false;
   const { tabSize, insertSpaces } = detectIndent(content);
   const formatOptions = {
@@ -611,17 +1023,17 @@ async function removeJsonConfig(filePath, configKey, serverName) {
   if (!content.endsWith("\n")) {
     content += "\n";
   }
-  await writeFile(filePath, content, "utf-8");
+  await writeFile2(filePath, content, "utf-8");
   return true;
 }
 
 // src/core/formats/toml.ts
-import { existsSync as existsSync5 } from "fs";
-import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { existsSync as existsSync6 } from "fs";
+import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
 import TOML from "@iarna/toml";
 async function readTomlConfig(filePath) {
-  if (!existsSync5(filePath)) return {};
-  const content = await readFile2(filePath, "utf-8");
+  if (!existsSync6(filePath)) return {};
+  const content = await readFile3(filePath, "utf-8");
   if (!content.trim()) return {};
   const result = TOML.parse(content);
   return result;
@@ -634,12 +1046,12 @@ async function writeTomlConfig(filePath, configKey, serverName, serverConfig) {
   for (const part of [...keyParts].reverse()) {
     newEntry = { [part]: newEntry };
   }
-  const merged = deepMerge(existing, newEntry);
+  const merged = deepMerge2(existing, newEntry);
   const content = TOML.stringify(merged);
-  await writeFile2(filePath, content, "utf-8");
+  await writeFile3(filePath, content, "utf-8");
 }
 async function removeTomlConfig(filePath, configKey, serverName) {
-  if (!existsSync5(filePath)) return false;
+  if (!existsSync6(filePath)) return false;
   const existing = await readTomlConfig(filePath);
   const keyParts = configKey.split(".");
   let current = existing;
@@ -651,17 +1063,17 @@ async function removeTomlConfig(filePath, configKey, serverName) {
   if (!(serverName in current)) return false;
   delete current[serverName];
   const content = TOML.stringify(existing);
-  await writeFile2(filePath, content, "utf-8");
+  await writeFile3(filePath, content, "utf-8");
   return true;
 }
 
 // src/core/formats/yaml.ts
-import { existsSync as existsSync6 } from "fs";
-import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
+import { existsSync as existsSync7 } from "fs";
+import { readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
 import yaml from "js-yaml";
 async function readYamlConfig(filePath) {
-  if (!existsSync6(filePath)) return {};
-  const content = await readFile3(filePath, "utf-8");
+  if (!existsSync7(filePath)) return {};
+  const content = await readFile4(filePath, "utf-8");
   if (!content.trim()) return {};
   const result = yaml.load(content);
   return result ?? {};
@@ -674,17 +1086,17 @@ async function writeYamlConfig(filePath, configKey, serverName, serverConfig) {
   for (const part of [...keyParts].reverse()) {
     newEntry = { [part]: newEntry };
   }
-  const merged = deepMerge(existing, newEntry);
+  const merged = deepMerge2(existing, newEntry);
   const content = yaml.dump(merged, {
     indent: 2,
     lineWidth: -1,
     noRefs: true,
     sortKeys: false
   });
-  await writeFile3(filePath, content, "utf-8");
+  await writeFile4(filePath, content, "utf-8");
 }
 async function removeYamlConfig(filePath, configKey, serverName) {
-  if (!existsSync6(filePath)) return false;
+  if (!existsSync7(filePath)) return false;
   const existing = await readYamlConfig(filePath);
   const keyParts = configKey.split(".");
   let current = existing;
@@ -701,7 +1113,7 @@ async function removeYamlConfig(filePath, configKey, serverName) {
     noRefs: true,
     sortKeys: false
   });
-  await writeFile3(filePath, content, "utf-8");
+  await writeFile4(filePath, content, "utf-8");
   return true;
 }
 
@@ -749,8 +1161,8 @@ async function removeConfig(filePath, format, key, serverName) {
 }
 
 // src/core/skills/audit/scanner.ts
-import { existsSync as existsSync7 } from "fs";
-import { readFile as readFile4 } from "fs/promises";
+import { existsSync as existsSync8 } from "fs";
+import { readFile as readFile5 } from "fs/promises";
 
 // src/core/skills/audit/rules.ts
 function rule(id, name, description, severity, category, pattern) {
@@ -1122,10 +1534,10 @@ var SEVERITY_WEIGHTS = {
   info: 0
 };
 async function scanFile(filePath, rules) {
-  if (!existsSync7(filePath)) {
+  if (!existsSync8(filePath)) {
     return { file: filePath, findings: [], score: 100, passed: true };
   }
-  const content = await readFile4(filePath, "utf-8");
+  const content = await readFile5(filePath, "utf-8");
   const lines = content.split("\n");
   const activeRules = rules ?? AUDIT_RULES;
   const findings = [];
@@ -1155,15 +1567,15 @@ async function scanFile(filePath, rules) {
   return { file: filePath, findings, score, passed };
 }
 async function scanDirectory(dirPath) {
-  const { readdir: readdir2 } = await import("fs/promises");
-  const { join: join7 } = await import("path");
-  if (!existsSync7(dirPath)) return [];
-  const entries = await readdir2(dirPath, { withFileTypes: true });
+  const { readdir: readdir3 } = await import("fs/promises");
+  const { join: join8 } = await import("path");
+  if (!existsSync8(dirPath)) return [];
+  const entries = await readdir3(dirPath, { withFileTypes: true });
   const results = [];
   for (const entry of entries) {
     if (entry.isDirectory() || entry.isSymbolicLink()) {
-      const skillFile = join7(dirPath, entry.name, "SKILL.md");
-      if (existsSync7(skillFile)) {
+      const skillFile = join8(dirPath, entry.name, "SKILL.md");
+      if (existsSync8(skillFile)) {
         results.push(await scanFile(skillFile));
       }
     }
@@ -1349,7 +1761,7 @@ function parseSource(input) {
       value: input,
       inferredName: inferName(input, "library"),
       owner: libraryMatch[1],
-      // This will be the package name, e.g. @cleocode/ct-skills
+      // This will be the package name, e.g. @cleocode/skills
       repo: libraryMatch[2]
       // This will be the skill name, e.g. ct-research-agent
     };
@@ -1384,8 +1796,8 @@ import { promisify } from "util";
 import { simpleGit } from "simple-git";
 
 // src/core/lock-utils.ts
-import { existsSync as existsSync8 } from "fs";
-import { mkdir as mkdir3, open, readFile as readFile5, rename, rm as rm3, stat, writeFile as writeFile4 } from "fs/promises";
+import { existsSync as existsSync9 } from "fs";
+import { mkdir as mkdir4, open, readFile as readFile6, rename as rename2, rm as rm4, stat, writeFile as writeFile5 } from "fs/promises";
 var LOCK_GUARD_PATH = `${LOCK_FILE_PATH}.lock`;
 var STALE_LOCK_MS = 5e3;
 function sleep(ms) {
@@ -1395,7 +1807,7 @@ async function removeStaleLock() {
   try {
     const info = await stat(LOCK_GUARD_PATH);
     if (Date.now() - info.mtimeMs > STALE_LOCK_MS) {
-      await rm3(LOCK_GUARD_PATH, { force: true });
+      await rm4(LOCK_GUARD_PATH, { force: true });
       return true;
     }
   } catch {
@@ -1403,7 +1815,7 @@ async function removeStaleLock() {
   return false;
 }
 async function acquireLockGuard(retries = 40, delayMs = 25) {
-  await mkdir3(AGENTS_HOME, { recursive: true });
+  await mkdir4(AGENTS_HOME, { recursive: true });
   for (let attempt = 0; attempt < retries; attempt += 1) {
     try {
       const handle = await open(LOCK_GUARD_PATH, "wx");
@@ -1423,19 +1835,19 @@ async function acquireLockGuard(retries = 40, delayMs = 25) {
   throw new Error("Timed out waiting for lock file guard");
 }
 async function releaseLockGuard() {
-  await rm3(LOCK_GUARD_PATH, { force: true });
+  await rm4(LOCK_GUARD_PATH, { force: true });
 }
 async function writeLockFileUnsafe(lock) {
   const tmpPath = `${LOCK_FILE_PATH}.tmp-${process.pid}-${Date.now()}`;
-  await writeFile4(tmpPath, JSON.stringify(lock, null, 2) + "\n", "utf-8");
-  await rename(tmpPath, LOCK_FILE_PATH);
+  await writeFile5(tmpPath, JSON.stringify(lock, null, 2) + "\n", "utf-8");
+  await rename2(tmpPath, LOCK_FILE_PATH);
 }
 async function readLockFile() {
   try {
-    if (!existsSync8(LOCK_FILE_PATH)) {
+    if (!existsSync9(LOCK_FILE_PATH)) {
       return { version: 1, skills: {}, mcpServers: {} };
     }
-    const content = await readFile5(LOCK_FILE_PATH, "utf-8");
+    const content = await readFile6(LOCK_FILE_PATH, "utf-8");
     return JSON.parse(content);
   } catch {
     return { version: 1, skills: {}, mcpServers: {} };
@@ -2163,9 +2575,9 @@ async function recommendSkills2(query, criteria, options = {}) {
 }
 
 // src/core/skills/library-loader.ts
-import { existsSync as existsSync9, readdirSync, readFileSync } from "fs";
+import { existsSync as existsSync10, readdirSync, readFileSync } from "fs";
 import { createRequire } from "module";
-import { basename as basename2, dirname as dirname2, join as join4 } from "path";
+import { basename as basename2, dirname as dirname3, join as join5 } from "path";
 var require2 = createRequire(import.meta.url);
 function loadLibraryFromModule(root) {
   let mod;
@@ -2211,16 +2623,16 @@ function loadLibraryFromModule(root) {
   return mod;
 }
 function buildLibraryFromFiles(root) {
-  const catalogPath = join4(root, "skills.json");
-  if (!existsSync9(catalogPath)) {
+  const catalogPath = join5(root, "skills.json");
+  if (!existsSync10(catalogPath)) {
     throw new Error(`No skills.json found at ${root}`);
   }
   const catalogData = JSON.parse(readFileSync(catalogPath, "utf-8"));
   const entries = catalogData.skills ?? [];
   const version = catalogData.version ?? "0.0.0";
-  const manifestPath = join4(root, "skills", "manifest.json");
+  const manifestPath = join5(root, "skills", "manifest.json");
   let manifest;
-  if (existsSync9(manifestPath)) {
+  if (existsSync10(manifestPath)) {
     manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
   } else {
     manifest = {
@@ -2230,14 +2642,14 @@ function buildLibraryFromFiles(root) {
       skills: []
     };
   }
-  const profilesDir = join4(root, "profiles");
+  const profilesDir = join5(root, "profiles");
   const profiles = /* @__PURE__ */ new Map();
-  if (existsSync9(profilesDir)) {
+  if (existsSync10(profilesDir)) {
     for (const file of readdirSync(profilesDir)) {
       if (!file.endsWith(".json")) continue;
       try {
         const profile = JSON.parse(
-          readFileSync(join4(profilesDir, file), "utf-8")
+          readFileSync(join5(profilesDir, file), "utf-8")
         );
         profiles.set(profile.name, profile);
       } catch {
@@ -2251,9 +2663,9 @@ function buildLibraryFromFiles(root) {
   function getSkillDir2(name) {
     const entry = skillMap.get(name);
     if (entry) {
-      return dirname2(join4(root, entry.path));
+      return dirname3(join5(root, entry.path));
     }
-    return join4(root, "skills", name);
+    return join5(root, "skills", name);
   }
   function resolveDeps(names, visited = /* @__PURE__ */ new Set()) {
     const result = [];
@@ -2281,7 +2693,7 @@ function buildLibraryFromFiles(root) {
     return resolveDeps([...new Set(skills)]);
   }
   function discoverFiles(dir, ext) {
-    if (!existsSync9(dir)) return [];
+    if (!existsSync10(dir)) return [];
     return readdirSync(dir).filter((f) => f.endsWith(ext)).map((f) => basename2(f, ext));
   }
   const library = {
@@ -2298,14 +2710,14 @@ function buildLibraryFromFiles(root) {
     getSkillPath(name) {
       const entry = skillMap.get(name);
       if (entry) {
-        return join4(root, entry.path);
+        return join5(root, entry.path);
       }
-      return join4(root, "skills", name, "SKILL.md");
+      return join5(root, "skills", name, "SKILL.md");
     },
     getSkillDir: getSkillDir2,
     readSkillContent(name) {
       const skillPath = library.getSkillPath(name);
-      if (!existsSync9(skillPath)) {
+      if (!existsSync10(skillPath)) {
         throw new Error(`Skill content not found: ${skillPath}`);
       }
       return readFileSync(skillPath, "utf-8");
@@ -2332,11 +2744,11 @@ function buildLibraryFromFiles(root) {
       return resolveProfileByName(name);
     },
     listSharedResources() {
-      return discoverFiles(join4(root, "skills", "_shared"), ".md");
+      return discoverFiles(join5(root, "skills", "_shared"), ".md");
     },
     getSharedResourcePath(name) {
-      const resourcePath = join4(root, "skills", "_shared", `${name}.md`);
-      return existsSync9(resourcePath) ? resourcePath : void 0;
+      const resourcePath = join5(root, "skills", "_shared", `${name}.md`);
+      return existsSync10(resourcePath) ? resourcePath : void 0;
     },
     readSharedResource(name) {
       const resourcePath = library.getSharedResourcePath(name);
@@ -2344,15 +2756,15 @@ function buildLibraryFromFiles(root) {
       return readFileSync(resourcePath, "utf-8");
     },
     listProtocols() {
-      const rootProtocols = discoverFiles(join4(root, "protocols"), ".md");
+      const rootProtocols = discoverFiles(join5(root, "protocols"), ".md");
       if (rootProtocols.length > 0) return rootProtocols;
-      return discoverFiles(join4(root, "skills", "protocols"), ".md");
+      return discoverFiles(join5(root, "skills", "protocols"), ".md");
     },
     getProtocolPath(name) {
-      const rootPath = join4(root, "protocols", `${name}.md`);
-      if (existsSync9(rootPath)) return rootPath;
-      const skillsPath = join4(root, "skills", "protocols", `${name}.md`);
-      return existsSync9(skillsPath) ? skillsPath : void 0;
+      const rootPath = join5(root, "protocols", `${name}.md`);
+      if (existsSync10(rootPath)) return rootPath;
+      const skillsPath = join5(root, "skills", "protocols", `${name}.md`);
+      return existsSync10(skillsPath) ? skillsPath : void 0;
     },
     readProtocol(name) {
       const protocolPath = library.getProtocolPath(name);
@@ -2377,8 +2789,8 @@ function buildLibraryFromFiles(root) {
       if (!entry.version) {
         issues.push({ level: "warn", field: "version", message: "Missing version" });
       }
-      const skillPath = join4(root, entry.path);
-      if (!existsSync9(skillPath)) {
+      const skillPath = join5(root, entry.path);
+      if (!existsSync10(skillPath)) {
         issues.push({
           level: "error",
           field: "path",
@@ -2437,15 +2849,15 @@ __export(catalog_exports, {
   validateAll: () => validateAll,
   validateSkillFrontmatter: () => validateSkillFrontmatter
 });
-import { existsSync as existsSync10 } from "fs";
-import { join as join5 } from "path";
+import { existsSync as existsSync11 } from "fs";
+import { join as join6 } from "path";
 var _library = null;
 function registerSkillLibrary(library) {
   _library = library;
 }
 function registerSkillLibraryFromPath(root) {
-  const indexPath = join5(root, "index.js");
-  if (existsSync10(indexPath)) {
+  const indexPath = join6(root, "index.js");
+  if (existsSync11(indexPath)) {
     _library = loadLibraryFromModule(root);
     return;
   }
@@ -2456,13 +2868,13 @@ function clearRegisteredLibrary() {
 }
 function discoverLibrary() {
   const envPath = process.env["CAAMP_SKILL_LIBRARY"];
-  if (envPath && existsSync10(envPath)) {
+  if (envPath && existsSync11(envPath)) {
     try {
-      const indexPath = join5(envPath, "index.js");
-      if (existsSync10(indexPath)) {
+      const indexPath = join6(envPath, "index.js");
+      if (existsSync11(indexPath)) {
         return loadLibraryFromModule(envPath);
       }
-      if (existsSync10(join5(envPath, "skills.json"))) {
+      if (existsSync11(join6(envPath, "skills.json"))) {
         return buildLibraryFromFiles(envPath);
       }
     } catch {
@@ -2569,13 +2981,13 @@ function getLibraryRoot() {
 }
 
 // src/core/skills/discovery.ts
-import { existsSync as existsSync11 } from "fs";
-import { readdir, readFile as readFile6 } from "fs/promises";
-import { join as join6 } from "path";
+import { existsSync as existsSync12 } from "fs";
+import { readdir as readdir2, readFile as readFile7 } from "fs/promises";
+import { join as join7 } from "path";
 import matter from "gray-matter";
 async function parseSkillFile(filePath) {
   try {
-    const content = await readFile6(filePath, "utf-8");
+    const content = await readFile7(filePath, "utf-8");
     const { data } = matter(content);
     if (!data.name || !data.description) {
       return null;
@@ -2595,8 +3007,8 @@ async function parseSkillFile(filePath) {
   }
 }
 async function discoverSkill(skillDir) {
-  const skillFile = join6(skillDir, "SKILL.md");
-  if (!existsSync11(skillFile)) return null;
+  const skillFile = join7(skillDir, "SKILL.md");
+  if (!existsSync12(skillFile)) return null;
   const metadata = await parseSkillFile(skillFile);
   if (!metadata) return null;
   return {
@@ -2607,12 +3019,12 @@ async function discoverSkill(skillDir) {
   };
 }
 async function discoverSkills(rootDir) {
-  if (!existsSync11(rootDir)) return [];
-  const entries = await readdir(rootDir, { withFileTypes: true });
+  if (!existsSync12(rootDir)) return [];
+  const entries = await readdir2(rootDir, { withFileTypes: true });
   const skills = [];
   for (const entry of entries) {
     if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
-    const skillDir = join6(rootDir, entry.name);
+    const skillDir = join7(rootDir, entry.name);
     const skill = await discoverSkill(skillDir);
     if (skill) {
       skills.push(skill);
@@ -2636,8 +3048,8 @@ async function discoverSkillsMulti(dirs) {
 }
 
 // src/core/skills/validator.ts
-import { existsSync as existsSync12 } from "fs";
-import { readFile as readFile7 } from "fs/promises";
+import { existsSync as existsSync13 } from "fs";
+import { readFile as readFile8 } from "fs/promises";
 import matter2 from "gray-matter";
 var RESERVED_NAMES = [
   "anthropic",
@@ -2658,14 +3070,14 @@ var WARN_BODY_LINES = 500;
 var WARN_DESCRIPTION_LENGTH = 50;
 async function validateSkill(filePath) {
   const issues = [];
-  if (!existsSync12(filePath)) {
+  if (!existsSync13(filePath)) {
     return {
       valid: false,
       issues: [{ level: "error", field: "file", message: "File does not exist" }],
       metadata: null
     };
   }
-  const content = await readFile7(filePath, "utf-8");
+  const content = await readFile8(filePath, "utf-8");
   if (!content.startsWith("---")) {
     issues.push({
       level: "error",
@@ -2793,7 +3205,14 @@ export {
   selectProvidersByMinimumPriority,
   installBatchWithRollback,
   updateInstructionsSingleOperation,
-  deepMerge,
+  PiHarness,
+  getHarnessFor,
+  getPrimaryHarness,
+  getAllHarnesses,
+  resolveDefaultTargetProviders,
+  dispatchInstallSkillAcrossProviders,
+  dispatchRemoveSkillAcrossProviders,
+  deepMerge2 as deepMerge,
   getNestedValue,
   ensureDir,
   readConfig,
@@ -2839,4 +3258,4 @@ export {
   discoverSkillsMulti,
   validateSkill
 };
-//# sourceMappingURL=chunk-6NBM4CAF.js.map
+//# sourceMappingURL=chunk-43GULI6J.js.map