@cleocode/caamp 2026.4.6 → 2026.4.9

package/dist/cli.js

@@ -2,14 +2,17 @@
 import {
   CANONICAL_SKILLS_DIR,
   MarketplaceClient,
+  PiHarness,
   RECOMMENDATION_ERROR_CODES,
   checkSkillUpdate,
   detectAllProviders,
+  detectMcpInstallations,
   detectProjectProviders,
   discoverSkill,
   discoverSkillsMulti,
   dispatchInstallSkillAcrossProviders,
   dispatchRemoveSkillAcrossProviders,
+  fetchWithTimeout,
   formatNetworkError,
   formatSkillRecommendations,
   getHarnessFor,
@@ -18,12 +21,15 @@ import {
   getSkillDir,
   getTrackedSkills,
   installBatchWithRollback,
+  installMcpServer,
   isCatalogAvailable,
   isHuman,
   isMarketplaceScoped,
   isQuiet,
   isVerbose,
+  listAllMcpServers,
   listCanonicalSkills,
+  listMcpServers,
   listProfiles,
   listSkills,
   parseSource,
@@ -31,6 +37,8 @@ import {
   readLockFile,
   recommendSkills,
   recordSkillInstall,
+  removeMcpServer,
+  removeMcpServerFromAll,
   removeSkillFromLock,
   resolveDefaultTargetProviders,
   resolveProfile,
@@ -44,7 +52,7 @@ import {
   tokenizeCriteriaValue,
   updateInstructionsSingleOperation,
   validateSkill
-} from "./chunk-43GULI6J.js";
+} from "./chunk-JC77OAHA.js";
 import {
   buildSkillsMap,
   checkAllInjections,
@@ -1537,6 +1545,1399 @@ function registerInstructionsCommands(program2) {
   registerInstructionsUpdate(instructions);
 }
 
+// src/commands/mcp/common.ts
+var MCP_ERROR_CODES = {
+  /** Caller-supplied input failed validation (shape, type, enum). */
+  VALIDATION: "E_VALIDATION_SCHEMA",
+  /** Referenced resource does not exist on disk or in the registry. */
+  NOT_FOUND: "E_NOT_FOUND_RESOURCE",
+  /** Server entry already exists and overwrite was not requested. */
+  CONFLICT: "E_CONFLICT_VERSION",
+  /** Upstream operation failed; retry is viable. */
+  TRANSIENT: "E_TRANSIENT_UPSTREAM"
+};
+function requireMcpProvider(providerId) {
+  const provider = getProvider(providerId);
+  if (provider === void 0) {
+    throw new LAFSCommandError(
+      MCP_ERROR_CODES.NOT_FOUND,
+      `Unknown provider id: ${providerId}`,
+      "Run `caamp providers list` to see registered provider ids.",
+      false
+    );
+  }
+  if (provider.capabilities.mcp === null) {
+    throw new LAFSCommandError(
+      MCP_ERROR_CODES.NOT_FOUND,
+      `Provider ${providerId} does not declare an MCP capability.`,
+      "This provider does not consume MCP servers via a config file. Pick a different provider, or check `caamp providers list` for MCP-capable providers.",
+      false
+    );
+  }
+  return provider;
+}
+function parseScope(raw, defaultScope) {
+  if (raw === void 0) return defaultScope;
+  if (raw === "project" || raw === "global") return raw;
+  throw new LAFSCommandError(
+    MCP_ERROR_CODES.VALIDATION,
+    `Invalid --scope value: ${raw}`,
+    "Use one of: 'project', 'global'.",
+    false
+  );
+}
+function resolveProjectDir(scope, explicit) {
+  if (scope !== "project") return void 0;
+  if (explicit !== void 0 && explicit.length > 0) return explicit;
+  return process.cwd();
+}
+function parseEnvAssignment(raw) {
+  const idx = raw.indexOf("=");
+  if (idx <= 0) {
+    throw new LAFSCommandError(
+      MCP_ERROR_CODES.VALIDATION,
+      `Invalid --env value: ${raw}`,
+      "Use KEY=VALUE format, e.g. --env GITHUB_TOKEN=ghp_...",
+      false
+    );
+  }
+  const key = raw.slice(0, idx);
+  const value = raw.slice(idx + 1);
+  if (key.length === 0) {
+    throw new LAFSCommandError(
+      MCP_ERROR_CODES.VALIDATION,
+      `Invalid --env value: ${raw}`,
+      "KEY must be non-empty.",
+      false
+    );
+  }
+  return [key, value];
+}
+
+// src/commands/mcp/detect.ts
+function registerMcpDetectCommand(parent) {
+  parent.command("detect").description("Detect which providers currently have MCP config files on disk").option("--scope <scope>", "Scope: project|global (default: project)").option("--project-dir <path>", "Project directory for the project scope (default: cwd)").option("--only-existing", "Only include providers whose config file exists on disk").action(
+    async (opts) => runLafsCommand("mcp.detect", "standard", async () => {
+      const scope = parseScope(opts.scope, "project");
+      const projectDir = resolveProjectDir(scope, opts.projectDir);
+      const all = await detectMcpInstallations(scope, projectDir);
+      const filtered = opts.onlyExisting === true ? all.filter((e) => e.exists) : all;
+      const existingCount = filtered.filter((e) => e.exists).length;
+      const totalServers = filtered.reduce((sum, e) => sum + (e.serverCount ?? 0), 0);
+      return {
+        scope,
+        providersProbed: all.length,
+        existingCount,
+        totalServers,
+        entries: filtered
+      };
+    })
+  );
+}
+
+// src/commands/mcp/install.ts
+import { existsSync as existsSync3 } from "fs";
+import { readFile as readFile2 } from "fs/promises";
+function coerceServerConfig(value, source) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new LAFSCommandError(
+      MCP_ERROR_CODES.VALIDATION,
+      `${source} did not contain a JSON object.`,
+      "Pass an object with at least `command` or `url` (and optional `args`, `env`).",
+      false
+    );
+  }
+  const obj = value;
+  const hasCommand = typeof obj["command"] === "string";
+  const hasUrl = typeof obj["url"] === "string";
+  const hasType = typeof obj["type"] === "string";
+  if (!hasCommand && !hasUrl && !hasType) {
+    throw new LAFSCommandError(
+      MCP_ERROR_CODES.VALIDATION,
+      `${source} must contain at least one of: command, url, type.`,
+      "Provide either a stdio `command` (with optional `args`/`env`) or a remote `url`/`type`.",
+      false
+    );
+  }
+  return obj;
+}
+async function buildConfigFromOptions(inlineArgs, opts) {
+  let base = null;
+  if (opts.from !== void 0 && opts.from.length > 0) {
+    if (!existsSync3(opts.from)) {
+      throw new LAFSCommandError(
+        MCP_ERROR_CODES.NOT_FOUND,
+        `--from file does not exist: ${opts.from}`,
+        "Check the path and try again.",
+        false
+      );
+    }
+    let parsed;
+    try {
+      const content = await readFile2(opts.from, "utf8");
+      parsed = JSON.parse(content);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      throw new LAFSCommandError(
+        MCP_ERROR_CODES.VALIDATION,
+        `Failed to read --from JSON: ${message}`,
+        "Ensure the file is valid JSON containing an MCP server config object.",
+        false
+      );
+    }
+    base = coerceServerConfig(parsed, `--from ${opts.from}`);
+  }
+  if (inlineArgs.length > 0) {
+    const command = inlineArgs[0];
+    if (command === void 0 || command.length === 0) {
+      throw new LAFSCommandError(
+        MCP_ERROR_CODES.VALIDATION,
+        "Inline command was empty.",
+        "Pass `--` followed by a command, e.g. `-- npx -y @mcp/server-github`.",
+        false
+      );
+    }
+    const args = inlineArgs.slice(1);
+    base = {
+      ...base ?? {},
+      command,
+      ...args.length > 0 ? { args } : {}
+    };
+  }
+  if (base === null) {
+    throw new LAFSCommandError(
+      MCP_ERROR_CODES.VALIDATION,
+      "Either an inline `-- <command> [args...]` or `--from <file>` is required.",
+      "Pass an MCP server definition via inline command or a JSON file.",
+      false
+    );
+  }
+  if (opts.env !== void 0 && opts.env.length > 0) {
+    const env = { ...base.env ?? {} };
+    for (const entry of opts.env) {
+      const [k, v] = parseEnvAssignment(entry);
+      env[k] = v;
+    }
+    base = { ...base, env };
+  }
+  return base;
+}
+function registerMcpInstallCommand(parent) {
+  parent.command("install <serverName> [args...]").description("Install an MCP server entry into a provider config file").option("--provider <id>", "Provider id to install into (required)").option("--from <file>", "Path to a JSON file containing an MCP server config").option(
+    "--env <kv>",
+    "Repeatable env var KEY=VALUE",
+    (value, prev = []) => [...prev, value],
+    []
+  ).option("--scope <scope>", "Scope: project|global (default: project)").option("--force", "Overwrite an existing server entry").option("--project-dir <path>", "Project directory for the project scope (default: cwd)").action(
+    async (serverName, inlineArgs, opts) => runLafsCommand("mcp.install", "standard", async () => {
+      if (opts.provider === void 0 || opts.provider.length === 0) {
+        throw new LAFSCommandError(
+          MCP_ERROR_CODES.VALIDATION,
+          "--provider <id> is required",
+          "Pass a provider id, e.g. --provider claude-desktop.",
+          false
+        );
+      }
+      if (serverName.length === 0) {
+        throw new LAFSCommandError(
+          MCP_ERROR_CODES.VALIDATION,
+          "Server name is required",
+          "Pass a non-empty server name as the first positional argument.",
+          false
+        );
+      }
+      const provider = requireMcpProvider(opts.provider);
+      const scope = parseScope(opts.scope, "project");
+      const projectDir = resolveProjectDir(scope, opts.projectDir);
+      const config = await buildConfigFromOptions(inlineArgs, opts);
+      const result = await installMcpServer(provider, serverName, config, {
+        scope,
+        force: opts.force ?? false,
+        projectDir
+      });
+      if (!result.installed && result.conflicted) {
+        throw new LAFSCommandError(
+          MCP_ERROR_CODES.CONFLICT,
+          `Server ${serverName} already exists in ${result.sourcePath}`,
+          "Re-run with --force to overwrite the existing entry.",
+          false,
+          { sourcePath: result.sourcePath, providerId: result.providerId }
+        );
+      }
+      return {
+        installed: true,
+        conflicted: result.conflicted,
+        provider: provider.id,
+        serverName,
+        scope,
+        sourcePath: result.sourcePath,
+        config
+      };
+    })
+  );
+}
+
+// src/commands/mcp/list.ts
+function registerMcpListCommand(parent) {
+  parent.command("list").description("List MCP servers configured for one or every MCP-capable provider").option("--provider <id>", "Restrict to a single provider id").option("--scope <scope>", "Scope: project|global (default: project)").option("--project-dir <path>", "Project directory for the project scope (default: cwd)").action(
+    async (opts) => runLafsCommand("mcp.list", "standard", async () => {
+      const scope = parseScope(opts.scope, "project");
+      const projectDir = resolveProjectDir(scope, opts.projectDir);
+      if (opts.provider !== void 0 && opts.provider.length > 0) {
+        const provider = requireMcpProvider(opts.provider);
+        const entries = await listMcpServers(provider, scope, projectDir);
+        return {
+          scope,
+          provider: {
+            id: provider.id,
+            toolName: provider.toolName
+          },
+          count: entries.length,
+          entries
+        };
+      }
+      const map = await listAllMcpServers(scope, projectDir);
+      const flat = [];
+      const byProvider = {};
+      for (const [providerId, entries] of map.entries()) {
+        byProvider[providerId] = entries.length;
+        flat.push(...entries);
+      }
+      return {
+        scope,
+        providers: byProvider,
+        count: flat.length,
+        entries: flat
+      };
+    })
+  );
+}
+
+// src/commands/mcp/remove.ts
+function registerMcpRemoveCommand(parent) {
+  parent.command("remove <serverName>").description("Remove an MCP server entry from a provider config file").option("--provider <id>", "Provider id to remove from").option("--all-providers", "Remove from every MCP-capable provider in the registry").option("--scope <scope>", "Scope: project|global (default: project)").option("--project-dir <path>", "Project directory for the project scope (default: cwd)").action(
+    async (serverName, opts) => runLafsCommand("mcp.remove", "standard", async () => {
+      if (serverName.length === 0) {
+        throw new LAFSCommandError(
+          MCP_ERROR_CODES.VALIDATION,
+          "Server name is required",
+          "Pass a non-empty server name as the positional argument.",
+          false
+        );
+      }
+      const usingAll = opts.allProviders === true;
+      const usingProvider = opts.provider !== void 0 && opts.provider.length > 0;
+      if (usingAll === usingProvider) {
+        throw new LAFSCommandError(
+          MCP_ERROR_CODES.VALIDATION,
+          "Pass exactly one of --provider <id> or --all-providers",
+          "Use --provider for a single target, or --all-providers to remove everywhere.",
+          false
+        );
+      }
+      const scope = parseScope(opts.scope, "project");
+      const projectDir = resolveProjectDir(scope, opts.projectDir);
+      if (usingAll) {
+        const results = await removeMcpServerFromAll(serverName, { scope, projectDir });
+        const removedCount = results.filter((r) => r.removed).length;
+        return {
+          mode: "all-providers",
+          serverName,
+          scope,
+          removedCount,
+          providersProbed: results.length,
+          results
+        };
+      }
+      const provider = requireMcpProvider(opts.provider);
+      const result = await removeMcpServer(provider, serverName, { scope, projectDir });
+      return {
+        mode: "single-provider",
+        serverName,
+        scope,
+        provider: provider.id,
+        removed: result.removed,
+        reason: result.reason,
+        sourcePath: result.sourcePath
+      };
+    })
+  );
+}
+
+// src/commands/mcp/index.ts
+function registerMcpCommands(program2) {
+  const mcp = program2.command("mcp").description("MCP server config management across providers");
+  registerMcpDetectCommand(mcp);
+  registerMcpListCommand(mcp);
+  registerMcpInstallCommand(mcp);
+  registerMcpRemoveCommand(mcp);
+}
+
+// src/commands/pi/cant.ts
+import { existsSync as existsSync4 } from "fs";
+import { writeFile } from "fs/promises";
+import { tmpdir as tmpdir3 } from "os";
+import { join as join5 } from "path";
+
+// src/core/sources/github.ts
+import { mkdtemp, rm } from "fs/promises";
+import { tmpdir } from "os";
+import { join as join3 } from "path";
+import { simpleGit } from "simple-git";
+async function cloneRepo(owner, repo, ref, subPath) {
+  const tmpDir = await mkdtemp(join3(tmpdir(), "caamp-"));
+  const repoUrl = `https://github.com/${owner}/${repo}.git`;
+  const git = simpleGit();
+  const cloneOptions = ["--depth", "1"];
+  if (ref) {
+    cloneOptions.push("--branch", ref);
+  }
+  await git.clone(repoUrl, tmpDir, cloneOptions);
+  const localPath = subPath ? join3(tmpDir, subPath) : tmpDir;
+  return {
+    localPath,
+    cleanup: async () => {
+      try {
+        await rm(tmpDir, { recursive: true });
+      } catch {
+      }
+    }
+  };
+}
+
+// src/core/sources/gitlab.ts
+import { mkdtemp as mkdtemp2, rm as rm2 } from "fs/promises";
+import { tmpdir as tmpdir2 } from "os";
+import { join as join4 } from "path";
+import { simpleGit as simpleGit2 } from "simple-git";
+async function cloneGitLabRepo(owner, repo, ref, subPath) {
+  const tmpDir = await mkdtemp2(join4(tmpdir2(), "caamp-gl-"));
+  const repoUrl = `https://gitlab.com/${owner}/${repo}.git`;
+  const git = simpleGit2();
+  const cloneOptions = ["--depth", "1"];
+  if (ref) {
+    cloneOptions.push("--branch", ref);
+  }
+  await git.clone(repoUrl, tmpDir, cloneOptions);
+  const localPath = subPath ? join4(tmpDir, subPath) : tmpDir;
+  return {
+    localPath,
+    cleanup: async () => {
+      try {
+        await rm2(tmpDir, { recursive: true });
+      } catch {
+      }
+    }
+  };
+}
+
+// src/commands/pi/common.ts
+var PI_ERROR_CODES = {
+  /** Caller-supplied input failed validation (shape, type, enum). */
+  VALIDATION: "E_VALIDATION_SCHEMA",
+  /** Referenced resource does not exist on disk or in the registry. */
+  NOT_FOUND: "E_NOT_FOUND_RESOURCE",
+  /** Write target already exists and overwrite was not requested. */
+  CONFLICT: "E_CONFLICT_VERSION",
+  /** Network/upstream call failed; retry is viable. */
+  TRANSIENT: "E_TRANSIENT_UPSTREAM"
+};
+function requirePiHarness() {
+  const provider = getProvider("pi");
+  if (provider === void 0) {
+    throw new LAFSCommandError(
+      PI_ERROR_CODES.NOT_FOUND,
+      "Pi provider is not registered in the CAAMP registry.",
+      "This is a configuration bug \u2014 open an issue with `caamp providers list`.",
+      false
+    );
+  }
+  const installed = getInstalledProviders();
+  const piInstalled = installed.some((p) => p.id === "pi");
+  if (!piInstalled) {
+    throw new LAFSCommandError(
+      PI_ERROR_CODES.NOT_FOUND,
+      "Pi is not installed. Run: caamp providers install pi",
+      "Install Pi via its official installer, then retry this command.",
+      true
+    );
+  }
+  const harness = getHarnessFor(provider);
+  if (!(harness instanceof PiHarness)) {
+    throw new LAFSCommandError(
+      "E_INTERNAL_UNEXPECTED",
+      "Pi provider is registered but no PiHarness implementation was returned.",
+      "This is a programming error \u2014 the harness dispatcher should always return a PiHarness for Pi.",
+      false
+    );
+  }
+  return harness;
+}
+function parseScope2(raw, defaultTier) {
+  if (raw === void 0) return defaultTier;
+  if (raw === "project" || raw === "user" || raw === "global") return raw;
+  throw new LAFSCommandError(
+    PI_ERROR_CODES.VALIDATION,
+    `Invalid --scope value: ${raw}`,
+    "Use one of: 'project', 'user', 'global'.",
+    false
+  );
+}
+function resolveProjectDir2(tier, explicit) {
+  if (tier !== "project") return void 0;
+  if (explicit !== void 0 && explicit.length > 0) return explicit;
+  return process.cwd();
+}
+
+// src/commands/pi/cant.ts
+async function resolveCantSource(source) {
+  if (source.startsWith("/") || source.startsWith("./") || source.startsWith("../") || source.startsWith("~")) {
+    const expanded = source.startsWith("~/") ? join5(process.env["HOME"] ?? "", source.slice(2)) : source;
+    if (!existsSync4(expanded)) {
+      throw new LAFSCommandError(
+        PI_ERROR_CODES.NOT_FOUND,
+        `Source file does not exist: ${expanded}`,
+        "Check the path and try again.",
+        false
+      );
+    }
+    return {
+      localPath: expanded,
+      cleanup: async () => {
+      },
+      inferredName: inferNameFromPath(expanded)
+    };
+  }
+  if (/^https?:\/\//.test(source)) {
+    const parsed2 = parseSource(source);
+    if (parsed2.type === "github" && parsed2.owner !== void 0 && parsed2.repo !== void 0) {
+      const cloneResult = await cloneRepo(parsed2.owner, parsed2.repo, parsed2.ref);
+      const filePath = parsed2.path !== void 0 ? join5(cloneResult.localPath, parsed2.path) : cloneResult.localPath;
+      if (!existsSync4(filePath)) {
+        await cloneResult.cleanup();
+        throw new LAFSCommandError(
+          PI_ERROR_CODES.NOT_FOUND,
+          `Source path not found inside cloned repo: ${parsed2.path ?? "(root)"}`,
+          "Check the repository URL and path.",
+          false
+        );
+      }
+      return {
+        localPath: filePath,
+        cleanup: cloneResult.cleanup,
+        inferredName: inferNameFromPath(filePath)
+      };
+    }
+    if (parsed2.type === "gitlab" && parsed2.owner !== void 0 && parsed2.repo !== void 0) {
+      const cloneResult = await cloneGitLabRepo(parsed2.owner, parsed2.repo, parsed2.ref);
+      const filePath = parsed2.path !== void 0 ? join5(cloneResult.localPath, parsed2.path) : cloneResult.localPath;
+      if (!existsSync4(filePath)) {
+        await cloneResult.cleanup();
+        throw new LAFSCommandError(
+          PI_ERROR_CODES.NOT_FOUND,
+          `Source path not found inside cloned repo: ${parsed2.path ?? "(root)"}`,
+          "Check the repository URL and path.",
+          false
+        );
+      }
+      return {
+        localPath: filePath,
+        cleanup: cloneResult.cleanup,
+        inferredName: inferNameFromPath(filePath)
+      };
+    }
+    const resp = await fetchWithTimeout(source);
+    if (!resp.ok) {
+      throw new LAFSCommandError(
+        PI_ERROR_CODES.TRANSIENT,
+        `Failed to download source from ${source}: HTTP ${resp.status}`,
+        "Check the URL and network connectivity.",
+        true
+      );
+    }
+    const body = await resp.text();
+    const baseName = inferNameFromUrl(source);
+    const tmp = join5(tmpdir3(), `caamp-pi-cant-${process.pid}-${Date.now()}-${baseName}.cant`);
+    await writeFile(tmp, body, "utf8");
+    return {
+      localPath: tmp,
+      cleanup: async () => {
+        try {
+          await (await import("fs/promises")).rm(tmp, { force: true });
+        } catch {
+        }
+      },
+      inferredName: baseName
+    };
+  }
+  const parsed = parseSource(source);
+  if (parsed.type === "github" && parsed.owner !== void 0 && parsed.repo !== void 0) {
+    const cloneResult = await cloneRepo(parsed.owner, parsed.repo, parsed.ref);
+    const filePath = parsed.path !== void 0 ? join5(cloneResult.localPath, parsed.path) : cloneResult.localPath;
+    if (!existsSync4(filePath)) {
+      await cloneResult.cleanup();
+      throw new LAFSCommandError(
+        PI_ERROR_CODES.NOT_FOUND,
+        `Source path not found inside cloned repo: ${parsed.path ?? "(root)"}`,
+        "Check the repository shorthand and path.",
+        false
+      );
+    }
+    return {
+      localPath: filePath,
+      cleanup: cloneResult.cleanup,
+      inferredName: inferNameFromPath(filePath)
+    };
+  }
+  throw new LAFSCommandError(
+    PI_ERROR_CODES.VALIDATION,
+    `Unsupported source: ${source}`,
+    "Use a local file path, HTTPS URL, or GitHub shorthand (owner/repo/path.cant).",
+    false
+  );
+}
+function inferNameFromPath(filePath) {
+  const base = filePath.split(/[/\\]/).pop() ?? filePath;
+  return base.replace(/\.cant$/, "");
+}
+function inferNameFromUrl(url) {
+  try {
+    const u = new URL(url);
+    const seg = u.pathname.split("/").filter(Boolean).pop() ?? "profile";
+    return seg.replace(/\.cant$/, "");
+  } catch {
+    return "profile";
+  }
+}
+async function invokeInstallCantProfile(harness, sourcePath, name, tier, projectDir, installOpts) {
+  try {
+    return await harness.installCantProfile(sourcePath, name, tier, projectDir, installOpts);
+  } catch (err) {
+    rethrowAsLafs(err);
+  }
+}
+function rethrowAsLafs(err) {
+  const message = err instanceof Error ? err.message : String(err);
+  if (/already exists/i.test(message)) {
+    throw new LAFSCommandError(
+      PI_ERROR_CODES.CONFLICT,
+      message,
+      "Pass --force to overwrite the existing profile.",
+      false
+    );
+  }
+  if (/does not exist|not found/i.test(message)) {
+    throw new LAFSCommandError(PI_ERROR_CODES.NOT_FOUND, message, "Check the path.", false);
+  }
+  if (/failed cant-core validation|expected a CANT source file|not a regular file/i.test(message)) {
+    throw new LAFSCommandError(
+      PI_ERROR_CODES.VALIDATION,
+      message,
+      "Run `caamp pi cant validate <path>` to inspect the diagnostics.",
+      false
+    );
+  }
+  throw new LAFSCommandError(
+    "E_INTERNAL_UNEXPECTED",
+    message,
+    "Inspect the message for the underlying cant-core failure mode.",
+    false
+  );
+}
+function registerPiCantCommands(parent) {
+  const cant = parent.command("cant").description("Manage Pi CANT profiles across tiers");
+  cant.command("list").description("List Pi CANT profiles across project, user, and global tiers").option("--scope <tier>", "Filter to a single tier: project|user|global").option("--project-dir <path>", "Project directory for the project tier (default: cwd)").action(
+    async (opts) => runLafsCommand("pi.cant.list", "standard", async () => {
+      const harness = requirePiHarness();
+      const projectDir = opts.projectDir ?? process.cwd();
+      const allEntries = await harness.listCantProfiles(projectDir);
+      const filterTier = opts.scope === void 0 ? null : parseScope2(opts.scope, "project");
+      const entries = filterTier === null ? allEntries : allEntries.filter((e) => e.tier === filterTier);
+      const sorted = [...entries].sort((a, b) => a.name.localeCompare(b.name));
+      return {
+        count: sorted.length,
+        entries: sorted
+      };
+    })
+  );
+  cant.command("install <source>").description("Install a Pi CANT profile from a local path, HTTPS URL, or GitHub shorthand").option("--scope <tier>", "Install tier: project|user|global (default: project)").option("--name <name>", "Override the inferred profile name").option("--force", "Overwrite an existing profile at the target tier").option("--project-dir <path>", "Project directory for the project tier (default: cwd)").action(
+    async (source, opts) => runLafsCommand("pi.cant.install", "standard", async () => {
+      const harness = requirePiHarness();
+      const tier = parseScope2(opts.scope, "project");
+      const projectDir = resolveProjectDir2(tier, opts.projectDir);
+      const resolved = await resolveCantSource(source);
+      try {
+        const name = opts.name ?? resolved.inferredName;
+        const installOpts = { force: opts.force ?? false };
+        const result = await invokeInstallCantProfile(
+          harness,
+          resolved.localPath,
+          name,
+          tier,
+          projectDir,
+          installOpts
+        );
+        return {
+          installed: {
+            name,
+            tier: result.tier,
+            targetPath: result.targetPath,
+            counts: result.counts,
+            source
+          }
+        };
+      } finally {
+        await resolved.cleanup();
+      }
+    })
+  );
+  cant.command("remove <name>").description("Remove a Pi CANT profile from the given tier").option("--scope <tier>", "Target tier: project|user|global (default: project)").option("--project-dir <path>", "Project directory for the project tier (default: cwd)").action(
+    async (name, opts) => runLafsCommand("pi.cant.remove", "standard", async () => {
+      const harness = requirePiHarness();
+      const tier = parseScope2(opts.scope, "project");
+      const projectDir = resolveProjectDir2(tier, opts.projectDir);
+      const removed = await harness.removeCantProfile(name, tier, projectDir);
+      return {
+        name,
+        tier,
+        removed
+      };
+    })
+  );
+  cant.command("validate <path>").description("Validate a .cant file via cant-core without installing it").action(
+    async (path) => runLafsCommand("pi.cant.validate", "standard", async () => {
+      const harness = requirePiHarness();
+      if (!existsSync4(path)) {
+        throw new LAFSCommandError(
+          PI_ERROR_CODES.NOT_FOUND,
+          `Source file does not exist: ${path}`,
+          "Check the path and try again.",
+          false
+        );
+      }
+      const result = await harness.validateCantProfile(path);
+      if (!result.valid) {
+        throw new LAFSCommandError(
+          PI_ERROR_CODES.VALIDATION,
+          `cant-core validation failed with ${result.errors.length} diagnostic(s)`,
+          "See the `errors` field for ruleId/line/col/message details.",
+          false,
+          { valid: false, counts: result.counts, errors: result.errors }
+        );
+      }
+      return {
+        valid: true,
+        counts: result.counts,
+        errors: result.errors
+      };
+    })
+  );
+}
+
+// src/commands/pi/extensions.ts
+import { existsSync as existsSync5 } from "fs";
+import { writeFile as writeFile2 } from "fs/promises";
+import { tmpdir as tmpdir4 } from "os";
+import { join as join6 } from "path";
+async function resolveExtensionSource(source) {
+  if (source.startsWith("/") || source.startsWith("./") || source.startsWith("../") || source.startsWith("~")) {
+    const expanded = source.startsWith("~/") ? join6(process.env["HOME"] ?? "", source.slice(2)) : source;
+    if (!existsSync5(expanded)) {
+      throw new LAFSCommandError(
+        PI_ERROR_CODES.NOT_FOUND,
+        `Source file does not exist: ${expanded}`,
+        "Check the path and try again.",
+        false
+      );
+    }
+    const inferredName = inferNameFromPath2(expanded);
+    return {
+      localPath: expanded,
+      cleanup: async () => {
+      },
+      inferredName
+    };
+  }
+  if (/^https?:\/\//.test(source)) {
+    const parsed2 = parseSource(source);
+    if (parsed2.type === "github" && parsed2.owner !== void 0 && parsed2.repo !== void 0) {
+      const cloneResult = await cloneRepo(parsed2.owner, parsed2.repo, parsed2.ref);
+      const filePath = parsed2.path !== void 0 ? join6(cloneResult.localPath, parsed2.path) : cloneResult.localPath;
+      if (!existsSync5(filePath)) {
+        await cloneResult.cleanup();
+        throw new LAFSCommandError(
+          PI_ERROR_CODES.NOT_FOUND,
+          `Source path not found inside cloned repo: ${parsed2.path ?? "(root)"}`,
+          "Check the repository URL and path.",
+          false
+        );
+      }
+      return {
+        localPath: filePath,
+        cleanup: cloneResult.cleanup,
+        inferredName: inferNameFromPath2(filePath)
+      };
+    }
+    if (parsed2.type === "gitlab" && parsed2.owner !== void 0 && parsed2.repo !== void 0) {
+      const cloneResult = await cloneGitLabRepo(parsed2.owner, parsed2.repo, parsed2.ref);
+      const filePath = parsed2.path !== void 0 ? join6(cloneResult.localPath, parsed2.path) : cloneResult.localPath;
+      if (!existsSync5(filePath)) {
+        await cloneResult.cleanup();
+        throw new LAFSCommandError(
+          PI_ERROR_CODES.NOT_FOUND,
+          `Source path not found inside cloned repo: ${parsed2.path ?? "(root)"}`,
+          "Check the repository URL and path.",
+          false
+        );
+      }
+      return {
+        localPath: filePath,
+        cleanup: cloneResult.cleanup,
+        inferredName: inferNameFromPath2(filePath)
+      };
+    }
+    const resp = await fetchWithTimeout(source);
+    if (!resp.ok) {
+      throw new LAFSCommandError(
+        PI_ERROR_CODES.TRANSIENT,
+        `Failed to download source from ${source}: HTTP ${resp.status}`,
+        "Check the URL and network connectivity.",
+        true
+      );
+    }
+    const body = await resp.text();
+    const baseName = inferNameFromUrl2(source);
+    const tmp = join6(tmpdir4(), `caamp-pi-ext-${process.pid}-${Date.now()}-${baseName}.ts`);
+    await writeFile2(tmp, body, "utf8");
+    return {
+      localPath: tmp,
+      cleanup: async () => {
+        try {
+          await (await import("fs/promises")).rm(tmp, { force: true });
+        } catch {
+        }
+      },
+      inferredName: baseName
+    };
+  }
+  const parsed = parseSource(source);
+  if (parsed.type === "github" && parsed.owner !== void 0 && parsed.repo !== void 0) {
+    const cloneResult = await cloneRepo(parsed.owner, parsed.repo, parsed.ref);
+    const filePath = parsed.path !== void 0 ? join6(cloneResult.localPath, parsed.path) : cloneResult.localPath;
+    if (!existsSync5(filePath)) {
+      await cloneResult.cleanup();
+      throw new LAFSCommandError(
+        PI_ERROR_CODES.NOT_FOUND,
+        `Source path not found inside cloned repo: ${parsed.path ?? "(root)"}`,
+        "Check the repository shorthand and path.",
+        false
+      );
+    }
+    return {
+      localPath: filePath,
+      cleanup: cloneResult.cleanup,
+      inferredName: inferNameFromPath2(filePath)
+    };
+  }
+  throw new LAFSCommandError(
+    PI_ERROR_CODES.VALIDATION,
+    `Unsupported source: ${source}`,
+    "Use a local file path, HTTPS URL, or GitHub shorthand (owner/repo/path.ts).",
+    false
+  );
+}
+function inferNameFromPath2(filePath) {
+  const base = filePath.split(/[/\\]/).pop() ?? filePath;
+  return base.replace(/\.(ts|tsx|mts)$/, "");
+}
+function inferNameFromUrl2(url) {
+  try {
+    const u = new URL(url);
+    const seg = u.pathname.split("/").filter(Boolean).pop() ?? "extension";
+    return seg.replace(/\.(ts|tsx|mts)$/, "");
+  } catch {
+    return "extension";
+  }
+}
+function registerPiExtensionsCommands(parent) {
+  const ext = parent.command("extensions").description("Manage Pi extensions across tiers");
+  ext.command("list").description("List Pi extensions across project, user, and global tiers").option("--project-dir <path>", "Project directory for the project tier (default: cwd)").action(
+    async (opts) => runLafsCommand("pi.extensions.list", "standard", async () => {
+      const harness = requirePiHarness();
+      const projectDir = opts.projectDir ?? process.cwd();
+      const entries = await harness.listExtensions(projectDir);
+      return {
+        count: entries.length,
+        extensions: entries
+      };
+    })
+  );
+  ext.command("install <source>").description("Install a Pi extension from a local path, HTTPS URL, or GitHub shorthand").option("--scope <tier>", "Install tier: project|user|global (default: project)").option("--name <name>", "Override the inferred extension name").option("--force", "Overwrite an existing extension at the target tier").option("--project-dir <path>", "Project directory for the project tier (default: cwd)").action(
+    async (source, opts) => runLafsCommand("pi.extensions.install", "standard", async () => {
+      const harness = requirePiHarness();
+      const tier = parseScope2(opts.scope, "project");
+      const projectDir = resolveProjectDir2(tier, opts.projectDir);
+      const resolved = await resolveExtensionSource(source);
+      try {
+        const name = opts.name ?? resolved.inferredName;
+        const installOpts = { force: opts.force ?? false };
+        const result = await harness.installExtension(
+          resolved.localPath,
+          name,
+          tier,
+          projectDir,
+          installOpts
+        );
+        return {
+          installed: {
+            name,
+            tier: result.tier,
+            targetPath: result.targetPath,
+            source
+          }
+        };
+      } finally {
+        await resolved.cleanup();
+      }
+    })
+  );
+  ext.command("remove <name>").description("Remove a Pi extension from the given tier").option("--scope <tier>", "Target tier: project|user|global (default: project)").option("--project-dir <path>", "Project directory for the project tier (default: cwd)").action(
+    async (name, opts) => runLafsCommand("pi.extensions.remove", "standard", async () => {
+      const harness = requirePiHarness();
+      const tier = parseScope2(opts.scope, "project");
+      const projectDir = resolveProjectDir2(tier, opts.projectDir);
+      const removed = await harness.removeExtension(name, tier, projectDir);
+      return {
+        name,
+        tier,
+        removed
+      };
+    })
+  );
+}
+
+// src/commands/pi/models.ts
+function parseModelSpec(spec) {
+  const idx = spec.indexOf(":");
+  if (idx <= 0 || idx === spec.length - 1) {
+    throw new LAFSCommandError(
+      PI_ERROR_CODES.VALIDATION,
+      `Invalid model specifier: ${spec}`,
+      "Use 'provider:model-id', e.g. 'anthropic:claude-sonnet-4-20250514'.",
+      false
+    );
+  }
+  return { provider: spec.slice(0, idx), id: spec.slice(idx + 1) };
+}
+function resolveModelsScope(opts) {
+  if (opts.global === true) return { kind: "global" };
+  if (opts.projectDir !== void 0 && opts.projectDir.length > 0) {
+    return { kind: "project", projectDir: opts.projectDir };
+  }
+  return { kind: "global" };
+}
+function parsePositiveInt(raw, name) {
+  if (raw === void 0) return void 0;
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0 || String(parsed) !== raw.trim()) {
+    throw new LAFSCommandError(
+      PI_ERROR_CODES.VALIDATION,
+      `Invalid value for --${name}: ${raw}`,
+      `--${name} must be a positive integer.`,
+      false
+    );
+  }
+  return parsed;
+}
+function registerPiModelsCommands(parent) {
+  const models = parent.command("models").description("Manage Pi's dual-file models configuration");
+  models.command("list").description("List every model known to Pi (union of models.json and enabledModels)").option("--global", "Read from the Pi global state root (default)").option("--project-dir <path>", "Read from a project-scoped Pi config").action(
+    async (opts) => runLafsCommand("pi.models.list", "standard", async () => {
+      const harness = requirePiHarness();
+      const scope = resolveModelsScope(opts);
+      const entries = await harness.listModels(scope);
+      const active = entries.filter((e) => e.enabled);
+      const def = entries.find((e) => e.isDefault) ?? null;
+      return {
+        scope: scope.kind,
+        count: entries.length,
+        activeCount: active.length,
+        default: def,
+        models: entries
+      };
+    })
+  );
+  models.command("add <spec>").description("Add a custom model definition to models.json (e.g. provider:model-id)").option("--global", "Write to the Pi global state root (default)").option("--project-dir <path>", "Write to a project-scoped Pi config").option("--display-name <name>", "Human-readable model name").option("--base-url <url>", "Override the provider base URL").option("--reasoning", "Mark the model as reasoning-capable").option("--context-window <tokens>", "Context window size in tokens").option("--max-tokens <tokens>", "Maximum output tokens").action(
+    async (spec, opts) => runLafsCommand("pi.models.add", "standard", async () => {
+      const harness = requirePiHarness();
+      const scope = resolveModelsScope(opts);
+      const { provider, id } = parseModelSpec(spec);
+      const contextWindow = parsePositiveInt(opts.contextWindow, "context-window");
+      const maxTokens = parsePositiveInt(opts.maxTokens, "max-tokens");
+      const config = await harness.readModelsConfig(scope);
+      const providerBlock = config.providers[provider] ?? {};
+      if (opts.baseUrl !== void 0) providerBlock.baseUrl = opts.baseUrl;
+      const nextModels = providerBlock.models ? [...providerBlock.models] : [];
+      const existingIdx = nextModels.findIndex((m) => m.id === id);
+      const definition = {
+        id,
+        name: opts.displayName ?? id
+      };
+      if (opts.reasoning === true) definition.reasoning = true;
+      if (contextWindow !== void 0) definition.contextWindow = contextWindow;
+      if (maxTokens !== void 0) definition.maxTokens = maxTokens;
+      if (existingIdx >= 0) {
+        nextModels[existingIdx] = definition;
+      } else {
+        nextModels.push(definition);
+      }
+      providerBlock.models = nextModels;
+      const nextConfig = {
+        providers: { ...config.providers, [provider]: providerBlock }
+      };
+      await harness.writeModelsConfig(nextConfig, scope);
+      return {
+        added: { provider, id, name: definition.name },
+        replaced: existingIdx >= 0,
+        scope: scope.kind
+      };
+    })
+  );
+  models.command("remove <spec>").description("Remove a custom model definition from models.json").option("--global", "Write to the Pi global state root (default)").option("--project-dir <path>", "Write to a project-scoped Pi config").action(
+    async (spec, opts) => runLafsCommand("pi.models.remove", "standard", async () => {
+      const harness = requirePiHarness();
+      const scope = resolveModelsScope(opts);
+      const { provider, id } = parseModelSpec(spec);
+      const config = await harness.readModelsConfig(scope);
+      const providerBlock = config.providers[provider];
+      if (providerBlock === void 0 || providerBlock.models === void 0) {
+        return { removed: false, provider, id, reason: "provider-not-found" };
+      }
+      const before = providerBlock.models.length;
+      const filtered = providerBlock.models.filter((m) => m.id !== id);
+      if (filtered.length === before) {
+        return { removed: false, provider, id, reason: "model-not-found" };
+      }
+      const nextProviderBlock = { ...providerBlock, models: filtered };
+      if (filtered.length === 0) {
+        delete nextProviderBlock.models;
+      }
+      const nextConfig = {
+        providers: { ...config.providers, [provider]: nextProviderBlock }
+      };
+      await harness.writeModelsConfig(nextConfig, scope);
+      return { removed: true, provider, id, scope: scope.kind };
+    })
+  );
+  models.command("enable <spec>").description("Enable a model by appending it to settings.json:enabledModels").option("--global", "Write to the Pi global state root (default)").option("--project-dir <path>", "Write to a project-scoped Pi config").action(
+    async (spec, opts) => runLafsCommand("pi.models.enable", "standard", async () => {
+      const harness = requirePiHarness();
+      const scope = resolveModelsScope(opts);
+      const { provider, id } = parseModelSpec(spec);
+      if (!id.includes("*")) {
+        const config = await harness.readModelsConfig(scope);
+        const providerBlock = config.providers[provider];
+        const defined = providerBlock?.models?.some((m) => m.id === id) ?? false;
+        if (!defined) {
+        }
+      }
+      const current = await harness.readSettings(scope);
+      const currentObj = typeof current === "object" && current !== null && !Array.isArray(current) ? current : {};
+      const enabledRaw = currentObj["enabledModels"];
+      const enabled = Array.isArray(enabledRaw) ? enabledRaw.filter((v) => typeof v === "string") : [];
+      const already = enabled.includes(spec);
+      if (already) {
+        return { enabled: false, reason: "already-enabled", spec, scope: scope.kind };
+      }
+      enabled.push(spec);
+      await harness.writeSettings({ enabledModels: enabled }, scope);
+      return { enabled: true, spec, provider, id, scope: scope.kind };
+    })
+  );
+  models.command("disable <spec>").description("Disable a model by removing it from settings.json:enabledModels").option("--global", "Write to the Pi global state root (default)").option("--project-dir <path>", "Write to a project-scoped Pi config").action(
+    async (spec, opts) => runLafsCommand("pi.models.disable", "standard", async () => {
+      const harness = requirePiHarness();
+      const scope = resolveModelsScope(opts);
+      const current = await harness.readSettings(scope);
+      const currentObj = typeof current === "object" && current !== null && !Array.isArray(current) ? current : {};
+      const enabledRaw = currentObj["enabledModels"];
+      const enabled = Array.isArray(enabledRaw) ? enabledRaw.filter((v) => typeof v === "string") : [];
+      const filtered = enabled.filter((e) => e !== spec);
+      if (filtered.length === enabled.length) {
+        return { disabled: false, reason: "not-enabled", spec, scope: scope.kind };
+      }
+      await harness.writeSettings({ enabledModels: filtered }, scope);
+      return { disabled: true, spec, scope: scope.kind };
+    })
+  );
+  models.command("default <spec>").description("Set settings.json:defaultProvider and defaultModel").option("--global", "Write to the Pi global state root (default)").option("--project-dir <path>", "Write to a project-scoped Pi config").action(
+    async (spec, opts) => runLafsCommand("pi.models.default", "standard", async () => {
+      const harness = requirePiHarness();
+      const scope = resolveModelsScope(opts);
+      const { provider, id } = parseModelSpec(spec);
+      const config = await harness.readModelsConfig(scope);
+      const providerBlock = config.providers[provider];
+      const defined = providerBlock?.models?.some((m) => m.id === id) ?? false;
+      await harness.writeSettings({ defaultProvider: provider, defaultModel: id }, scope);
+      return {
+        set: true,
+        provider,
+        id,
+        knownInModelsJson: defined,
+        scope: scope.kind
+      };
+    })
+  );
+}
+
+// src/commands/pi/prompts.ts
+import { existsSync as existsSync6 } from "fs";
+import { join as join7, resolve } from "path";
+function inferPromptName(sourceDir) {
+  const normalized = resolve(sourceDir).replace(/[\\/]+$/, "");
+  const base = normalized.split(/[\\/]/).pop();
+  if (base === void 0 || base.length === 0) {
+    throw new LAFSCommandError(
+      PI_ERROR_CODES.VALIDATION,
+      `Could not infer a prompt name from source: ${sourceDir}`,
+      "Pass --name <name> to override the inferred name.",
+      false
+    );
+  }
+  return base;
+}
+function registerPiPromptsCommands(parent) {
+  const prompts = parent.command("prompts").description("Manage Pi prompts across tiers");
+  prompts.command("install <source>").description("Install a Pi prompt directory (contains prompt.md + optional metadata)").option("--scope <tier>", "Install tier: project|user|global (default: project)").option("--name <name>", "Override the inferred prompt name").option("--force", "Overwrite an existing prompt at the target tier").option("--project-dir <path>", "Project directory for the project tier (default: cwd)").action(
+    async (source, opts) => runLafsCommand("pi.prompts.install", "standard", async () => {
+      const harness = requirePiHarness();
+      const tier = parseScope2(opts.scope, "project");
+      const projectDir = resolveProjectDir2(tier, opts.projectDir);
+      const absSource = resolve(source);
+      if (!existsSync6(absSource)) {
+        throw new LAFSCommandError(
+          PI_ERROR_CODES.NOT_FOUND,
+          `Source directory does not exist: ${absSource}`,
+          "Check the path and try again.",
+          false
+        );
+      }
+      if (!existsSync6(join7(absSource, "prompt.md"))) {
+        throw new LAFSCommandError(
+          PI_ERROR_CODES.VALIDATION,
+          `Source directory is missing prompt.md: ${absSource}`,
+          "Add a prompt.md to the source directory and retry.",
+          false
+        );
+      }
+      const name = opts.name ?? inferPromptName(absSource);
+      const installOpts = { force: opts.force ?? false };
+      const result = await harness.installPrompt(absSource, name, tier, projectDir, installOpts);
+      return {
+        installed: {
+          name,
+          tier: result.tier,
+          targetPath: result.targetPath,
+          source: absSource
+        }
+      };
+    })
+  );
+  prompts.command("list").description("List Pi prompts across project, user, and global tiers").option("--project-dir <path>", "Project directory for the project tier (default: cwd)").action(
+    async (opts) => runLafsCommand("pi.prompts.list", "standard", async () => {
+      const harness = requirePiHarness();
+      const projectDir = opts.projectDir ?? process.cwd();
+      const entries = await harness.listPrompts(projectDir);
+      return {
+        count: entries.length,
+        prompts: entries
+      };
+    })
+  );
+  prompts.command("remove <name>").description("Remove a Pi prompt from the given tier").option("--scope <tier>", "Target tier: project|user|global (default: project)").option("--project-dir <path>", "Project directory for the project tier (default: cwd)").action(
+    async (name, opts) => runLafsCommand("pi.prompts.remove", "standard", async () => {
+      const harness = requirePiHarness();
+      const tier = parseScope2(opts.scope, "project");
+      const projectDir = resolveProjectDir2(tier, opts.projectDir);
+      const removed = await harness.removePrompt(name, tier, projectDir);
+      return { name, tier, removed };
+    })
+  );
+}
+
+// src/commands/pi/sessions.ts
+import { spawn } from "child_process";
+import { createReadStream, createWriteStream, existsSync as existsSync7 } from "fs";
+import { createInterface } from "readline/promises";
+async function streamSession(filePath, outputPath, transform) {
+  const writeToFile = outputPath !== void 0 && outputPath.length > 0;
+  const out = writeToFile ? createWriteStream(outputPath) : process.stdout;
+  const reader = createInterface({
+    input: createReadStream(filePath, { encoding: "utf8" }),
+    crlfDelay: Infinity
+  });
+  let emitted = 0;
+  try {
+    for await (const line of reader) {
+      const result = transform(line);
+      if (result === null) continue;
+      out.write(`${result}
+`);
+      emitted += 1;
+    }
+  } finally {
+    reader.close();
+    if (writeToFile && "end" in out) {
+      await new Promise((resolve3) => {
+        out.end(resolve3);
+      });
+    }
+  }
+  return emitted;
+}
+function sessionEntryToMarkdown(line) {
+  let parsed;
+  try {
+    parsed = JSON.parse(line);
+  } catch {
+    return null;
+  }
+  if (typeof parsed !== "object" || parsed === null) return null;
+  const obj = parsed;
+  const type = typeof obj["type"] === "string" ? obj["type"] : null;
+  if (type === "session") {
+    const id = typeof obj["id"] === "string" ? obj["id"] : "(no id)";
+    const ts = typeof obj["timestamp"] === "string" ? obj["timestamp"] : "";
+    return `# Session ${id}${ts.length > 0 ? ` \xB7 ${ts}` : ""}
+`;
+  }
+  if (type === "message") {
+    const role = typeof obj["role"] === "string" ? obj["role"] : "assistant";
+    const content = extractMessageContent(obj["content"]);
+    if (content === null) return null;
+    const label = role.charAt(0).toUpperCase() + role.slice(1);
+    return `## ${label}
+
+${content}
+`;
+  }
+  if (type === "custom_message") {
+    const label = typeof obj["label"] === "string" ? obj["label"] : "Custom";
+    const text = typeof obj["text"] === "string" ? obj["text"] : "";
+    return `### ${label}
+
+${text}
+`;
+  }
+  return null;
+}
+function extractMessageContent(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return null;
+  const parts = [];
+  for (const block of content) {
+    if (typeof block === "string") {
+      parts.push(block);
+      continue;
+    }
+    if (typeof block !== "object" || block === null) continue;
+    const b = block;
+    if (b["type"] === "text" && typeof b["text"] === "string") {
+      parts.push(b["text"]);
+    }
+  }
+  if (parts.length === 0) return null;
+  return parts.join("\n\n");
+}
+function registerPiSessionsCommands(parent) {
+  const sessions = parent.command("sessions").description("Inspect and resume Pi sessions");
+  sessions.command("list").description("List Pi sessions (reads only line 1 of each JSONL file)").option("--no-subagents", "Skip sessions under subagents/").action(
+    async (opts) => runLafsCommand("pi.sessions.list", "standard", async () => {
+      const harness = requirePiHarness();
+      const summaries = await harness.listSessions({
+        includeSubagents: opts.includeSubagents !== false
+      });
+      return {
+        count: summaries.length,
+        sessions: summaries
+      };
+    })
+  );
+  sessions.command("show <id>").description("Show the full body of a Pi session by id").action(
+    async (id) => runLafsCommand("pi.sessions.show", "full", async () => {
+      const harness = requirePiHarness();
+      const doc = await harness.showSession(id);
+      return {
+        summary: doc.summary,
+        entryCount: doc.entries.length,
+        entries: doc.entries
+      };
+    })
+  );
+  sessions.command("export <id>").description("Export a Pi session to JSONL or Markdown").option("--jsonl", "Emit the raw JSONL body (default)").option("--md", "Emit a Markdown transcription (messages only)").option("--output <path>", "Write to this file instead of stdout").action(
+    async (id, opts) => runLafsCommand("pi.sessions.export", "standard", async () => {
+      if (opts.jsonl === true && opts.md === true) {
+        throw new LAFSCommandError(
+          PI_ERROR_CODES.VALIDATION,
+          "Cannot pass both --jsonl and --md",
+          "Pick one of --jsonl or --md.",
+          false
+        );
+      }
+      const harness = requirePiHarness();
+      const summaries = await harness.listSessions({ includeSubagents: true });
+      const match = summaries.find((s) => s.id === id);
+      if (match === void 0) {
+        throw new LAFSCommandError(
+          PI_ERROR_CODES.NOT_FOUND,
+          `No session found with id ${id}`,
+          "Run `caamp pi sessions list` to see known ids.",
+          false
+        );
+      }
+      const format = opts.md === true ? "md" : "jsonl";
+      const emitted = format === "md" ? await streamSession(match.filePath, opts.output, sessionEntryToMarkdown) : await streamSession(
+        match.filePath,
+        opts.output,
+        (line) => line.length === 0 ? null : line
+      );
+      return {
+        id,
+        format,
+        filePath: match.filePath,
+        output: opts.output ?? "stdout",
+        entriesEmitted: emitted
+      };
+    })
+  );
+  sessions.command("resume <id>").description("Resume a Pi session by shelling out to `pi --session <id>`").action(
+    async (id) => runLafsCommand("pi.sessions.resume", "standard", async () => {
+      const harness = requirePiHarness();
+      const summaries = await harness.listSessions({ includeSubagents: true });
+      const match = summaries.find((s) => s.id === id);
+      if (match === void 0) {
+        throw new LAFSCommandError(
+          PI_ERROR_CODES.NOT_FOUND,
+          `No session found with id ${id}`,
+          "Run `caamp pi sessions list` to see known ids.",
+          false
+        );
+      }
+      const piBinary = harness.provider.detection.binary ?? "pi";
+      if (!existsSync7(piBinary) && piBinary === "pi") {
+      }
+      const child = spawn(piBinary, ["--session", id], {
+        stdio: "inherit",
+        detached: false
+      });
+      const exitCode = await new Promise((resolve3) => {
+        child.on("exit", (code) => resolve3(code ?? 0));
+      });
+      if (exitCode !== 0) {
+        throw new LAFSCommandError(
+          PI_ERROR_CODES.TRANSIENT,
+          `pi --session ${id} exited with code ${exitCode}`,
+          "Check the Pi binary output for details.",
+          true
+        );
+      }
+      return {
+        id,
+        filePath: match.filePath,
+        exitCode
+      };
+    })
+  );
+}
+
+// src/commands/pi/themes.ts
+import { existsSync as existsSync8, statSync } from "fs";
+import { extname, resolve as resolve2 } from "path";
+function inferThemeName(sourceFile) {
+  const base = resolve2(sourceFile).split(/[\\/]/).pop();
+  if (base === void 0 || base.length === 0) {
+    throw new LAFSCommandError(
+      PI_ERROR_CODES.VALIDATION,
+      `Could not infer a theme name from source: ${sourceFile}`,
+      "Pass --name <name> to override the inferred name.",
+      false
+    );
+  }
+  const ext = extname(base);
+  if (ext === "") return base;
+  return base.slice(0, -ext.length);
+}
+function registerPiThemesCommands(parent) {
+  const themes = parent.command("themes").description("Manage Pi themes across tiers");
+  themes.command("install <source>").description("Install a Pi theme file (.ts/.tsx/.mts/.json)").option("--scope <tier>", "Install tier: project|user|global (default: project)").option("--name <name>", "Override the inferred theme name").option("--force", "Overwrite an existing theme at the target tier").option("--project-dir <path>", "Project directory for the project tier (default: cwd)").action(
+    async (source, opts) => runLafsCommand("pi.themes.install", "standard", async () => {
+      const harness = requirePiHarness();
+      const tier = parseScope2(opts.scope, "project");
+      const projectDir = resolveProjectDir2(tier, opts.projectDir);
+      const absSource = resolve2(source);
+      if (!existsSync8(absSource)) {
+        throw new LAFSCommandError(
+          PI_ERROR_CODES.NOT_FOUND,
+          `Source theme does not exist: ${absSource}`,
+          "Check the path and try again.",
+          false
+        );
+      }
+      const stats = statSync(absSource);
+      if (!stats.isFile()) {
+        throw new LAFSCommandError(
+          PI_ERROR_CODES.VALIDATION,
+          `Source theme is not a regular file: ${absSource}`,
+          "Themes must be a single .ts/.tsx/.mts/.json file.",
+          false
+        );
+      }
+      const name = opts.name ?? inferThemeName(absSource);
+      const installOpts = { force: opts.force ?? false };
+      const result = await harness.installTheme(absSource, name, tier, projectDir, installOpts);
+      return {
+        installed: {
+          name,
+          tier: result.tier,
+          targetPath: result.targetPath,
+          source: absSource
+        }
+      };
+    })
+  );
+  themes.command("list").description("List Pi themes across project, user, and global tiers").option("--project-dir <path>", "Project directory for the project tier (default: cwd)").action(
+    async (opts) => runLafsCommand("pi.themes.list", "standard", async () => {
+      const harness = requirePiHarness();
+      const projectDir = opts.projectDir ?? process.cwd();
+      const entries = await harness.listThemes(projectDir);
+      return {
+        count: entries.length,
+        themes: entries
+      };
+    })
+  );
+  themes.command("remove <name>").description("Remove a Pi theme from the given tier").option("--scope <tier>", "Target tier: project|user|global (default: project)").option("--project-dir <path>", "Project directory for the project tier (default: cwd)").action(
+    async (name, opts) => runLafsCommand("pi.themes.remove", "standard", async () => {
+      const harness = requirePiHarness();
+      const tier = parseScope2(opts.scope, "project");
+      const projectDir = resolveProjectDir2(tier, opts.projectDir);
+      const removed = await harness.removeTheme(name, tier, projectDir);
+      return { name, tier, removed };
+    })
+  );
+}
+
+// src/commands/pi/index.ts
+function registerPiCommands(program2) {
+  const pi = program2.command("pi").description("Pi harness operations (extensions, sessions, models, prompts, themes, cant)");
+  registerPiExtensionsCommands(pi);
+  registerPiSessionsCommands(pi);
+  registerPiModelsCommands(pi);
+  registerPiPromptsCommands(pi);
+  registerPiThemesCommands(pi);
+  registerPiCantCommands(pi);
+}
+
 // src/commands/providers.ts
 import { randomUUID as randomUUID3 } from "crypto";
 import { resolveOutputFormat as resolveOutputFormat2 } from "@cleocode/lafs";
