agent-cli-runtime 0.1.0-alpha.0

package/examples/cli-dogfood.md

@@ -0,0 +1,113 @@
+# CLI Dogfood
+
+These commands are safe defaults for a local checkout. They do not launch an authenticated real agent run unless `--allow-real-run` is explicitly present.
+
+## Local Checkout
+
+```bash
+npm ci
+npm run build
+npm run dogfood
+```
+
+`npm run dogfood` rebuilds the package, runs offline fixtures and fake conformance, performs real local detection/profile conformance without real runs, checks `agents` and `doctor`, performs an npm pack dry-run, installs the packed tarball into a temporary project, and verifies the installed package import plus CLI fixtures/fake paths.
+
+## Fixtures And Fake Paths
+
+```bash
+node ./dist/cli/main.js conformance --mode fixtures --json
+node ./dist/cli/main.js conformance --mode fake --json
+node ./dist/cli/main.js smoke --mode fixtures --json
+node ./dist/cli/main.js agents --json
+node ./dist/cli/main.js doctor --json
+```
+
+Fixtures exercise parser contracts offline. Fake conformance creates temporary fake CLIs and runs the real adapter argv/stdin/parser path without real accounts, provider tokens, or network agent runs.
+
+## Real Local Profile Conformance
+
+```bash
+node ./dist/cli/main.js conformance --mode real --agent all --json
+```
+
+This performs real executable/version/auth/model/profile certification. It does not launch a real agent run. Runnable adapters report `runClassification: "real_run_skipped"` and `skippedReason: "real_run_not_allowed"`.
+
+## Optional Real Run
+
+Run this only on a machine where the selected CLI is installed, authorized, and safe to use. Without `--cwd`, the command uses an isolated temporary cwd and asks for read-only behavior.
+
+```bash
+node ./dist/cli/main.js conformance \
+  --mode real \
+  --agent codex \
+  --allow-real-run \
+  --json \
+  --timeout-ms 30000
+```
+
+Equivalent detailed smoke:
+
+```bash
+node ./dist/cli/main.js smoke \
+  --mode real \
+  --agent codex \
+  --allow-real-run \
+  --json \
+  --diagnostics \
+  --timeout-ms 30000
+```
+
+## Run And Goal
+
+Use a disposable directory for manual mutation tests:
+
+```bash
+tmp="$(mktemp -d /tmp/agent-runtime-run-XXXXXX)"
+node ./dist/cli/main.js run \
+  --agent codex \
+  --cwd "$tmp" \
+  --permission workspace-write \
+  --prompt "Create smoke.txt containing exactly: agent-runtime smoke ok" \
+  --stream jsonl \
+  --diagnostics
+```
+
+```bash
+tmp="$(mktemp -d /tmp/agent-runtime-goal-XXXXXX)"
+node ./dist/cli/main.js goal \
+  --agent codex \
+  --cwd "$tmp" \
+  --permission workspace-write \
+  --prompt "Create one file named goal-smoke.txt containing exactly: agent-runtime goal smoke ok" \
+  --stream jsonl \
+  --diagnostics
+```
+
+## Diagnostics And Store Health
+
+```bash
+store="$(mktemp -d /tmp/agent-runtime-store-XXXXXX)"
+node ./dist/cli/main.js store-health --storage-dir "$store" --json
+node ./dist/cli/main.js store-lock --storage-dir "$store" --json
+node ./dist/cli/main.js store-repair --storage-dir "$store" --dry-run --json
+```
+
+After a stored run or goal exists:
+
+```bash
+node ./dist/cli/main.js runs --storage-dir "$store" --json
+node ./dist/cli/main.js goals --storage-dir "$store" --json
+node ./dist/cli/main.js replay-run run_123 --storage-dir "$store" --after 10 --jsonl
+node ./dist/cli/main.js replay-goal goal_123 --storage-dir "$store" --after 10 --jsonl
+node ./dist/cli/main.js diagnostics run run_123 --storage-dir "$store" --json
+node ./dist/cli/main.js diagnostics goal goal_123 --storage-dir "$store" --json --out diagnostics-goal_123.json
+```
+
+## Package Boundary
+
+```bash
+npm pack --dry-run
+npm pack --json --ignore-scripts --pack-destination "$(mktemp -d /tmp/agent-runtime-pack-XXXXXX)"
+```
+
+Before publishing, confirm the packed file list includes `dist/`, README files, `LICENSE`, `docs/`, and `examples/`, and excludes `.reference/`, `tests/`, fixture files, raw CLI output, real private paths, and secrets.

