@warpgogol/forge 2.8.0 → 2.8.2

package/src/migration-adapters/node-typescript-pnpm/index.ts

@@ -0,0 +1,189 @@
+/*
+<MODULE_CONTRACT>
+<purpose>Node/TypeScript/pnpm migration adapter — detects Node+TS+pnpm projects, derives bindings, copies code into forge turborepo (RFC-0546).</purpose>
+<non-goals>
+  <item>Do not import from @warpgogol/* — this module is portable.</item>
+  <item>Do not transform business logic — copy only.</item>
+  <item>Do not overwrite forge-protected files.</item>
+</non-goals>
+</MODULE_CONTRACT>
+<CHANGE_SUMMARY>
+  <item>RFC-0546: initial node-typescript-pnpm migration adapter.</item>
+  <item>RFC-0547: implement postSetup with git init / format-patch + git am.</item>
+</CHANGE_SUMMARY>
+*/
+
+import fs from "node:fs";
+import path from "node:path";
+import type { MigrationAdapter, AdapterAnalysis, MigrationResult, Conflict } from "../types.ts";
+import { FORGE_PROTECTED_PATHS, DEFAULT_EXCLUDE_PATTERNS } from "../types.ts";
+import { runPostSetup } from "../git-utils.ts";
+
+interface PackageJson {
+  name?: string;
+  scripts?: Record<string, string>;
+  dependencies?: Record<string, string>;
+  devDependencies?: Record<string, string>;
+}
+
+function readPackageJson(sourceDir: string): PackageJson | null {
+  const pkgPath = path.join(sourceDir, "package.json");
+  if (!fs.existsSync(pkgPath)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(pkgPath, "utf8")) as PackageJson;
+  } catch {
+    return null;
+  }
+}
+
+export const nodeTypescriptPnpmAdapter: MigrationAdapter = {
+  id: "node-typescript-pnpm",
+
+  detect(sourceDir: string): boolean {
+    const hasPackageJson = fs.existsSync(path.join(sourceDir, "package.json"));
+    const hasTsconfig = fs.existsSync(path.join(sourceDir, "tsconfig.json"));
+    const hasPnpmLock = fs.existsSync(path.join(sourceDir, "pnpm-lock.yaml"));
+    return hasPackageJson && hasTsconfig && hasPnpmLock;
+  },
+
+  analyze(sourceDir: string): AdapterAnalysis {
+    const pkg = readPackageJson(sourceDir) ?? {};
+    const scripts = pkg.scripts ?? {};
+
+    const typecheck =
+      scripts["build:check"] ?? ((scripts["typecheck"] ?? scripts["tsc"]) ? `tsc --noEmit` : null);
+    const test = scripts["test"] ?? null;
+    const scopedBuild = scripts["build"] ?? null;
+
+    const appName = pkg.name
+      ? pkg.name
+          .replace(/^@[^/]+\//, "")
+          .replace(/[^a-z0-9-]/gi, "-")
+          .toLowerCase()
+      : path
+          .basename(sourceDir)
+          .toLowerCase()
+          .replace(/[^a-z0-9-]/gi, "-");
+
+    return {
+      stack: ["typescript", "node"],
+      packageManager: "pnpm",
+      bindings: { typecheck, test, scopedBuild },
+      placement: "apps",
+      appName,
+      excludePatterns: [...DEFAULT_EXCLUDE_PATTERNS],
+      gitHistory: fs.existsSync(path.join(sourceDir, ".git")),
+    };
+  },
+
+  migrate(sourceDir: string, targetDir: string, analysis: AdapterAnalysis): MigrationResult {
+    const destDir = path.join(targetDir, analysis.placement, analysis.appName);
+    const filesCopied: string[] = [];
+    const filesSkipped: string[] = [];
+    const conflicts: Conflict[] = [];
+
+    copyDirectory(
+      sourceDir,
+      destDir,
+      sourceDir,
+      analysis.excludePatterns,
+      filesCopied,
+      filesSkipped,
+      conflicts,
+    );
+
+    let workspaceUpdated = false;
+    const workspacePath = path.join(targetDir, "pnpm-workspace.yaml");
+    if (fs.existsSync(workspacePath)) {
+      const content = fs.readFileSync(workspacePath, "utf8");
+      const entry = `  - ${analysis.placement}/${analysis.appName}`;
+      if (!content.includes(entry)) {
+        const updated = content.trimEnd() + "\n" + entry + "\n";
+        fs.writeFileSync(workspacePath, updated);
+        workspaceUpdated = true;
+      }
+    }
+
+    const turboPath = path.join(targetDir, "turbo.json");
+    if (fs.existsSync(turboPath)) {
+      try {
+        const turbo = JSON.parse(fs.readFileSync(turboPath, "utf8")) as Record<string, unknown>;
+        if (turbo && typeof turbo === "object") {
+          fs.writeFileSync(turboPath, JSON.stringify(turbo, null, 2) + "\n");
+          workspaceUpdated = true;
+        }
+      } catch {
+        // turbo.json parse failure — skip update
+      }
+    }
+
+    return { filesCopied, filesSkipped, conflicts, workspaceUpdated };
+  },
+
+  postSetup(sourceDir: string, targetDir: string, analysis: AdapterAnalysis): void {
+    runPostSetup(sourceDir, targetDir, analysis);
+  },
+};
+
+function isForgeProtected(relPath: string): boolean {
+  const normalized = relPath.replace(/\\/g, "/");
+  return FORGE_PROTECTED_PATHS.some((p) => normalized === p || normalized.startsWith(p + "/"));
+}
+
+function isExcluded(relPath: string, patterns: string[]): boolean {
+  const parts = relPath.split(path.sep);
+  return patterns.some((p) => parts.includes(p));
+}
+
+function copyDirectory(
+  src: string,
+  dest: string,
+  rootSrc: string,
+  excludePatterns: string[],
+  filesCopied: string[],
+  filesSkipped: string[],
+  conflicts: Conflict[],
+): void {
+  if (!fs.existsSync(dest)) {
+    fs.mkdirSync(dest, { recursive: true });
+  }
+
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    const relPath = path.relative(rootSrc, srcPath);
+
+    if (entry.isDirectory()) {
+      if (isExcluded(relPath, excludePatterns)) continue;
+      copyDirectory(
+        srcPath,
+        destPath,
+        rootSrc,
+        excludePatterns,
+        filesCopied,
+        filesSkipped,
+        conflicts,
+      );
+    } else if (entry.isFile()) {
+      if (isExcluded(relPath, excludePatterns)) continue;
+
+      if (isForgeProtected(relPath)) {
+        filesSkipped.push(relPath);
+        continue;
+      }
+
+      if (fs.existsSync(destPath)) {
+        conflicts.push({
+          path: relPath,
+          sourceExists: true,
+          forgeExists: true,
+          resolution: "source-wins",
+        });
+      }
+
+      fs.copyFileSync(srcPath, destPath);
+      filesCopied.push(relPath);
+    }
+  }
+}