@@ -2083,9 +3484,9 @@ CAMP Hook Support (mappings v${getHookMappingsVersion()})
     console.log(`  ${"\u2500".repeat(22)} ${"\u2500".repeat(20)} ${"\u2500".repeat(8)} ${"\u2500".repeat(20)}`);
     for (const row of matrix) {
       const hooks2 = row.hooksCount > 0 ? String(row.hooksCount) : "-";
-      const spawn = row.spawnMechanism ?? "-";
+      const spawn2 = row.spawnMechanism ?? "-";
       console.log(
-        `  ${row.toolName.padEnd(22)} ${row.skillsPrecedence.padEnd(20)} ${hooks2.padEnd(8)} ${spawn}`
+        `  ${row.toolName.padEnd(22)} ${row.skillsPrecedence.padEnd(20)} ${hooks2.padEnd(8)} ${spawn2}`
       );
     }
     console.log(pc6.dim(`
@@ -2126,13 +3527,13 @@ function emitJsonError2(operation, mvi, code, message, category, details = {}) {
 }
 
 // src/commands/skills/audit.ts
-import { existsSync as existsSync3, statSync } from "fs";
+import { existsSync as existsSync9, statSync as statSync2 } from "fs";
 import pc7 from "picocolors";
 function registerSkillsAudit(parent) {
   parent.command("audit").description("Security scan skill files (46+ rules, SARIF output)").argument("[path]", "Path to SKILL.md or directory", ".").option("--sarif", "Output in SARIF format (raw SARIF, not LAFS envelope)").option("--json", "Output as JSON (LAFS envelope)").option("--human", "Output in human-readable format").action(async (path, opts) => {
     const operation = "skills.audit";
     const mvi = "standard";
-    if (!existsSync3(path)) {
+    if (!existsSync9(path)) {
       const message = `Path not found: ${path}`;
       if (opts.sarif) {
         console.error(
@@ -2194,7 +3595,7 @@ function registerSkillsAudit(parent) {
       );
       process.exit(1);
     }
-    const stat = statSync(path);
+    const stat = statSync2(path);
     let results;
     try {
       if (stat.isFile()) {
@@ -2704,9 +4105,9 @@ function emitJsonError3(operation, mvi, code, message, category, details = {}) {
 }
 
 // src/commands/skills/init.ts
-import { existsSync as existsSync4 } from "fs";
-import { mkdir, writeFile } from "fs/promises";
-import { join as join3 } from "path";
+import { existsSync as existsSync10 } from "fs";
+import { mkdir, writeFile as writeFile3 } from "fs/promises";
+import { join as join8 } from "path";
 import pc10 from "picocolors";
 function registerSkillsInit(parent) {
   parent.command("init").description("Create a new SKILL.md template").argument("[name]", "Skill name").option("-d, --dir <path>", "Output directory", ".").option("--json", "Output as JSON (default)").option("--human", "Output in human-readable format").action(
@@ -2732,8 +4133,8 @@ function registerSkillsInit(parent) {
         process.exit(1);
       }
       const skillName = name ?? "my-skill";
-      const skillDir = join3(opts.dir, skillName);
-      if (existsSync4(skillDir)) {
+      const skillDir = join8(opts.dir, skillName);
+      if (existsSync10(skillDir)) {
         const message = `Directory already exists: ${skillDir}`;
         if (format === "json") {
           emitJsonError(
@@ -2775,7 +4176,7 @@ Provide detailed instructions for the AI agent here.
 
 Show example inputs and expected outputs.
 `;
-      await writeFile(join3(skillDir, "SKILL.md"), template, "utf-8");
+      await writeFile3(join8(skillDir, "SKILL.md"), template, "utf-8");
       const result = {
         name: skillName,
         directory: skillDir,
@@ -2789,69 +4190,15 @@ Show example inputs and expected outputs.
       console.log(pc10.green(`\u2713 Created skill template: ${skillDir}/SKILL.md`));
       console.log(pc10.dim("\nNext steps:"));
       console.log(pc10.dim("  1. Edit SKILL.md with your instructions"));
-      console.log(pc10.dim(`  2. Validate: caamp skills validate ${join3(skillDir, "SKILL.md")}`));
+      console.log(pc10.dim(`  2. Validate: caamp skills validate ${join8(skillDir, "SKILL.md")}`));
       console.log(pc10.dim(`  3. Install: caamp skills install ${skillDir}`));
     }
   );
 }
 
 // src/commands/skills/install.ts
