sdtk-kit 1.2.0 → 1.3.0

package/package.json

@@ -1,60 +1,65 @@
-{
-  "name": "sdtk-kit",
-  "version": "1.2.0",
-  "description": "Install all five SDTK toolkits in one command. Meta-package for sdtk-spec-kit, sdtk-code-kit, sdtk-ops-kit, sdtk-design-kit, and sdtk-wiki-kit.",
-  "type": "commonjs",
-  "bin": {
-    "sdtk-spec": "bin/sdtk-spec.js",
-    "sdtk-code": "bin/sdtk-code.js",
-    "sdtk-ops": "bin/sdtk-ops.js",
-    "sdtk-design": "bin/sdtk-design.js",
-    "sdtk-wiki": "bin/sdtk-wiki.js"
-  },
-  "files": [
-    "bin/",
-    "scripts/",
-    "README.md",
-    "LICENSE"
-  ],
-  "scripts": {
-    "postinstall": "node scripts/postinstall.js",
-    "pack:smoke": "npm pack --dry-run"
-  },
-  "dependencies": {
-    "sdtk-spec-kit": "^0.4.7",
-    "sdtk-code-kit": "^0.3.0",
-    "sdtk-ops-kit": "^0.2.4",
-    "sdtk-design-kit": "^0.3.0",
-    "sdtk-wiki-kit": "^0.2.0"
-  },
-  "engines": {
-    "node": ">=18.13.0"
-  },
-  "keywords": [
-    "sdtk",
-    "sdtk-kit",
-    "sdtk-spec",
-    "sdtk-code",
-    "sdtk-ops",
-    "sdtk-design",
-    "sdtk-wiki",
-    "cli",
-    "toolkit",
-    "ai-workflow",
-    "solo-founder",
-    "mvp"
-  ],
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/codexsdtk/sdtk-toolkit.git",
-    "directory": "products/sdtk-kit/distribution/sdtk-kit"
-  },
-  "homepage": "https://sdtk.dev",
-  "bugs": {
-    "url": "https://github.com/codexsdtk/sdtk-toolkit/issues"
-  },
-  "publishConfig": {
-    "access": "public"
-  }
-}
+{
+  "name": "sdtk-kit",
+  "version": "1.3.0",
+  "description": "Install all five SDTK toolkits in one command. Meta-package for sdtk-spec-kit, sdtk-code-kit, sdtk-ops-kit, sdtk-design-kit, and sdtk-wiki-kit.",
+  "type": "commonjs",
+  "bin": {
+    "sdtk": "bin/sdtk.js",
+    "sdtk-spec": "bin/sdtk-spec.js",
+    "sdtk-code": "bin/sdtk-code.js",
+    "sdtk-ops": "bin/sdtk-ops.js",
+    "sdtk-design": "bin/sdtk-design.js",
+    "sdtk-wiki": "bin/sdtk-wiki.js"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "scripts/",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "postinstall": "node scripts/postinstall.js",
+    "test": "node scripts/unified-init.test.js",
+    "install:smoke:local": "node scripts/install-smoke.js --mode local",
+    "install:smoke:published": "node scripts/install-smoke.js --mode published --package sdtk-kit@latest",
+    "pack:smoke": "npm pack --dry-run"
+  },
+  "dependencies": {
+    "sdtk-spec-kit": "^0.4.7",
+    "sdtk-code-kit": "^0.3.0",
+    "sdtk-ops-kit": "^0.2.4",
+    "sdtk-design-kit": "^0.3.0",
+    "sdtk-wiki-kit": "^0.2.0"
+  },
+  "engines": {
+    "node": ">=18.13.0"
+  },
+  "keywords": [
+    "sdtk",
+    "sdtk-kit",
+    "sdtk-spec",
+    "sdtk-code",
+    "sdtk-ops",
+    "sdtk-design",
+    "sdtk-wiki",
+    "cli",
+    "toolkit",
+    "ai-workflow",
+    "solo-founder",
+    "mvp"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/codexsdtk/sdtk-toolkit.git",
+    "directory": "products/sdtk-kit/distribution/sdtk-kit"
+  },
+  "homepage": "https://sdtk.dev",
+  "bugs": {
+    "url": "https://github.com/codexsdtk/sdtk-toolkit/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/scripts/install-smoke.js

@@ -0,0 +1,190 @@
+#!/usr/bin/env node
+"use strict";
+
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const { spawnSync } = require("child_process");
+
+const PACKAGE_ROOT = path.resolve(__dirname, "..");
+const PACKAGE_JSON = path.join(PACKAGE_ROOT, "package.json");
+const TOOLKITS = Object.freeze([
+  { cli: "sdtk-spec", packageName: "sdtk-spec-kit" },
+  { cli: "sdtk-code", packageName: "sdtk-code-kit" },
+  { cli: "sdtk-ops", packageName: "sdtk-ops-kit" },
+  { cli: "sdtk-design", packageName: "sdtk-design-kit" },
+  { cli: "sdtk-wiki", packageName: "sdtk-wiki-kit" },
+]);
+
+function usage() {
+  return [
+    "Usage:",
+    "  node scripts/install-smoke.js --mode local [--package ./sdtk-kit-1.2.0.tgz] [--keep-prefix]",
+    "  node scripts/install-smoke.js --mode published [--package sdtk-kit@latest] [--keep-prefix]",
+    "",
+    "Modes:",
+    "  local      Packs the local sdtk-kit package when --package is omitted, then installs it into a clean prefix.",
+    "  published  Installs a published package spec, defaulting to sdtk-kit@latest, into a clean prefix.",
+  ].join("\n");
+}
+
+function parseArgs(argv) {
+  const args = { mode: "local", packageSpec: null, keepPrefix: false };
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === "--mode") {
+      args.mode = argv[++i];
+    } else if (arg === "--package") {
+      args.packageSpec = argv[++i];
+    } else if (arg === "--keep-prefix") {
+      args.keepPrefix = true;
+    } else if (arg === "--help" || arg === "-h") {
+      console.log(usage());
+      process.exit(0);
+    } else {
+      throw new Error(`Unknown argument: ${arg}\n${usage()}`);
+    }
+  }
+  if (!new Set(["local", "published"]).has(args.mode)) {
+    throw new Error(`Invalid --mode: ${args.mode}\n${usage()}`);
+  }
+  return args;
+}
+
+function run(command, args, options = {}) {
+  const result = spawnSync(command, args, {
+    cwd: options.cwd || PACKAGE_ROOT,
+    env: options.env || process.env,
+    encoding: "utf8",
+    shell: options.shell || false,
+  });
+  if (result.status !== 0) {
+    throw new Error([
+      `Command failed: ${command} ${args.join(" ")}`,
+      `exit=${result.status}`,
+      result.stdout ? `stdout:\n${result.stdout}` : "stdout: <empty>",
+      result.stderr ? `stderr:\n${result.stderr}` : "stderr: <empty>",
+    ].join("\n"));
+  }
+  return result;
+}
+
+function readJson(file) {
+  return JSON.parse(fs.readFileSync(file, "utf8"));
+}
+
+function assertPackageMetadata(packageJson) {
+  const missingBins = [];
+  const missingDeps = [];
+  for (const toolkit of TOOLKITS) {
+    if (!packageJson.bin || packageJson.bin[toolkit.cli] !== `bin/${toolkit.cli}.js`) {
+      missingBins.push(toolkit.cli);
+    }
+    if (!packageJson.dependencies || !packageJson.dependencies[toolkit.packageName]) {
+      missingDeps.push(toolkit.packageName);
+    }
+  }
+  if (missingBins.length || missingDeps.length) {
+    throw new Error(`sdtk-kit metadata is incomplete: missingBins=${missingBins.join(",") || "none"}; missingDeps=${missingDeps.join(",") || "none"}`);
+  }
+}
+
+function packLocalPackage() {
+  const result = run("npm", ["pack", "--json"], { cwd: PACKAGE_ROOT });
+  const entries = JSON.parse(result.stdout);
+  if (!Array.isArray(entries) || entries.length !== 1 || !entries[0].filename) {
+    throw new Error(`Unexpected npm pack --json output: ${result.stdout}`);
+  }
+  return path.join(PACKAGE_ROOT, entries[0].filename);
+}
+
+function npmBinPath(prefix, cli) {
+  const binDir = path.join(prefix, "node_modules", ".bin");
+  const candidates = process.platform === "win32"
+    ? [path.join(binDir, `${cli}.cmd`), path.join(binDir, `${cli}.ps1`), path.join(binDir, cli)]
+    : [path.join(binDir, cli)];
+  return candidates.find((candidate) => fs.existsSync(candidate));
+}
+
+function installedPackageJson(prefix, packageName) {
+  const candidates = [
+    path.join(prefix, "node_modules", packageName, "package.json"),
+    path.join(prefix, "node_modules", "sdtk-kit", "node_modules", packageName, "package.json"),
+  ];
+  const found = candidates.find((candidate) => fs.existsSync(candidate));
+  if (!found) {
+    throw new Error(`Cannot find installed package.json for ${packageName} under ${prefix}`);
+  }
+  return readJson(found);
+}
+
+function runCliVersion(binPath) {
+  return run(binPath, ["--version"], { shell: process.platform === "win32" });
+}
+
+function smokeInstall(packageSpec, mode, keepPrefix) {
+  const prefix = fs.mkdtempSync(path.join(os.tmpdir(), "sdtk-kit-install-smoke-"));
+  let packedTarball = null;
+  try {
+    const localPackageJson = readJson(PACKAGE_JSON);
+    assertPackageMetadata(localPackageJson);
+
+    let installSpec = packageSpec;
+    if (mode === "local" && !installSpec) {
+      packedTarball = packLocalPackage();
+      installSpec = packedTarball;
+    }
+    if (mode === "published" && !installSpec) {
+      installSpec = "sdtk-kit@latest";
+    }
+    if (!installSpec) {
+      throw new Error("No package spec resolved for install smoke.");
+    }
+
+    console.log(`[sdtk-kit smoke] mode=${mode}`);
+    console.log(`[sdtk-kit smoke] prefix=${prefix}`);
+    console.log(`[sdtk-kit smoke] install=${installSpec}`);
+    run("npm", ["install", "--prefix", prefix, installSpec]);
+
+    const installedMeta = installedPackageJson(prefix, "sdtk-kit");
+    assertPackageMetadata(installedMeta);
+    console.log(`[sdtk-kit smoke] installed sdtk-kit ${installedMeta.version}`);
+
+    for (const toolkit of TOOLKITS) {
+      const binPath = npmBinPath(prefix, toolkit.cli);
+      if (!binPath) {
+        throw new Error(`Missing CLI shim for ${toolkit.cli} in ${path.join(prefix, "node_modules", ".bin")}`);
+      }
+      const expected = installedPackageJson(prefix, toolkit.packageName).version;
+      const result = runCliVersion(binPath);
+      const output = `${result.stdout || ""}${result.stderr || ""}`.trim();
+      if (!output.includes(expected)) {
+        throw new Error(`${toolkit.cli} --version did not include installed ${toolkit.packageName} version ${expected}. Output: ${output}`);
+      }
+      console.log(`[sdtk-kit smoke] ${toolkit.cli} -> ${output}`);
+    }
+
+    console.log("[sdtk-kit smoke] PASS all five CLI shims exist and --version checks passed.");
+  } finally {
+    if (packedTarball && fs.existsSync(packedTarball)) {
+      fs.rmSync(packedTarball, { force: true });
+    }
+    if (keepPrefix) {
+      console.log(`[sdtk-kit smoke] kept prefix: ${prefix}`);
+    } else {
+      fs.rmSync(prefix, { recursive: true, force: true });
+    }
+  }
+}
+
+function main() {
+  const args = parseArgs(process.argv.slice(2));
+  smokeInstall(args.packageSpec, args.mode, args.keepPrefix);
+}
+
+try {
+  main();
+} catch (error) {
+  console.error(`[sdtk-kit smoke] FAIL ${error.message}`);
+  process.exit(1);
+}