package/src/migration-adapters/phaser-pnpm/index.ts

@@ -0,0 +1,189 @@
+/*
+<MODULE_CONTRACT>
+<purpose>Phaser/pnpm migration adapter — detects Phaser+pnpm projects, derives bindings, copies code into forge turborepo (RFC-0546).</purpose>
+<non-goals>
+  <item>Do not import from @warpgogol/* — this module is portable.</item>
+  <item>Do not transform business logic — copy only.</item>
+  <item>Do not overwrite forge-protected files.</item>
+</non-goals>
+</MODULE_CONTRACT>
+<CHANGE_SUMMARY>
+  <item>RFC-0546: initial phaser-pnpm migration adapter.</item>
+  <item>RFC-0547: implement postSetup with git init / format-patch + git am.</item>
+</CHANGE_SUMMARY>
+*/
+
+import fs from "node:fs";
+import path from "node:path";
+import type { MigrationAdapter, AdapterAnalysis, MigrationResult, Conflict } from "../types.ts";
+import { FORGE_PROTECTED_PATHS, DEFAULT_EXCLUDE_PATTERNS } from "../types.ts";
+import { runPostSetup } from "../git-utils.ts";
+
+interface PackageJson {
+  name?: string;
+  scripts?: Record<string, string>;
+  dependencies?: Record<string, string>;
+  devDependencies?: Record<string, string>;
+}
+
+function readPackageJson(sourceDir: string): PackageJson | null {
+  const pkgPath = path.join(sourceDir, "package.json");
+  if (!fs.existsSync(pkgPath)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(pkgPath, "utf8")) as PackageJson;
+  } catch {
+    return null;
+  }
+}
+
+export const phaserPnpmAdapter: MigrationAdapter = {
+  id: "phaser-pnpm",
+
+  detect(sourceDir: string): boolean {
+    const pkg = readPackageJson(sourceDir);
+    if (!pkg) return false;
+    const deps = { ...(pkg.dependencies ?? {}), ...(pkg.devDependencies ?? {}) };
+    return "phaser" in deps;
+  },
+
+  analyze(sourceDir: string): AdapterAnalysis {
+    const pkg = readPackageJson(sourceDir) ?? {};
+    const scripts = pkg.scripts ?? {};
+
+    const typecheck =
+      scripts["build:check"] ?? ((scripts["typecheck"] ?? scripts["tsc"]) ? `tsc --noEmit` : null);
+    const test = scripts["test"] ?? null;
+    const scopedBuild = scripts["build"] ?? null;
+
+    const appName = pkg.name
+      ? pkg.name
+          .replace(/^@[^/]+\//, "")
+          .replace(/[^a-z0-9-]/gi, "-")
+          .toLowerCase()
+      : path
+          .basename(sourceDir)
+          .toLowerCase()
+          .replace(/[^a-z0-9-]/gi, "-");
+
+    return {
+      stack: ["typescript", "phaser"],
+      packageManager: "pnpm",
+      bindings: { typecheck, test, scopedBuild },
+      placement: "apps",
+      appName,
+      excludePatterns: [...DEFAULT_EXCLUDE_PATTERNS],
+      gitHistory: fs.existsSync(path.join(sourceDir, ".git")),
+    };
+  },
+
+  migrate(sourceDir: string, targetDir: string, analysis: AdapterAnalysis): MigrationResult {
+    const destDir = path.join(targetDir, analysis.placement, analysis.appName);
+    const filesCopied: string[] = [];
+    const filesSkipped: string[] = [];
+    const conflicts: Conflict[] = [];
+
+    copyDirectory(
+      sourceDir,
+      destDir,
+      sourceDir,
+      analysis.excludePatterns,
+      filesCopied,
+      filesSkipped,
+      conflicts,
+    );
+
+    let workspaceUpdated = false;
+    const workspacePath = path.join(targetDir, "pnpm-workspace.yaml");
+    if (fs.existsSync(workspacePath)) {
+      const content = fs.readFileSync(workspacePath, "utf8");
+      const entry = `  - ${analysis.placement}/${analysis.appName}`;
+      if (!content.includes(entry)) {
+        const updated = content.trimEnd() + "\n" + entry + "\n";
+        fs.writeFileSync(workspacePath, updated);
+        workspaceUpdated = true;
+      }
+    }
+
+    const turboPath = path.join(targetDir, "turbo.json");
+    if (fs.existsSync(turboPath)) {
+      try {
+        const turbo = JSON.parse(fs.readFileSync(turboPath, "utf8")) as Record<string, unknown>;
+        if (turbo && typeof turbo === "object") {
+          fs.writeFileSync(turboPath, JSON.stringify(turbo, null, 2) + "\n");
+          workspaceUpdated = true;
+        }
+      } catch {
+        // turbo.json parse failure — skip update
+      }
+    }
+
+    return { filesCopied, filesSkipped, conflicts, workspaceUpdated };
+  },
+
+  postSetup(sourceDir: string, targetDir: string, analysis: AdapterAnalysis): void {
+    runPostSetup(sourceDir, targetDir, analysis);
+  },
+};
+
+function isForgeProtected(relPath: string): boolean {
+  const normalized = relPath.replace(/\\/g, "/");
+  return FORGE_PROTECTED_PATHS.some((p) => normalized === p || normalized.startsWith(p + "/"));
+}
+
+function isExcluded(relPath: string, patterns: string[]): boolean {
+  const parts = relPath.split(path.sep);
+  return patterns.some((p) => parts.includes(p));
+}
+
+function copyDirectory(
+  src: string,
+  dest: string,
+  rootSrc: string,
+  excludePatterns: string[],
+  filesCopied: string[],
+  filesSkipped: string[],
+  conflicts: Conflict[],
+): void {
+  if (!fs.existsSync(dest)) {
+    fs.mkdirSync(dest, { recursive: true });
+  }
+
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    const relPath = path.relative(rootSrc, srcPath);
+
+    if (entry.isDirectory()) {
+      if (isExcluded(relPath, excludePatterns)) continue;
+      copyDirectory(
+        srcPath,
+        destPath,
+        rootSrc,
+        excludePatterns,
+        filesCopied,
+        filesSkipped,
+        conflicts,
+      );
+    } else if (entry.isFile()) {
+      if (isExcluded(relPath, excludePatterns)) continue;
+
+      if (isForgeProtected(relPath)) {
+        filesSkipped.push(relPath);
+        continue;
+      }
+
+      if (fs.existsSync(destPath)) {
+        conflicts.push({
+          path: relPath,
+          sourceExists: true,
+          forgeExists: true,
+          resolution: "source-wins",
+        });
+      }
+
+      fs.copyFileSync(srcPath, destPath);
+      filesCopied.push(relPath);
+    }
+  }
+}

