@guilz-dev/sdlc-gh 0.1.0

package/scripts/setup-wizard.mjs

@@ -0,0 +1,426 @@
+#!/usr/bin/env node
+import readline from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { execFileSync } from "node:child_process";
+import {
+  applyCodeownersOwner,
+  buildWizardPlan,
+  codeownersHasPlaceholder,
+  detectRepoProfile,
+  detectStackCandidates,
+  getStack,
+  ghReady,
+  isValidCodeownersOwner,
+  readHarnessStack,
+  resolveGithubRepo,
+  runBootstrap,
+  runDoctor,
+  runSetupGithub,
+  stackIds,
+  suggestStack,
+  writeHarnessStack,
+} from "./lib/setup-wizard.mjs";
+import { resolveTemplateRoot } from "./lib/template-root.mjs";
+import { postInstallHint } from "./lib/npm-package.mjs";
+
+function fail(message) {
+  console.error(message);
+  process.exit(1);
+}
+
+function resolveRepoRoot() {
+  try {
+    return execFileSync("git", ["rev-parse", "--show-toplevel"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+    }).trim();
+  } catch {
+    return process.cwd();
+  }
+}
+
+function parseArgs(argv) {
+  const args = {
+    repoRoot: "",
+    stack: "",
+    codeowners: "",
+    githubRepo: "",
+    mode: "",
+    yes: false,
+    skipGithub: false,
+    withEvalRuleset: false,
+    template: false,
+    dryRun: false,
+    bootstrap: false,
+    forceBootstrap: false,
+    patchCodeowners: false,
+    templateRoot: "",
+  };
+
+  for (let i = 0; i < argv.length; i += 1) {
+    const value = argv[i];
+    if (value === "--repo") {
+      args.repoRoot = argv[++i] ?? "";
+    } else if (value === "--stack") {
+      args.stack = argv[++i] ?? "";
+    } else if (value === "--codeowners" || value === "--codeowners-team") {
+      args.codeowners = argv[++i] ?? "";
+    } else if (value === "--github-repo") {
+      args.githubRepo = argv[++i] ?? "";
+    } else if (value === "--mode") {
+      args.mode = argv[++i] ?? "";
+    } else if (value === "--yes") {
+      args.yes = true;
+    } else if (value === "--skip-github") {
+      args.skipGithub = true;
+    } else if (value === "--with-eval-ruleset") {
+      args.withEvalRuleset = true;
+    } else if (value === "--template") {
+      args.template = true;
+    } else if (value === "--dry-run") {
+      args.dryRun = true;
+    } else if (value === "--bootstrap") {
+      args.bootstrap = true;
+    } else if (value === "--force-bootstrap") {
+      args.forceBootstrap = true;
+      args.bootstrap = true;
+    } else if (value === "--patch-codeowners") {
+      args.patchCodeowners = true;
+    } else if (value === "--template-root") {
+      args.templateRoot = argv[++i] ?? "";
+    } else if (value === "--help" || value === "-h") {
+      printUsage();
+      process.exit(0);
+    } else {
+      fail(`Unknown argument: ${value}`);
+    }
+  }
+  return args;
+}
+
+function printUsage() {
+  console.log(`Usage: setup-wizard.mjs [options]
+
+Interactive setup for Phase 0–1: .harness-stack, CODEOWNERS, GitHub labels/rulesets, doctor.
+
+Options:
+  --repo <path>              Repository root (default: git root)
+  --stack <id>               Primary stack (${stackIds().join("|")})
+  --codeowners @org/team     CODEOWNERS owner (team or @username)
+  --github-repo owner/name   GitHub repository for setup-github
+  --mode new|existing        Bootstrap mode when harness is missing
+  --template                 Template repo mode (multiple product-ci workflows)
+  --patch-codeowners         Replace CODEOWNERS placeholder (default off in --template mode)
+  --with-eval-ruleset        Also apply harness-pr-eval-required ruleset
+  --skip-github              Local files only; skip setup-github
+  --bootstrap                Force bootstrap when harness is missing
+  --force-bootstrap          Re-run bootstrap on an existing harness (overwrites assets)
+  --dry-run                  Print plan; skip mutating GitHub and doctor
+  --yes                      Non-interactive (requires stack + codeowners when configuring)
+  --template-root <path>     Harness template source (auto-detected when omitted)
+
+Examples:
+  npx @guilz-dev/sdlc-gh
+  ./scripts/setup-wizard.mjs
+  ./scripts/setup-wizard.mjs --template --yes --stack ts
+  ./scripts/setup-wizard.mjs --yes --stack ts --codeowners @acme/platform
+`);
+}
+
+async function ask(rl, question, defaultValue = "") {
+  const suffix = defaultValue ? ` [${defaultValue}]` : "";
+  const answer = (await rl.question(`${question}${suffix}: `)).trim();
+  return answer || defaultValue;
+}
+
+async function confirm(rl, summary, yes) {
+  if (yes) return true;
+  if (summary) console.log(summary);
+  const answer = (await rl.question("Proceed? [y/N]: ")).trim();
+  return /^(y|yes)$/i.test(answer);
+}
+
+async function resolveStack(rl, repoRoot, stackArg, yes) {
+  if (stackArg) {
+    getStack(stackArg);
+    return stackArg;
+  }
+
+  const existing = readHarnessStack(repoRoot);
+  if (existing) {
+    getStack(existing);
+    console.log(`Existing .harness-stack: ${existing}`);
+    if (yes) return existing;
+    const keep = await ask(rl, "Keep this stack? (y/n)", "y");
+    if (/^(y|yes)$/i.test(keep)) return existing;
+  }
+
+  const suggested = suggestStack(repoRoot);
+  if (suggested && !detectStackCandidates(repoRoot).ambiguous) {
+    console.log(`Detected stack: ${suggested}`);
+    if (yes) return suggested;
+    const answer = await ask(rl, "Use this stack? (y/n)", "y");
+    if (/^(y|yes)$/i.test(answer)) return suggested;
+  }
+
+  if (yes) fail("--stack is required with --yes when stack cannot be inferred.");
+
+  const detected = detectStackCandidates(repoRoot);
+  if (detected.rootMatches.length || detected.nestedMatches.length) {
+    for (const match of detected.rootMatches) {
+      console.log(`  root: ${match.stackId} (${match.path})`);
+    }
+    for (const match of detected.nestedMatches) {
+      console.log(`  nested: ${match.stackId} (${match.path})`);
+    }
+  }
+
+  const stack = await ask(rl, `Choose stack (${stackIds().join(", ")})`, suggested || "ts");
+  getStack(stack);
+  return stack;
+}
+
+async function resolveCodeowners(rl, codeownersArg, yes, required) {
+  if (codeownersArg) {
+    if (!isValidCodeownersOwner(codeownersArg)) fail(`Invalid CODEOWNERS owner: ${codeownersArg}`);
+    return codeownersArg.trim();
+  }
+  if (!required) return "";
+  if (yes) fail("--codeowners is required with --yes.");
+  const owner = await ask(rl, "CODEOWNERS owner (@org/team or @username)");
+  if (!isValidCodeownersOwner(owner)) fail(`Invalid CODEOWNERS owner: ${owner}`);
+  return owner.trim();
+}
+
+async function resolveBootstrapMode(rl, repoRoot, modeArg, yes) {
+  if (modeArg === "new" || modeArg === "existing") return modeArg;
+  if (yes) fail("--mode is required with --yes when bootstrapping.");
+
+  const answer = await ask(rl, "Bootstrap mode (new=copy sample to root, existing=keep product code)", "existing");
+  if (answer !== "new" && answer !== "existing") fail(`Unknown mode: ${answer}`);
+  return answer;
+}
+
+function printPlanHeader(plan) {
+  console.log("\nSetup wizard plan");
+  console.log(`  repo: ${plan.repoRoot}`);
+  console.log(`  profile: ${plan.template ? "template" : "product"}`);
+  console.log(`  stack: ${plan.stackId}`);
+  if (plan.owner) console.log(`  CODEOWNERS: ${plan.owner}`);
+  if (!plan.skipGithub) console.log(`  github: ${plan.githubRepo || "(auto-detect)"}`);
+  if (plan.withEvalRuleset) console.log("  eval ruleset: yes");
+  console.log("  steps:");
+  for (const step of plan.steps) {
+    console.log(`    - ${step.id}: ${step.detail}`);
+  }
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const repoRoot = args.repoRoot || resolveRepoRoot();
+  const profile = detectRepoProfile(repoRoot, { template: args.template });
+  const template = profile.template || args.template;
+  const wantsBootstrap = args.bootstrap || args.forceBootstrap;
+  const needsBootstrap = !profile.harnessPresent || wantsBootstrap;
+
+  if (args.templateRoot.trim()) {
+    process.env.SDLCGH_TEMPLATE_ROOT = args.templateRoot.trim();
+  }
+  let templateRoot = args.templateRoot.trim();
+  try {
+    templateRoot = resolveTemplateRoot({ fromModule: import.meta.url });
+  } catch (error) {
+    if (needsBootstrap) {
+      fail(error.message);
+    }
+    templateRoot = repoRoot;
+  }
+
+  if (profile.harnessPresent && wantsBootstrap && !args.forceBootstrap) {
+    fail(
+      "Harness assets already present. Omit --bootstrap or pass --force-bootstrap to overwrite (destructive).",
+    );
+  }
+
+  if (profile.harnessPresent && args.forceBootstrap && args.yes) {
+    fail("--force-bootstrap requires interactive confirmation; omit --yes.");
+  }
+
+  const nodeMajor = Number.parseInt(process.versions.node.split(".")[0], 10);
+  if (nodeMajor < 22) {
+    fail(`Node.js 22+ required (current: ${process.versions.node}).`);
+  }
+
+  const rl = readline.createInterface({ input, output });
+
+  try {
+    console.log("SDLC-GH setup wizard (Phase 0–1)\n");
+    console.log(`Repository: ${repoRoot}`);
+    console.log(`Profile: ${profile.kind}${template ? " (template mode)" : ""}`);
+
+    let stackId = args.stack;
+    let owner = args.codeowners;
+    let ranBootstrap = false;
+    let bootstrapMode = "";
+
+    if (needsBootstrap) {
+      if (args.forceBootstrap) {
+        console.log("\nWARNING: --force-bootstrap will overwrite harness assets in this repository.");
+      } else {
+        console.log("\nHarness assets not detected — bootstrap required.");
+      }
+      stackId = await resolveStack(rl, repoRoot, stackId, args.yes);
+      bootstrapMode = await resolveBootstrapMode(rl, repoRoot, args.mode, args.yes);
+      owner = await resolveCodeowners(rl, owner, args.yes, true);
+
+      const bootstrapSummary = [
+        "Bootstrap summary",
+        `  repo: ${repoRoot}`,
+        `  stack: ${stackId}`,
+        `  mode: ${bootstrapMode}`,
+        `  CODEOWNERS: ${owner}`,
+      ].join("\n");
+
+      if (!(await confirm(rl, bootstrapSummary, args.yes))) {
+        console.log("Cancelled.");
+        process.exit(1);
+      }
+
+      if (args.dryRun) {
+        console.log("[dry-run] bootstrap-harness.sh would run");
+      } else {
+        const bootstrapResult = runBootstrap({
+          repoRoot,
+          stackId,
+          mode: bootstrapMode,
+          owner,
+          yes: true,
+          templateRoot,
+        });
+        if (bootstrapResult.status !== 0) {
+          console.error(bootstrapResult.stderr || bootstrapResult.stdout);
+          fail("Bootstrap failed.");
+        }
+        if (bootstrapResult.stdout) console.log(bootstrapResult.stdout);
+        ranBootstrap = true;
+      }
+    } else {
+      stackId = await resolveStack(rl, repoRoot, stackId, args.yes);
+      if (template && !args.patchCodeowners) {
+        console.log("Template repo: keeping CODEOWNERS placeholder (pass --patch-codeowners to replace).");
+        if (args.codeowners) {
+          console.log("::notice::--codeowners ignored in template mode without --patch-codeowners.");
+        }
+      } else {
+        const needsOwner = codeownersHasPlaceholder(repoRoot);
+        if (needsOwner) {
+          owner = await resolveCodeowners(rl, owner, args.yes, true);
+        } else if (owner) {
+          if (!isValidCodeownersOwner(owner)) fail(`Invalid CODEOWNERS owner: ${owner}`);
+          owner = owner.trim();
+        } else {
+          console.log("CODEOWNERS: placeholder already replaced.");
+        }
+      }
+    }
+
+    const githubRepo = args.githubRepo || resolveGithubRepo(repoRoot);
+    if (!args.skipGithub && !args.dryRun) {
+      const gh = ghReady(repoRoot);
+      if (!gh.ok) fail(`${gh.reason}. Use --skip-github to configure local files only.`);
+    }
+
+    const allowCodeownersPatch = !template || args.patchCodeowners;
+    const willPatchCodeowners =
+      allowCodeownersPatch && Boolean(owner) && codeownersHasPlaceholder(repoRoot);
+    const ownerLabel = owner || "(unchanged)";
+
+    const plan = buildWizardPlan({
+      repoRoot,
+      stackId,
+      owner: ownerLabel,
+      githubRepo,
+      template,
+      withEvalRuleset: args.withEvalRuleset,
+      yes: args.yes,
+      skipGithub: args.skipGithub,
+      dryRun: args.dryRun,
+      writeHarnessStack: !ranBootstrap,
+      patchCodeowners: !ranBootstrap && willPatchCodeowners,
+    });
+
+    if (owner && !willPatchCodeowners && !ranBootstrap) {
+      console.log(
+        "::notice::CODEOWNERS placeholder already replaced; --codeowners ignored (edit .github/CODEOWNERS manually).",
+      );
+    }
+
+    if (ranBootstrap) {
+      plan.steps = plan.steps.filter((step) => step.id !== "harness-stack" && step.id !== "codeowners");
+    }
+
+    printPlanHeader({ ...plan, repoRoot, stackId, owner });
+
+    if (!(await confirm(rl, "", args.yes))) {
+      console.log("Cancelled.");
+      process.exit(1);
+    }
+
+    if (args.dryRun) {
+      console.log("\nDry run complete.");
+      process.exit(0);
+    }
+
+    if (!ranBootstrap) {
+      writeHarnessStack(repoRoot, stackId);
+      if (willPatchCodeowners) {
+        applyCodeownersOwner(repoRoot, owner);
+      }
+    }
+
+    if (!args.skipGithub) {
+      const setupResult = runSetupGithub({
+        repoRoot,
+        githubRepo,
+        withEvalRuleset: args.withEvalRuleset,
+        yes: true,
+        dryRun: false,
+      });
+      if (setupResult.status !== 0) {
+        console.error(setupResult.stderr || setupResult.stdout);
+        fail("setup-github failed.");
+      }
+      console.log(setupResult.stdout || "GitHub setup complete.");
+    }
+
+    const doctorResult = runDoctor({ repoRoot, template, strict: true });
+    if (doctorResult.stdout) console.log(doctorResult.stdout);
+    if (doctorResult.stderr) console.error(doctorResult.stderr);
+
+    if (doctorResult.status !== 0) {
+      fail("doctor --strict reported failures. Fix the items above and re-run.");
+    }
+
+    console.log("\nSetup wizard complete.");
+    if (template) {
+      console.log("Template repo: CODEOWNERS remains placeholder-only; commit .harness-stack is gitignored.");
+    } else {
+      console.log("Next: commit CODEOWNERS and open a test PR to verify required checks.");
+    }
+    if (ranBootstrap && bootstrapMode === "new") {
+      console.log(postInstallHint(stackId));
+    }
+    if (profile.harnessPresent && !ranBootstrap && templateRoot !== repoRoot) {
+      console.log(
+        "Harness already present — bootstrap was skipped. To refresh harness assets from a newer package, re-run with `--force-bootstrap` (destructive).",
+      );
+    }
+    console.log("Then: run `npm run check-l1-readiness` before starting spec-driven L1 delegation.");
+  } finally {
+    rl.close();
+  }
+}
+
+main().catch((error) => {
+  fail(error.message);
+});

