gsd-pi 2.80.0-dev.96f4d89d5 → 2.80.0-dev.a947d025c

package/src/resources/extensions/gsd/tests/cwd-fallback-hardening.test.ts

@@ -0,0 +1,138 @@
+// Project/App: GSD-2
+// File Purpose: Behavior tests for deleted-cwd fallback handling.
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { registerDbTools } from "../bootstrap/db-tools.ts";
+import { registerDynamicTools, ensureDbOpen, safeWorkspaceCwd } from "../bootstrap/dynamic-tools.ts";
+import { registerExecTools } from "../bootstrap/exec-tools.ts";
+import { registerJournalTools } from "../bootstrap/journal-tools.ts";
+import { registerMemoryTools } from "../bootstrap/memory-tools.ts";
+import { registerQueryTools } from "../bootstrap/query-tools.ts";
+
+async function withDeletedCwd(fn: (projectRoot: string) => Promise<void> | void): Promise<void> {
+  const previousCwd = process.cwd();
+  const previousProjectRoot = process.env.GSD_PROJECT_ROOT;
+  const projectRoot = mkdtempSync(join(tmpdir(), "gsd-safe-cwd-project-"));
+  const removedCwd = mkdtempSync(join(tmpdir(), "gsd-removed-cwd-"));
+
+  process.env.GSD_PROJECT_ROOT = projectRoot;
+  process.chdir(removedCwd);
+  rmSync(removedCwd, { recursive: true, force: true });
+
+  try {
+    assert.throws(() => process.cwd(), /ENOENT/);
+    await fn(projectRoot);
+  } finally {
+    process.chdir(previousCwd);
+    if (previousProjectRoot === undefined) delete process.env.GSD_PROJECT_ROOT;
+    else process.env.GSD_PROJECT_ROOT = previousProjectRoot;
+    rmSync(projectRoot, { recursive: true, force: true });
+  }
+}
+
+function collectTools(register: (pi: any) => void): any[] {
+  const tools: any[] = [];
+  register({
+    registerTool(tool: any) {
+      tools.push(tool);
+    },
+  });
+  return tools;
+}
+
+test("safeWorkspaceCwd falls back to captured project root when cwd was removed", async () => {
+  await withDeletedCwd((projectRoot) => {
+    assert.equal(safeWorkspaceCwd(), projectRoot);
+  });
+});
+
+test("ensureDbOpen default path does not throw when cwd was removed", async () => {
+  await withDeletedCwd(async () => {
+    assert.equal(await ensureDbOpen(), false);
+  });
+});
+
+test("dynamic tools register when cwd was removed", async () => {
+  await withDeletedCwd(() => {
+    const tools = collectTools(registerDynamicTools);
+    assert.equal(tools.length, 4);
+  });
+});
+
+test("db-backed tool fallbacks return normal unavailable-db errors when cwd was removed", async () => {
+  await withDeletedCwd(async () => {
+    const tools = collectTools(registerDbTools);
+    const decisionSave = tools.find((tool) => tool.name === "gsd_decision_save");
+
+    const result = await decisionSave.execute(
+      "call-1",
+      {
+        scope: "test",
+        decision: "Handle deleted cwd",
+        choice: "Use captured project root",
+        rationale: "The worktree cwd may disappear during cleanup.",
+      },
+      undefined,
+      undefined,
+      undefined,
+    );
+
+    assert.equal(result.details.error, "db_unavailable");
+  });
+});
+
+test("memory and query tools do not throw when cwd was removed", async () => {
+  await withDeletedCwd(async () => {
+    const memoryTools = collectTools(registerMemoryTools);
+    const queryTools = collectTools(registerQueryTools);
+
+    await assert.doesNotReject(() =>
+      memoryTools.find((tool) => tool.name === "memory_query").execute(
+        "call-1",
+        { query: "cwd fallback" },
+        undefined,
+        undefined,
+        undefined,
+      ),
+    );
+    await assert.doesNotReject(() =>
+      queryTools.find((tool) => tool.name === "gsd_milestone_status").execute(
+        "call-2",
+        { milestoneId: "M001" },
+        undefined,
+        undefined,
+        undefined,
+      ),
+    );
+  });
+});
+
+test("journal and exec tools do not throw when cwd was removed", async () => {
+  await withDeletedCwd(async () => {
+    const journalTools = collectTools(registerJournalTools);
+    const execTools = collectTools(registerExecTools);
+
+    await assert.doesNotReject(() =>
+      journalTools.find((tool) => tool.name === "gsd_journal_query").execute(
+        "call-1",
+        { limit: 1 },
+        undefined,
+        undefined,
+        undefined,
+      ),
+    );
+    await assert.doesNotReject(() =>
+      execTools.find((tool) => tool.name === "gsd_resume").execute(
+        "call-2",
+        {},
+        undefined,
+        undefined,
+        undefined,
+      ),
+    );
+  });
+});

