@warpgogol/forge 2.8.0 → 2.8.2

package/src/tests/create.test.ts

@@ -0,0 +1,289 @@
+/*
+<MODULE_CONTRACT>
+<purpose>Unit tests for forge.create command — in-place scaffolding via scaffold + init + package-manager post-processing.</purpose>
+</MODULE_CONTRACT>
+<CHANGE_SUMMARY>
+  <item>RFC-0544: initial forge.create tests.</item>
+  <item>RFC-0877: rewrite tests for --in-place mode, add strict empty-directory check and name-derivation tests.</item>
+</CHANGE_SUMMARY>
+*/
+
+import { test, expect, beforeEach, afterEach } from "vitest";
+import { mkdtemp, rm, writeFile, mkdir } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { runCreate } from "../onboarding/create.ts";
+import { loadForgeConfig } from "../config/forge-config.ts";
+import type { ForgeRuntimeContext } from "../types.ts";
+
+const silentLogger = {
+  section: () => {},
+  info: () => {},
+  warn: () => {},
+  error: () => {},
+  success: () => {},
+};
+
+const FORGE_ROOT = join(import.meta.dirname, "..", "..");
+const _WORKSPACE_ROOT = join(FORGE_ROOT, "..", "..");
+
+function makeContext(workspaceRoot: string): ForgeRuntimeContext {
+  return {
+    workspaceRoot,
+    logger: silentLogger as never,
+    dryRun: false,
+    outputFormat: "json",
+    forgeRoot: FORGE_ROOT,
+  };
+}
+
+let tempDir: string;
+
+beforeEach(async () => {
+  tempDir = await mkdtemp(join(tmpdir(), "create-test-"));
+});
+
+afterEach(async () => {
+  await rm(tempDir, { recursive: true, force: true });
+});
+
+test("forge create --in-place scaffolds in cwd with forge.yaml and docs dirs", async () => {
+  const result = await runCreate(
+    { argv: [], flags: { "in-place": true, profile: "forge-shell", name: "my-project" } },
+    makeContext(tempDir),
+  );
+  expect(result.exitCode).toBe(0);
+  expect(result.data?.status).toBe("pass");
+
+  expect(existsSync(join(tempDir, "forge.yaml"))).toBe(true);
+  expect(existsSync(join(tempDir, "docs", "rfcs"))).toBe(true);
+  expect(existsSync(join(tempDir, "docs", "adrs"))).toBe(true);
+  expect(existsSync(join(tempDir, "PREFERENCES.md"))).toBe(true);
+  expect(existsSync(join(tempDir, "package.json"))).toBe(true);
+  expect(existsSync(join(tempDir, "scripts", "clean.mjs"))).toBe(true);
+}, 30000);
+
+test("forge create --in-place refuses when forge artifacts already exist", async () => {
+  await writeFile(join(tempDir, "forge.yaml"), "existing: true", "utf8");
+
+  const result = await runCreate(
+    { argv: [], flags: { "in-place": true, profile: "forge-shell", name: "my-project" } },
+    makeContext(tempDir),
+  );
+  expect(result.exitCode).toBe(1);
+  expect(result.data?.status).toBe("fail");
+  expect(result.data?.errors[0]).toContain("not empty");
+});
+
+test("forge create --in-place refuses when non-forge files exist in target directory", async () => {
+  await writeFile(join(tempDir, "some-file.txt"), "hello", "utf8");
+
+  const result = await runCreate(
+    { argv: [], flags: { "in-place": true, profile: "forge-shell", name: "my-project" } },
+    makeContext(tempDir),
+  );
+  expect(result.exitCode).toBe(1);
+  expect(result.data?.status).toBe("fail");
+  expect(result.data?.errors[0]).toContain("not empty");
+  expect(result.data?.errors[0]).toContain("some-file.txt");
+});
+
+test("forge create --in-place tolerates only .git directory in target directory", async () => {
+  await mkdir(join(tempDir, ".git"), { recursive: true });
+
+  const result = await runCreate(
+    { argv: [], flags: { "in-place": true, profile: "forge-shell", name: "my-project" } },
+    makeContext(tempDir),
+  );
+  expect(result.exitCode).toBe(0);
+  expect(result.data?.status).toBe("pass");
+  expect(existsSync(join(tempDir, "forge.yaml"))).toBe(true);
+  expect(existsSync(join(tempDir, ".git"))).toBe(true);
+}, 30000);
+
+test("forge create fails on non-kebab-case name", async () => {
+  const result = await runCreate(
+    { argv: [], flags: { "in-place": true, profile: "forge-shell", name: "MyProject" } },
+    makeContext(tempDir),
+  );
+  expect(result.exitCode).toBe(1);
+  expect(result.data?.status).toBe("fail");
+  expect(result.data?.errors[0]).toContain("kebab-case");
+});
+
+test("forge create fails on missing --in-place flag", async () => {
+  const result = await runCreate(
+    { argv: [], flags: { profile: "forge-shell", name: "my-project" } },
+    makeContext(tempDir),
+  );
+  expect(result.exitCode).toBe(1);
+  expect(result.data?.status).toBe("fail");
+  expect(result.data?.errors[0]).toContain("--in-place");
+});
+
+test("forge create fails on missing --profile flag", async () => {
+  const result = await runCreate(
+    { argv: [], flags: { "in-place": true, name: "my-project" } },
+    makeContext(tempDir),
+  );
+  expect(result.exitCode).toBe(1);
+  expect(result.data?.status).toBe("fail");
+  expect(result.data?.errors[0]).toContain("--profile");
+});
+
+test("forge create --in-place --profile forge-shell uses forge-shell profile", async () => {
+  const result = await runCreate(
+    { argv: [], flags: { "in-place": true, profile: "forge-shell", name: "my-project" } },
+    makeContext(tempDir),
+  );
+  expect(result.exitCode).toBe(0);
+  expect(result.data?.profile).toBe("forge-shell");
+}, 30000);
+
+test("forge create --package-manager npm writes npm into forge.yaml with npx bindings", async () => {
+  const result = await runCreate(
+    {
+      argv: [],
+      flags: {
+        "in-place": true,
+        profile: "forge-shell",
+        name: "my-project",
+        "package-manager": "npm",
+      },
+    },
+    makeContext(tempDir),
+  );
+  expect(result.exitCode).toBe(0);
+
+  const config = loadForgeConfig(tempDir);
+  expect(config.project.packageManager).toBe("npm");
+  expect(config.bindings?.commands.validateRfc).toContain("npx");
+  expect(config.bindings?.commands.validateRfc).toContain("forge rfc.validate");
+}, 30000);
+
+test("forge create --package-manager pnpm writes pnpm into forge.yaml", async () => {
+  const result = await runCreate(
+    {
+      argv: [],
+      flags: {
+        "in-place": true,
+        profile: "forge-shell",
+        name: "my-project",
+        "package-manager": "pnpm",
+      },
+    },
+    makeContext(tempDir),
+  );
+  expect(result.exitCode).toBe(0);
+
+  const config = loadForgeConfig(tempDir);
+  expect(config.project.packageManager).toBe("pnpm");
+  expect(config.bindings?.commands.validateRfc).toContain("pnpm exec");
+}, 30000);
+
+test("forge.yaml has non-null forge-CLI bindings and null stack bindings", async () => {
+  await runCreate(
+    { argv: [], flags: { "in-place": true, profile: "forge-shell", name: "my-project" } },
+    makeContext(tempDir),
+  );
+
+  const config = loadForgeConfig(tempDir);
+  expect(config.bindings?.commands.validateRfc).not.toBeNull();
+  expect(config.bindings?.commands.validateAdr).not.toBeNull();
+  expect(config.bindings?.commands.implementStamp).not.toBeNull();
+  expect(config.bindings?.commands.specValidate).not.toBeNull();
+  expect(config.bindings?.commands.sessionSave).not.toBeNull();
+  expect(config.bindings?.commands.typecheck).toBeNull();
+  expect(config.bindings?.commands.test).toBeNull();
+  expect(config.bindings?.commands.scopedBuild).toBeNull();
+}, 30000);
+
+test("forge.yaml has forge.syncedVersion set", async () => {
+  await runCreate(
+    { argv: [], flags: { "in-place": true, profile: "forge-shell", name: "my-project" } },
+    makeContext(tempDir),
+  );
+
+  const config = loadForgeConfig(tempDir);
+  expect(config.forge?.syncedVersion).toBeTruthy();
+}, 30000);
+
+test("result includes nextSteps with forge-bootstrap", async () => {
+  const result = await runCreate(
+    { argv: [], flags: { "in-place": true, profile: "forge-shell", name: "my-project" } },
+    makeContext(tempDir),
+  );
+  expect(result.exitCode).toBe(0);
+  expect(result.nextSteps).toBeDefined();
+  expect(result.nextSteps?.some((s) => s.action.includes("forge-bootstrap"))).toBe(true);
+  expect(result.nextSteps?.some((s) => s.kind === "required")).toBe(true);
+}, 30000);
+
+test("forge create generates AGENTS.md with behavioral layer (RFC-0548)", async () => {
+  const result = await runCreate(
+    { argv: [], flags: { "in-place": true, profile: "forge-shell", name: "my-project" } },
+    makeContext(tempDir),
+  );
+  expect(result.exitCode).toBe(0);
+
+  const agentsMdPath = join(tempDir, "AGENTS.md");
+  expect(existsSync(agentsMdPath)).toBe(true);
+
+  const { readFile: readFileAsync } = await import("node:fs/promises");
+  const agentsMd = await readFileAsync(agentsMdPath, "utf8");
+  expect(agentsMd).toContain("<!-- forge:begin behavioral-layer -->");
+  expect(agentsMd).toContain("<!-- forge:end behavioral-layer -->");
+  expect(agentsMd).toContain("### Intent-to-skill routing");
+}, 30000);
+
+test("forge create writes NEXT_STEPS.md with greenfield and transplant guidance (RFC-0550)", async () => {
+  const result = await runCreate(
+    { argv: [], flags: { "in-place": true, profile: "forge-shell", name: "my-project" } },
+    makeContext(tempDir),
+  );
+  expect(result.exitCode).toBe(0);
+
+  const nextStepsPath = join(tempDir, "NEXT_STEPS.md");
+  expect(existsSync(nextStepsPath)).toBe(true);
+
+  const { readFile: readFileAsync } = await import("node:fs/promises");
+  const nextSteps = await readFileAsync(nextStepsPath, "utf8");
+  expect(nextSteps).toContain("required");
+  expect(nextSteps).toContain("forge-bootstrap");
+  expect(nextSteps).toContain("language");
+  expect(result.data?.filesCreated).toContain("NEXT_STEPS.md");
+}, 30000);
+
+test("forge create root package.json has scripts and replaced project name", async () => {
+  const result = await runCreate(
+    { argv: [], flags: { "in-place": true, profile: "forge-shell", name: "my-project" } },
+    makeContext(tempDir),
+  );
+  expect(result.exitCode).toBe(0);
+
+  const { readFile: readFileAsync } = await import("node:fs/promises");
+  const pkgJson = JSON.parse(await readFileAsync(join(tempDir, "package.json"), "utf8"));
+  expect(pkgJson.name).toBe("my-project");
+  expect(pkgJson.scripts.clean).toBe("node scripts/clean.mjs");
+  expect(pkgJson.scripts.format).toBe("prettier --write .");
+  expect(pkgJson.scripts["format:check"]).toBe("prettier --check .");
+  expect(pkgJson.scripts.test).toBe("vitest run --passWithNoTests");
+  expect(pkgJson.scripts["upgrade-packages"]).toBe("pnpm up");
+}, 30000);
+
+test("forge create --in-place derives name from folder name when --name omitted", async () => {
+  const namedDir = join(tempDir, "my-derived-project");
+  await mkdir(namedDir, { recursive: true });
+
+  const result = await runCreate(
+    { argv: [], flags: { "in-place": true, profile: "forge-shell" } },
+    makeContext(namedDir),
+  );
+  expect(result.exitCode).toBe(0);
+  expect(result.data?.status).toBe("pass");
+
+  const { readFile: readFileAsync } = await import("node:fs/promises");
+  const pkgJson = JSON.parse(await readFileAsync(join(namedDir, "package.json"), "utf8"));
+  expect(pkgJson.name).toBe("my-derived-project");
+}, 30000);