package/examples/library-goal.js

@@ -0,0 +1,94 @@
+import { chmod, mkdir, mkdtemp, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { createAgentRuntime } from "agent-cli-runtime";
+
+async function writeFakeCodex(binDir) {
+  const bin = path.join(binDir, "codex");
+  await writeFile(bin, `#!${process.execPath}
+const args = process.argv.slice(2);
+if (args[0] === "--version") {
+  console.log("codex-cli example-fake");
+  process.exit(0);
+}
+if (args[0] === "debug" && args[1] === "models") {
+  console.log(JSON.stringify({ models: [{ slug: "gpt-example", display_name: "GPT Example" }] }));
+  process.exit(0);
+}
+let input = "";
+process.stdin.setEncoding("utf8");
+process.stdin.on("data", (chunk) => input += chunk);
+process.stdin.on("end", () => {
+  console.log(JSON.stringify({ type: "thread.started" }));
+  if (input.includes("Return strict JSON only")) {
+    const nodeCommand = JSON.stringify(process.execPath) + ' -e "process.exit(0)"';
+    const graph = {
+      tasks: [
+        {
+          id: "T001",
+          title: "Run fake task",
+          objective: "Complete the local fake task without editing files.",
+          dependencies: [],
+          allowedFiles: [],
+          validationCommands: [nodeCommand],
+          agentId: "codex"
+        }
+      ]
+    };
+    console.log(JSON.stringify({ type: "item.completed", item: { type: "agent_message", text: JSON.stringify(graph) } }));
+  } else {
+    console.log(JSON.stringify({ type: "item.completed", item: { type: "agent_message", text: "fake task completed" } }));
+  }
+  console.log(JSON.stringify({ type: "turn.completed", usage: { input_tokens: 20, output_tokens: 10 } }));
+});
+`, "utf8");
+  await chmod(bin, 0o755);
+  return bin;
+}
+
+const root = await mkdtemp(path.join(os.tmpdir(), "agent-runtime-example-goal-"));
+const binDir = path.join(root, "bin");
+const cwd = path.join(root, "work");
+const storageDir = path.join(root, "store");
+await Promise.all([
+  mkdir(binDir, { recursive: true }),
+  mkdir(cwd, { recursive: true }),
+]);
+const codexBin = await writeFakeCodex(binDir);
+
+const runtime = createAgentRuntime({
+  storageDir,
+  env: {
+    ...process.env,
+    PATH: binDir,
+    CODEX_BIN: codexBin,
+  },
+  searchPath: [binDir],
+});
+
+try {
+  const goal = await runtime.createGoal({
+    cwd,
+    objective: "Dogfood the goal scheduler with one fake task.",
+    defaultAgentId: "codex",
+    permissionPolicy: "read-only",
+    timeoutMs: 10_000,
+  });
+
+  const eventTypes = [];
+  for await (const event of goal.events) eventTypes.push(event.type);
+
+  const record = await runtime.getGoal(goal.goalId);
+  const replay = await runtime.replayGoalEvents(goal.goalId);
+  const diagnostics = await runtime.exportDiagnostics({ kind: "goal", goalId: goal.goalId });
+
+  console.log(JSON.stringify({
+    goal: { id: record?.id, status: record?.status, result: record?.result },
+    tasks: record?.tasks.map((task) => ({ id: task.id, status: task.status, attempts: task.evidence.attempts?.length ?? 0 })),
+    eventTypes,
+    replayEvents: replay.length,
+    diagnosticsSchema: diagnostics.schemaVersion,
+  }, null, 2));
+} finally {
+  await runtime.shutdown("example complete");
+}

package/examples/library-run.js

@@ -0,0 +1,84 @@
+import { chmod, mkdir, mkdtemp, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { createAgentRuntime } from "agent-cli-runtime";
+
+async function writeFakeCodex(binDir) {
+  const bin = path.join(binDir, "codex");
+  await writeFile(bin, `#!${process.execPath}
+const args = process.argv.slice(2);
+if (args[0] === "--version") {
+  console.log("codex-cli example-fake");
+  process.exit(0);
+}
+if (args[0] === "debug" && args[1] === "models") {
+  console.log(JSON.stringify({ models: [{ slug: "gpt-example", display_name: "GPT Example" }] }));
+  process.exit(0);
+}
+let input = "";
+process.stdin.setEncoding("utf8");
+process.stdin.on("data", (chunk) => input += chunk);
+process.stdin.on("end", () => {
+  console.log(JSON.stringify({ type: "thread.started" }));
+  console.log(JSON.stringify({
+    type: "item.completed",
+    item: { type: "agent_message", text: "example run ok: " + input.trim().slice(0, 80) }
+  }));
+  console.log(JSON.stringify({ type: "turn.completed", usage: { input_tokens: 12, output_tokens: 8 } }));
+});
+`, "utf8");
+  await chmod(bin, 0o755);
+  return bin;
+}
+
+const root = await mkdtemp(path.join(os.tmpdir(), "agent-runtime-example-run-"));
+const binDir = path.join(root, "bin");
+const cwd = path.join(root, "work");
+const storageDir = path.join(root, "store");
+await Promise.all([
+  mkdir(binDir, { recursive: true }),
+  mkdir(cwd, { recursive: true }),
+]);
+const codexBin = await writeFakeCodex(binDir);
+
+const runtime = createAgentRuntime({
+  storageDir,
+  env: {
+    ...process.env,
+    PATH: binDir,
+    CODEX_BIN: codexBin,
+  },
+  searchPath: [binDir],
+});
+
+try {
+  const agents = await runtime.detect({ includeUnavailable: true });
+  const run = await runtime.run({
+    agentId: "codex",
+    cwd,
+    prompt: "Say hello from the library-run example.",
+    permissionPolicy: "read-only",
+    timeoutMs: 10_000,
+  });
+
+  let observedText = "";
+  for await (const event of run.events) {
+    if (event.type === "text_delta") observedText += event.text;
+  }
+
+  const record = await runtime.getRun(run.runId);
+  const replay = await runtime.replayRunEvents(run.runId);
+  const diagnostics = await runtime.exportDiagnostics({ kind: "run", runId: run.runId });
+  const health = await runtime.inspectStore();
+
+  console.log(JSON.stringify({
+    detected: agents.map((agent) => ({ id: agent.id, available: agent.available, version: agent.version })),
+    run: { id: record?.id, status: record?.status, result: record?.result },
+    observedText,
+    replayEvents: replay.length,
+    diagnosticsSchema: diagnostics.schemaVersion,
+    storeOk: health.ok,
+  }, null, 2));
+} finally {
+  await runtime.shutdown("example complete");
+}

package/package.json

@@ -0,0 +1,79 @@
+{
+  "name": "agent-cli-runtime",
+  "version": "0.1.0-alpha.0",
+  "description": "Local-first TypeScript runtime for scheduling Codex CLI, Claude Code, OpenCode, and compatible coding-agent CLIs.",
+  "type": "module",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/iiwish/agent-cli-runtime.git"
+  },
+  "homepage": "https://github.com/iiwish/agent-cli-runtime#readme",
+  "bugs": {
+    "url": "https://github.com/iiwish/agent-cli-runtime/issues"
+  },
+  "bin": {
+    "agent-runtime": "dist/cli/main.js"
+  },
+  "publishConfig": {
+    "tag": "alpha"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "CHANGELOG.md",
+    "CONTRIBUTING.md",
+    "SECURITY.md",
+    "README.md",
+    "README.zh-CN.md",
+    "LICENSE",
+    "examples",
+    "docs/release-checklist.md",
+    "docs/release-report.md",
+    "docs/release-publish-runbook.md",
+    "docs/api-schema-contract.md",
+    "docs/daemon-ready-contract.md",
+    "docs/ssot.md",
+    "docs/compatibility.md",
+    "docs/production-readiness.md",
+    "scripts/dogfood.mjs"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "ci": "npm run typecheck && npm run lint && npm test && npm run build && npm audit --omit=dev && npm run package:check && npm pack --dry-run",
+    "daemon:verify": "node ./scripts/verify-daemon-ready.mjs",
+    "dogfood": "node ./scripts/dogfood.mjs",
+    "package:check": "node ./scripts/check-package-boundary.mjs",
+    "prepublish:check": "npm run typecheck && npm run lint && npm test && npm run build && npm run daemon:verify && npm run runtime:safety && npm run dogfood && npm audit --omit=dev && npm run package:check && npm pack --dry-run",
+    "prepack": "npm run build",
+    "release:candidate": "node ./scripts/create-release-candidate.mjs",
+    "release:verify": "node ./scripts/verify-release-artifacts.mjs",
+    "runtime:safety": "node ./scripts/verify-runtime-safety.mjs",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "lint": "tsc -p tsconfig.json --noEmit",
+    "test": "npm run build && vitest run --reporter=verbose --no-file-parallelism --testTimeout 30000"
+  },
+  "keywords": [
+    "agent",
+    "cli",
+    "codex",
+    "claude",
+    "opencode",
+    "runtime"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.0",
+    "typescript": "^5.8.0",
+    "vitest": "^3.2.0"
+  }
+}

package/scripts/dogfood.mjs

@@ -0,0 +1,243 @@
+#!/usr/bin/env node
+import { chmodSync, mkdtempSync, mkdirSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+
+const repoRoot = process.cwd();
+const node = process.execPath;
+
+function run(command, args, options = {}) {
+  console.log(`\n$ ${[command, ...args].join(" ")}`);
+  const result = spawnSync(command, args, {
+    cwd: options.cwd ?? repoRoot,
+    env: options.env ?? process.env,
+    stdio: options.capture ? ["ignore", "pipe", "pipe"] : "inherit",
+    encoding: "utf8",
+  });
+  if (result.status !== 0) {
+    if (options.capture) {
+      process.stdout.write(result.stdout ?? "");
+      process.stderr.write(result.stderr ?? "");
+    }
+    throw new Error(`command failed: ${command} ${args.join(" ")}`);
+  }
+  return result.stdout ?? "";
+}
+
+function writeNodeBin(dir, name, body) {
+  const file = path.join(dir, name);
+  writeFileSync(file, `#!${node}\n${body}`, "utf8");
+  chmodSync(file, 0o755);
+  return file;
+}
+
+function createFakeBins(parent) {
+  const binDir = path.join(parent, "fake-bin");
+  mkdirSync(binDir, { recursive: true });
+  const codex = writeNodeBin(binDir, "codex", `
+const args = process.argv.slice(2);
+if (args[0] === "--version") { console.log("codex-cli dogfood-fake"); process.exit(0); }
+if (args[0] === "debug" && args[1] === "models") { console.log(JSON.stringify({ models: [{ slug: "gpt-dogfood", display_name: "GPT Dogfood" }] })); process.exit(0); }
+process.stdin.resume();
+process.stdin.on("end", () => {
+  console.log(JSON.stringify({ type: "thread.started" }));
+  console.log(JSON.stringify({ type: "item.completed", item: { type: "agent_message", text: "agent-runtime codex smoke ok" } }));
+});
+`);
+  const claude = writeNodeBin(binDir, "claude", `
+const args = process.argv.slice(2);
+if (args[0] === "--version") { console.log("Claude Code dogfood-fake"); process.exit(0); }
+if (args[0] === "-p" && args[1] === "--help") { console.log("--include-partial-messages\\n--add-dir"); process.exit(0); }
+if (args[0] === "auth" && args[1] === "status") { console.log(JSON.stringify({ loggedIn: true })); process.exit(0); }
+process.stdin.resume();
+process.stdin.on("end", () => {
+  console.log(JSON.stringify({ type: "system" }));
+  console.log(JSON.stringify({ type: "assistant", message: { content: [{ type: "text", text: "agent-runtime claude smoke ok" }] } }));
+});
+`);
+  const opencode = writeNodeBin(binDir, "opencode", `
+const args = process.argv.slice(2);
+if (args[0] === "--version") { console.log("opencode dogfood-fake"); process.exit(0); }
+if (args[0] === "models") { console.log("openai/gpt-dogfood"); process.exit(0); }
+process.stdin.resume();
+process.stdin.on("end", () => {
+  console.log(JSON.stringify({ type: "step_start" }));
+  console.log(JSON.stringify({ type: "text", part: { text: "agent-runtime opencode smoke ok" } }));
+});
+`);
+  writeNodeBin(binDir, "opencode-cli", `
+const args = process.argv.slice(2);
+if (args[0] === "--version") { console.log("opencode dogfood-fake"); process.exit(0); }
+if (args[0] === "models") { console.log("openai/gpt-dogfood"); process.exit(0); }
+process.stdin.resume();
+process.stdin.on("end", () => {
+  console.log(JSON.stringify({ type: "step_start" }));
+  console.log(JSON.stringify({ type: "text", part: { text: "agent-runtime opencode smoke ok" } }));
+});
+`);
+  return {
+    PATH: `${binDir}${path.delimiter}${process.env.PATH ?? ""}`,
+    CODEX_BIN: codex,
+    CLAUDE_BIN: claude,
+    OPENCODE_BIN: opencode,
+  };
+}
+
+function runCli(args, options = {}) {
+  return run(node, ["./dist/cli/main.js", ...args], options);
+}
+
+function installSmoke() {
+  const tmp = mkdtempSync(path.join(tmpdir(), "agent-runtime-dogfood-"));
+  const packText = run("npm", ["pack", "--json", "--ignore-scripts", "--pack-destination", tmp], { capture: true });
+  const [packInfo] = JSON.parse(packText);
+  const tarball = path.join(tmp, packInfo.filename);
+  run("npm", ["init", "-y"], { cwd: tmp, capture: true });
+  run("npm", ["install", tarball, "--no-save", "--ignore-scripts", "--no-audit", "--no-fund"], { cwd: tmp });
+
+  const fakeEnv = { ...process.env, ...createFakeBins(tmp) };
+  const consumerAgent = writeNodeBin(path.join(tmp, "fake-bin"), "consumer-agent", `
+const args = process.argv.slice(2);
+if (args[0] === "--version") {
+  console.log("consumer-agent dogfood-fake");
+  process.exit(0);
+}
+let input = "";
+process.stdin.setEncoding("utf8");
+process.stdin.on("data", chunk => input += chunk);
+process.stdin.on("end", () => {
+  if (input.includes("Return strict JSON")) {
+    console.log(JSON.stringify({ tasks: [
+      { id: "T001", title: "Consumer task", objective: "consumer task run", dependencies: [], validationCommands: ["node -e \\"process.exit(0)\\""] }
+    ] }));
+    return;
+  }
+  console.log("consumer fake run ok");
+});
+`);
+  fakeEnv.PATH = `${path.dirname(consumerAgent)}${path.delimiter}${fakeEnv.PATH ?? ""}`;
+  const installedCli = path.join(tmp, "node_modules", ".bin", "agent-runtime");
+  run(node, ["-e", "const m = await import('agent-cli-runtime'); if (typeof m.createAgentRuntime !== 'function') process.exit(1); console.log(typeof m.createAgentRuntime);"], { cwd: tmp });
+  writeFileSync(path.join(tmp, "tsconfig.json"), JSON.stringify({
+    compilerOptions: {
+      target: "ES2022",
+      module: "NodeNext",
+      moduleResolution: "NodeNext",
+      strict: true,
+      skipLibCheck: false,
+      lib: ["ES2022", "DOM"],
+      noEmit: true,
+    },
+    include: ["consumer.ts"],
+  }, null, 2), "utf8");
+  writeFileSync(path.join(tmp, "consumer.ts"), `
+import {
+  createAgentRuntime,
+  type AgentAdapterDef,
+  type AgentEvent,
+  type CreateGoalRequest,
+  type DiagnosticsBundle,
+  type ReplayEvent,
+  type RunRequest,
+  type RuntimeOptions,
+  type StoreHealth,
+} from "agent-cli-runtime";
+
+const adapter: AgentAdapterDef = {
+  id: "consumer-fake",
+  displayName: "Consumer Fake",
+  bin: "consumer-agent",
+  versionArgs: ["--version"],
+  fallbackModels: [{ id: "default", label: "Default" }],
+  buildArgs: () => [],
+  promptTransport: { kind: "stdin", inputFormat: "text" },
+  stream: {
+    create: () => ({
+      parse: (chunk: string) => [{ type: "text_delta", text: chunk }],
+      flush: () => [],
+    }),
+  },
+};
+
+const runRequest: RunRequest = { agentId: "consumer-fake", cwd: ".", prompt: "consumer run" };
+const goalRequest: CreateGoalRequest = { defaultAgentId: "consumer-fake", cwd: ".", objective: "consumer goal" };
+const options: RuntimeOptions = { adapters: [adapter], searchPath: ["."], storageDir: "./consumer-store" };
+const runtime = createAgentRuntime(options);
+const health: Promise<StoreHealth> = runtime.inspectStore();
+const diagnostics: Promise<DiagnosticsBundle> = runtime.exportDiagnostics({ kind: "run", runId: "run_missing" });
+const replay: ReplayEvent<AgentEvent>[] = [];
+
+void runRequest;
+void goalRequest;
+void health;
+void diagnostics;
+void replay;
+void runtime.shutdown();
+`, "utf8");
+  writeFileSync(path.join(tmp, "consumer.mjs"), `
+import { createAgentRuntime } from "agent-cli-runtime";
+
+const fakeBin = ${JSON.stringify(path.join(tmp, "fake-bin"))};
+const cwd = process.cwd();
+const runtime = createAgentRuntime({
+  adapters: [{
+    id: "consumer-fake",
+    displayName: "Consumer Fake",
+    bin: "consumer-agent",
+    versionArgs: ["--version"],
+    fallbackModels: [{ id: "default", label: "Default" }],
+    buildArgs: () => [],
+    promptTransport: { kind: "stdin", inputFormat: "text" },
+    stream: {
+      create: () => ({
+        parse: (chunk) => chunk.split(/\\r?\\n/u).filter(Boolean).map((line) => ({ type: "text_delta", text: line + "\\n" })),
+        flush: () => [],
+      }),
+    },
+  }],
+  searchPath: [fakeBin],
+  storageDir: cwd + "/consumer-store",
+});
+
+const runHandle = await runtime.run({ agentId: "consumer-fake", cwd, prompt: "consumer run" });
+for await (const _event of runHandle.events) {}
+const run = await runtime.getRun(runHandle.runId);
+const runReplay = await runtime.replayRunEvents(runHandle.runId);
+const runDiagnostics = await runtime.exportDiagnostics({ kind: "run", runId: runHandle.runId });
+
+const goalHandle = await runtime.createGoal({ defaultAgentId: "consumer-fake", cwd, objective: "consumer goal" });
+for await (const _event of goalHandle.events) {}
+const goal = await runtime.getGoal(goalHandle.goalId);
+const goalReplay = await runtime.replayGoalEvents(goalHandle.goalId);
+const goalDiagnostics = await runtime.exportDiagnostics({ kind: "goal", goalId: goalHandle.goalId });
+const health = await runtime.inspectStore();
+await runtime.shutdown("consumer smoke complete");
+
+if (run?.status !== "succeeded" || goal?.status !== "succeeded") process.exit(1);
+if (runReplay.length === 0 || goalReplay.length === 0) process.exit(1);
+if (runDiagnostics.schemaVersion !== "agent-runtime.diagnostics.v1") process.exit(1);
+if (goalDiagnostics.schemaVersion !== "agent-runtime.diagnostics.v1") process.exit(1);
+if (!health.ok) process.exit(1);
+console.log(JSON.stringify({ run: run.status, goal: goal.status, runReplay: runReplay.length, goalReplay: goalReplay.length }));
+`, "utf8");
+  run(node, [path.join(repoRoot, "node_modules", "typescript", "bin", "tsc"), "--noEmit"], { cwd: tmp });
+  run(node, ["consumer.mjs"], { cwd: tmp, env: fakeEnv });
+  run(node, [installedCli, "agents", "--json"], { cwd: tmp, env: fakeEnv });
+  run(node, [installedCli, "doctor", "--json"], { cwd: tmp, env: fakeEnv });
+  run(node, [installedCli, "smoke", "--mode", "fixtures", "--json"], { cwd: tmp, env: fakeEnv });
+  run(node, [installedCli, "conformance", "--mode", "fixtures", "--json"], { cwd: tmp, env: fakeEnv });
+  run(node, [installedCli, "conformance", "--mode", "fake", "--json"], { cwd: tmp, env: fakeEnv });
+}
+
+run("npm", ["run", "build"]);
+runCli(["conformance", "--mode", "fixtures", "--json"]);
+runCli(["conformance", "--mode", "fake", "--json"]);
+runCli(["conformance", "--mode", "real", "--agent", "all", "--json"]);
+runCli(["smoke", "--mode", "fixtures", "--json"]);
+runCli(["agents", "--json"]);
+runCli(["doctor", "--json"]);
+run(node, ["examples/library-run.js"]);
+run(node, ["examples/library-goal.js"]);
+run("npm", ["pack", "--dry-run"]);
+installSmoke();