package/src/resources/extensions/gsd/tests/dashboard-custom-engine.test.ts

@@ -1,21 +1,12 @@
 /**
- * dashboard-custom-engine.test.ts — Tests that the custom engine path
- * calls updateProgressWidget and that unitLabel handles "custom-step".
- *
- * Uses source-level assertions for the non-exported unitLabel function
- * and the updateProgressWidget call placement. Tests exported helpers
- * (unitVerb, unitPhaseLabel) directly.
+ * dashboard-custom-engine.test.ts — custom-step dashboard labels.
  */
 
 import { describe, it } from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { resolve } from "node:path";
-import { fileURLToPath } from "node:url";
 
 import { unitVerb, unitPhaseLabel } from "../auto-dashboard.js";
-
-// ─── Tests ───────────────────────────────────────────────────────────────
+import { unitLabel } from "../dashboard-overlay.ts";
 
 describe("Dashboard custom-engine: unitLabel and related helpers", () => {
   it('unitVerb("custom-step") returns "executing workflow step"', () => {
@@ -26,62 +17,7 @@ describe("Dashboard custom-engine: unitLabel and related helpers", () => {
     assert.equal(unitPhaseLabel("custom-step"), "WORKFLOW");
   });
 
-  it('dashboard-overlay.ts contains a case for "custom-step" returning "Workflow Step"', () => {
-    const __filename = fileURLToPath(import.meta.url);
-    const overlayPath = resolve(__filename, "../../dashboard-overlay.ts");
-    const source = readFileSync(overlayPath, "utf-8");
-    assert.ok(
-      source.includes('"custom-step"') && source.includes('"Workflow Step"'),
-      'dashboard-overlay.ts should contain case "custom-step": return "Workflow Step"',
-    );
-  });
-});
-
-describe("Dashboard custom-engine: updateProgressWidget in custom engine path", () => {
-  it("loop.ts custom engine path includes updateProgressWidget call before runGuards", () => {
-    const __filename = fileURLToPath(import.meta.url);
-    const loopPath = resolve(__filename, "../../auto/loop.ts");
-    const source = readFileSync(loopPath, "utf-8");
-
-    // Find the custom engine block
-    const customEngineStart = source.indexOf("shouldUseCustomEnginePath({");
-    assert.ok(customEngineStart > -1, "Should find custom engine path in loop.ts");
-
-    // The updateProgressWidget call should appear after the custom engine block start
-    // and before the runGuards call in that block
-    const afterCustomEngine = source.slice(customEngineStart);
-    const widgetCallIndex = afterCustomEngine.indexOf(
-      "deps.updateProgressWidget(ctx, iterData.unitType, iterData.unitId, iterData.state)",
-    );
-    const guardsCallIndex = afterCustomEngine.indexOf("runGuards(ic,");
-    assert.ok(widgetCallIndex > -1, "updateProgressWidget should be called in custom engine path");
-    assert.ok(
-      widgetCallIndex < guardsCallIndex,
-      "updateProgressWidget should be called before runGuards in custom engine path",
-    );
-  });
-
-  it("updateProgressWidget call is placed after iterData is built", () => {
-    const __filename = fileURLToPath(import.meta.url);
-    const loopPath = resolve(__filename, "../../auto/loop.ts");
-    const source = readFileSync(loopPath, "utf-8");
-
-    const customEngineStart = source.indexOf("shouldUseCustomEnginePath({");
-    const afterCustomEngine = source.slice(customEngineStart);
-
-    // Verify custom engine path has iterData built before the widget call
-    const iterDataIndex = afterCustomEngine.indexOf("buildCustomEngineIterationData({");
-    const widgetIndex = afterCustomEngine.indexOf("deps.updateProgressWidget");
-    assert.ok(iterDataIndex > -1 && widgetIndex > -1, "Both iterData and widget call should exist");
-    assert.ok(
-      iterDataIndex < widgetIndex,
-      "iterData should be built before updateProgressWidget is called",
-    );
-
-    // Verify the call uses iterData.state (which holds the derived GSD state)
-    assert.ok(
-      afterCustomEngine.includes("iterData.state"),
-      "Custom engine updateProgressWidget should reference iterData.state",
-    );
+  it('unitLabel("custom-step") returns "Workflow Step"', () => {
+    assert.equal(unitLabel("custom-step"), "Workflow Step");
   });
 });

package/src/resources/extensions/gsd/tests/db-schema-metadata.test.ts

@@ -106,10 +106,10 @@ describe("db-schema-metadata", () => {
   test("records schema version rows with timestamps", () => {
     const db = new FakeAdapter();
 
-    recordSchemaVersion(db, 25);
+    recordSchemaVersion(db, 26);
 
     assert.equal(db.runCalls.length, 1);
-    assert.equal((db.runCalls[0][0] as Record<string, unknown>)[":version"], 25);
+    assert.equal((db.runCalls[0][0] as Record<string, unknown>)[":version"], 26);
     assert.equal(typeof (db.runCalls[0][0] as Record<string, unknown>)[":applied_at"], "string");
   });
 });

package/src/resources/extensions/gsd/tests/deep-project-auto-loop.test.ts

@@ -20,6 +20,7 @@ import {
   clearPendingAutoStart,
   checkDeepProjectSetupAfterTurn,
   clearPendingDeepProjectSetup,
+  FOREGROUND_DEEP_SETUP_RULE_NAMES,
   showSmartEntry,
   startDeepProjectSetupForeground,
 } from "../guided-flow.ts";
@@ -272,7 +273,7 @@ test("deep project setup: bootstrap can start auto-mode without an active milest
         shouldUseWorktreeIsolation: () => false,
         registerSigtermHandler: () => {},
         lockBase: () => base,
-        buildResolver: () => ({}) as any,
+        buildLifecycle: () => ({}) as any,
       },
       {
         classification: "none",
@@ -377,7 +378,7 @@ test("deep project setup: bootstrap continues queued M002 without milestone cont
         shouldUseWorktreeIsolation: () => false,
         registerSigtermHandler: () => {},
         lockBase: () => base,
-        buildResolver: () => ({}) as any,
+        buildLifecycle: () => ({}) as any,
       },
       {
         classification: "none",
@@ -1013,15 +1014,9 @@ test("deep project setup: same project advances when agent_end session id change
 });
 
 test("deep project setup: foreground dispatcher does not probe research-project rule", () => {
-  const source = readFileSync(new URL("../guided-flow.ts", import.meta.url), "utf-8");
-  const match = source.match(/const FOREGROUND_DEEP_SETUP_RULE_NAMES = new Set\(\[([\s\S]*?)\]\);/);
-  assert.ok(match, "foreground deep setup rule allowlist should be present");
-  assert.doesNotMatch(
-    match![1]!,
-    /research-project/,
-    "foreground setup must not evaluate research-project because that rule claims the inflight marker",
-  );
-  assert.match(source, /research-project have dispatch-time side effects/);
+  assert.equal(FOREGROUND_DEEP_SETUP_RULE_NAMES.has("deep: pre-planning (no PROJECT) → discuss-project"), true);
+  assert.equal(FOREGROUND_DEEP_SETUP_RULE_NAMES.has("deep: pre-planning (no research decision) → research-decision"), true);
+  assert.equal(FOREGROUND_DEEP_SETUP_RULE_NAMES.has("deep: pre-planning (no PROJECT research) → research-project"), false);
 });
 
 test("deep project setup: project-level units verify their real artifacts", () => {

package/src/resources/extensions/gsd/tests/deferred-milestone-dir-4996.test.ts

@@ -1,14 +1,10 @@
 // GSD Extension — Regression test for #4996: deferred milestone dir creation
-// Verifies that showHeadlessMilestoneCreation does not pre-create the milestone
-// directory before the discuss flow runs. The dir should only appear after a
-// writer (saveArtifactToDb / atomicWriteAsync) emits the first artifact.
 
 import { describe, it, beforeEach, afterEach } from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, existsSync, rmSync, readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
+import { mkdtempSync, mkdirSync, existsSync, rmSync } from "node:fs";
+import { join } from "node:path";
 import { tmpdir } from "node:os";
-import { fileURLToPath } from "node:url";
 
 import { isReusableGhostMilestone } from "../state.ts";
 import { nextMilestoneIdReserved } from "../milestone-id-reservation.ts";
@@ -16,47 +12,12 @@ import { clearReservedMilestoneIds, findMilestoneIds } from "../milestone-ids.ts
 import { invalidateAllCaches } from "../cache.ts";
 import { closeDatabase, openDatabase } from "../gsd-db.ts";
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const GUIDED_FLOW_PATH = join(__dirname, "..", "guided-flow.ts");
-
-function getShowHeadlessBody(): string {
-  const source = readFileSync(GUIDED_FLOW_PATH, "utf-8");
-  const fnStart = source.indexOf("export async function showHeadlessMilestoneCreation");
-  assert.ok(fnStart > -1, "showHeadlessMilestoneCreation must exist in guided-flow.ts");
-  const nextExport = source.indexOf("\nexport ", fnStart + 1);
-  return source.slice(fnStart, nextExport === -1 ? source.length : nextExport);
-}
-
 function makeBase(prefix = "gsd-deferred-dir-"): string {
   const base = mkdtempSync(join(tmpdir(), prefix));
   mkdirSync(join(base, ".gsd", "milestones"), { recursive: true });
   return base;
 }
 
-describe("showHeadlessMilestoneCreation source guard (#4996)", () => {
-  it("does not call mkdirSync in the headless milestone creation path", () => {
-    const body = getShowHeadlessBody();
-    assert.doesNotMatch(
-      body,
-      /\bmkdirSync\s*\(/,
-      "showHeadlessMilestoneCreation must not pre-create milestone directories",
-    );
-  });
-
-  it("does not call mkdir or mkdirp before dispatchWorkflow", () => {
-    const body = getShowHeadlessBody();
-    const dispatchIdx = body.indexOf("dispatchWorkflow");
-    assert.ok(dispatchIdx > -1, "dispatchWorkflow must be present");
-
-    const beforeDispatch = body.slice(0, dispatchIdx);
-    assert.doesNotMatch(
-      beforeDispatch,
-      /\b(?:mkdir|mkdirp)\s*\(/,
-      "showHeadlessMilestoneCreation must defer directory creation until artifact write",
-    );
-  });
-});
-
 describe("deferred milestone dir creation (#4996)", () => {
   let base: string;
 
@@ -74,43 +35,31 @@ describe("deferred milestone dir creation (#4996)", () => {
   it("(a) fresh project: milestones dir has no M001 entry before any discuss flow", () => {
     base = makeBase();
     const nextId = nextMilestoneIdReserved(findMilestoneIds(base), false, base);
-    assert.equal(nextId, "M001", "reservation should choose M001 for a fresh project");
+    assert.equal(nextId, "M001");
 
     const ids = findMilestoneIds(base);
-    assert.equal(ids.length, 0, "no milestone dirs should exist before any discuss flow");
-
-    // And specifically M001 should not exist
-    const m001Dir = join(base, ".gsd", "milestones", "M001");
-    assert.ok(!existsSync(m001Dir), "M001 dir must not exist before the discuss flow runs");
+    assert.equal(ids.length, 0);
+    assert.ok(!existsSync(join(base, ".gsd", "milestones", "M001")));
   });
 
-  it("(b) abandoned discuss flow leaves no orphan: isReusableGhostMilestone returns false for non-existent dir", () => {
+  it("(b) abandoned discuss flow leaves no orphan", () => {
     base = makeBase();
     const nextId = nextMilestoneIdReserved(findMilestoneIds(base), false, base);
-    assert.equal(nextId, "M001", "reservation should not require a pre-created directory");
+    assert.equal(nextId, "M001");
 
     const m001Dir = join(base, ".gsd", "milestones", "M001");
-    assert.ok(!existsSync(m001Dir), "no M001 dir should exist");
-    assert.equal(isReusableGhostMilestone(base, "M001"), false, "non-existent milestone should not be reusable");
-    // findMilestoneIds only returns dirs that exist
-    const ids = findMilestoneIds(base);
-    assert.ok(!ids.includes("M001"), "M001 should not appear in findMilestoneIds when no dir exists");
+    assert.ok(!existsSync(m001Dir));
+    assert.equal(isReusableGhostMilestone(base, "M001"), false);
+    assert.ok(!findMilestoneIds(base).includes("M001"));
   });
 
-  it("(c) a stub dir left from a previous bug IS reusable but a newly-generated ID with no dir is not in the ghost list", () => {
+  it("(c) a stub dir left from a previous bug is reusable", () => {
     base = makeBase();
     openDatabase(join(base, ".gsd", "gsd.db"));
-    // Create a stub to represent a pre-existing phantom
     mkdirSync(join(base, ".gsd", "milestones", "M001", "slices"), { recursive: true });
 
-    // isReusableGhostMilestone identifies the orphaned stub
-    assert.ok(isReusableGhostMilestone(base, "M001"), "pre-existing stub should be identified as reusable ghost");
-    const nextId = nextMilestoneIdReserved(findMilestoneIds(base), false, base);
-    assert.equal(nextId, "M001", "reservation should reuse the pre-existing ghost");
-
-    // The new ID (M002, which would be max+1 in this scenario but ghost reuse returns M001)
-    // should not have a dir
-    const m002Dir = join(base, ".gsd", "milestones", "M002");
-    assert.ok(!existsSync(m002Dir), "a freshly-requested ID should have no dir until first artifact write");
+    assert.equal(isReusableGhostMilestone(base, "M001"), true);
+    assert.equal(nextMilestoneIdReserved(findMilestoneIds(base), false, base), "M001");
+    assert.ok(!existsSync(join(base, ".gsd", "milestones", "M002")));
   });
 });

package/src/resources/extensions/gsd/tests/detection.test.ts

@@ -11,12 +11,14 @@
 import test from "node:test";
 import assert from "node:assert/strict";
 import { mkdirSync, writeFileSync, rmSync, existsSync } from "node:fs";
+import { execFileSync } from "node:child_process";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import {
   detectProjectState,
   detectV1Planning,
   detectProjectSignals,
+  classifyProject,
   scanProjectFiles,
 } from "../detection.ts";
 
@@ -37,6 +39,18 @@ function cleanup(dir: string): void {
   }
 }
 
+function git(dir: string, args: string[]): void {
+  execFileSync("git", args, { cwd: dir, stdio: "ignore" });
+}
+
+function makeGitRepo(prefix: string): string {
+  const dir = makeTempDir(prefix);
+  git(dir, ["init"]);
+  git(dir, ["config", "user.email", "test@example.com"]);
+  git(dir, ["config", "user.name", "Test User"]);
+  return dir;
+}
+
 // ─── detectProjectState ─────────────────────────────────────────────────────────
 
 test("detectProjectState: empty directory returns state=none", (t) => {
@@ -49,6 +63,132 @@ test("detectProjectState: empty directory returns state=none", (t) => {
   assert.equal(result.v2, undefined);
 });
 
+test("classifyProject: no git repo is invalid", (t) => {
+  const dir = makeTempDir("classify-invalid");
+  t.after(() => cleanup(dir));
+
+  const classification = classifyProject(dir);
+  assert.equal(classification.kind, "invalid-repo");
+});
+
+test("classifyProject: empty git repo is greenfield", (t) => {
+  const dir = makeGitRepo("classify-greenfield");
+  t.after(() => cleanup(dir));
+
+  const classification = classifyProject(dir);
+  assert.equal(classification.kind, "greenfield");
+});
+
+test("classifyProject: nested empty git repo does not inherit ancestor markers", (t) => {
+  const parent = makeGitRepo("classify-parent-marker");
+  t.after(() => cleanup(parent));
+
+  writeFileSync(join(parent, "package.json"), JSON.stringify({ name: "parent" }), "utf-8");
+  git(parent, ["add", "package.json"]);
+  git(parent, ["commit", "-m", "add parent marker"]);
+  const child = join(parent, "nested");
+  mkdirSync(child, { recursive: true });
+  git(child, ["init"]);
+  git(child, ["config", "user.email", "test@example.com"]);
+  git(child, ["config", "user.name", "Test User"]);
+
+  const classification = classifyProject(child);
+  assert.equal(classification.kind, "greenfield");
+});
+
+test("classifyProject: tracked static HTML is existing untyped content", (t) => {
+  const dir = makeGitRepo("classify-index");
+  t.after(() => cleanup(dir));
+
+  writeFileSync(join(dir, "index.html"), "<main></main>\n", "utf-8");
+  git(dir, ["add", "index.html"]);
+  git(dir, ["commit", "-m", "add static page"]);
+
+  const classification = classifyProject(dir);
+  assert.equal(classification.kind, "untyped-existing");
+  assert.deepEqual(classification.contentFiles, ["index.html"]);
+});
+
+test("classifyProject: README-only repo is existing untyped content", (t) => {
+  const dir = makeGitRepo("classify-readme");
+  t.after(() => cleanup(dir));
+
+  writeFileSync(join(dir, "README.md"), "# docs\n", "utf-8");
+  git(dir, ["add", "README.md"]);
+  git(dir, ["commit", "-m", "add docs"]);
+
+  const classification = classifyProject(dir);
+  assert.equal(classification.kind, "untyped-existing");
+});
+
+test("classifyProject: src-only content is untyped existing, not typed marker", (t) => {
+  const dir = makeGitRepo("classify-src-only");
+  t.after(() => cleanup(dir));
+
+  mkdirSync(join(dir, "src"), { recursive: true });
+  writeFileSync(join(dir, "src", "index.txt"), "content\n", "utf-8");
+  git(dir, ["add", "src/index.txt"]);
+  git(dir, ["commit", "-m", "add source content"]);
+
+  const classification = classifyProject(dir);
+  assert.equal(classification.kind, "untyped-existing");
+  assert.deepEqual(classification.contentFiles, ["src/index.txt"]);
+});
+
+test("classifyProject: nested untracked files count as project content", (t) => {
+  const dir = makeGitRepo("classify-untracked-nested");
+  t.after(() => cleanup(dir));
+
+  mkdirSync(join(dir, "docs"), { recursive: true });
+  writeFileSync(join(dir, "docs", "index.html"), "<main></main>\n", "utf-8");
+
+  const classification = classifyProject(dir);
+  assert.equal(classification.kind, "untyped-existing");
+  assert.deepEqual(classification.untrackedFiles, ["docs/index.html"]);
+});
+
+test("classifyProject: known markers produce typed existing project", (t) => {
+  const dir = makeGitRepo("classify-typed");
+  t.after(() => cleanup(dir));
+
+  writeFileSync(join(dir, "package.json"), JSON.stringify({ name: "typed" }), "utf-8");
+  git(dir, ["add", "package.json"]);
+  git(dir, ["commit", "-m", "add package"]);
+
+  const classification = classifyProject(dir);
+  assert.equal(classification.kind, "typed-existing");
+  assert.ok(classification.markers.includes("package.json"));
+});
+
+test("classifyProject: ignored build/cache-only files do not count as content", (t) => {
+  const dir = makeGitRepo("classify-ignored");
+  t.after(() => cleanup(dir));
+
+  writeFileSync(join(dir, ".gitignore"), "dist/\n.cache/\n", "utf-8");
+  git(dir, ["add", ".gitignore"]);
+  git(dir, ["commit", "-m", "ignore generated files"]);
+  mkdirSync(join(dir, "dist"), { recursive: true });
+  writeFileSync(join(dir, "dist", "bundle.js"), "generated\n", "utf-8");
+  mkdirSync(join(dir, ".cache"), { recursive: true });
+  writeFileSync(join(dir, ".cache", "x"), "cache\n", "utf-8");
+
+  const classification = classifyProject(dir);
+  assert.equal(classification.kind, "greenfield");
+});
+
+test("classifyProject: generated framework/cache dirs do not count as content", (t) => {
+  const dir = makeGitRepo("classify-generated-dirs");
+  t.after(() => cleanup(dir));
+
+  mkdirSync(join(dir, ".next", "server"), { recursive: true });
+  writeFileSync(join(dir, ".next", "server", "page.js"), "generated\n", "utf-8");
+  mkdirSync(join(dir, ".venv", "lib"), { recursive: true });
+  writeFileSync(join(dir, ".venv", "lib", "site.py"), "generated\n", "utf-8");
+
+  const classification = classifyProject(dir);
+  assert.equal(classification.kind, "greenfield");
+});
+
 test("detectProjectState: directory with .gsd/milestones/M001 returns v2-gsd", (t) => {
   const dir = makeTempDir("v2-gsd");
   t.after(() => cleanup(dir));