package/src/tests/doctor-autonomy.test.ts

@@ -0,0 +1,98 @@
+/*
+<MODULE_CONTRACT>
+<purpose>Unit tests for forge.doctor autonomy guard — verifies @warpgogol/* import detection.</purpose>
+</MODULE_CONTRACT>
+<CHANGE_SUMMARY>
+  <item>RFC-0391: initial doctor autonomy guard tests.</item>
+</CHANGE_SUMMARY>
+*/
+
+import { test, expect, beforeEach, afterEach } from "vitest";
+import { mkdtemp, mkdir, writeFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { runDoctor } from "../onboarding/doctor.ts";
+import type { ForgeRuntimeContext, ForgeLogger } from "../types.ts";
+
+const mockLogger: ForgeLogger = {
+  section: () => {},
+  info: () => {},
+  warn: () => {},
+  error: () => {},
+  success: () => {},
+};
+
+const mockContext = (workspaceRoot: string): ForgeRuntimeContext => ({
+  workspaceRoot,
+  logger: mockLogger,
+  dryRun: false,
+  outputFormat: "json",
+});
+
+let tempDir: string;
+
+beforeEach(async () => {
+  tempDir = await mkdtemp(join(tmpdir(), "forge-doctor-test-"));
+});
+
+afterEach(async () => {
+  await rm(tempDir, { recursive: true, force: true });
+});
+
+test("doctor passes on clean tree with no @warpgogol/* imports", async () => {
+  await mkdir(join(tempDir, "packages", "forge", "src"), { recursive: true });
+  await writeFile(
+    join(tempDir, "packages", "forge", "package.json"),
+    '{"name":"@warpgogol/forge"}',
+    "utf8",
+  );
+  await writeFile(
+    join(tempDir, "packages", "forge", "src", "index.ts"),
+    "export const x = 1;",
+    "utf8",
+  );
+
+  const result = await runDoctor({ argv: [], flags: {} }, mockContext(tempDir));
+  const autonomyCheck = result.data?.checks.find((c) => c.name === "autonomy-guard");
+  expect(autonomyCheck?.status).toBe("pass");
+  expect(result.data?.forbiddenImports).toEqual([]);
+});
+
+test("doctor detects @warpgogol/* import specifiers", async () => {
+  await mkdir(join(tempDir, "packages", "forge", "src"), { recursive: true });
+  await writeFile(
+    join(tempDir, "packages", "forge", "package.json"),
+    '{"name":"@warpgogol/forge"}',
+    "utf8",
+  );
+  await writeFile(
+    join(tempDir, "packages", "forge", "src", "bad.ts"),
+    'import { foo } from "@warpgogol/werkstatt/kernel";\nexport const x = foo;',
+    "utf8",
+  );
+
+  const result = await runDoctor({ argv: [], flags: {} }, mockContext(tempDir));
+  const autonomyCheck = result.data?.checks.find((c) => c.name === "autonomy-guard");
+  expect(autonomyCheck?.status).toBe("fail");
+  expect(result.data?.forbiddenImports.length).toBe(1);
+  expect(result.data?.forbiddenImports[0]?.specifier).toBe("@warpgogol/werkstatt/kernel");
+});
+
+test("doctor ignores @warpgogol/* in comments", async () => {
+  await mkdir(join(tempDir, "packages", "forge", "src"), { recursive: true });
+  await writeFile(
+    join(tempDir, "packages", "forge", "package.json"),
+    '{"name":"@warpgogol/forge"}',
+    "utf8",
+  );
+  await writeFile(
+    join(tempDir, "packages", "forge", "src", "clean.ts"),
+    "/* Do not import from @warpgogol/werkstatt/kernel */\nexport const x = 1;",
+    "utf8",
+  );
+
+  const result = await runDoctor({ argv: [], flags: {} }, mockContext(tempDir));
+  const autonomyCheck = result.data?.checks.find((c) => c.name === "autonomy-guard");
+  expect(autonomyCheck?.status).toBe("pass");
+  expect(result.data?.forbiddenImports).toEqual([]);
+});

package/src/tests/doctor-bindings.test.ts

@@ -0,0 +1,286 @@
+/*
+<MODULE_CONTRACT>
+<purpose>Unit tests for forge.doctor defaultable-binding-null notices (RFC-0540).</purpose>
+</MODULE_CONTRACT>
+<CHANGE_SUMMARY>
+  <item>RFC-0540: initial doctor binding notices tests.</item>
+</CHANGE_SUMMARY>
+*/
+
+import { test, expect, beforeEach, afterEach } from "vitest";
+import { mkdtemp, mkdir, writeFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { runDoctor } from "../onboarding/doctor.ts";
+import type { ForgeRuntimeContext, ForgeLogger } from "../types.ts";
+
+const mockLogger: ForgeLogger = {
+  section: () => {},
+  info: () => {},
+  warn: () => {},
+  error: () => {},
+  success: () => {},
+};
+
+const mockContext = (workspaceRoot: string): ForgeRuntimeContext => ({
+  workspaceRoot,
+  logger: mockLogger,
+  dryRun: false,
+  outputFormat: "json",
+});
+
+let tempDir: string;
+
+beforeEach(async () => {
+  tempDir = await mkdtemp(join(tmpdir(), "forge-doctor-bindings-test-"));
+});
+
+afterEach(async () => {
+  await rm(tempDir, { recursive: true, force: true });
+});
+
+async function writeForgeYaml(dir: string, yaml: string): Promise<void> {
+  await writeFile(join(dir, "forge.yaml"), yaml, "utf8");
+}
+
+async function setupMinimalProject(dir: string): Promise<void> {
+  await mkdir(join(dir, "packages", "forge", "src"), { recursive: true });
+  await writeFile(
+    join(dir, "packages", "forge", "package.json"),
+    '{"name":"@warpgogol/forge"}',
+    "utf8",
+  );
+  await writeFile(join(dir, "packages", "forge", "src", "index.ts"), "export const x = 1;", "utf8");
+  await mkdir(join(dir, ".agents", "skills"), { recursive: true });
+  await mkdir(join(dir, "docs", "rfcs"), { recursive: true });
+  await mkdir(join(dir, "docs", "adrs"), { recursive: true });
+  await writeFile(join(dir, "AGENTS.md"), "# Test", "utf8");
+  await writeFile(join(dir, "PREFERENCES.md"), "# Test", "utf8");
+}
+
+test("doctor emits defaultable-binding-null notices for all 5 forge-CLI bindings when null", async () => {
+  await setupMinimalProject(tempDir);
+  await writeForgeYaml(
+    tempDir,
+    `schema: forge/config@1
+project:
+  name: test
+  stack: []
+  packageManager: pnpm
+paths:
+  rfcsDir: docs/rfcs
+  adrsDir: docs/adrs
+  plansDir: docs/plans
+  auditsDir: docs/audits
+  specsDir: docs/specs
+  skillsDir: .agents/skills
+bindings:
+  schema: forge/bindings@1
+  commands:
+    validateRfc: null
+    validateAdr: null
+    implementStamp: null
+    typecheck: null
+    test: null
+    scopedBuild: null
+    specValidate: null
+    sessionSave: null
+  paths:
+    invariantsFile: null
+    compassDocs: []
+    reviewsDir: null
+    handoffsDir: null
+    sessionsDir: null
+`,
+  );
+
+  const result = await runDoctor({ argv: [], flags: {} }, mockContext(tempDir));
+  const notices = result.data?.bindings?.notices ?? [];
+  expect(notices).toHaveLength(5);
+  const keys = notices.map((n) => n.key);
+  expect(keys).toContain("commands.validateRfc");
+  expect(keys).toContain("commands.validateAdr");
+  expect(keys).toContain("commands.implementStamp");
+  expect(keys).toContain("commands.specValidate");
+  expect(keys).toContain("commands.sessionSave");
+  for (const notice of notices) {
+    expect(notice.rule).toBe("defaultable-binding-null");
+    expect(notice.suggestion).toContain("pnpm exec forge");
+  }
+});
+
+test("doctor does NOT emit notices for non-null forge-CLI bindings (operator override)", async () => {
+  await setupMinimalProject(tempDir);
+  await writeForgeYaml(
+    tempDir,
+    `schema: forge/config@1
+project:
+  name: test
+  stack: []
+  packageManager: pnpm
+paths:
+  rfcsDir: docs/rfcs
+  adrsDir: docs/adrs
+  plansDir: docs/plans
+  auditsDir: docs/audits
+  specsDir: docs/specs
+  skillsDir: .agents/skills
+bindings:
+  schema: forge/bindings@1
+  commands:
+    validateRfc: "custom rfc validate command"
+    validateAdr: "custom adr validate command"
+    implementStamp: "custom stamp command"
+    typecheck: null
+    test: null
+    scopedBuild: null
+    specValidate: "custom spec validate command"
+    sessionSave: "custom session save command"
+  paths:
+    invariantsFile: null
+    compassDocs: []
+    reviewsDir: null
+    handoffsDir: null
+    sessionsDir: null
+`,
+  );
+
+  const result = await runDoctor({ argv: [], flags: {} }, mockContext(tempDir));
+  const notices = result.data?.bindings?.notices ?? [];
+  expect(notices).toHaveLength(0);
+});
+
+test("doctor emits zero notices when all forge-CLI bindings are non-null", async () => {
+  await setupMinimalProject(tempDir);
+  await writeForgeYaml(
+    tempDir,
+    `schema: forge/config@1
+project:
+  name: test
+  stack: []
+  packageManager: npm
+paths:
+  rfcsDir: docs/rfcs
+  adrsDir: docs/adrs
+  plansDir: docs/plans
+  auditsDir: docs/audits
+  specsDir: docs/specs
+  skillsDir: .agents/skills
+bindings:
+  schema: forge/bindings@1
+  commands:
+    validateRfc: "npx forge rfc.validate --id {id} --json"
+    validateAdr: "npx forge adr.validate --id {id} --json"
+    implementStamp: "npx forge rfc.implement.stamp --id {id} --implementation-commit {commit}"
+    typecheck: null
+    test: null
+    scopedBuild: null
+    specValidate: "npx forge spec.validate --spec={id} --json"
+    sessionSave: "npx forge session.save --json"
+  paths:
+    invariantsFile: null
+    compassDocs: []
+    reviewsDir: null
+    handoffsDir: null
+    sessionsDir: null
+`,
+  );
+
+  const result = await runDoctor({ argv: [], flags: {} }, mockContext(tempDir));
+  const notices = result.data?.bindings?.notices ?? [];
+  expect(notices).toHaveLength(0);
+});
+
+test("doctor notice suggestion uses npm runner when packageManager is npm", async () => {
+  await setupMinimalProject(tempDir);
+  await writeForgeYaml(
+    tempDir,
+    `schema: forge/config@1
+project:
+  name: test
+  stack: []
+  packageManager: npm
+paths:
+  rfcsDir: docs/rfcs
+  adrsDir: docs/adrs
+  plansDir: docs/plans
+  auditsDir: docs/audits
+  specsDir: docs/specs
+  skillsDir: .agents/skills
+bindings:
+  schema: forge/bindings@1
+  commands:
+    validateRfc: null
+    validateAdr: null
+    implementStamp: null
+    typecheck: null
+    test: null
+    scopedBuild: null
+    specValidate: null
+    sessionSave: null
+  paths:
+    invariantsFile: null
+    compassDocs: []
+    reviewsDir: null
+    handoffsDir: null
+    sessionsDir: null
+`,
+  );
+
+  const result = await runDoctor({ argv: [], flags: {} }, mockContext(tempDir));
+  const notices = result.data?.bindings?.notices ?? [];
+  expect(notices.length).toBeGreaterThan(0);
+  for (const notice of notices) {
+    expect(notice.suggestion).toContain("npx forge");
+  }
+});
+
+test("doctor detects directories as existing paths (regression: pathExists used readFile which throws EISDIR on dirs)", async () => {
+  await setupMinimalProject(tempDir);
+  await mkdir(join(tempDir, "docs", "sessions"), { recursive: true });
+  await writeForgeYaml(
+    tempDir,
+    `schema: forge/config@1
+project:
+  name: test
+  stack: []
+  packageManager: pnpm
+paths:
+  rfcsDir: docs/rfcs
+  adrsDir: docs/adrs
+  plansDir: docs/plans
+  auditsDir: docs/audits
+  specsDir: docs/specs
+  skillsDir: .agents/skills
+  sessionsDir: docs/sessions
+bindings:
+  schema: forge/bindings@1
+  commands:
+    validateRfc: "pnpm exec forge rfc.validate --id {id} --json"
+    validateAdr: "pnpm exec forge adr.validate --id {id} --json"
+    implementStamp: "pnpm exec forge rfc.implement.stamp --id {id} --implementation-commit {commit}"
+    typecheck: null
+    test: null
+    scopedBuild: null
+    specValidate: "pnpm exec forge spec.validate --spec={id} --json"
+    sessionSave: "pnpm exec forge session.save --json"
+  paths:
+    invariantsFile: null
+    compassDocs: []
+    reviewsDir: null
+    handoffsDir: null
+    sessionsDir: docs/sessions
+`,
+  );
+
+  const result = await runDoctor({ argv: [], flags: {} }, mockContext(tempDir));
+  const checks = result.data?.checks ?? [];
+  const skillsCheck = checks.find((c) => c.name === ".agents/skills/");
+  expect(skillsCheck?.status).toBe("pass");
+  const rfcsCheck = checks.find((c) => c.name === "docs/rfcs/");
+  expect(rfcsCheck?.status).toBe("pass");
+  const adrsCheck = checks.find((c) => c.name === "docs/adrs/");
+  expect(adrsCheck?.status).toBe("pass");
+  const bindingsCheck = checks.find((c) => c.name === "bindings");
+  expect(bindingsCheck?.status).toBe("pass");
+});