@jaybeeuu/agent-cortex 1.38.1 → 1.40.0

package/skills/workflow/run-pipeline-stage/scripts/node_modules/.bin/tsc

@@ -0,0 +1,21 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*)
+        if command -v cygpath > /dev/null 2>&1; then
+            basedir=`cygpath -w "$basedir"`
+        fi
+    ;;
+esac
+
+if [ -z "$NODE_PATH" ]; then
+  export NODE_PATH="/home/runner/work/agent-cortex/agent-cortex/node_modules/.pnpm/typescript@5.9.3/node_modules/typescript/node_modules:/home/runner/work/agent-cortex/agent-cortex/node_modules/.pnpm/typescript@5.9.3/node_modules:/home/runner/work/agent-cortex/agent-cortex/node_modules/.pnpm/node_modules"
+else
+  export NODE_PATH="/home/runner/work/agent-cortex/agent-cortex/node_modules/.pnpm/typescript@5.9.3/node_modules/typescript/node_modules:/home/runner/work/agent-cortex/agent-cortex/node_modules/.pnpm/typescript@5.9.3/node_modules:/home/runner/work/agent-cortex/agent-cortex/node_modules/.pnpm/node_modules:$NODE_PATH"
+fi
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../typescript/bin/tsc" "$@"
+else
+  exec node  "$basedir/../typescript/bin/tsc" "$@"
+fi

package/skills/workflow/run-pipeline-stage/scripts/node_modules/.bin/tsserver

@@ -0,0 +1,21 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*)
+        if command -v cygpath > /dev/null 2>&1; then
+            basedir=`cygpath -w "$basedir"`
+        fi
+    ;;
+esac
+
+if [ -z "$NODE_PATH" ]; then
+  export NODE_PATH="/home/runner/work/agent-cortex/agent-cortex/node_modules/.pnpm/typescript@5.9.3/node_modules/typescript/node_modules:/home/runner/work/agent-cortex/agent-cortex/node_modules/.pnpm/typescript@5.9.3/node_modules:/home/runner/work/agent-cortex/agent-cortex/node_modules/.pnpm/node_modules"
+else
+  export NODE_PATH="/home/runner/work/agent-cortex/agent-cortex/node_modules/.pnpm/typescript@5.9.3/node_modules/typescript/node_modules:/home/runner/work/agent-cortex/agent-cortex/node_modules/.pnpm/typescript@5.9.3/node_modules:/home/runner/work/agent-cortex/agent-cortex/node_modules/.pnpm/node_modules:$NODE_PATH"
+fi
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../typescript/bin/tsserver" "$@"
+else
+  exec node  "$basedir/../typescript/bin/tsserver" "$@"
+fi

package/skills/workflow/run-pipeline-stage/scripts/node_modules/.bin/tsx

@@ -0,0 +1,21 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*)
+        if command -v cygpath > /dev/null 2>&1; then
+            basedir=`cygpath -w "$basedir"`
+        fi
+    ;;
+esac
+
+if [ -z "$NODE_PATH" ]; then
+  export NODE_PATH="/home/runner/work/agent-cortex/agent-cortex/node_modules/.pnpm/tsx@4.22.4/node_modules/tsx/node_modules:/home/runner/work/agent-cortex/agent-cortex/node_modules/.pnpm/tsx@4.22.4/node_modules:/home/runner/work/agent-cortex/agent-cortex/node_modules/.pnpm/node_modules"
+else
+  export NODE_PATH="/home/runner/work/agent-cortex/agent-cortex/node_modules/.pnpm/tsx@4.22.4/node_modules/tsx/node_modules:/home/runner/work/agent-cortex/agent-cortex/node_modules/.pnpm/tsx@4.22.4/node_modules:/home/runner/work/agent-cortex/agent-cortex/node_modules/.pnpm/node_modules:$NODE_PATH"
+fi
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../tsx/dist/cli.mjs" "$@"
+else
+  exec node  "$basedir/../tsx/dist/cli.mjs" "$@"
+fi

