@warpgogol/forge 2.7.0 → 2.8.1

package/src/tests/adr-implement-stamp.test.ts

@@ -0,0 +1,368 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { mkdtemp, rm, mkdir, writeFile, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { execFileSync } from "node:child_process";
+
+import { runAdrImplementStamp } from "../../os/adr/handlers/implement-stamp.ts";
+import type { ForgeCommandInput, ForgeRuntimeContext, ForgeLogger } from "../../src/types.ts";
+
+// ─── Test helpers ─────────────────────────────────────────────────────────────
+
+const noopLogger: ForgeLogger = {
+  section: () => {},
+  info: () => {},
+  warn: () => {},
+  error: () => {},
+  success: () => {},
+};
+
+function makeContext(workspaceRoot: string): ForgeRuntimeContext {
+  return {
+    workspaceRoot,
+    logger: noopLogger,
+    dryRun: false,
+    outputFormat: "json",
+  };
+}
+
+function makeInput(id: string, commit: string, dryRun?: boolean): ForgeCommandInput {
+  return {
+    argv: [],
+    flags: {
+      id,
+      "implementation-commit": commit,
+      ...(dryRun ? { "dry-run": true } : {}),
+    },
+  };
+}
+
+const ADR_BODY = (id: string, status: string): string => `---
+id: ${id}
+title: "Test ADR"
+status: ${status}
+scope: workspace
+decider: human:test
+createdAt: 2026-08-01
+updatedAt: 2026-08-01
+---
+
+# ${id}: Test ADR
+
+## Context
+
+Test context.
+
+## Decision
+
+Test decision.
+
+## Justification
+
+Test justification.
+
+## Consequences
+
+Test consequences.
+
+## Evolution
+
+Test evolution.
+`;
+
+async function makeGitRepo(dir: string): Promise<void> {
+  execFileSync("git", ["init"], { cwd: dir, timeout: 5000 });
+  execFileSync("git", ["config", "user.email", "test@test.com"], { cwd: dir, timeout: 5000 });
+  execFileSync("git", ["config", "user.name", "Test"], { cwd: dir, timeout: 5000 });
+}
+
+async function commitAll(dir: string, message: string): Promise<string> {
+  execFileSync("git", ["add", "-A"], { cwd: dir, timeout: 5000 });
+  execFileSync("git", ["commit", "-m", message], { cwd: dir, timeout: 5000 });
+  return execFileSync("git", ["rev-parse", "HEAD"], { cwd: dir, timeout: 5000 }).toString().trim();
+}
+
+// ─── Tests ────────────────────────────────────────────────────────────────────
+
+describe("adr.implement.stamp", () => {
+  let workspaceRoot: string;
+
+  beforeEach(async () => {
+    workspaceRoot = await mkdtemp(join(tmpdir(), "adr-stamp-test-"));
+    await mkdir(join(workspaceRoot, "docs", "adrs"), { recursive: true });
+    await makeGitRepo(workspaceRoot);
+  });
+
+  afterEach(async () => {
+    await rm(workspaceRoot, { recursive: true, force: true });
+  });
+
+  // ── ADR-IMP-01: status checks ───────────────────────────────────────────────
+
+  it("rejects ADR with status superseded", async () => {
+    await writeFile(
+      join(workspaceRoot, "docs", "adrs", "adr-0001-test.md"),
+      ADR_BODY("ADR-0001", "superseded"),
+    );
+    const sha = await commitAll(workspaceRoot, "initial");
+
+    const result = await runAdrImplementStamp(
+      makeInput("ADR-0001", sha),
+      makeContext(workspaceRoot),
+    );
+
+    expect(result.data?.status).toBe("fail");
+    expect(result.data?.violations.some((v) => v.rule === "ADR-IMP-01")).toBe(true);
+    expect(result.exitCode).toBe(1);
+  });
+
+  it("rejects ADR with status reviewing", async () => {
+    await writeFile(
+      join(workspaceRoot, "docs", "adrs", "adr-0001-test.md"),
+      ADR_BODY("ADR-0001", "reviewing"),
+    );
+    const sha = await commitAll(workspaceRoot, "initial");
+
+    const result = await runAdrImplementStamp(
+      makeInput("ADR-0001", sha),
+      makeContext(workspaceRoot),
+    );
+
+    expect(result.data?.status).toBe("fail");
+    expect(result.data?.violations.some((v) => v.rule === "ADR-IMP-01")).toBe(true);
+  });
+
+  it("rejects ADR with status implemented (already done)", async () => {
+    await writeFile(
+      join(workspaceRoot, "docs", "adrs", "adr-0001-test.md"),
+      ADR_BODY("ADR-0001", "implemented"),
+    );
+    const sha = await commitAll(workspaceRoot, "initial");
+
+    const result = await runAdrImplementStamp(
+      makeInput("ADR-0001", sha),
+      makeContext(workspaceRoot),
+    );
+
+    expect(result.data?.status).toBe("fail");
+    expect(result.data?.violations.some((v) => v.rule === "ADR-IMP-01")).toBe(true);
+  });
+
+  it("rejects ADR not found", async () => {
+    await writeFile(join(workspaceRoot, "dummy.txt"), "test");
+    const sha = await commitAll(workspaceRoot, "initial");
+
+    const result = await runAdrImplementStamp(
+      makeInput("ADR-9999", sha),
+      makeContext(workspaceRoot),
+    );
+
+    expect(result.data?.status).toBe("fail");
+    expect(result.data?.violations.some((v) => v.rule === "ADR-IMP-01")).toBe(true);
+  });
+
+  // ── ADR-IMP-03: commit validation ───────────────────────────────────────────
+
+  it("rejects commit not reachable from HEAD", async () => {
+    await writeFile(
+      join(workspaceRoot, "docs", "adrs", "adr-0001-test.md"),
+      ADR_BODY("ADR-0001", "accepted"),
+    );
+    await commitAll(workspaceRoot, "initial commit ADR-0001");
+
+    // Create a divergent commit
+    await writeFile(join(workspaceRoot, "dummy.txt"), "test");
+    const sha1 = await commitAll(workspaceRoot, "first");
+    execFileSync("git", ["reset", "--hard", "HEAD~1"], { cwd: workspaceRoot, timeout: 5000 });
+    await writeFile(join(workspaceRoot, "other.txt"), "test");
+    await commitAll(workspaceRoot, "second");
+
+    const result = await runAdrImplementStamp(
+      makeInput("ADR-0001", sha1),
+      makeContext(workspaceRoot),
+    );
+
+    expect(result.data?.status).toBe("fail");
+    expect(result.data?.violations.some((v) => v.rule === "ADR-IMP-03")).toBe(true);
+  });
+
+  it("rejects commit that does not reference ADR id", async () => {
+    await writeFile(
+      join(workspaceRoot, "docs", "adrs", "adr-0001-test.md"),
+      ADR_BODY("ADR-0001", "accepted"),
+    );
+    await commitAll(workspaceRoot, "add ADR");
+
+    await writeFile(join(workspaceRoot, "code.ts"), "console.log('hello');");
+    const sha = await commitAll(workspaceRoot, "add code without ADR reference");
+
+    const result = await runAdrImplementStamp(
+      makeInput("ADR-0001", sha),
+      makeContext(workspaceRoot),
+    );
+
+    expect(result.data?.status).toBe("fail");
+    expect(result.data?.violations.some((v) => v.rule === "ADR-IMP-03")).toBe(true);
+  });
+
+  it("passes when commit message references ADR id", async () => {
+    await writeFile(
+      join(workspaceRoot, "docs", "adrs", "adr-0001-test.md"),
+      ADR_BODY("ADR-0001", "accepted"),
+    );
+    await commitAll(workspaceRoot, "add ADR-0001");
+
+    await writeFile(join(workspaceRoot, "code.ts"), "console.log('hello');");
+    const sha = await commitAll(workspaceRoot, "implement: ADR-0001 add feature");
+
+    const result = await runAdrImplementStamp(
+      makeInput("ADR-0001", sha),
+      makeContext(workspaceRoot),
+    );
+
+    expect(result.data?.status).toBe("pass");
+    expect(result.exitCode).toBe(0);
+  });
+
+  it("passes when commit changed files contain ADR slug", async () => {
+    await writeFile(
+      join(workspaceRoot, "docs", "adrs", "adr-0001-test.md"),
+      ADR_BODY("ADR-0001", "accepted"),
+    );
+    await commitAll(workspaceRoot, "add ADR-0001");
+
+    // Commit touches the ADR file itself (slug "adr-0001" is in the path)
+    await writeFile(
+      join(workspaceRoot, "docs", "adrs", "adr-0001-test.md"),
+      ADR_BODY("ADR-0001", "accepted") + "\n<!-- update -->\n",
+    );
+    const sha = await commitAll(workspaceRoot, "update adr-0001 file");
+
+    const result = await runAdrImplementStamp(
+      makeInput("ADR-0001", sha),
+      makeContext(workspaceRoot),
+    );
+
+    expect(result.data?.status).toBe("pass");
+  });
+
+  // ── ADR-IMP-04: file cleanliness ─────────────────────────────────────────────
+
+  it("rejects when ADR file has uncommitted changes", async () => {
+    await writeFile(
+      join(workspaceRoot, "docs", "adrs", "adr-0001-test.md"),
+      ADR_BODY("ADR-0001", "accepted"),
+    );
+    const sha = await commitAll(workspaceRoot, "add ADR-0001");
+
+    // Make uncommitted change to the ADR file
+    await writeFile(
+      join(workspaceRoot, "docs", "adrs", "adr-0001-test.md"),
+      ADR_BODY("ADR-0001", "accepted") + "\n<!-- dirty -->\n",
+    );
+
+    const result = await runAdrImplementStamp(
+      makeInput("ADR-0001", sha),
+      makeContext(workspaceRoot),
+    );
+
+    expect(result.data?.status).toBe("fail");
+    expect(result.data?.violations.some((v) => v.rule === "ADR-IMP-04")).toBe(true);
+  });
+
+  // ── ADR-IMP-05: concurrent lock ──────────────────────────────────────────────
+
+  it("rejects when a concurrent lock is held", async () => {
+    await writeFile(
+      join(workspaceRoot, "docs", "adrs", "adr-0001-test.md"),
+      ADR_BODY("ADR-0001", "accepted"),
+    );
+    const sha = await commitAll(workspaceRoot, "implement: ADR-0001 add feature");
+
+    // Pre-create the lock file to simulate a concurrent stamp
+    await mkdir(join(workspaceRoot, ".adr-locks"), { recursive: true });
+    await writeFile(
+      join(workspaceRoot, ".adr-locks", "adr-0001.lock"),
+      JSON.stringify({ pid: 99999, acquiredAt: new Date().toISOString() }),
+    );
+
+    const result = await runAdrImplementStamp(
+      makeInput("ADR-0001", sha),
+      makeContext(workspaceRoot),
+    );
+
+    expect(result.data?.status).toBe("fail");
+    expect(result.data?.violations.some((v) => v.rule === "ADR-IMP-05")).toBe(true);
+  });
+
+  // ── Dry-run ──────────────────────────────────────────────────────────────────
+
+  it("dry-run checks preconditions without mutating file", async () => {
+    const adrPath = join(workspaceRoot, "docs", "adrs", "adr-0001-test.md");
+    await writeFile(adrPath, ADR_BODY("ADR-0001", "accepted"));
+    await commitAll(workspaceRoot, "add ADR-0001");
+
+    await writeFile(join(workspaceRoot, "code.ts"), "console.log('hello');");
+    const sha = await commitAll(workspaceRoot, "implement: ADR-0001 add feature");
+
+    const originalContent = await readFile(adrPath, "utf-8");
+
+    const result = await runAdrImplementStamp(
+      makeInput("ADR-0001", sha, true),
+      makeContext(workspaceRoot),
+    );
+
+    expect(result.data?.status).toBe("pass");
+    expect(result.data?.data?.adrId).toBe("ADR-0001");
+
+    // File should not be mutated
+    const afterContent = await readFile(adrPath, "utf-8");
+    expect(afterContent).toBe(originalContent);
+  });
+
+  // ── Atomic stamp: accepted → implemented ─────────────────────────────────────
+
+  it("atomically stamps accepted ADR as implemented", async () => {
+    const adrPath = join(workspaceRoot, "docs", "adrs", "adr-0001-test.md");
+    await writeFile(adrPath, ADR_BODY("ADR-0001", "accepted"));
+    await commitAll(workspaceRoot, "add ADR-0001");
+
+    await writeFile(join(workspaceRoot, "code.ts"), "console.log('hello');");
+    const sha = await commitAll(workspaceRoot, "implement: ADR-0001 add feature");
+
+    const result = await runAdrImplementStamp(
+      makeInput("ADR-0001", sha),
+      makeContext(workspaceRoot),
+    );
+
+    expect(result.data?.status).toBe("pass");
+    expect(result.data?.data?.adrId).toBe("ADR-0001");
+    expect(result.data?.data?.implementationCommit).toBe(sha);
+    expect(result.exitCode).toBe(0);
+
+    // Verify file was mutated
+    const afterContent = await readFile(adrPath, "utf-8");
+    expect(afterContent).toContain("status: implemented");
+    expect(afterContent).toContain("implementedAt:");
+    expect(afterContent).toContain("updatedAt:");
+  });
+
+  // ── Post-hoc ADR: proposed → implemented ─────────────────────────────────────
+
+  it("stamps proposed ADR as implemented (post-hoc)", async () => {
+    const adrPath = join(workspaceRoot, "docs", "adrs", "adr-0002-test.md");
+    await writeFile(adrPath, ADR_BODY("ADR-0002", "proposed"));
+    const sha = await commitAll(workspaceRoot, "add ADR-0002");
+
+    const result = await runAdrImplementStamp(
+      makeInput("ADR-0002", sha),
+      makeContext(workspaceRoot),
+    );
+
+    expect(result.data?.status).toBe("pass");
+    expect(result.data?.data?.adrId).toBe("ADR-0002");
+
+    const afterContent = await readFile(adrPath, "utf-8");
+    expect(afterContent).toContain("status: implemented");
+  });
+});

package/src/tests/agents-generate-domain.test.ts

@@ -0,0 +1,317 @@
+/*
+<MODULE_CONTRACT>
+<purpose>Unit tests for RFC-0643: per-domain AGENTS.md template generation —
+terminology substitution, register selection, nested template selection, fallback,
+path traversal rejection, details field, and regression.</purpose>
+</MODULE_CONTRACT>
+<CHANGE_SUMMARY>
+  <item>RFC-0643: initial domain template tests — terminology substitution, register selection, nested templates, fallback, path traversal, details field, regression.</item>
+</CHANGE_SUMMARY>
+*/
+
+import { test, expect, beforeEach, afterEach } from "vitest";
+import { mkdtemp, rm, writeFile, readFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  runAgentsGenerate,
+  substituteTemplate,
+  selectRootTemplate,
+} from "../onboarding/agents-generate.ts";
+import { selectNestedTemplate } from "../onboarding/nested-agents-templates.ts";
+import type { ForgeRuntimeContext } from "../types.ts";
+import type { ProfileWorkspaceType } from "../profiles/profile-schema.ts";
+import type { StackProfile } from "../profiles/stack-profile.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(), "agents-gen-domain-test-"));
+});
+
+afterEach(async () => {
+  await rm(tempDir, { recursive: true, force: true });
+});
+
+async function makeForgeYaml(dir: string, extra?: string): Promise<void> {
+  const lines = [
+    "schema: forge/config@1",
+    "project:",
+    "  name: test-project",
+    "  stack: [typescript]",
+    "  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: pnpm exec forge rfc.validate",
+    "    validateAdr: pnpm exec forge adr.validate",
+    "    typecheck: null",
+    "    test: null",
+    "    scopedBuild: null",
+    "    implementStamp: pnpm exec forge rfc.implement.stamp",
+    "    specValidate: pnpm exec forge spec.validate",
+    "    sessionSave: pnpm exec forge session.save",
+    "  paths:",
+    "    invariantsFile: docs/architecture-dna.md",
+    "    reviewsDir: docs/reviews",
+    "    handoffsDir: docs/handoffs",
+    "    sessionsDir: docs/sessions",
+    "    compassDocs: [docs/requirements.xml]",
+    "forge:",
+    "  syncedVersion: 0.1.2",
+  ];
+  if (extra) lines.push(extra);
+  await writeFile(join(dir, "forge.yaml"), lines.join("\n"), "utf8");
+}
+
+// --- substituteTemplate tests ---
+
+test("substituteTemplate replaces {{terminology.artifact}} with 'game'", () => {
+  const result = substituteTemplate("Each {{terminology.artifact}} is a workspace.", {
+    artifact: "game",
+  });
+  expect(result).toBe("Each game is a workspace.");
+});
+
+test("substituteTemplate replaces unknown key with key name itself", () => {
+  const result = substituteTemplate("The {{terminology.unknown}} is here.", {});
+  expect(result).toBe("The unknown is here.");
+});
+
+test("substituteTemplate leaves content without placeholders unchanged", () => {
+  const content = "No placeholders here.";
+  expect(substituteTemplate(content, { artifact: "game" })).toBe(content);
+});
+
+test("substituteTemplate replaces multiple placeholders in one pass", () => {
+  const result = substituteTemplate(
+    "The {{terminology.operator}} creates {{terminology.artifactPlural}}.",
+    { operator: "developer", artifactPlural: "games" },
+  );
+  expect(result).toBe("The developer creates games.");
+});
+
+// --- selectRootTemplate tests ---
+
+test("selectRootTemplate('business') returns business template content", () => {
+  const content = selectRootTemplate("business");
+  expect(content).toContain("{{projectName}}");
+  expect(content).toContain("{{rfcsDir}}");
+});
+
+test("selectRootTemplate('creative') returns creative template content", () => {
+  const content = selectRootTemplate("creative");
+  expect(content).toContain("{{projectName}}");
+  expect(content).toContain("{{rfcsDir}}");
+});
+
+test("business template contains {{terminology.key}} placeholders", () => {
+  const content = selectRootTemplate("business");
+  // Templates use {{projectName}} etc. — no {{terminology.*}} needed in static prose
+  // but the template should contain {{dynamicSections}} marker
+  expect(content).toContain("{{dynamicSections}}");
+});
+
+test("creative template contains {{dynamicSections}} marker", () => {
+  const content = selectRootTemplate("creative");
+  expect(content).toContain("{{dynamicSections}}");
+});
+
+test("selectRootTemplate with profile rootAgentsMdTemplate loads profile template", () => {
+  const profile = {
+    id: "godot-csharp",
+    rootAgentsMdTemplate: "root-agents-godot.md",
+  } as StackProfile;
+  const content = selectRootTemplate("creative", profile);
+  expect(content).toContain("Godot 4.x with .NET / C#");
+  expect(content).toContain("{{dynamicSections}}");
+});
+
+test("selectRootTemplate with missing rootAgentsMdTemplate falls back to register template", () => {
+  const profile = {
+    id: "test-profile",
+    rootAgentsMdTemplate: "nonexistent-template.md",
+  } as StackProfile;
+  const content = selectRootTemplate("business", profile);
+  expect(content).toContain("{{projectName}}");
+  expect(content).toContain("{{rfcsDir}}");
+});
+
+test("selectRootTemplate rejects path traversal in rootAgentsMdTemplate", () => {
+  const profile = {
+    id: "evil-profile",
+    rootAgentsMdTemplate: "../../../etc/passwd",
+  } as StackProfile;
+  const content = selectRootTemplate("business", profile);
+  expect(content).toContain("{{projectName}}");
+  expect(content).not.toContain("root:");
+});
+
+test("selectRootTemplate rejects absolute path in rootAgentsMdTemplate", () => {
+  const profile = {
+    id: "evil-profile",
+    rootAgentsMdTemplate: "/etc/passwd",
+  } as StackProfile;
+  const content = selectRootTemplate("business", profile);
+  expect(content).toContain("{{projectName}}");
+  expect(content).not.toContain("root:");
+});
+
+// --- selectNestedTemplate tests ---
+
+test("selectNestedTemplate without agentsMdTemplate uses fallback", () => {
+  const wsType: ProfileWorkspaceType = {
+    id: "package",
+    detect: { glob: "package.json" },
+  };
+  const profile = { id: "forge-shell" } as StackProfile;
+  const result = selectNestedTemplate(wsType, profile, {}, "FALLBACK");
+  expect(result).toBe("FALLBACK");
+});
+
+test("selectNestedTemplate without profile uses fallback", () => {
+  const wsType: ProfileWorkspaceType = {
+    id: "game",
+    detect: { glob: "*.ts" },
+    agentsMdTemplate: "some-template.md",
+  };
+  const result = selectNestedTemplate(wsType, undefined, {}, "FALLBACK");
+  expect(result).toBe("FALLBACK");
+});
+
+test("selectNestedTemplate rejects path traversal (..) with fallback", () => {
+  const wsType: ProfileWorkspaceType = {
+    id: "evil",
+    detect: { glob: "*" },
+    agentsMdTemplate: "../../../etc/passwd",
+  };
+  const profile = { id: "evil-profile" } as StackProfile;
+  const result = selectNestedTemplate(wsType, profile, {}, "FALLBACK");
+  expect(result).toBe("FALLBACK");
+});
+
+test("selectNestedTemplate rejects absolute path with fallback", () => {
+  const wsType: ProfileWorkspaceType = {
+    id: "evil",
+    detect: { glob: "*" },
+    agentsMdTemplate: "/etc/passwd",
+  };
+  const profile = { id: "evil-profile" } as StackProfile;
+  const result = selectNestedTemplate(wsType, profile, {}, "FALLBACK");
+  expect(result).toBe("FALLBACK");
+});
+
+// --- Integration: --json output has details field ---
+
+test("agents-generate --json output has details field with domain, register, workspaceType", async () => {
+  await makeForgeYaml(tempDir);
+  const ctx = makeContext(tempDir);
+  ctx.dryRun = true;
+
+  const result = await runAgentsGenerate({ argv: [], flags: {} }, ctx);
+  expect(result.exitCode).toBe(0);
+  expect(result.data?.details).toBeDefined();
+  expect(Array.isArray(result.data?.details)).toBe(true);
+  expect(result.data?.details?.length).toBeGreaterThan(0);
+  const rootDetail = result.data?.details?.find((d) => d.path === "AGENTS.md");
+  expect(rootDetail).toBeDefined();
+  expect(rootDetail?.register).toBe("business");
+});
+
+test("agents-generate --json output generated field is string[]", async () => {
+  await makeForgeYaml(tempDir);
+  const ctx = makeContext(tempDir);
+  ctx.dryRun = true;
+
+  const result = await runAgentsGenerate({ argv: [], flags: {} }, ctx);
+  expect(result.exitCode).toBe(0);
+  expect(result.data?.generated).toEqual(["AGENTS.md"]);
+  // generated is string[], not object array
+  expect(typeof result.data?.generated?.[0]).toBe("string");
+});
+
+// --- Regression: no profile → identical output ---
+
+test("agents-generate with no profile generates identical AGENTS.md (regression)", async () => {
+  await makeForgeYaml(tempDir);
+  const ctx = makeContext(tempDir);
+  ctx.dryRun = true;
+
+  const result = await runAgentsGenerate({ argv: [], flags: {} }, ctx);
+  const content = result.data?.renderedFiles?.["AGENTS.md"];
+  expect(content).toBeDefined();
+
+  const goldenFixture = await readFile(
+    join(import.meta.dirname, "fixtures", "agents-generate-business-before.txt"),
+    "utf8",
+  );
+  expect(content).toBe(goldenFixture);
+});
+
+// --- Integration: creative register uses creative template ---
+
+test("agents-generate with creative register uses creative template", async () => {
+  await makeForgeYaml(tempDir);
+  await writeFile(
+    join(tempDir, "PREFERENCES.md"),
+    "---\naiLanguage: en\ndocumentationLanguage: en\nregister: creative\n---\n",
+    "utf8",
+  );
+
+  const ctx = makeContext(tempDir);
+  ctx.dryRun = true;
+
+  const result = await runAgentsGenerate({ argv: [], flags: {} }, ctx);
+  expect(result.exitCode).toBe(0);
+  const content = result.data?.renderedFiles?.["AGENTS.md"];
+  expect(content).toBeDefined();
+  expect(content).toContain("Agent Guide: test-project");
+  // Creative register should have extended behavioral layer
+  expect(content).toContain("Extended behavioral layer (creative register)");
+  // Details should show creative register
+  const rootDetail = result.data?.details?.find((d) => d.path === "AGENTS.md");
+  expect(rootDetail?.register).toBe("creative");
+});
+
+test("agents-generate with godot-csharp profile generates Godot-specific AGENTS.md", async () => {
+  await makeForgeYaml(tempDir, "profile: godot-csharp");
+  const ctx = makeContext(tempDir);
+  ctx.dryRun = true;
+
+  const result = await runAgentsGenerate({ argv: [], flags: {} }, ctx);
+  expect(result.exitCode).toBe(0);
+  const content = result.data?.renderedFiles?.["AGENTS.md"];
+  expect(content).toBeDefined();
+  expect(content).toContain("Godot 4.x with .NET / C#");
+  expect(content).toContain("dotnet build");
+  expect(content).toContain("Scenes and Resources");
+  expect(content).toContain("Definition of Done");
+});