@jaybeeuu/agent-cortex 2.1.0 → 2.2.0

package/test/claude-installer.test.mjs

@@ -1,308 +0,0 @@
-// Tests for `agent-cortex install claude` runtime registration: after
-// materialising the plugin into the home install root, the plain install
-// registers the plugin with Claude Code by driving the `claude plugin` CLI.
-// Registration is
-// idempotent by STATE, not by exit code: `marketplace list --json` decides
-// add-vs-update and `plugin list --json` decides install-vs-update against the
-// materialised version. The real CLI is a genuine external system (and its
-// home config must never be touched), so these tests drive the stateful fake
-// from test/helpers/fake-claude.mjs; fixture manifests (makeMarketplaceRoot)
-// stand in for the home install root's generated marketplace manifest.
-
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-import { execFile } from "node:child_process";
-import { mkdtemp, mkdir, writeFile, rm, readFile, stat } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { fileURLToPath } from "node:url";
-import { dirname, join } from "node:path";
-import { registerClaude } from "../bin/installers/claude.mjs";
-import { makeFakeClaude, registrationActions } from "./helpers/fake-claude.mjs";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const ROOT = join(__dirname, "..");
-const CLI_PATH = join(ROOT, "bin", "agent-cortex.mjs");
-
-function runCli(args, env = {}) {
-  return new Promise((resolve) => {
-    execFile(
-      process.execPath,
-      [CLI_PATH, ...args],
-      { env: { ...process.env, ...env } },
-      (error, stdout, stderr) => {
-        resolve({ exitCode: error ? error.code ?? 1 : 0, stdout, stderr });
-      },
-    );
-  });
-}
-
-/** True when a path exists (stat succeeds). */
-async function pathExists(p) {
-  try {
-    await stat(p);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function makeTmp() {
-  return mkdtemp(join(tmpdir(), "agent-cortex-claude-installer-"));
-}
-
-async function callLines(log) {
-  return (await readFile(log, "utf-8")).trim().split("\n").filter(Boolean);
-}
-
-/** Registration actions logged at/after line `since` (0 = whole log). */
-async function actionsSince(log, since = 0) {
-  return registrationActions((await callLines(log)).slice(since));
-}
-
-/** A minimal marketplace tree (as seen at the real install root): the
- * marketplace manifest exposing ./claude plus the materialised plugin.json the
- * fake reads for the installed version. */
-async function makeMarketplaceRoot({ name = "jaybeeuu", plugin = "agent-cortex", version = "1.0.0" } = {}) {
-  const root = await mkdtemp(join(tmpdir(), "agent-cortex-marketplace-"));
-  await mkdir(join(root, ".claude-plugin"), { recursive: true });
-  await writeFile(
-    join(root, ".claude-plugin", "marketplace.json"),
-    JSON.stringify({
-      name,
-      owner: { name: "tester" },
-      plugins: [{ name: plugin, source: "./claude", description: "test plugin" }],
-    }),
-  );
-  await mkdir(join(root, "claude", ".claude-plugin"), { recursive: true });
-  await writeFile(
-    join(root, "claude", ".claude-plugin", "plugin.json"),
-    JSON.stringify({ name: plugin, version, description: "test plugin" }),
-  );
-  return root;
-}
-
-// ─── registerClaude ──────────────────────────────────────────────────────────
-
-describe("registerClaude", () => {
-  it("drives marketplace add → install on a fresh registration, skipping the market update/plugin update no-ops", async () => {
-    const tmp = await makeTmp();
-    const root = await makeMarketplaceRoot();
-    const fake = await makeFakeClaude(tmp);
-    try {
-      const result = await registerClaude({ root, claudeBin: fake.bin });
-      assert.equal(result.marketplace, "jaybeeuu");
-      assert.equal(result.plugin, "agent-cortex");
-      assert.equal(result.dryRun, false);
-      assert.equal(result.registered, true);
-      assert.deepEqual(result.commands, [
-        ["plugin", "marketplace", "add", root],
-        ["plugin", "install", "agent-cortex@jaybeeuu", "-y"],
-      ]);
-      // The availability probe (`plugin --help`) and the state queries
-      // (`marketplace list --json`, `plugin list --json`) are not actions.
-      assert.deepEqual(await actionsSince(fake.log), [
-        `plugin marketplace add ${root}`,
-        "plugin install agent-cortex@jaybeeuu -y",
-      ]);
-    } finally {
-      await rm(tmp, { recursive: true, force: true });
-      await rm(root, { recursive: true, force: true });
-    }
-  });
-
-  it("derives marketplace and plugin names from the manifest", async () => {
-    const tmp = await makeTmp();
-    const root = await makeMarketplaceRoot({ name: "scratchmkt", plugin: "scratchplug" });
-    const fake = await makeFakeClaude(tmp);
-    try {
-      const result = await registerClaude({ root, claudeBin: fake.bin });
-      assert.equal(result.marketplace, "scratchmkt");
-      assert.equal(result.plugin, "scratchplug");
-      const actions = await actionsSince(fake.log);
-      assert.ok(actions.some((c) => c === "plugin install scratchplug@scratchmkt -y"));
-      // Fresh registration has no update commands.
-      assert.ok(!actions.some((c) => c.startsWith("plugin update")));
-    } finally {
-      await rm(tmp, { recursive: true, force: true });
-      await rm(root, { recursive: true, force: true });
-    }
-  });
-
-  it("re-running at the same materialised version is the update path: marketplace update only, no re-add or double-install", async () => {
-    const tmp = await makeTmp();
-    const root = await makeMarketplaceRoot();
-    const fake = await makeFakeClaude(tmp);
-    try {
-      await registerClaude({ root, claudeBin: fake.bin });
-      assert.deepEqual(await actionsSince(fake.log), [
-        `plugin marketplace add ${root}`,
-        "plugin install agent-cortex@jaybeeuu -y",
-      ]);
-      const run1End = (await callLines(fake.log)).length;
-
-      const second = await registerClaude({ root, claudeBin: fake.bin });
-      assert.equal(second.registered, true);
-      // Second run: the marketplace is present so only the update path runs;
-      // the plugin is already at the materialised version so nothing installs.
-      assert.deepEqual(await actionsSince(fake.log, run1End), ["plugin marketplace update jaybeeuu"]);
-      assert.ok(second.skipped.some((s) => s.includes("already installed")));
-
-      // Across both runs the marketplace was added exactly once and the
-      // plugin installed exactly once.
-      const all = await actionsSince(fake.log);
-      assert.equal(all.filter((c) => c.startsWith("plugin marketplace add")).length, 1);
-      assert.equal(all.filter((c) => c === "plugin install agent-cortex@jaybeeuu -y").length, 1);
-    } finally {
-      await rm(tmp, { recursive: true, force: true });
-      await rm(root, { recursive: true, force: true });
-    }
-  });
-
-  it("runs plugin update when a newer version is materialised, refreshing the installed version", async () => {
-    const tmp = await makeTmp();
-    const root = await makeMarketplaceRoot({ version: "1.0.0" });
-    const fake = await makeFakeClaude(tmp);
-    try {
-      await registerClaude({ root, claudeBin: fake.bin });
-      assert.deepEqual(await actionsSince(fake.log), [
-        `plugin marketplace add ${root}`,
-        "plugin install agent-cortex@jaybeeuu -y",
-      ]);
-      const run1End = (await callLines(fake.log)).length;
-
-      // A new version is materialised into the source the marketplace exposes.
-      await writeFile(
-        join(root, "claude", ".claude-plugin", "plugin.json"),
-        JSON.stringify({ name: "agent-cortex", version: "2.0.0", description: "test plugin" }),
-      );
-
-      const updated = await registerClaude({ root, claudeBin: fake.bin });
-      assert.deepEqual(await actionsSince(fake.log, run1End), [
-        "plugin marketplace update jaybeeuu",
-        "plugin update agent-cortex -y",
-      ]);
-      assert.ok(updated.skipped.some((s) => s.includes("already installed")));
-      const state = JSON.parse(await readFile(fake.state, "utf-8"));
-      assert.equal(state.installed[0].version, "2.0.0", "plugin update refreshed the installed version");
-
-      // At the new version another run is back to update-path-only.
-      const run2End = (await callLines(fake.log)).length;
-      await registerClaude({ root, claudeBin: fake.bin });
-      assert.deepEqual(await actionsSince(fake.log, run2End), ["plugin marketplace update jaybeeuu"]);
-    } finally {
-      await rm(tmp, { recursive: true, force: true });
-      await rm(root, { recursive: true, force: true });
-    }
-  });
-
-  it("--dry-run plans the commands without spawning claude at all", async () => {
-    const tmp = await makeTmp();
-    const root = await makeMarketplaceRoot();
-    const fake = await makeFakeClaude(tmp);
-    try {
-      const result = await registerClaude({ root, claudeBin: fake.bin, dryRun: true });
-      assert.equal(result.dryRun, true);
-      assert.equal(result.registered, true);
-      // Dry-run cannot know live state without spawning — no commands decided.
-      assert.deepEqual(result.commands, []);
-      // No registration spawns happened at all in dry-run mode.
-      assert.equal(await pathExists(fake.log), false);
-    } finally {
-      await rm(tmp, { recursive: true, force: true });
-      await rm(root, { recursive: true, force: true });
-    }
-  });
-
-  it("defaults the claude binary to `claude` from PATH (dry-run only — no spawn)", async () => {
-    const root = await makeMarketplaceRoot();
-    try {
-      const result = await registerClaude({ root, dryRun: true });
-      assert.equal(result.marketplace, "jaybeeuu");
-      assert.equal(result.plugin, "agent-cortex");
-      assert.equal(result.dryRun, true);
-    } finally {
-      await rm(root, { recursive: true, force: true });
-    }
-  });
-
-  it("warns with manual commands when the claude binary lacks the plugin subcommand; --require-register fails the run", async () => {
-    const tmp = await makeTmp();
-    const root = await makeMarketplaceRoot();
-    const fake = await makeFakeClaude(tmp, { failWhen: "plugin --help" });
-    try {
-      const warnings = [];
-      const result = await registerClaude({ root, claudeBin: fake.bin, warn: (m) => warnings.push(m) });
-      assert.equal(result.registered, false);
-      const manual = warnings.join("\n");
-      assert.match(manual, /NOT registered/);
-      assert.match(manual, new RegExp(`claude plugin marketplace add ${root.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`));
-      assert.match(manual, /claude plugin install agent-cortex@jaybeeuu -y/);
-
-      await assert.rejects(
-        registerClaude({ root, claudeBin: fake.bin, requireRegister: true }),
-        /require-register/,
-      );
-    } finally {
-      await rm(tmp, { recursive: true, force: true });
-      await rm(root, { recursive: true, force: true });
-    }
-  });
-
-  it("fails, naming the failing command, when a claude plugin command errors", async () => {
-    const tmp = await makeTmp();
-    const root = await makeMarketplaceRoot();
-    const fake = await makeFakeClaude(tmp, { failWhen: "plugin install" });
-    try {
-      await assert.rejects(
-        registerClaude({ root, claudeBin: fake.bin }),
-        /claude plugin install agent-cortex@jaybeeuu -y/,
-      );
-    } finally {
-      await rm(tmp, { recursive: true, force: true });
-      await rm(root, { recursive: true, force: true });
-    }
-  });
-
-  it("fails when the checkout has no marketplace manifest", async () => {
-    const tmp = await makeTmp();
-    const root = await mkdtemp(join(tmpdir(), "agent-cortex-no-market-"));
-    const fake = await makeFakeClaude(tmp);
-    try {
-      await assert.rejects(
-        registerClaude({ root, claudeBin: fake.bin }),
-        /marketplace\.json/,
-      );
-      // The failed manifest read happens before any claude invocation.
-      assert.equal(await pathExists(fake.log), false);
-    } finally {
-      await rm(tmp, { recursive: true, force: true });
-      await rm(root, { recursive: true, force: true });
-    }
-  });
-});
-
-// ─── CLI wiring ───────────────────────────────────────────────────────────────
-
-describe("install claude CLI: registration", () => {
-  it("--dry-run without --output prints the registration plan and writes nothing", async () => {
-    const { exitCode, stdout } = await runCli(["install", "claude", "--dry-run"]);
-    assert.equal(exitCode, 0);
-    assert.ok(stdout.includes("would run: claude plugin marketplace add"));
-    assert.ok(stdout.includes("claude plugin install agent-cortex@jaybeeuu"));
-    assert.ok(stdout.includes("plugin marketplace update"));
-    assert.ok(stdout.includes("plugin update agent-cortex"));
-    assert.ok(/dry-run/i.test(stdout));
-  });
-
-  it("--output <dir> generates only — no registration plan is printed", async () => {
-    const out = await mkdtemp(join(tmpdir(), "agent-cortex-cli-out-"));
-    try {
-      const { exitCode, stdout } = await runCli(["install", "claude", "--output", out]);
-      assert.equal(exitCode, 0);
-      assert.doesNotMatch(stdout, /claude plugin/);
-      assert.ok(stdout.includes("Generated"));
-    } finally {
-      await rm(out, { recursive: true, force: true });
-    }
-  });
-});

package/test/cli.test.mjs

@@ -1,314 +0,0 @@
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-import { execFile } from "node:child_process";
-import { mkdtemp, readFile, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { fileURLToPath } from "node:url";
-import { dirname, join } from "node:path";
-import { parseArgs, buildHelpText, validateHarness } from "../lib/cli.mjs";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const CLI_PATH = join(__dirname, "..", "bin", "agent-cortex.mjs");
-
-/** True when a path exists (stat succeeds). */
-async function pathExists(p) {
-  try {
-    await stat(p);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-/** Run the CLI; optionally pass a custom env (e.g. a fake HOME). */
-function runCli(args, env = {}) {
-  return new Promise((resolve) => {
-    execFile(
-      process.execPath,
-      [CLI_PATH, ...args],
-      { env: { ...process.env, ...env } },
-      (error, stdout, stderr) => {
-        resolve({
-          exitCode: error ? error.code ?? 1 : 0,
-          stdout: stdout,
-          stderr: stderr,
-        });
-      },
-    );
-  });
-}
-
-describe("parseArgs", () => {
-  it("returns { command: 'help' } when no arguments given", async () => {
-    const result = parseArgs([]);
-    assert.deepStrictEqual(result, { command: "help" });
-  });
-
-  it("returns { command: 'help' } for --help flag", async () => {
-    const result = parseArgs(["--help"]);
-    assert.deepStrictEqual(result, { command: "help" });
-  });
-
-  it("returns { command: 'help' } for -h flag", async () => {
-    const result = parseArgs(["-h"]);
-    assert.deepStrictEqual(result, { command: "help" });
-  });
-
-  it("returns { command: 'install', harness: 'claude' } for install claude", async () => {
-    const result = parseArgs(["install", "claude"]);
-    assert.deepStrictEqual(result, { command: "install", harness: "claude" });
-  });
-
-  it("returns { command: 'install', harness: 'pi' } for install pi", async () => {
-    const result = parseArgs(["install", "pi"]);
-    assert.deepStrictEqual(result, { command: "install", harness: "pi" });
-  });
-
-  it("returns { command: 'install', harness: null } when install has no harness", async () => {
-    const result = parseArgs(["install"]);
-    assert.deepStrictEqual(result, { command: "install", harness: null });
-  });
-
-  it("returns output for install claude --output <dir>", async () => {
-    const result = parseArgs(["install", "claude", "--output", "/tmp/x"]);
-    assert.deepStrictEqual(result, { command: "install", harness: "claude", output: "/tmp/x" });
-  });
-
-  it("returns output for install claude --output=<dir>", async () => {
-    const result = parseArgs(["install", "claude", "--output=/tmp/x"]);
-    assert.deepStrictEqual(result, { command: "install", harness: "claude", output: "/tmp/x" });
-  });
-
-  it("returns dryRun for install claude --dry-run", async () => {
-    const result = parseArgs(["install", "claude", "--dry-run"]);
-    assert.deepStrictEqual(result, { command: "install", harness: "claude", dryRun: true });
-  });
-
-  it("combines --dry-run with --output", async () => {
-    const result = parseArgs(["install", "claude", "--output", "/tmp/x", "--dry-run"]);
-    assert.deepStrictEqual(result, { command: "install", harness: "claude", output: "/tmp/x", dryRun: true });
-  });
-
-  it("reports an unknown option for claude", async () => {
-    const result = parseArgs(["install", "claude", "--bogus"]);
-    assert.equal(result.command, "install");
-    assert.equal(result.harness, "claude");
-    assert.ok(result.optionError.includes("--bogus"));
-  });
-
-  it("reports a missing value for --output for claude", async () => {
-    const result = parseArgs(["install", "claude", "--output"]);
-    assert.equal(result.command, "install");
-    assert.equal(result.harness, "claude");
-    assert.ok(result.optionError.includes("--output"));
-  });
-
-  it("parses --dry-run for install", async () => {
-    const result = parseArgs(["install", "pi", "--dry-run"]);
-    assert.deepStrictEqual(result, { command: "install", harness: "pi", dryRun: true });
-  });
-
-  it("parses --output <dir> for install", async () => {
-    const result = parseArgs(["install", "pi", "--output", "/tmp/out"]);
-    assert.deepStrictEqual(result, { command: "install", harness: "pi", output: "/tmp/out" });
-  });
-
-  it("parses --plugin-root <dir> for install", async () => {
-    const result = parseArgs(["install", "pi", "--plugin-root", "/tmp/plugin"]);
-    assert.deepStrictEqual(result, { command: "install", harness: "pi", pluginRoot: "/tmp/plugin" });
-  });
-
-  it("combines multiple install options", async () => {
-    const result = parseArgs(["install", "pi", "--dry-run", "--output", "/tmp/out", "--plugin-root", "/tmp/plugin"]);
-    assert.deepStrictEqual(result, {
-      command: "install",
-      harness: "pi",
-      dryRun: true,
-      output: "/tmp/out",
-      pluginRoot: "/tmp/plugin",
-    });
-  });
-
-  it("reports a missing value for --output", async () => {
-    const result = parseArgs(["install", "pi", "--output"]);
-    assert.equal(result.command, "install");
-    assert.equal(result.harness, "pi");
-    assert.ok(result.optionError.includes("--output"));
-  });
-
-  it("reports an unknown option", async () => {
-    const result = parseArgs(["install", "pi", "--bogus"]);
-    assert.equal(result.command, "install");
-    assert.equal(result.harness, "pi");
-    assert.ok(result.optionError.includes("--bogus"));
-  });
-
-  it("keeps the old shape when no options are given", async () => {
-    assert.deepStrictEqual(parseArgs(["install", "pi"]), { command: "install", harness: "pi" });
-  });
-
-  it("returns { command: 'unknown', name: 'foo' } for unknown command", async () => {
-    const result = parseArgs(["foo"]);
-    assert.deepStrictEqual(result, { command: "unknown", name: "foo" });
-  });
-});
-
-describe("buildHelpText", () => {
-  it("returns a string containing usage info", async () => {
-    const text = buildHelpText();
-    assert.ok(typeof text === "string");
-    assert.ok(text.includes("agent-cortex"));
-    assert.ok(text.includes("install"));
-  });
-});
-
-describe("validateHarness", () => {
-  it("returns ok for supported harnesses", async () => {
-    for (const h of ["claude", "pi"]) {
-      assert.deepStrictEqual(validateHarness(h), { ok: true });
-    }
-  });
-
-  it("returns error for copilot, which is no longer a deploy target", async () => {
-    const result = validateHarness("copilot");
-    assert.equal(result.ok, false);
-    assert.ok(result.error.includes("Unknown harness"));
-  });
-
-  it("returns error when harness is null", async () => {
-    const result = validateHarness(null);
-    assert.equal(result.ok, false);
-    assert.ok(result.error.includes("Missing harness"));
-  });
-
-  it("returns error for unknown harness", async () => {
-    const result = validateHarness("docker");
-    assert.equal(result.ok, false);
-    assert.ok(result.error.includes("Unknown harness"));
-  });
-});
-
-describe("CLI integration", () => {
-  it("exits 0 and prints help when run with no arguments", async () => {
-    const { exitCode, stdout } = await runCli([]);
-    assert.equal(exitCode, 0);
-    assert.ok(stdout.includes("agent-cortex"));
-    assert.ok(stdout.includes("install"));
-  });
-
-  it("exits 0 and prints help for --help", async () => {
-    const { exitCode, stdout } = await runCli(["--help"]);
-    assert.equal(exitCode, 0);
-    assert.ok(stdout.includes("Usage:"));
-  });
-
-  it("exits 0 and prints help for -h", async () => {
-    const { exitCode, stdout } = await runCli(["-h"]);
-    assert.equal(exitCode, 0);
-    assert.ok(stdout.includes("Usage:"));
-  });
-
-  it("exits 1 for install copilot, which is no longer a deploy target", async () => {
-    const { exitCode, stderr } = await runCli(["install", "copilot"]);
-    assert.equal(exitCode, 1);
-    assert.ok(stderr.includes("Unknown harness"));
-  });
-
-  it("exits 0 for install claude (into a temp output dir)", async () => {
-    const dir = await mkdtemp(join(tmpdir(), "agent-cortex-cli-"));
-    const { exitCode, stdout } = await runCli(["install", "claude", "--output", dir]);
-    assert.equal(exitCode, 0);
-    assert.ok(stdout.includes("claude"));
-  });
-
-  it("exits 0 for install pi (into a temp output dir)", async () => {
-    const outDir = await mkdtemp(join(tmpdir(), "cli-pi-default-"));
-    try {
-      const { exitCode, stdout } = await runCli(["install", "pi", "--output", outDir]);
-      assert.equal(exitCode, 0);
-      assert.ok(stdout.includes("pi"));
-    } finally {
-      await rm(outDir, { recursive: true, force: true });
-    }
-  });
-
-  it("exits 1 and prints error for install with no harness", async () => {
-    const { exitCode, stderr } = await runCli(["install"]);
-    assert.equal(exitCode, 1);
-    assert.ok(stderr.includes("Missing harness"));
-  });
-
-  it("exits 1 and prints error for install with an unknown option", async () => {
-    const { exitCode, stderr } = await runCli(["install", "pi", "--bogus"]);
-    assert.equal(exitCode, 1);
-    assert.ok(stderr.includes("--bogus"));
-  });
-
-  it("exits 1 for the removed --no-provision flag", async () => {
-    const { exitCode, stderr } = await runCli(["install", "pi", "--no-provision"]);
-    assert.equal(exitCode, 1);
-    assert.ok(stderr.includes("--no-provision"), "the removed flag is named in the error");
-  });
-
-  it("exits 1 and prints error for install with a missing option value", async () => {
-    const { exitCode, stderr } = await runCli(["install", "pi", "--output"]);
-    assert.equal(exitCode, 1);
-    assert.ok(stderr.includes("--output"));
-  });
-
-  it("exits 0 for install pi --dry-run and writes nothing", async () => {
-    // A throwaway HOME keeps the registration plan (which reads pi's settings)
-    // off the developer's real ~/.pi/agent.
-    const fakeHome = await mkdtemp(join(tmpdir(), "cli-pi-dry-run-home-"));
-    try {
-      const { exitCode, stdout } = await runCli(["install", "pi", "--dry-run"], { HOME: fakeHome });
-      assert.equal(exitCode, 0);
-      assert.ok(stdout.includes("ralph.agent.md"));
-      assert.ok(stdout.includes("dry-run"));
-    } finally {
-      await rm(fakeHome, { recursive: true, force: true });
-    }
-  });
-
-  it("install pi --dry-run reports the bundled pi packages it would stage", async () => {
-    const fakeHome = await mkdtemp(join(tmpdir(), "cli-pi-home-"));
-    try {
-      const { exitCode, stdout } = await runCli(["install", "pi", "--dry-run"], { HOME: fakeHome });
-      assert.equal(exitCode, 0);
-      assert.ok(stdout.includes("Bundled pi package pi-questions"), "pi-questions staged");
-      assert.ok(stdout.includes("Bundled pi package pi-web-access"), "pi-web-access staged");
-      assert.ok(stdout.includes(join(fakeHome, ".agent-cortex", "pi")), "default output is the home staging dir");
-    } finally {
-      await rm(fakeHome, { recursive: true, force: true });
-    }
-  });
-
-  it("exits 0 for install pi --output <tmp> and stages a loadable pi package", async () => {
-    const outDir = await mkdtemp(join(tmpdir(), "cli-pi-install-"));
-    try {
-      const { exitCode, stdout } = await runCli(["install", "pi", "--output", outDir]);
-      assert.equal(exitCode, 0);
-      assert.ok(stdout.includes("ralph.agent.md"));
-      const ralph = await readFile(join(outDir, "agents", "ralph.agent.md"), "utf-8");
-      assert.ok(ralph.includes("agent-cortex:ralph"));
-      const manifest = JSON.parse(await readFile(join(outDir, "package.json"), "utf-8"));
-      assert.deepEqual(manifest.keywords, ["pi-package"]);
-      assert.ok(manifest.pi.extensions.includes("./extensions"));
-      assert.ok(manifest.pi.skills.includes("./skills"));
-    } finally {
-      await rm(outDir, { recursive: true, force: true });
-    }
-  });
-
-  it("exits 1 and prints error for install with unknown harness", async () => {
-    const { exitCode, stderr } = await runCli(["install", "docker"]);
-    assert.equal(exitCode, 1);
-    assert.ok(stderr.includes("Unknown harness"));
-  });
-
-  it("exits 1 and prints error for unknown command", async () => {
-    const { exitCode, stderr } = await runCli(["bogus"]);
-    assert.equal(exitCode, 1);
-    assert.ok(stderr.includes("Unknown command"));
-  });
-});