package/scripts/test-bootstrap-guidance-scenarios.mjs

@@ -0,0 +1,94 @@
+#!/usr/bin/env node
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { spawnSync } from "node:child_process";
+
+const ROOT = resolve(process.cwd());
+const scriptPath = join(ROOT, "scripts/bootstrap-harness.sh");
+
+function runBootstrap({
+  repoPath,
+  extraEnv = {},
+}) {
+  return spawnSync(
+    scriptPath,
+    [
+      "--repo",
+      repoPath,
+      "--stack",
+      "ts",
+      "--mode",
+      "new",
+      "--codeowners-team",
+      "@acme/platform",
+      "--yes",
+    ],
+    {
+      cwd: ROOT,
+      encoding: "utf8",
+      env: {
+        ...process.env,
+        ...extraEnv,
+      },
+    },
+  );
+}
+
+const noGhRepoDir = mkdtempSync(join(tmpdir(), "sdlc-gh-guidance-no-gh-"));
+const noGhRepo = join(noGhRepoDir, "repo");
+mkdirSync(noGhRepo, { recursive: true });
+const noGhResult = runBootstrap({ repoPath: noGhRepo });
+assert.equal(noGhResult.status, 0, noGhResult.stderr);
+assert.match(
+  noGhResult.stdout,
+  /Next: npx @guilz-dev\/sdlc-gh --yes --stack ts --codeowners @acme\/platform/,
+);
+assert.match(
+  noGhResult.stdout,
+  /setup-wizard\.mjs --yes --stack ts --codeowners @acme\/platform --github-repo OWNER\/REPO/,
+);
+
+const fakeBinDir = mkdtempSync(join(tmpdir(), "sdlc-gh-guidance-bin-"));
+const fakeGh = join(fakeBinDir, "gh");
+writeFileSync(
+  fakeGh,
+  `#!/bin/sh
+if [ "$1" = "repo" ] && [ "$2" = "view" ] && [ "$3" = "--json" ] && [ "$4" = "nameWithOwner" ]; then
+  printf '{"nameWithOwner":"acme/test-repo"}\\n'
+  exit 0
+fi
+exit 1
+`,
+  { mode: 0o755 },
+);
+
+const ghRepoDir = mkdtempSync(join(tmpdir(), "sdlc-gh-guidance-gh-"));
+const ghRepo = join(ghRepoDir, "repo");
+mkdirSync(ghRepo, { recursive: true });
+const gitInit = spawnSync("git", ["init"], {
+  cwd: ghRepo,
+  encoding: "utf8",
+});
+assert.equal(gitInit.status, 0, gitInit.stderr);
+const ghResult = runBootstrap({
+  repoPath: ghRepo,
+  extraEnv: {
+    PATH: `${fakeBinDir}:${process.env.PATH}`,
+  },
+});
+assert.equal(ghResult.status, 0, ghResult.stderr);
+assert.match(
+  ghResult.stdout,
+  /Next: npx @guilz-dev\/sdlc-gh --yes --stack ts --codeowners @acme\/platform/,
+);
+assert.doesNotMatch(
+  ghResult.stdout,
+  /npx @guilz-dev\/sdlc-gh --yes --stack ts --codeowners @acme\/platform --github-repo OWNER\/REPO/,
+);
+
+const copiedTest = readFileSync(join(ghRepo, "scripts/test-bootstrap-guidance-scenarios.mjs"), "utf8");
+assert.ok(copiedTest.includes("setup-wizard.mjs"));
+
+console.log("Bootstrap guidance scenario tests passed");