package/src/migration-adapters/registry.ts

@@ -0,0 +1,61 @@
+/*
+<MODULE_CONTRACT>
+<purpose>Migration-adapter registry — built-in adapters + config-discovered external adapters (RFC-0546).</purpose>
+<non-goals>
+  <item>Do not import from @warpgogol/* — this module is portable.</item>
+  <item>Do not apply migration here — selection only.</item>
+</non-goals>
+</MODULE_CONTRACT>
+<CHANGE_SUMMARY>
+  <item>RFC-0546: initial migration-adapter registry with built-in adapters.</item>
+</CHANGE_SUMMARY>
+*/
+
+import type { MigrationAdapter } from "./types.ts";
+import { nodeTypescriptPnpmAdapter } from "./node-typescript-pnpm/index.ts";
+import { phaserPnpmAdapter } from "./phaser-pnpm/index.ts";
+import type { ForgeConfig } from "../config/forge-config.ts";
+
+const BUILT_IN_ADAPTERS: MigrationAdapter[] = [nodeTypescriptPnpmAdapter, phaserPnpmAdapter];
+
+export function getAdapters(config?: ForgeConfig): MigrationAdapter[] {
+  const adapters = [...BUILT_IN_ADAPTERS];
+
+  const configAdapters = config?.migrationAdapters ?? [];
+  for (const entry of configAdapters) {
+    if (entry.module) {
+      // External adapter — would require dynamic import at runtime.
+      // The skill handles dynamic import; registry returns built-ins only for now.
+      // External adapters with module field are resolved by the skill at runtime.
+      continue;
+    }
+    // Built-in adapter referenced by id only — already in BUILT_IN_ADAPTERS
+  }
+
+  return adapters;
+}
+
+export function detectAdapter(sourceDir: string, config?: ForgeConfig): MigrationAdapter | null {
+  const adapters = getAdapters(config);
+  const matches = adapters.filter((a) => {
+    try {
+      return a.detect(sourceDir);
+    } catch {
+      return false;
+    }
+  });
+
+  if (matches.length === 0) return null;
+  return matches[0];
+}
+
+export function detectAdapters(sourceDir: string, config?: ForgeConfig): MigrationAdapter[] {
+  const adapters = getAdapters(config);
+  return adapters.filter((a) => {
+    try {
+      return a.detect(sourceDir);
+    } catch {
+      return false;
+    }
+  });
+}

