@jaybeeuu/agent-cortex 2.0.0 → 2.2.0

package/test/create-chores.test.mjs

@@ -1,85 +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 { makeFakeBd } from "./helpers/fake-bd.mjs";
-
-const testDir = dirname(fileURLToPath(import.meta.url));
-const CREATE_CHORES = join(testDir, "..", "skills", "planning", "create-task", "scripts", "create-chores.ts");
-
-/** Run create-chores.ts against the fake `bd` with a parent that already
- * carries implementation-type:afk — the label `bd create --parent` inherits.
- * @param {string[]} parentLabels  Labels seeded on the parent bead
- * @returns {Promise<{ ids: Record<string, string>, beads: Array<{ id: string, title: string, labels: string[] }> }>} */
-async function createChoresAgainstFakeBd(parentLabels) {
-  const dir = await mkdtemp(join(tmpdir(), "create-chores-"));
-  const { bin, state } = await makeFakeBd(dir, {
-    beads: [{ id: "parent-1", title: "Feature", labels: parentLabels }],
-  });
-
-  try {
-    const { exitCode, stdout, stderr } = await runScript(
-      ["--parent", "parent-1"],
-      { BD_PATH: bin, FAKE_BD_STATE: state },
-    );
-    assert.equal(exitCode, 0, stderr);
-
-    const ids = JSON.parse(stdout);
-    const { beads } = JSON.parse(await readFile(state, "utf8"));
-    return { ids, beads };
-  } finally {
-    await rm(dir, { recursive: true, force: true });
-  }
-}
-
-/** Run create-chores.ts with the given env overrides. */
-function runScript(args, env) {
-  return new Promise((resolve) => {
-    execFile(
-      process.execPath,
-      [CREATE_CHORES, ...args],
-      { env: { ...process.env, ...env } },
-      (error, stdout, stderr) => {
-        resolve({ exitCode: error ? error.code ?? 1 : 0, stdout, stderr });
-      },
-    );
-  });
-}
-
-describe("create-chores", () => {
-  it("gives the PR gate exactly its declared labels, without the parent's inherited implementation-type:afk", async () => {
-    const { ids, beads } = await createChoresAgainstFakeBd(["implementation-type:afk"]);
-
-    const gate = beads.find((b) => b.id === ids.featurePrReview);
-    assert.deepEqual(
-      [...gate.labels].sort(),
-      ["implementation-type:hitl", "lifecycle:feature-pr"],
-    );
-  });
-
-  it("still lets stage chores inherit implementation-type:afk from the parent", async () => {
-    const { ids, beads } = await createChoresAgainstFakeBd(["implementation-type:afk"]);
-
-    const codeChore = beads.find((b) => b.id === ids.code);
-    assert.deepEqual(
-      [...codeChore.labels].sort(),
-      ["implementation-type:afk", "stage:code"],
-    );
-  });
-
-  it("validates the PR gate task but not the stage chores", async () => {
-    const { ids, beads } = await createChoresAgainstFakeBd(["implementation-type:afk"]);
-
-    const gate = beads.find((b) => b.id === ids.featurePrReview);
-    assert.equal(gate.type, "task");
-    assert.equal(gate.validated, true);
-    assert.match(gate.description, /## Acceptance Criteria/);
-
-    const codeChore = beads.find((b) => b.id === ids.code);
-    assert.equal(codeChore.validated, false);
-  });
-});

package/test/fake-bd.test.mjs

@@ -1,72 +0,0 @@
-// Tests for the stateful fake `bd` helper's `--validate` model.
-// The fake mirrors `bd create --validate`: a substantive bead whose description lacks the
-// required section(s) for its type is rejected; chores have no requirements.
-
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-import { execFile } from "node:child_process";
-import { mkdtemp, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import { makeFakeBd } from "./helpers/fake-bd.mjs";
-
-/** Run the fake `bd` binary with the given args. */
-function runFake(bin, state, args) {
-  return new Promise((resolve) => {
-    execFile(bin, args, { env: { ...process.env, FAKE_BD_STATE: state } }, (error, stdout, stderr) => {
-      resolve({ exitCode: error ? error.code ?? 1 : 0, stdout, stderr });
-    });
-  });
-}
-
-/** Create a fresh fake workspace, run `fn`, then remove it. */
-async function withFake(fn) {
-  const dir = await mkdtemp(join(tmpdir(), "fake-bd-"));
-  try {
-    const { bin, state } = await makeFakeBd(dir, { beads: [] });
-    await fn(bin, state);
-  } finally {
-    await rm(dir, { recursive: true, force: true });
-  }
-}
-
-describe("fake bd --validate", () => {
-  it("rejects a section-less task", async () => {
-    await withFake(async (bin, state) => {
-      const { exitCode, stderr } = await runFake(bin, state, ["create", "empty", "--type", "task", "--validate"]);
-      assert.equal(exitCode, 1);
-      assert.match(stderr, /Acceptance Criteria/);
-    });
-  });
-
-  it("accepts a task carrying ## Acceptance Criteria (case-insensitive)", async () => {
-    await withFake(async (bin, state) => {
-      const { exitCode } = await runFake(bin, state, [
-        "create", "ok", "--type", "task",
-        "--description", "## Acceptance criteria\n- [ ] done",
-        "--validate",
-      ]);
-      assert.equal(exitCode, 0);
-    });
-  });
-
-  it("requires ## Success Criteria for an epic", async () => {
-    await withFake(async (bin, state) => {
-      const { exitCode, stderr } = await runFake(bin, state, [
-        "create", "ep", "--type", "epic",
-        "--description", "## Acceptance Criteria\n- [ ] x",
-        "--validate",
-      ]);
-      assert.equal(exitCode, 1);
-      assert.match(stderr, /Success Criteria/);
-    });
-  });
-
-  it("does not require sections for a chore", async () => {
-    await withFake(async (bin, state) => {
-      const { exitCode } = await runFake(bin, state, ["create", "c", "--type", "chore", "--validate"]);
-      assert.equal(exitCode, 0);
-    });
-  });
-});

package/test/fs.test.mjs

@@ -1,76 +0,0 @@
-// Unit tests for scripts/lib/fs.mjs — the shared async stat wrappers. The
-// helpers are exercised through their public API only; each case creates its
-// own throwaway fixture under os.tmpdir().
-
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtemp, writeFile, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { isDirectory, isFile } from "../scripts/lib/fs.mjs";
-
-async function makeTmp() {
-  return await mkdtemp(join(tmpdir(), "agent-cortex-fs-"));
-}
-
-describe("isFile", () => {
-  it("is true for an existing regular file", async () => {
-    const dir = await makeTmp();
-    try {
-      const file = join(dir, "file.txt");
-      await writeFile(file, "hello");
-      assert.equal(await isFile(file), true);
-    } finally {
-      await rm(dir, { recursive: true, force: true });
-    }
-  });
-
-  it("is false for a directory", async () => {
-    const dir = await makeTmp();
-    try {
-      assert.equal(await isFile(dir), false);
-    } finally {
-      await rm(dir, { recursive: true, force: true });
-    }
-  });
-
-  it("is false for a missing path", async () => {
-    const dir = await makeTmp();
-    try {
-      assert.equal(await isFile(join(dir, "nope.txt")), false);
-    } finally {
-      await rm(dir, { recursive: true, force: true });
-    }
-  });
-});
-
-describe("isDirectory", () => {
-  it("is true for an existing directory", async () => {
-    const dir = await makeTmp();
-    try {
-      assert.equal(await isDirectory(dir), true);
-    } finally {
-      await rm(dir, { recursive: true, force: true });
-    }
-  });
-
-  it("is false for a regular file", async () => {
-    const dir = await makeTmp();
-    try {
-      const file = join(dir, "file.txt");
-      await writeFile(file, "hello");
-      assert.equal(await isDirectory(file), false);
-    } finally {
-      await rm(dir, { recursive: true, force: true });
-    }
-  });
-
-  it("is false for a missing path", async () => {
-    const dir = await makeTmp();
-    try {
-      assert.equal(await isDirectory(join(dir, "nope")), false);
-    } finally {
-      await rm(dir, { recursive: true, force: true });
-    }
-  });
-});

package/test/helpers/fake-bd.mjs

@@ -1,87 +0,0 @@
-// Shared test helper: a stateful fake `bd` binary for create-chores.ts.
-// `bd` is a genuine external system (its real database must never be touched
-// by tests), so the script is driven against this fake via the BD_PATH
-// override. The fake reproduces the real behaviours the tests depend on —
-// `bd create --parent` label inheritance (unless `--no-inherit-labels` is
-// passed) and `bd create --validate` section enforcement — and records every
-// created bead to a JSON state file the test can read back.
-//
-// State lives in `state.json` next to the binary; the test seeds it with the
-// parent bead and reads the children back after the script runs. Written async
-// throughout — the repo's check-no-sync lint scans test/ (including helpers).
-
-import { chmod, writeFile } from "node:fs/promises";
-import { join } from "node:path";
-
-const FAKE_BD_SCRIPT = [
-  "#!/usr/bin/env node",
-  "// Stateful fake for `bd create` (test/helpers/fake-bd.mjs).",
-  "const fs = require('node:fs/promises');",
-  "",
-  "const stateFile = process.env.FAKE_BD_STATE;",
-  "const VALUE_FLAGS = new Set(['--type', '--description', '--priority', '--labels', '--parent']);",
-  "const BOOL_FLAGS = new Set(['--silent', '--no-inherit-labels', '--validate']);",
-  "",
-  "(async () => {",
-  "  const argv = process.argv.slice(2);",
-  "  if (argv[0] === 'dep') process.exit(0);",
-  "  if (argv[0] !== 'create') process.exit(1);",
-  "",
-  "  const title = argv[1];",
-  "  const flags = {};",
-  "  const bools = new Set();",
-  "  for (let i = 2; i < argv.length; i++) {",
-  "    const arg = argv[i];",
-  "    if (BOOL_FLAGS.has(arg)) { bools.add(arg); continue; }",
-  "    if (VALUE_FLAGS.has(arg)) { flags[arg] = argv[++i]; continue; }",
-  "  }",
-  "",
-  "  const state = JSON.parse(await fs.readFile(stateFile, 'utf8'));",
-  "",
-  "  // Model `bd create --validate`: reject a substantive bead whose description lacks the",
-  "  // required section(s) for its type. Chores have no requirements and always pass.",
-  "  if (bools.has('--validate')) {",
-  "    const type = flags['--type'] || 'task';",
-  "    const required = {",
-  "      task: ['## Acceptance Criteria'],",
-  "      feature: ['## Acceptance Criteria'],",
-  "      bug: ['## Steps to Reproduce', '## Acceptance Criteria'],",
-  "      epic: ['## Success Criteria'],",
-  "      chore: [],",
-  "    }[type] || ['## Acceptance Criteria'];",
-  "    const description = flags['--description'] || '';",
-  "    const missing = required.filter((section) => !description.toLowerCase().includes(section.toLowerCase()));",
-  "    if (missing.length > 0) {",
-  "      console.error('missing required sections for ' + type + ': ' + missing.join(', '));",
-  "      process.exit(1);",
-  "    }",
-  "  }",
-  "",
-  "  const explicit = (flags['--labels'] || '').split(',').filter(Boolean);",
-  "  const parent = state.beads.find((b) => b.id === flags['--parent']);",
-  "  const inherited = parent && !bools.has('--no-inherit-labels') ? parent.labels : [];",
-  "  const labels = [...new Set([...inherited, ...explicit])];",
-  "",
-  "  const id = 'bd-' + state.nextId++;",
-  "  state.beads.push({ id, title, labels, parent: flags['--parent'] ?? null, type: flags['--type'] || 'task', description: flags['--description'] || '', validated: bools.has('--validate') });",
-  "  await fs.writeFile(stateFile, JSON.stringify(state));",
-  "  process.stdout.write(id + '\\n');",
-  "})().catch((err) => {",
-  "  console.error(err);",
-  "  process.exit(1);",
-  "});",
-].join("\n");
-
-/** Create a stateful fake `bd` binary in `dir`.
- * @param {string} dir  Directory to hold the binary and its state.json
- * @param {{ beads: Array<{ id: string, title: string, labels: string[] }> }} seed
- *        Pre-existing beads (the parent) the fake inherits labels from
- * @returns {Promise<{ bin: string, state: string }>} */
-export async function makeFakeBd(dir, { beads }) {
-  const bin = join(dir, "bd");
-  const state = join(dir, "state.json");
-  await writeFile(bin, FAKE_BD_SCRIPT + "\n");
-  await chmod(bin, 0o755);
-  await writeFile(state, JSON.stringify({ beads, nextId: 1 }));
-  return { bin, state };
-}

package/test/helpers/fake-claude.mjs

@@ -1,152 +0,0 @@
-// Shared test helper: a stateful fake `claude` binary for the `claude plugin`
-// CLI. The real CLI is a genuine external system (and its home config must
-// never be touched by tests), so tests drive this fake instead. It records
-// every invocation to `calls.log` (argv, space-joined, one line each) and
-// simulates just enough real behaviour for idempotency assertions:
-//
-//   plugin --help                    → exit 0 (availability probe)
-//   plugin marketplace list --json   → registered marketplaces as JSON
-//   plugin marketplace add <root>    → registers <root> (name read from its
-//                                      .claude-plugin/marketplace.json)
-//   plugin marketplace update <m>    → exit 0
-//   plugin list --json               → installed plugins as JSON
-//   plugin install <id> -y           → records id at the version published by
-//                                      the marketplace source's plugin.json
-//   plugin update <name> -y          → re-reads the version from the source
-//
-// State lives in `state.json` next to the binary, so a test can re-run the CLI
-// against the same fake and observe the update path. `failWhen` makes any
-// invocation whose argv contains the substring exit 1 (probe/command failures).
-//
-// Written async throughout (the fake is a child process and the helper's own
-// I/O is test code) — the repo's check-no-sync lint scans test/ for *Sync.
-
-import { chmod, writeFile } from "node:fs/promises";
-import { join } from "node:path";
-
-const FAKE_CLAUDE_SCRIPT = [
-  "#!/usr/bin/env node",
-  "// Stateful fake for the `claude plugin` CLI (test/helpers/fake-claude.mjs).",
-  "const fs = require('node:fs/promises');",
-  "const path = require('node:path');",
-  "",
-  "const dir = __dirname;",
-  "const stateFile = path.join(dir, 'state.json');",
-  "const logFile = path.join(dir, 'calls.log');",
-  "const failWhenFile = path.join(dir, 'failWhen.txt');",
-  "",
-  "(async () => {",
-  "  const argv = process.argv.slice(2);",
-  "  const joined = argv.join(' ');",
-  "  await fs.appendFile(logFile, joined + '\\n');",
-  "",
-  "  const failWhen = await fs.readFile(failWhenFile, 'utf8').catch(() => null);",
-  "  if (failWhen && joined.includes(failWhen)) process.exit(1);",
-  "",
-  "  if (argv[0] !== 'plugin') process.exit(0);",
-  "",
-  "  const readState = async () => {",
-  "    try {",
-  "      return JSON.parse(await fs.readFile(stateFile, 'utf8'));",
-  "    } catch {",
-  "      return { markets: [], installed: [] };",
-  "    }",
-  "  };",
-  "  const writeState = (state) => fs.writeFile(stateFile, JSON.stringify(state));",
-  "",
-  "  // Real claude resolves the plugin version from the marketplace source's",
-  "  // plugin.json; the fake mirrors that by reading <source>/claude/.claude-plugin/plugin.json.",
-  "  const pluginJsonVersion = async (marketPath) => {",
-  "    try {",
-  "      return JSON.parse(await fs.readFile(path.join(marketPath, 'claude', '.claude-plugin', 'plugin.json'), 'utf8')).version;",
-  "    } catch {",
-  "      return undefined;",
-  "    }",
-  "  };",
-  "  const marketplaceName = async (source) => {",
-  "    try {",
-  "      return JSON.parse(await fs.readFile(path.join(source, '.claude-plugin', 'marketplace.json'), 'utf8')).name;",
-  "    } catch {",
-  "      return undefined;",
-  "    }",
-  "  };",
-  "",
-  "  const state = await readState();",
-  "  const [sub, ...rest] = argv.slice(1);",
-  "",
-  "  if (sub === '--help') process.exit(0);",
-  "",
-  "  if (sub === 'marketplace') {",
-  "    const [op, ...opArgs] = rest;",
-  "    if (op === 'list') {",
-  "      console.log(JSON.stringify(state.markets));",
-  "      process.exit(0);",
-  "    }",
-  "    if (op === 'add') {",
-  "      const source = path.resolve(opArgs[0]);",
-  "      const name = (await marketplaceName(source)) ?? 'market-' + state.markets.length;",
-  "      if (!state.markets.some((m) => m.name === name)) state.markets.push({ name, path: source });",
-  "      await writeState(state);",
-  "      process.exit(0);",
-  "    }",
-  "    if (op === 'update') process.exit(0);",
-  "    process.exit(0);",
-  "  }",
-  "",
-  "  if (sub === 'list') {",
-  "    console.log(JSON.stringify(state.installed));",
-  "    process.exit(0);",
-  "  }",
-  "",
-  "  if (sub === 'install') {",
-  "    const id = rest[0];",
-  "    if (!state.installed.some((i) => i.id === id)) {",
-  "      const [name, market] = id.split('@');",
-  "      const m = state.markets.find((x) => x.name === market);",
-  "      state.installed.push({ id, version: m ? (await pluginJsonVersion(m.path)) ?? '0.0.0' : '0.0.0' });",
-  "      await writeState(state);",
-  "    }",
-  "    process.exit(0);",
-  "  }",
-  "",
-  "  if (sub === 'update') {",
-  "    const name = rest[0];",
-  "    const entry = state.installed.find((i) => i.id.startsWith(name + '@'));",
-  "    if (entry) {",
-  "      const m = state.markets.find((x) => x.name === entry.id.split('@')[1]);",
-  "      const v = m ? await pluginJsonVersion(m.path) : undefined;",
-  "      if (v) entry.version = v;",
-  "      await writeState(state);",
-  "    }",
-  "    process.exit(0);",
-  "  }",
-  "",
-  "  process.exit(0);",
-  "})().catch((err) => {",
-  "  console.error(err);",
-  "  process.exit(1);",
-  "});",
-].join("\n");
-
-/** Create a stateful fake `claude` binary in `dir`.
- * @param {string} dir  Directory to hold bin, calls.log, state.json
- * @param {{ failWhen?: string|null }} [options]  Invocations whose argv contains
- *                                                failWhen exit 1
- * @returns {Promise<{ bin: string, log: string, state: string }>} */
-export async function makeFakeClaude(dir, { failWhen = null } = {}) {
-  const bin = join(dir, "claude");
-  const log = join(dir, "calls.log");
-  const state = join(dir, "state.json");
-  await writeFile(bin, FAKE_CLAUDE_SCRIPT + "\n");
-  await chmod(bin, 0o755);
-  await writeFile(state, JSON.stringify({ markets: [], installed: [] }));
-  if (failWhen) await writeFile(join(dir, "failWhen.txt"), failWhen);
-  return { bin, log, state };
-}
-
-/** Registration actions from a fake call log: probes and state queries dropped.
- * @param {string[]} lines  Raw call-log lines
- * @returns {string[]}      Action lines (marketplace add/update, install, update) */
-export function registrationActions(lines) {
-  return lines.filter((c) => !c.startsWith("plugin --help") && !c.includes("--json"));
-}

package/test/helpers/fake-pi.mjs

@@ -1,132 +0,0 @@
-// Shared test helper: a stateful fake `pi` binary for pi's package commands.
-// The real CLI is a genuine external system (and its user settings must never
-// be touched by tests), so tests drive this fake instead. It records every
-// invocation to `calls.log` (argv, space-joined, one line each) and simulates
-// just enough real behaviour to assert registration state:
-//
-//   --version          → exit 0 (availability probe)
-//   list               → configured package sources
-//   install <source>   → adds <source> to settings.json `packages`, persisted
-//                        relative to the settings file's directory (what real
-//                        pi does) unless an entry already resolves to it
-//   remove <source>    → drops the matching entry; exit 1 when none matches
-//
-// Local sources are resolved the way pi resolves them: relative to the
-// directory holding settings.json. `failWhen` makes any invocation whose argv
-// contains the substring exit 1 (command failures).
-//
-// Written async throughout (the fake is a child process and the helper's own
-// I/O is test code) — the repo's check-no-sync lint scans test/ for *Sync.
-
-import { chmod, writeFile } from "node:fs/promises";
-import { join } from "node:path";
-
-const FAKE_PI_SCRIPT = [
-  "#!/usr/bin/env node",
-  "// Stateful fake for the `pi` package CLI (test/helpers/fake-pi.mjs).",
-  "const fs = require('node:fs/promises');",
-  "const path = require('node:path');",
-  "const os = require('node:os');",
-  "",
-  "const dir = __dirname;",
-  "const settingsFile = path.join(dir, 'settings.json');",
-  "const logFile = path.join(dir, 'calls.log');",
-  "const failWhenFile = path.join(dir, 'failWhen.txt');",
-  "",
-  "const expand = (p) => (p === '~' ? os.homedir() : p.startsWith('~/') ? path.join(os.homedir(), p.slice(2)) : p);",
-  "const sourceOf = (entry) => (typeof entry === 'string' ? entry : entry && entry.source);",
-  "// pi resolves a configured local source against the settings file's directory.",
-  "const resolvedSource = (entry) => path.resolve(dir, expand(sourceOf(entry)));",
-  "const resolvedArgument = (arg) => path.resolve(dir, expand(arg));",
-  "",
-  "(async () => {",
-  "  const argv = process.argv.slice(2);",
-  "  const joined = argv.join(' ');",
-  "  await fs.appendFile(logFile, joined + '\\n');",
-  "",
-  "  const failWhen = await fs.readFile(failWhenFile, 'utf8').catch(() => null);",
-  "  if (failWhen && joined.includes(failWhen)) process.exit(1);",
-  "",
-  "  if (argv[0] === '--version' || argv[0] === '-v') {",
-  "    console.log('1.4.0');",
-  "    process.exit(0);",
-  "  }",
-  "",
-  "  const readSettings = async () => {",
-  "    try {",
-  "      return JSON.parse(await fs.readFile(settingsFile, 'utf8'));",
-  "    } catch {",
-  "      return {};",
-  "    }",
-  "  };",
-  "  const writePackages = async (settings, packages) =>",
-  "    fs.writeFile(settingsFile, JSON.stringify({ ...settings, packages }, null, 2) + '\\n');",
-  "",
-  "  const [command, argument] = argv;",
-  "  const settings = await readSettings();",
-  "  const packages = settings.packages ?? [];",
-  "",
-  "  if (command === 'list') {",
-  "    if (packages.length === 0) {",
-  "      console.log('No packages installed.');",
-  "      process.exit(0);",
-  "    }",
-  "    console.log('User packages:');",
-  "    for (const entry of packages) console.log('  ' + sourceOf(entry));",
-  "    process.exit(0);",
-  "  }",
-  "",
-  "  if (command === 'install') {",
-  "    const target = resolvedArgument(argument);",
-  "    const persisted = path.relative(dir, target) || '.';",
-  "    const index = packages.findIndex((entry) => resolvedSource(entry) === target);",
-  "    if (index === -1) {",
-  "      packages.push(persisted);",
-  "    } else if (typeof packages[index] === 'string') {",
-  "      packages[index] = persisted;",
-  "    } else {",
-  "      packages[index] = { ...packages[index], source: persisted };",
-  "    }",
-  "    await writePackages(settings, packages);",
-  "    console.log('Installed ' + argument);",
-  "    process.exit(0);",
-  "  }",
-  "",
-  "  if (command === 'remove') {",
-  "    const target = resolvedArgument(argument);",
-  "    const next = packages.filter((entry) => resolvedSource(entry) !== target);",
-  "    if (next.length === packages.length) {",
-  "      console.error('No matching package found for ' + argument);",
-  "      process.exit(1);",
-  "    }",
-  "    await writePackages(settings, next);",
-  "    console.log('Removed ' + argument);",
-  "    process.exit(0);",
-  "  }",
-  "",
-  "  process.exit(0);",
-  "})().catch((err) => {",
-  "  console.error(err);",
-  "  process.exit(1);",
-  "});",
-].join("\n");
-
-/** Create a stateful fake `pi` binary in `dir`.
- *
- * The binary's own directory doubles as pi's settings directory, so a local
- * package source is persisted relative to it exactly as real pi does.
- * @param {string} dir  Directory to hold bin, calls.log, settings.json
- * @param {{ failWhen?: string|null, packages?: unknown[] }} [options]
- *   failWhen: invocations whose argv contains the substring exit 1;
- *   packages: initial `packages` array for settings.json
- * @returns {Promise<{ bin: string, log: string, settingsPath: string }>} */
-export async function makeFakePi(dir, { failWhen = null, packages = [] } = {}) {
-  const bin = join(dir, "pi");
-  const log = join(dir, "calls.log");
-  const settingsPath = join(dir, "settings.json");
-  await writeFile(bin, FAKE_PI_SCRIPT + "\n");
-  await chmod(bin, 0o755);
-  await writeFile(settingsPath, `${JSON.stringify({ packages }, null, 2)}\n`);
-  if (failWhen) await writeFile(join(dir, "failWhen.txt"), failWhen);
-  return { bin, log, settingsPath };
-}