package/scripts/test-diff-size-scenarios.mjs

@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+import assert from "node:assert/strict";
+import {
+  aggregateDiffStats,
+  evaluateDiffSize,
+  resolveAutonomyLevel,
+  resolveEnforcementMode,
+  resolveLimits,
+} from "./lib/diff-size.mjs";
+
+// no label / L1 default warn
+const l1Default = evaluateDiffSize({
+  labels: [],
+  numstatText: "400\t0\tbig.ts",
+});
+assert.equal(l1Default.level, "L1");
+assert.equal(l1Default.mode, "warn");
+assert.equal(l1Default.overLimit, true);
+
+// L1 hard-fail opt-in
+const l1Hard = evaluateDiffSize({
+  labels: ["autonomy:L1"],
+  numstatText: "400\t0\tbig.ts",
+  l1HardFail: true,
+});
+assert.equal(l1Hard.mode, "hard-fail");
+assert.equal(l1Hard.overLimit, true);
+
+// L2 over-limit fail
+const l2 = evaluateDiffSize({
+  labels: ["autonomy:L2"],
+  numstatText: "150\t0\ta.ts\n10\t0\tb.ts\n10\t0\tc.ts\n10\t0\td.ts\n10\t0\te.ts",
+});
+assert.equal(l2.level, "L2");
+assert.equal(l2.mode, "hard-fail");
+assert.equal(l2.overLimit, true);
+assert.equal(resolveLimits("L2").loc, 120);
+
+// L3 over-limit fail
+const l3 = evaluateDiffSize({
+  labels: ["autonomy:L3"],
+  numstatText: "70\t0\ta.ts\n10\t0\tb.ts\n10\t0\tc.ts",
+});
+assert.equal(l3.level, "L3");
+assert.equal(l3.mode, "hard-fail");
+assert.equal(l3.overLimit, true);
+
+// infra-sensitive path changed without task:infra warns
+const infra = evaluateDiffSize({
+  labels: ["task:docs", "autonomy:L1"],
+  numstatText: "5\t0\tREADME.md",
+  diffFiles: [".github/workflows/harness-ci.yml"],
+});
+assert.equal(infra.sensitiveWarnings.length, 1);
+assert.match(infra.sensitiveWarnings[0], /task:infra/);
+
+const infraOk = evaluateDiffSize({
+  labels: ["task:infra", "autonomy:L0"],
+  numstatText: "5\t0\t.github/workflows/harness-ci.yml",
+  diffFiles: [".github/workflows/harness-ci.yml"],
+});
+assert.equal(infraOk.sensitiveWarnings.length, 0);
+
+// L0 proposal-only: no size limits enforced (behavior/spec correction vs legacy L0→L1 fallback)
+const l0Huge = evaluateDiffSize({
+  labels: ["autonomy:L0"],
+  numstatText: "5000\t0\ta.ts\n5000\t0\tb.ts",
+});
+assert.equal(l0Huge.level, "L0");
+assert.equal(l0Huge.mode, "proposal-only");
+assert.equal(l0Huge.limits, null);
+assert.equal(l0Huge.overLimit, false);
+
+// within limits passes
+const ok = evaluateDiffSize({
+  labels: ["autonomy:L2"],
+  numstatText: "50\t0\ta.ts",
+});
+assert.equal(ok.overLimit, false);
+
+assert.equal(resolveAutonomyLevel(["autonomy:L3"]), "L3");
+assert.equal(resolveAutonomyLevel(["autonomy:L2"]), "L2");
+assert.equal(resolveAutonomyLevel(["autonomy:L0"]), "L0");
+assert.equal(resolveEnforcementMode("L1"), "warn");
+assert.equal(resolveEnforcementMode("L1", { l1HardFail: true }), "hard-fail");
+assert.equal(aggregateDiffStats("10\t5\tfile.ts").loc, 15);
+
+console.log("Diff-size scenario tests passed");