package/test/claude-installer.test.mjs

@@ -0,0 +1,308 @@
+// 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,7 +1,7 @@
 import { describe, it } from "node:test";
 import assert from "node:assert/strict";
 import { execFile } from "node:child_process";
-import { mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { mkdtemp, readFile, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { fileURLToPath } from "node:url";
 import { dirname, join } from "node:path";
@@ -10,6 +10,16 @@ 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;
+  }
+}
+
 function runCli(args) {
   return new Promise((resolve) => {
     execFile(process.execPath, [CLI_PATH, ...args], (error, stdout, stderr) => {
@@ -23,91 +33,91 @@ function runCli(args) {
 }
 
 describe("parseArgs", () => {
-  it("returns { command: 'help' } when no arguments given", () => {
+  it("returns { command: 'help' } when no arguments given", async () => {
     const result = parseArgs([]);
     assert.deepStrictEqual(result, { command: "help" });
   });
 
-  it("returns { command: 'help' } for --help flag", () => {
+  it("returns { command: 'help' } for --help flag", async () => {
     const result = parseArgs(["--help"]);
     assert.deepStrictEqual(result, { command: "help" });
   });
 
-  it("returns { command: 'help' } for -h flag", () => {
+  it("returns { command: 'help' } for -h flag", async () => {
     const result = parseArgs(["-h"]);
     assert.deepStrictEqual(result, { command: "help" });
   });
 
-  it("returns { command: 'install', harness: 'copilot' } for install copilot", () => {
+  it("returns { command: 'install', harness: 'copilot' } for install copilot", async () => {
     const result = parseArgs(["install", "copilot"]);
     assert.deepStrictEqual(result, { command: "install", harness: "copilot" });
   });
 
-  it("returns { command: 'install', harness: 'claude' } for install claude", () => {
+  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", () => {
+  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", () => {
+  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>", () => {
+  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>", () => {
+  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", () => {
+  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", () => {
+  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", () => {
+  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", () => {
+  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", () => {
+  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", () => {
+  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", () => {
+  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", () => {
+  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",
@@ -118,32 +128,32 @@ describe("parseArgs", () => {
     });
   });
 
-  it("reports a missing value for --output", () => {
+  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", () => {
+  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", () => {
+  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", () => {
+  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", () => {
+  it("returns a string containing usage info", async () => {
     const text = buildHelpText();
     assert.ok(typeof text === "string");
     assert.ok(text.includes("agent-cortex"));
@@ -152,19 +162,19 @@ describe("buildHelpText", () => {
 });
 
 describe("validateHarness", () => {
-  it("returns ok for supported harnesses", () => {
+  it("returns ok for supported harnesses", async () => {
     for (const h of ["copilot", "claude", "pi"]) {
       assert.deepStrictEqual(validateHarness(h), { ok: true });
     }
   });
 
-  it("returns error when harness is null", () => {
+  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", () => {
+  it("returns error for unknown harness", async () => {
     const result = validateHarness("docker");
     assert.equal(result.ok, false);
     assert.ok(result.error.includes("Unknown harness"));
@@ -198,7 +208,7 @@ describe("CLI integration", () => {
   });
 
   it("exits 0 for install claude (into a temp output dir)", async () => {
-    const dir = mkdtempSync(join(tmpdir(), "agent-cortex-cli-"));
+    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"));
@@ -236,15 +246,15 @@ describe("CLI integration", () => {
   });
 
   it("exits 0 for install pi --output <tmp> and writes agent files", async () => {
-    const outDir = mkdtempSync(join(tmpdir(), "cli-pi-install-"));
+    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 = readFileSync(join(outDir, "agents", "ralph.agent.md"), "utf-8");
+      const ralph = await readFile(join(outDir, "agents", "ralph.agent.md"), "utf-8");
       assert.ok(ralph.includes("agent-cortex:ralph"));
     } finally {
-      rmSync(outDir, { recursive: true, force: true });
+      await rm(outDir, { recursive: true, force: true });
     }
   });