package/scripts/postinstall.js

@@ -1,40 +1,43 @@
-#!/usr/bin/env node
-"use strict";
-
-// Skip banner in CI environments and headless installs.
-// This avoids noisy output in automated pipelines that install sdtk-kit
-// as a transitive dependency.
-const isCI =
-  process.env.CI === "true" ||
-  process.env.NODE_ENV === "test" ||
-  process.env.npm_config_loglevel === "silent" ||
-  process.env.npm_config_loglevel === "error";
-
-if (isCI) {
-  process.exit(0);
-}
-
-const lines = [
-  "",
-  "  ╔══════════════════════════════════════════════════════╗",
-  "  ║            SDTK — All Five Toolkits Installed        ║",
-  "  ╚══════════════════════════════════════════════════════╝",
-  "",
-  "  You now have all five SDTK CLI tools available:",
-  "",
-  "    sdtk-spec    — Spec-first SDLC: PM → BA → ARCH → DEV → QA",
-  "    sdtk-design  — MVP design: idea → prototype → handoff",
-  "    sdtk-code    — Governed coding: handoff → PR with review gates",
-  "    sdtk-ops     — Operations: deploy → smoke → sign-off",
-  "    sdtk-wiki    — Local second brain: your project memory",
-  "",
-  "  Start with the SPEC toolkit:",
-  "",
-  "    sdtk-spec init --runtime claude   (or --runtime codex)",
-  "    sdtk-spec generate --feature-key <YOUR_FEATURE>",
-  "",
-  "  Docs: https://sdtk.dev",
-  "",
-];
-
-process.stdout.write(lines.join("\n") + "\n");
+#!/usr/bin/env node
+"use strict";
+
+// Skip banner in CI environments and headless installs.
+// This avoids noisy output in automated pipelines that install sdtk-kit
+// as a transitive dependency.
+const isCI =
+  process.env.CI === "true" ||
+  process.env.NODE_ENV === "test" ||
+  process.env.npm_config_loglevel === "silent" ||
+  process.env.npm_config_loglevel === "error";
+
+if (isCI) {
+  process.exit(0);
+}
+
+const lines = [
+  "",
+  "  ╔══════════════════════════════════════════════════════╗",
+  "  ║            SDTK — All Five Toolkits Installed        ║",
+  "  ╚══════════════════════════════════════════════════════╝",
+  "",
+  "  You now have all five SDTK CLI tools available:",
+  "",
+  "    sdtk-spec    — Spec-first SDLC: PM → BA → ARCH → DEV → QA",
+  "    sdtk-design  — MVP design: idea → prototype → handoff",
+  "    sdtk-code    — Governed coding: handoff → PR with review gates",
+  "    sdtk-ops     — Operations: deploy → smoke → sign-off",
+  "    sdtk-wiki    — Local second brain: your project memory",
+  "",
+  "  Set up the whole suite in one command:",
+  "",
+  "    sdtk init --runtime claude   (or --runtime codex)",
+  "",
+  "  Then generate your first feature spec:",
+  "",
+  "    sdtk-spec generate --feature-key <YOUR_FEATURE>",
+  "",
+  "  Docs: https://sdtk.dev",
+  "",
+];
+
+process.stdout.write(lines.join("\n") + "\n");