package/scripts/test-doctor-scenarios.mjs

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { localChecks } from "./lib/doctor-local.mjs";
+
+const tempDir = mkdtempSync(join(tmpdir(), "sdlc-gh-doctor-"));
+
+mkdirSync(join(tempDir, ".github/workflows"), { recursive: true });
+writeFileSync(join(tempDir, ".harness-stack"), "ts\n");
+writeFileSync(join(tempDir, ".github/workflows/product-ci-ts.yml"), "name: product-ci-ts\n");
+writeFileSync(
+  join(tempDir, ".github/CODEOWNERS"),
+  "* @my-org/harness-engineers\n",
+);
+
+const healthy = localChecks(tempDir, { nodeVersion: "22.0.0" });
+assert.ok(healthy.entries.every((entry) => entry.status === "PASS"));
+assert.equal(healthy.stackId, "ts");
+
+const missingDir = mkdtempSync(join(tmpdir(), "sdlc-gh-doctor-missing-"));
+mkdirSync(join(missingDir, ".github/workflows"), { recursive: true });
+writeFileSync(join(missingDir, ".github/CODEOWNERS"), "* @my-org/harness-engineers\n");
+const noStack = localChecks(missingDir, { nodeVersion: "22.0.0" });
+assert.ok(noStack.entries.some((e) => e.label === ".harness-stack" && e.status === "FAIL"));
+assert.ok(noStack.entries.some((e) => e.label === "product-ci workflow" && e.status === "FAIL"));
+
+const inferredDir = mkdtempSync(join(tmpdir(), "sdlc-gh-doctor-inferred-"));
+mkdirSync(join(inferredDir, ".github/workflows"), { recursive: true });
+writeFileSync(join(inferredDir, ".github/workflows/product-ci-python.yml"), "name: product-ci-python\n");
+writeFileSync(join(inferredDir, ".github/CODEOWNERS"), "* @my-org/harness-engineers\n");
+const inferred = localChecks(inferredDir, { nodeVersion: "22.0.0" });
+assert.equal(inferred.stackId, "python");
+assert.ok(inferred.entries.some((e) => e.label === ".harness-stack" && e.status === "PASS" && e.detail.includes("inferred python")));
+
+const placeholderDir = mkdtempSync(join(tmpdir(), "sdlc-gh-doctor-placeholder-"));
+mkdirSync(join(placeholderDir, ".github/workflows"), { recursive: true });
+writeFileSync(join(placeholderDir, ".harness-stack"), "python\n");
+writeFileSync(join(placeholderDir, ".github/workflows/product-ci-python.yml"), "name: product-ci-python\n");
+writeFileSync(
+  join(placeholderDir, ".github/CODEOWNERS"),
+  "* @your-org/harness-engineers\n",
+);
+const placeholder = localChecks(placeholderDir, { nodeVersion: "22.0.0" });
+assert.ok(placeholder.entries.some((e) => e.label === "CODEOWNERS" && e.status === "FAIL"));
+
+const oldNode = localChecks(tempDir, { nodeVersion: "20.0.0" });
+assert.ok(oldNode.entries.some((e) => e.label === "Node.js" && e.status === "FAIL"));
+
+const templateMulti = mkdtempSync(join(tmpdir(), "sdlc-gh-doctor-template-"));
+mkdirSync(join(templateMulti, ".github/workflows"), { recursive: true });
+writeFileSync(join(templateMulti, ".harness-stack"), "ts\n");
+writeFileSync(join(templateMulti, ".github/workflows/product-ci-ts.yml"), "name: product-ci-ts\n");
+writeFileSync(join(templateMulti, ".github/workflows/product-ci-go.yml"), "name: product-ci-go\n");
+writeFileSync(join(templateMulti, ".github/CODEOWNERS"), "* @your-org/harness-engineers\n");
+const templateMode = localChecks(templateMulti, { nodeVersion: "22.0.0", templateMode: true });
+assert.ok(templateMode.entries.some((e) => e.label === "product-ci workflow" && e.status === "PASS"));
+assert.ok(templateMode.entries.some((e) => e.label === "CODEOWNERS" && e.status === "PASS"));
+
+const templatePersonalized = mkdtempSync(join(tmpdir(), "sdlc-gh-doctor-template-personal-"));
+mkdirSync(join(templatePersonalized, ".github/workflows"), { recursive: true });
+writeFileSync(join(templatePersonalized, ".harness-stack"), "ts\n");
+writeFileSync(join(templatePersonalized, ".github/workflows/product-ci-ts.yml"), "name: product-ci-ts\n");
+writeFileSync(join(templatePersonalized, ".github/workflows/product-ci-go.yml"), "name: product-ci-go\n");
+writeFileSync(join(templatePersonalized, ".github/CODEOWNERS"), "* @acme/platform\n");
+const templatePersonal = localChecks(templatePersonalized, { nodeVersion: "22.0.0", templateMode: true });
+assert.ok(templatePersonal.entries.some((e) => e.label === "CODEOWNERS" && e.status === "FAIL"));
+
+console.log("Doctor scenario tests passed");