-import { existsSync as existsSync5 } from "fs";
+import { existsSync as existsSync11 } from "fs";
 import pc11 from "picocolors";
-
-// src/core/sources/github.ts
-import { mkdtemp, rm } from "fs/promises";
-import { tmpdir } from "os";
-import { join as join4 } from "path";
-import { simpleGit } from "simple-git";
-async function cloneRepo(owner, repo, ref, subPath) {
-  const tmpDir = await mkdtemp(join4(tmpdir(), "caamp-"));
-  const repoUrl = `https://github.com/${owner}/${repo}.git`;
-  const git = simpleGit();
-  const cloneOptions = ["--depth", "1"];
-  if (ref) {
-    cloneOptions.push("--branch", ref);
-  }
-  await git.clone(repoUrl, tmpDir, cloneOptions);
-  const localPath = subPath ? join4(tmpDir, subPath) : tmpDir;
-  return {
-    localPath,
-    cleanup: async () => {
-      try {
-        await rm(tmpDir, { recursive: true });
-      } catch {
-      }
-    }
-  };
-}
-
-// src/core/sources/gitlab.ts
-import { mkdtemp as mkdtemp2, rm as rm2 } from "fs/promises";
-import { tmpdir as tmpdir2 } from "os";
-import { join as join5 } from "path";
-import { simpleGit as simpleGit2 } from "simple-git";
-async function cloneGitLabRepo(owner, repo, ref, subPath) {
-  const tmpDir = await mkdtemp2(join5(tmpdir2(), "caamp-gl-"));
-  const repoUrl = `https://gitlab.com/${owner}/${repo}.git`;
-  const git = simpleGit2();
-  const cloneOptions = ["--depth", "1"];
-  if (ref) {
-    cloneOptions.push("--branch", ref);
-  }
-  await git.clone(repoUrl, tmpDir, cloneOptions);
-  const localPath = subPath ? join5(tmpDir, subPath) : tmpDir;
-  return {
-    localPath,
-    cleanup: async () => {
-      try {
-        await rm2(tmpDir, { recursive: true });
-      } catch {
-      }
-    }
-  };
-}
-
-// src/commands/skills/install.ts
 function registerSkillsInstall(parent) {
   parent.command("install").description("Install a skill from GitHub, URL, marketplace, or registered skill library").argument("[source]", "Skill source (GitHub URL, owner/repo, @author/name, skill-name)").option(
     "-a, --agent <name>",
@@ -3335,7 +4682,7 @@ async function handleMarketplaceSource(source, _providers, _isGlobal, format, op
     for (const subPath of subPathCandidates) {
       try {
         const result = await cloneRepo(parsed.owner, parsed.repo, parsed.ref, subPath);
-        if (subPath && !existsSync5(result.localPath)) {
+        if (subPath && !existsSync11(result.localPath)) {
           await result.cleanup();
           continue;
         }
@@ -3650,8 +4997,8 @@ ${outdated.length} skill(s) have updates available:
     if (!opts.yes && format === "human") {
       const readline = await import("readline");
       const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-      const answer = await new Promise((resolve) => {
-        rl.question(pc14.dim("\nProceed with update? [y/N] "), resolve);
+      const answer = await new Promise((resolve3) => {
+        rl.question(pc14.dim("\nProceed with update? [y/N] "), resolve3);
       });
       rl.close();
       if (answer.toLowerCase() !== "y" && answer.toLowerCase() !== "yes") {
@@ -3884,6 +5231,8 @@ registerInstructionsCommands(program);
 registerConfigCommand(program);
 registerDoctorCommand(program);
 registerAdvancedCommands(program);
+registerMcpCommands(program);
+registerPiCommands(program);
 function toError(error) {
   if (error instanceof Error) return error;
   return new Error(String(error));