package/scripts/unified-init.test.js

@@ -0,0 +1,242 @@
+#!/usr/bin/env node
+"use strict";
+
+// Offline unit tests for the unified-init orchestrator (BK-268).
+// No real PowerShell, no network, no child processes — every effectful dep
+// (spawn / resolveBin / powershellCheck / log) is injected as a spy/stub.
+
+const assert = require("assert");
+const {
+  runUnifiedInit,
+  buildInitArgs,
+  TOOLKITS,
+  ToolkitResolveError,
+} = require("../src/lib/unified-init");
+
+const RUNTIME_KITS = ["sdtk-spec", "sdtk-ops", "sdtk-code"];
+const NON_RUNTIME_KITS = ["sdtk-design", "sdtk-wiki"];
+
+// Build an injected deps object with a recording spawn spy.
+// `failures` maps toolkit name → exit code to return (default 0).
+// `unresolvable` is a Set of kit package names that resolveBin should reject.
+function makeDeps({ failures = {}, unresolvable = new Set(), psOk = true } = {}) {
+  const spawnCalls = [];
+  const resolveCalls = [];
+  const logs = [];
+  return {
+    spawnCalls,
+    resolveCalls,
+    logs,
+    deps: {
+      spawn(binPath, argv, toolkit) {
+        spawnCalls.push({ binPath, argv, toolkit: toolkit.name });
+        const code = failures[toolkit.name] || 0;
+        return { status: code, stderr: code ? `stub stderr for ${toolkit.name}` : "" };
+      },
+      resolveBin(kitPkg, binName) {
+        resolveCalls.push(kitPkg);
+        if (unresolvable.has(kitPkg)) {
+          throw new ToolkitResolveError(kitPkg);
+        }
+        return `/stub/node_modules/${kitPkg}/bin/${binName}.js`;
+      },
+      powershellCheck() {
+        return { ok: psOk, exe: "pwsh" };
+      },
+      log(line) {
+        logs.push(line);
+      },
+    },
+  };
+}
+
+// Pull the argv recorded for one toolkit's spawn.
+function argvFor(spawnCalls, name) {
+  const call = spawnCalls.find((c) => c.toolkit === name);
+  return call ? call.argv : null;
+}
+
+const tests = [];
+function test(name, fn) {
+  tests.push({ name, fn });
+}
+
+// ── T1 — runtime claude forwards correctly to runtime kits ──────────────────
+test("T1 runtime=claude spawns spec/ops/code with init --runtime claude", () => {
+  const h = makeDeps();
+  const { exitCode } = runUnifiedInit({ runtime: "claude" }, h.deps);
+  assert.strictEqual(exitCode, 0);
+  for (const kit of RUNTIME_KITS) {
+    const argv = argvFor(h.spawnCalls, kit);
+    assert.deepStrictEqual(argv, ["init", "--runtime", "claude"], `${kit} argv`);
+  }
+});
+
+// ── T2 — runtime codex ──────────────────────────────────────────────────────
+test("T2 runtime=codex forwards --runtime codex", () => {
+  const h = makeDeps();
+  const { exitCode } = runUnifiedInit({ runtime: "codex" }, h.deps);
+  assert.strictEqual(exitCode, 0);
+  for (const kit of RUNTIME_KITS) {
+    assert.deepStrictEqual(argvFor(h.spawnCalls, kit), ["init", "--runtime", "codex"]);
+  }
+});
+
+// ── T3 — flag forwarding (runtime subset vs full) ───────────────────────────
+test("T3 forwards shared flags to runtime kits; only subset to design/wiki", () => {
+  const h = makeDeps();
+  const opts = {
+    runtime: "claude",
+    runtimeScope: "user",
+    projectPath: "/tmp/proj",
+    force: true,
+    skipRuntimeAssets: true,
+    verbose: true,
+  };
+  runUnifiedInit(opts, h.deps);
+
+  for (const kit of RUNTIME_KITS) {
+    const argv = argvFor(h.spawnCalls, kit);
+    assert.deepStrictEqual(
+      argv,
+      [
+        "init",
+        "--runtime",
+        "claude",
+        "--runtime-scope",
+        "user",
+        "--project-path",
+        "/tmp/proj",
+        "--force",
+        "--skip-runtime-assets",
+        "--verbose",
+      ],
+      `${kit} full forward`
+    );
+  }
+  for (const kit of NON_RUNTIME_KITS) {
+    const argv = argvFor(h.spawnCalls, kit);
+    assert.deepStrictEqual(
+      argv,
+      ["init", "--project-path", "/tmp/proj", "--force", "--verbose"],
+      `${kit} subset`
+    );
+    assert.ok(!argv.includes("--runtime"), `${kit} must not get --runtime`);
+    assert.ok(!argv.includes("--runtime-scope"), `${kit} must not get --runtime-scope`);
+    assert.ok(!argv.includes("--skip-runtime-assets"), `${kit} must not get --skip-runtime-assets`);
+  }
+});
+
+// ── T4 — missing/invalid runtime → exit 2, zero spawns ──────────────────────
+test("T4 missing runtime → exit 2, no spawns", () => {
+  const h = makeDeps();
+  const { exitCode } = runUnifiedInit({}, h.deps);
+  assert.strictEqual(exitCode, 2);
+  assert.strictEqual(h.spawnCalls.length, 0);
+});
+test("T4b invalid runtime → exit 2, no spawns", () => {
+  const h = makeDeps();
+  const { exitCode } = runUnifiedInit({ runtime: "bogus" }, h.deps);
+  assert.strictEqual(exitCode, 2);
+  assert.strictEqual(h.spawnCalls.length, 0);
+});
+
+// ── T5 — PowerShell missing → exit 3, zero spawns ───────────────────────────
+test("T5 powershell missing → exit 3, no spawns", () => {
+  const h = makeDeps({ psOk: false });
+  const { exitCode } = runUnifiedInit({ runtime: "claude" }, h.deps);
+  assert.strictEqual(exitCode, 3);
+  assert.strictEqual(h.spawnCalls.length, 0);
+});
+
+// ── T6 — order spec → ops → code → design → wiki ────────────────────────────
+test("T6 runs all five in registry order", () => {
+  const h = makeDeps();
+  runUnifiedInit({ runtime: "claude" }, h.deps);
+  const order = h.spawnCalls.map((c) => c.toolkit);
+  assert.deepStrictEqual(order, [
+    "sdtk-spec",
+    "sdtk-ops",
+    "sdtk-code",
+    "sdtk-design",
+    "sdtk-wiki",
+  ]);
+});
+
+// ── T7 — fail-fast default ──────────────────────────────────────────────────
+test("T7 fail-fast: middle failure stops subsequent toolkits, exit = child code", () => {
+  const h = makeDeps({ failures: { "sdtk-code": 7 } });
+  const { exitCode } = runUnifiedInit({ runtime: "claude" }, h.deps);
+  assert.strictEqual(exitCode, 7);
+  const order = h.spawnCalls.map((c) => c.toolkit);
+  assert.deepStrictEqual(order, ["sdtk-spec", "sdtk-ops", "sdtk-code"]);
+  assert.ok(!order.includes("sdtk-design"), "design must not be spawned after fail");
+  assert.ok(!order.includes("sdtk-wiki"), "wiki must not be spawned after fail");
+});
+
+// ── T8 — --keep-going ───────────────────────────────────────────────────────
+test("T8 keep-going: failure does not stop the rest; aggregate exit non-zero", () => {
+  const h = makeDeps({ failures: { "sdtk-code": 5 } });
+  const { exitCode, results } = runUnifiedInit({ runtime: "claude", keepGoing: true }, h.deps);
+  assert.strictEqual(exitCode, 5);
+  assert.strictEqual(h.spawnCalls.length, 5);
+  const failed = results.find((r) => r.name === "sdtk-code");
+  assert.strictEqual(failed.status, "FAILED");
+  const wiki = results.find((r) => r.name === "sdtk-wiki");
+  assert.strictEqual(wiki.status, "OK");
+});
+
+// ── T9 — unresolvable kit → exit 4 naming the kit ───────────────────────────
+test("T9 unresolvable kit → exit 4, names the kit, fail-fast no spawn", () => {
+  const h = makeDeps({ unresolvable: new Set(["sdtk-spec-kit"]) });
+  const { exitCode, results } = runUnifiedInit({ runtime: "claude" }, h.deps);
+  assert.strictEqual(exitCode, 4);
+  assert.strictEqual(h.spawnCalls.length, 0, "no spawns once first kit unresolvable (fail-fast)");
+  assert.ok(results[0].statusLabel.includes("sdtk-spec-kit"), "kit named in status");
+});
+test("T9b unresolvable kit with --keep-going continues, exit 4", () => {
+  const h = makeDeps({ unresolvable: new Set(["sdtk-ops-kit"]) });
+  const { exitCode } = runUnifiedInit({ runtime: "claude", keepGoing: true }, h.deps);
+  assert.strictEqual(exitCode, 4);
+  // spec + code + design + wiki spawn; ops is skipped (unresolvable)
+  const order = h.spawnCalls.map((c) => c.toolkit);
+  assert.deepStrictEqual(order, ["sdtk-spec", "sdtk-code", "sdtk-design", "sdtk-wiki"]);
+});
+
+// ── T10 — orchestrator only touches injected deps (no real fs/network/spawn) ─
+test("T10 orchestrator uses only injected deps (no real host access)", () => {
+  const h = makeDeps();
+  // Spy spawn/resolveBin do no real I/O. A successful run that records exactly
+  // the expected spy invocations proves the orchestrator never bypassed the seam.
+  runUnifiedInit({ runtime: "claude" }, h.deps);
+  assert.strictEqual(h.spawnCalls.length, 5, "all process work went through injected spawn");
+  assert.deepStrictEqual(h.resolveCalls, [
+    "sdtk-spec-kit",
+    "sdtk-ops-kit",
+    "sdtk-code-kit",
+    "sdtk-design-kit",
+    "sdtk-wiki-kit",
+  ]);
+  // buildInitArgs is pure: same input → same output, no side effects.
+  const a = buildInitArgs(TOOLKITS[0], { runtime: "claude" });
+  const b = buildInitArgs(TOOLKITS[0], { runtime: "claude" });
+  assert.deepStrictEqual(a, b);
+});
+
+// ── runner ──────────────────────────────────────────────────────────────────
+let passed = 0;
+let failed = 0;
+for (const t of tests) {
+  try {
+    t.fn();
+    passed += 1;
+    console.log(`  ok  ${t.name}`);
+  } catch (err) {
+    failed += 1;
+    console.error(`FAIL  ${t.name}`);
+    console.error(`      ${err.message}`);
+  }
+}
+console.log("");
+console.log(`unified-init tests: ${passed} passed, ${failed} failed`);
+process.exit(failed === 0 ? 0 : 1);