package/src/migration-adapters/types.ts

@@ -0,0 +1,68 @@
+/*
+<MODULE_CONTRACT>
+<purpose>Migration-adapter type contracts — interfaces for stack-specific code migration into forge projects (RFC-0546).</purpose>
+<non-goals>
+  <item>Do not import from @warpgogol/* — this module is portable.</item>
+  <item>Do not implement adapter logic here — only type definitions.</item>
+</non-goals>
+</MODULE_CONTRACT>
+<CHANGE_SUMMARY>
+  <item>RFC-0546: initial migration-adapter type contracts (MigrationAdapter, AdapterAnalysis, MigrationResult, Conflict).</item>
+  <item>RFC-0547: remove .git from DEFAULT_EXCLUDE_PATTERNS — git history handled by postSetup via format-patch + git am.</item>
+  <item>Re-add .git to DEFAULT_EXCLUDE_PATTERNS — copyDirectory copies into apps/<appName>/, not the project root; copying .git there creates a nested repo. Git history is handled by postSetup at the project root.</item>
+  <item>Add .env* to untracked-file transfer guarantee — the adapter copies ALL files on disk (including git-ignored), not just git-tracked files.</item>
+</CHANGE_SUMMARY>
+*/
+
+export interface MigrationAdapter {
+  id: string;
+  detect(sourceDir: string): boolean;
+  analyze(sourceDir: string): AdapterAnalysis;
+  migrate(sourceDir: string, targetDir: string, analysis: AdapterAnalysis): MigrationResult;
+  postSetup(sourceDir: string, targetDir: string, analysis: AdapterAnalysis): void;
+}
+
+export interface AdapterAnalysis {
+  stack: string[];
+  packageManager: string;
+  bindings: {
+    typecheck: string | null;
+    test: string | null;
+    scopedBuild: string | null;
+  };
+  placement: "apps" | "packages";
+  appName: string;
+  excludePatterns: string[];
+  gitHistory: boolean;
+}
+
+export interface MigrationResult {
+  filesCopied: string[];
+  filesSkipped: string[];
+  conflicts: Conflict[];
+  workspaceUpdated: boolean;
+}
+
+export interface Conflict {
+  path: string;
+  sourceExists: boolean;
+  forgeExists: boolean;
+  resolution: "forge-wins" | "source-wins";
+}
+
+export const FORGE_PROTECTED_PATHS = [
+  "forge.yaml",
+  ".agents",
+  "docs/rfcs",
+  "docs/adrs",
+  "PREFERENCES.md",
+] as const;
+
+export const DEFAULT_EXCLUDE_PATTERNS = [
+  "node_modules",
+  "dist",
+  ".next",
+  ".cache",
+  ".turbo",
+  ".git",
+] as const;

package/src/onboarding/__tests__/workspace-discovery.test.ts

@@ -0,0 +1,134 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { detectWorkspaceType, discoverWorkspaces } from "../workspace-discovery.ts";
+import { GENERATED_MARKER } from "../../utils/index.ts";
+import { mkdtemp, rm, writeFile, mkdir } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+let tempDir: string;
+
+beforeEach(async () => {
+  tempDir = await mkdtemp(join(tmpdir(), "forge-ws-discovery-"));
+});
+
+afterEach(async () => {
+  await rm(tempDir, { recursive: true, force: true });
+});
+
+describe("detectWorkspaceType", () => {
+  it("returns null when no package.json exists", () => {
+    expect(detectWorkspaceType(tempDir)).toBeNull();
+  });
+
+  it("detects 'app' when astro.config.mjs exists", async () => {
+    await writeFile(join(tempDir, "package.json"), '{"name":"app"}', "utf8");
+    await writeFile(join(tempDir, "astro.config.mjs"), "export default {}", "utf8");
+    expect(detectWorkspaceType(tempDir)).toBe("app");
+  });
+
+  it("detects 'app' when astro.config.ts exists", async () => {
+    await writeFile(join(tempDir, "package.json"), '{"name":"app"}', "utf8");
+    await writeFile(join(tempDir, "astro.config.ts"), "export default {}", "utf8");
+    expect(detectWorkspaceType(tempDir)).toBe("app");
+  });
+
+  it("detects 'service' when Dockerfile exists", async () => {
+    await writeFile(join(tempDir, "package.json"), '{"name":"svc"}', "utf8");
+    await writeFile(join(tempDir, "Dockerfile"), "FROM node:20", "utf8");
+    expect(detectWorkspaceType(tempDir)).toBe("service");
+  });
+
+  it("detects 'service' when service.config.yaml exists", async () => {
+    await writeFile(join(tempDir, "package.json"), '{"name":"svc"}', "utf8");
+    await writeFile(join(tempDir, "service.config.yaml"), "name: svc", "utf8");
+    expect(detectWorkspaceType(tempDir)).toBe("service");
+  });
+
+  it("defaults to 'package' when package.json exists but no markers", async () => {
+    await writeFile(join(tempDir, "package.json"), '{"name":"pkg"}', "utf8");
+    expect(detectWorkspaceType(tempDir)).toBe("package");
+  });
+
+  it("uses profile workspaceTypes when provided", async () => {
+    await writeFile(join(tempDir, "package.json"), '{"name":"pkg","dependencies":{"phaser":"^3"}}', "utf8");
+    const wst = [{ id: "game", detect: { packageJsonDep: "phaser" }, skills: [] }];
+    expect(detectWorkspaceType(tempDir, wst)).toBe("game");
+  });
+
+  it("returns null when profile workspaceTypes provided but no match", async () => {
+    await writeFile(join(tempDir, "package.json"), '{"name":"pkg"}', "utf8");
+    const wst = [{ id: "game", detect: { packageJsonDep: "phaser" }, skills: [] }];
+    expect(detectWorkspaceType(tempDir, wst)).toBeNull();
+  });
+
+  it("profile workspaceTypes with glob detection", async () => {
+    await writeFile(join(tempDir, "package.json"), '{"name":"pkg"}', "utf8");
+    await writeFile(join(tempDir, "game.config"), "config", "utf8");
+    const wst = [{ id: "game", detect: { glob: "game.*" }, skills: [] }];
+    expect(detectWorkspaceType(tempDir, wst)).toBe("game");
+  });
+
+  it("profile workspaceTypes with contains detection", async () => {
+    await writeFile(join(tempDir, "package.json"), '{"name":"pkg"}', "utf8");
+    await writeFile(join(tempDir, "marker.txt"), "marker", "utf8");
+    const wst = [{ id: "custom", detect: { contains: "marker.txt" }, skills: [] }];
+    expect(detectWorkspaceType(tempDir, wst)).toBe("custom");
+  });
+});
+
+describe("discoverWorkspaces", () => {
+  it("returns empty for directory with no workspaces", () => {
+    expect(discoverWorkspaces(tempDir)).toEqual([]);
+  });
+
+  it("discovers nested workspaces", async () => {
+    const appsDir = join(tempDir, "apps");
+    const appDir = join(appsDir, "my-app");
+    await mkdir(appDir, { recursive: true });
+    await writeFile(join(appDir, "package.json"), '{"name":"my-app"}', "utf8");
+    await writeFile(join(appDir, "astro.config.mjs"), "export default {}", "utf8");
+
+    const results = discoverWorkspaces(tempDir);
+    expect(results).toHaveLength(1);
+    expect(results[0].type).toBe("app");
+    expect(results[0].path).toContain("my-app");
+  });
+
+  it("skips node_modules, .git, dist, .turbo, .cache, .agents", async () => {
+    for (const skipDir of ["node_modules", ".git", "dist", ".turbo", ".cache", ".agents"]) {
+      const dir = join(tempDir, skipDir, "sub");
+      await mkdir(dir, { recursive: true });
+      await writeFile(join(dir, "package.json"), '{"name":"skip"}', "utf8");
+    }
+
+    const results = discoverWorkspaces(tempDir);
+    expect(results).toHaveLength(0);
+  });
+
+  it("detects hasAgentsMd and isGenerated", async () => {
+    const pkgDir = join(tempDir, "packages", "my-pkg");
+    await mkdir(pkgDir, { recursive: true });
+    await writeFile(join(pkgDir, "package.json"), '{"name":"my-pkg"}', "utf8");
+    await writeFile(
+      join(pkgDir, "AGENTS.md"),
+      `<!-- ${GENERATED_MARKER} -->\n# Test`,
+      "utf8",
+    );
+
+    const results = discoverWorkspaces(tempDir);
+    expect(results).toHaveLength(1);
+    expect(results[0].hasAgentsMd).toBe(true);
+    expect(results[0].isGenerated).toBe(true);
+  });
+
+  it("reports hasAgentsMd=false when no AGENTS.md", async () => {
+    const pkgDir = join(tempDir, "packages", "my-pkg");
+    await mkdir(pkgDir, { recursive: true });
+    await writeFile(join(pkgDir, "package.json"), '{"name":"my-pkg"}', "utf8");
+
+    const results = discoverWorkspaces(tempDir);
+    expect(results).toHaveLength(1);
+    expect(results[0].hasAgentsMd).toBe(false);
+    expect(results[0].isGenerated).toBe(false);
+  });
+});