@opengsd/gsd-pi 1.9.0 → 1.10.0-dev.a5e42e99

package/src/resources/extensions/gsd/tests/destructive-confirmation.test.ts

@@ -18,6 +18,7 @@ import test from "node:test";
 import assert from "node:assert/strict";
 
 import { registerHooks } from "../bootstrap/register-hooks.ts";
+import { autoSession } from "../auto-runtime-state.ts";
 import { classifyCommand } from "../safety/destructive-guard.ts";
 import {
   DESTRUCTIVE_CONFIRM_GATE_MARKER,
@@ -232,6 +233,38 @@ test("integration: real hooks block a force push, then allow it once after confi
   assert.equal(thirdAttempt?.block, true, "second run of the same command re-blocks (one-shot)");
 });
 
+test("integration: auto-mode destructive block does not pause before confirmation can be asked", async (t) => {
+  const dir = "/tmp/gsd-destructive-confirm-int-auto-defer";
+  const notifications: string[] = [];
+  const ctx = {
+    cwd: dir,
+    isIdle: () => true,
+    sessionManager: { getSessionFile: () => null },
+    ui: { notify: (message: string) => notifications.push(message) },
+  } as any;
+  resetDestructiveConfirmation(dir);
+  autoSession.reset();
+  autoSession.active = true;
+  autoSession.basePath = dir;
+  t.after(() => {
+    resetDestructiveConfirmation(dir);
+    autoSession.reset();
+  });
+
+  const { handlers, pi } = makeHookHarness();
+  registerHooks(pi, []);
+
+  const block = await runBashGuard(handlers, FORCE_PUSH, ctx);
+
+  assert.equal(block?.block, true, "real guard blocks the first destructive attempt");
+  assert.equal(autoSession.active, true, "auto-mode must remain active so ask_user_questions can run");
+  assert.deepEqual(
+    notifications.filter((message) => message.includes("Destructive-command confirmation")),
+    [],
+    "destructive confirmation pause must not fire from the bash tool_call hook",
+  );
+});
+
 test("integration: declining the confirm gate leaves the command blocked", async (t) => {
   const dir = "/tmp/gsd-destructive-confirm-int-decline";
   const ctx = { cwd: dir, ui: { notify: () => undefined } } as any;

package/src/resources/extensions/gsd/tests/destructive-guard.test.ts

@@ -29,6 +29,7 @@ test("destructive guard still detects direct and wrapper-prefixed recursive dele
     "find . -exec rm -rf {} \\;",
     "cat doomed.txt | xargs rm -rf /tmp/x",
     'rm -rf "/tmp/my build"',
+    "rm --recursive build",
   ];
 
   for (const command of destructiveCommands) {
@@ -39,6 +40,19 @@ test("destructive guard still detects direct and wrapper-prefixed recursive dele
   }
 });
 
+test("destructive guard does not classify force-only rm as recursive delete", () => {
+  const nonRecursiveCommands = [
+    "rm -f single-file.md",
+    "rm -fv single-file.md",
+    "rm single-file.md -f",
+    "rm --force single-file.md",
+  ];
+
+  for (const command of nonRecursiveCommands) {
+    assert.deepEqual(classifyCommand(command), { destructive: false, labels: [] }, command);
+  }
+});
+
 test("destructive guard treats quoted interpreter payloads as literals", () => {
   assert.deepEqual(classifyCommand('bash -c "rm -rf /"'), { destructive: false, labels: [] });
 });

package/src/resources/extensions/gsd/tests/doctor-scope-db-unavailable.test.ts

@@ -167,6 +167,77 @@ test("checkEngineHealth keeps PLAN checkbox divergence after stale projection fl
   assert.match(readFileSync(plan.planPath, "utf-8"), /- \[ \] \*\*T01\*\*:/);
 });
 
+test("checkEngineHealth ignores stale suffixed flat-phase duplicate when bare milestone exists", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-doctor-checkbox-flat-duplicate-"));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+
+  const gsdDir = join(base, ".gsd");
+  mkdirSync(gsdDir, { recursive: true });
+
+  openDatabase(join(gsdDir, "gsd.db"));
+  insertMilestone({ id: "M003", title: "M003-vaz73w: New milestone M003-vaz73w", status: "active" });
+  insertSlice({ id: "S01", milestoneId: "M003", title: "Slice", status: "pending", risk: "low", depends: [], sequence: 1 });
+  for (const taskId of ["T01", "T02", "T03"]) {
+    insertTask({ id: taskId, milestoneId: "M003", sliceId: "S01", title: taskId, status: "complete", sequence: Number(taskId.slice(1)) });
+  }
+
+  insertMilestone({ id: "M003-vaz73w", title: "New milestone M003-vaz73w", status: "active" });
+  insertSlice({ id: "S01", milestoneId: "M003-vaz73w", title: "Slice", status: "pending", risk: "low", depends: [], sequence: 1 });
+  for (const taskId of ["T01", "T02", "T03"]) {
+    insertTask({ id: taskId, milestoneId: "M003-vaz73w", sliceId: "S01", title: taskId, status: "complete", sequence: Number(taskId.slice(1)) });
+  }
+
+  const canonicalPlan = await renderPlanFromDb(base, "M003", "S01");
+  const staleDir = join(gsdDir, "phases", "03-vaz73w-new-milestone-m003-vaz73w");
+  mkdirSync(staleDir, { recursive: true });
+  writeFileSync(
+    join(staleDir, "03-01-PLAN.md"),
+    canonicalPlan.content.replace("- [x] **T03**:", "- [ ] **T03**:"),
+    "utf-8",
+  );
+
+  const issues: any[] = [];
+  await checkEngineHealth(base, issues, []);
+
+  assert.deepEqual(
+    issues.filter((issue) => issue.code === "checkbox_db_status_divergence").map((issue) => issue.unitId),
+    [],
+    "stale suffixed duplicate phase projection must not compete with the bare milestone projection",
+  );
+});
+
+test("checkEngineHealth reads task checkboxes from the canonical milestone worktree", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-doctor-checkbox-worktree-"));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+
+  const gsdDir = join(base, ".gsd");
+  mkdirSync(gsdDir, { recursive: true });
+
+  openDatabase(join(gsdDir, "gsd.db"));
+  insertMilestone({ id: "M003", title: "Milestone", status: "active" });
+  insertSlice({ id: "S01", milestoneId: "M003", title: "Slice", status: "pending", risk: "low", depends: [], sequence: 1 });
+  insertTask({ id: "T03", milestoneId: "M003", sliceId: "S01", title: "Task", status: "complete", sequence: 1 });
+
+  const plan = await renderPlanFromDb(base, "M003", "S01");
+  const checkedPlan = readFileSync(plan.planPath, "utf-8");
+  writeFileSync(plan.planPath, checkedPlan.replace("- [x] **T03**:", "- [ ] **T03**:"), "utf-8");
+
+  const worktree = join(base, ".gsd-worktrees", "M003");
+  const worktreePlan = join(worktree, ".gsd", "phases", "03-milestone", "03-01-PLAN.md");
+  mkdirSync(join(worktree, ".gsd", "phases", "03-milestone"), { recursive: true });
+  writeFileSync(join(worktree, ".git"), `gitdir: ${join(base, ".git", "worktrees", "M003")}\n`);
+  writeFileSync(worktreePlan, checkedPlan, "utf-8");
+
+  const issues: any[] = [];
+  await checkEngineHealth(base, issues, []);
+
+  assert.deepEqual(
+    issues.filter((issue) => issue.code === "checkbox_db_status_divergence").map((issue) => issue.unitId),
+    [],
+    "the stale project-root PLAN must not compete with the live milestone worktree projection",
+  );
+});
+
 test("checkEngineHealth reads task checkboxes from the <tasks> block, not a stray line above it", async (t) => {
   const base = mkdtempSync(join(tmpdir(), "gsd-doctor-task-section-"));
   t.after(() => rmSync(base, { recursive: true, force: true }));
@@ -336,6 +407,38 @@ test("checkEngineHealth reports artifact rows whose files are missing on disk",
   assert.equal(missing.fixable, false);
 });
 
+test("checkEngineHealth resolves artifact rows through the canonical milestone worktree", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-doctor-artifact-worktree-"));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+
+  const gsdDir = join(base, ".gsd");
+  const artifactPath = "phases/03-milestone/03-01-PLAN.md";
+  const worktree = join(base, ".gsd-worktrees", "M003");
+  mkdirSync(gsdDir, { recursive: true });
+  mkdirSync(join(worktree, ".gsd", "phases", "03-milestone"), { recursive: true });
+  writeFileSync(join(worktree, ".git"), `gitdir: ${join(base, ".git", "worktrees", "M003")}\n`);
+  writeFileSync(join(worktree, ".gsd", artifactPath), "# Plan\n", "utf-8");
+
+  openDatabase(join(gsdDir, "gsd.db"));
+  insertArtifact({
+    path: artifactPath,
+    artifact_type: "PLAN",
+    milestone_id: "M003",
+    slice_id: "S01",
+    task_id: null,
+    full_content: "# Plan\n",
+  });
+
+  const issues: any[] = [];
+  await checkEngineHealth(base, issues, []);
+
+  assert.equal(
+    issues.some((issue) => issue.code === "artifact_file_missing" && issue.file === artifactPath),
+    false,
+    "worktree-local artifact rows must not be reported missing from the project root",
+  );
+});
+
 test("checkEngineHealth resolves escaped .gsd artifact rows against the project .gsd directory", async (t) => {
   const base = mkdtempSync(join(tmpdir(), "gsd-doctor-escaped-artifact-"));
   t.after(() => rmSync(base, { recursive: true, force: true }));
@@ -428,6 +531,50 @@ test("checkEngineHealth repair prunes stale phases artifact rows with present mi
   assert.deepEqual(rows.map((row) => row.path), []);
 });
 
+test("checkEngineHealth repair prunes stale phases artifact rows with renamed flat-phase files", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-doctor-prune-renamed-flat-phase-artifact-"));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+
+  const gsdDir = join(base, ".gsd");
+  const stalePath = "phases/01-new-milestone-m001/01-01-PLAN.md";
+  const replacementPath = "phases/01-lokably-brand-foundation-and-welcome-pag/01-01-PLAN.md";
+  mkdirSync(join(gsdDir, "phases", "01-lokably-brand-foundation-and-welcome-pag"), { recursive: true });
+  writeFileSync(join(gsdDir, replacementPath), "# Plan\n", "utf-8");
+
+  openDatabase(join(gsdDir, "gsd.db"));
+  insertArtifact({
+    path: stalePath,
+    artifact_type: "PLAN",
+    milestone_id: "M001",
+    slice_id: "S01",
+    task_id: null,
+    full_content: "# stale plan\n",
+  });
+
+  const beforeIssues: any[] = [];
+  await checkEngineHealth(base, beforeIssues, []);
+
+  const beforeIssue = beforeIssues.find((issue) => issue.code === "artifact_file_missing" && issue.file === stalePath);
+  assert.ok(beforeIssue, "stale renamed phases row should be reported when repair is off");
+  assert.equal(beforeIssue.fixable, true, "renamed phases rows with a flat replacement should be fixable");
+
+  const repairIssues: any[] = [];
+  const fixes: string[] = [];
+  await checkEngineHealth(base, repairIssues, fixes, { repair: true });
+
+  assert.equal(
+    repairIssues.some((issue) => issue.code === "artifact_file_missing" && issue.file === stalePath),
+    false,
+    "repair should not report stale rows it pruned",
+  );
+  assert.ok(fixes.includes(`pruned stale flat-phase artifact row ${stalePath}`));
+
+  const rows = _getAdapter()!
+    .prepare("SELECT path FROM artifacts ORDER BY path")
+    .all() as Array<{ path: string }>;
+  assert.deepEqual(rows.map((row) => row.path), []);
+});
+
 test("checkEngineHealth repair keeps phases rows whose own file is still present", async (t) => {
   const base = mkdtempSync(join(tmpdir(), "gsd-doctor-keep-present-phase-artifact-"));
   t.after(() => rmSync(base, { recursive: true, force: true }));

package/src/resources/extensions/gsd/tests/exec-sandbox.test.ts

@@ -3,7 +3,7 @@
 
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
-import { existsSync, mkdtempSync, mkdirSync, readFileSync, rmSync } from 'node:fs';
+import { existsSync, mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 
@@ -152,6 +152,38 @@ test('runExecSandbox: node runtime executes JS', async () => {
   }
 });
 
+test('runExecSandbox: node runtime forwards NODE_PATH for GSD-installed dependencies', async () => {
+  const base = freshBase();
+  try {
+    const dependencyRoot = join(base, 'parent-node_modules');
+    const packageDir = join(dependencyRoot, 'fake-gsd-dep');
+    const worktree = join(base, 'project', '.gsd', 'worktrees', 'M003');
+    mkdirSync(packageDir, { recursive: true });
+    mkdirSync(worktree, { recursive: true });
+    writeFileSync(
+      join(packageDir, 'package.json'),
+      JSON.stringify({ name: 'fake-gsd-dep', version: '1.0.0', main: 'index.js' }),
+    );
+    writeFileSync(join(packageDir, 'index.js'), "module.exports = 'resolved-via-node-path';\n");
+
+    const result = await runExecSandbox(
+      { runtime: 'node', script: "console.log(require('fake-gsd-dep'))" },
+      baseOpts(worktree, {
+        env: {
+          PATH: '/usr/bin:/bin',
+          HOME: '/tmp',
+          NODE_PATH: dependencyRoot,
+        },
+      }),
+    );
+
+    assert.equal(result.exit_code, 0, readFileSync(result.stderr_path, 'utf-8'));
+    assert.ok(result.digest.includes('resolved-via-node-path'));
+  } finally {
+    cleanup(base);
+  }
+});
+
 test('runExecSandbox: rewrites NUL redirects for bash on Windows', async () => {
   const originalPlatform = process.platform;
   Object.defineProperty(process, 'platform', { value: 'win32' });

package/src/resources/extensions/gsd/tests/external-markdown-edit.test.ts

@@ -8,7 +8,8 @@ import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
 
 import { externalMarkdownEditHandler } from "../state-reconciliation/drift/external-markdown-edit.ts";
-import { writeCompatMarker, computeProjectionSha } from "../compat/compat-marker.ts";
+import { readCompatMarker, writeCompatMarker, computeProjectionSha } from "../compat/compat-marker.ts";
+import { closeDatabase, insertArtifact, openDatabase } from "../gsd-db.ts";
 import type { DriftContext } from "../state-reconciliation/types.ts";
 import type { GSDState } from "../types.ts";
 
@@ -28,6 +29,11 @@ function ctx(base: string): DriftContext {
 }
 
 afterEach(() => {
+  try {
+    closeDatabase();
+  } catch {
+    /* noop */
+  }
   for (const dir of tmpDirs) {
     try { rmSync(dir, { recursive: true, force: true }); } catch { /* */ }
   }
@@ -71,6 +77,37 @@ test("detect returns drift when file content differs from marker", async () => {
   assert.deepEqual(drift[0].entities, ["m1"]);
 });
 
+test("detect refreshes stale marker when current file already matches DB artifact", async () => {
+  const base = makeTmpBase();
+  const rel = "milestones/M001/M001-ROADMAP.md";
+  const dbRel = "phases/01-alpha/01-ROADMAP.md";
+  const content = "# M001: Alpha\n\n## Slices\n\n- [ ] **S01: Work** `risk:low` `depends:[]`\n";
+  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+  writeFileSync(join(base, ".gsd", rel), content, "utf-8");
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertArtifact({
+    path: dbRel,
+    artifact_type: "ROADMAP",
+    milestone_id: "M001",
+    slice_id: null,
+    task_id: null,
+    full_content: content,
+  });
+  writeCompatMarker(base, {
+    schema: 2,
+    lastWriter: "gsd-pi",
+    lastProjectedAt: "2026-06-21T00:00:00.000Z",
+    projections: { [rel]: { sha: "stale000000000000", entities: ["M001"] } },
+    planning: { active: false, layout: null, projections: {}, passthrough: {} },
+    piVersion: "1.9.0",
+  });
+
+  const drift = await externalMarkdownEditHandler.detect(stubState, ctx(base));
+  assert.equal(drift.length, 0);
+  const marker = readCompatMarker(base);
+  assert.equal(marker.projections[rel]?.sha, computeProjectionSha(content));
+});
+
 test("detect treats missing marker as drift on every tracked projection file", async () => {
   const base = makeTmpBase();
   const rel = "m1/roadmap.md";

package/src/resources/extensions/gsd/tests/flat-phase-migration.test.ts

@@ -122,7 +122,7 @@ test("migrateToFlatPhase creates a backup", async () => {
   assert.ok(backups.length >= 1, "at least one migrate-* backup dir should exist");
 });
 
-test("migrateToFlatPhase backs up existing phases projection before clearing it", async () => {
+test("migrateToFlatPhase removes disposable phases snapshot after successful migration", async () => {
   const base = makeTmp();
   const reviewPath = join(base, ".gsd", "phases", "01-foundation", "PLAN-REVIEW.md");
   mkdirSync(join(base, ".gsd", "phases", "01-foundation"), { recursive: true });
@@ -133,11 +133,10 @@ test("migrateToFlatPhase backs up existing phases projection before clearing it"
   const backupRoot = join(base, ".gsd-backups");
   const backups = readdirSync(backupRoot).filter(d => d.startsWith("migrate-"));
   assert.equal(backups.length, 1, "one migrate backup should exist");
-  const backedUpReview = join(backupRoot, backups[0]!, "__phases", "01-foundation", "PLAN-REVIEW.md");
   assert.equal(
-    readFileSync(backedUpReview, "utf-8"),
-    "# Plan Review\n\nHand-authored review.",
-    "pre-existing phases/ files should have a recovery copy",
+    existsSync(join(backupRoot, backups[0]!, "__phases")),
+    false,
+    "temporary phases/ recovery snapshot should be removed after success",
   );
 });
 
@@ -202,7 +201,7 @@ test("failed migration rolls back without leaking a .gsd-backups/migrate-* dir",
   assert.equal(leaked.length, 0, "rollback must delete the migrate-* backup it created");
 });
 
-test("resumed migration stores phases backup in retained migrate snapshot", async () => {
+test("resumed migration removes disposable phases snapshot after success", async () => {
   const base = makeTmp();
   const milestonesPath = join(base, ".gsd", "milestones");
   const migratingPath = join(base, ".gsd", "milestones.migrating");
@@ -218,9 +217,9 @@ test("resumed migration stores phases backup in retained migrate snapshot", asyn
   const backups = readdirSync(backupRoot).filter((d) => d.startsWith("migrate-"));
   assert.equal(backups.length, 1, "resumed migration should create one retained migrate backup");
   assert.equal(
-    readFileSync(join(backupRoot, backups[0]!, "__phases", "01-foundation", "PLAN-REVIEW.md"), "utf-8"),
-    "# Plan Review\n\nResume recovery copy.",
-    "resume should retain the phases snapshot under .gsd-backups",
+    existsSync(join(backupRoot, backups[0]!, "__phases")),
+    false,
+    "temporary phases/ recovery snapshot should be removed after resumed success",
   );
   assert.equal(
     existsSync(join(migratingPath, "__phases")),

package/src/resources/extensions/gsd/tests/flat-phase-validation-path.test.ts

@@ -9,7 +9,7 @@ import { join } from "node:path";
 import assert from "node:assert/strict";
 import test from "node:test";
 
-import { normalizeRealPath, relMilestoneFile, relSliceFile, resolveMilestoneFile, targetMilestoneFile } from "../paths.ts";
+import { normalizeRealPath, relMilestoneFile, relSliceFile, resolveMilestoneFile, resolveSliceFile, targetMilestoneFile } from "../paths.ts";
 
 function makeFlatPhaseFixture(): { basePath: string; cleanup: () => void } {
   const basePath = mkdtempSync(join(tmpdir(), "flat-phase-validation-"));
@@ -99,6 +99,25 @@ test("flat-phase: resolveMilestoneFile finds the on-disk file", (t) => {
   assert.equal(existsSync(abs!), true);
 });
 
+test("flat-phase: file resolvers ignore directories with artifact-like names", (t) => {
+  const basePath = mkdtempSync(join(tmpdir(), "flat-phase-dir-artifacts-"));
+  t.after(() => rmSync(basePath, { recursive: true, force: true }));
+  const phaseDir = join(basePath, ".gsd", "phases", "03-match-capture-manual-entry");
+  mkdirSync(join(phaseDir, "03-VALIDATION.md"), { recursive: true });
+  mkdirSync(join(phaseDir, "03-01-SUMMARY.md"), { recursive: true });
+
+  assert.equal(
+    resolveMilestoneFile(basePath, "M003", "VALIDATION"),
+    null,
+    "milestone resolver must not return a directory as a validation file",
+  );
+  assert.equal(
+    resolveSliceFile(basePath, "M003", "S01", "SUMMARY"),
+    null,
+    "slice resolver must not return a directory as a summary file",
+  );
+});
+
 test("flat-phase: the legacy hardcoded path does NOT resolve (regression for #876)", (t) => {
   const { basePath, cleanup } = makeFlatPhaseFixture();
   t.after(cleanup);

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

@@ -46,6 +46,9 @@ import {
   tryCreateMemoriesFts,
   _isLikelyWslDrvFsPathForTest,
   _shouldAttemptVacuumRecoveryForTest,
+  insertArtifact,
+  getArtifact,
+  upsertMilestonePlanning,
 } from '../gsd-db.ts';
 import { MigrationBackupError } from '../db-migration-backup.ts';
 import { _resetLogs, peekLogs, setStderrLoggingEnabled } from '../workflow-logger.ts';
@@ -357,6 +360,35 @@ describe('gsd-db', () => {
     closeDatabase();
   });
 
+  test("gsd-db: upsertMilestonePlanning rewrites placeholder phase artifact paths to final title slug", () => {
+    openDatabase(":memory:");
+
+    const stalePath = "phases/01-new-milestone-m001/01-ROADMAP.md";
+    const finalPath = "phases/01-lokably-brand-foundation-and-welcome-pag/01-ROADMAP.md";
+    insertMilestone({ id: "M001", title: "New milestone M001", status: "active" });
+    insertArtifact({
+      path: stalePath,
+      artifact_type: "ROADMAP",
+      milestone_id: "M001",
+      slice_id: null,
+      task_id: null,
+      full_content: "# Placeholder roadmap\n",
+    });
+
+    upsertMilestonePlanning("M001", {
+      title: "Lokably brand foundation and welcome page rebuild",
+    });
+
+    assert.equal(getArtifact(stalePath), null, "placeholder-derived artifact row should be removed");
+    assert.equal(
+      getArtifact(finalPath)?.full_content,
+      "# Placeholder roadmap\n",
+      "artifact row should move to the final title-derived phase path",
+    );
+
+    closeDatabase();
+  });
+
   test('gsd-db: active_requirements view excludes superseded', () => {
     openDatabase(':memory:');
 

package/src/resources/extensions/gsd/tests/guided-discuss-milestone-prompt-rendering.test.ts

@@ -87,6 +87,28 @@ test("guided milestone prompt builder preloads milestone planning context", asyn
   }
 });
 
+test("guided milestone prompt builder prepends configured response language", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-guided-milestone-language-"));
+  const gsdHome = mkdtempSync(join(tmpdir(), "gsd-guided-milestone-language-home-"));
+  const previousGsdHome = process.env.GSD_HOME;
+  process.env.GSD_HOME = gsdHome;
+
+  try {
+    writeFileSync(join(gsdHome, "PREFERENCES.md"), "---\nversion: 1\nlanguage: 中文\n---\n", "utf-8");
+
+    const prompt = await buildDiscussMilestonePrompt("M001", "Language Preference", base, "true", {
+      includeContextMode: false,
+    });
+
+    assert.match(prompt, /^## Response Language\n\nAlways respond in 中文/);
+  } finally {
+    if (previousGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = previousGsdHome;
+    rmSync(base, { recursive: true, force: true });
+    rmSync(gsdHome, { recursive: true, force: true });
+  }
+});
+
 test("guided milestone prompt builder caps prior draft seed before interpolation", async () => {
   const base = mkdtempSync(join(tmpdir(), "gsd-guided-milestone-draft-cap-"));
   const previousGsdHome = process.env.GSD_HOME;

package/src/resources/extensions/gsd/tests/integration/git-service.test.ts

@@ -1428,6 +1428,19 @@ process.exit(result.status ?? 0);
     rmSync(repo, { recursive: true, force: true });
   });
 
+  test('Integration branch: write does not create legacy milestones scaffold', () => {
+    const repo = initBranchTestRepo();
+    mkdirSync(join(repo, ".gsd", "phases"), { recursive: true });
+
+    writeIntegrationBranch(repo, "M001", "f-123-new-thing");
+
+    assert.deepStrictEqual(readIntegrationBranch(repo, "M001"), "f-123-new-thing");
+    assert.ok(existsSync(join(repo, ".gsd", "M001-META.json")), "metadata is written at the flat .gsd root");
+    assert.ok(!existsSync(join(repo, ".gsd", "milestones")), "legacy milestones/ root is not created");
+
+    rmSync(repo, { recursive: true, force: true });
+  });
+
   // ─── writeIntegrationBranch: updates when branch changes (#300) ──────
 
   test('Integration branch: updates on branch change', () => {

package/src/resources/extensions/gsd/tests/integration/paths.test.ts

@@ -1,6 +1,6 @@
 import { describe, test } from 'node:test';
 import assert from 'node:assert/strict';
-import { mkdtempSync, mkdirSync, rmSync, realpathSync, symlinkSync, writeFileSync } from "node:fs";
+import { mkdtempSync, mkdirSync, rmSync, realpathSync, symlinkSync, unlinkSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { spawnSync } from "node:child_process";
@@ -12,6 +12,8 @@ import {
   resolveGsdPathContract,
   resolveSliceFile,
   resolveTaskFile,
+  resolveTaskFiles,
+  taskIdFromTaskFileName,
   _clearGsdRootCache,
 } from "../../paths.ts";
 /** Create a tmp dir and resolve symlinks + 8.3 short names (macOS /var→/private/var, Windows RUNNER~1→runneradmin). */
@@ -171,21 +173,37 @@ describe('paths', () => {
   test('Case 9: flat-phase task SUMMARY resolves at phase root despite a stray slices/SID/ dir', () => {
     const root = tmp();
     try {
-      // Hybrid flat-phase milestone: phase dir holds flat TID-SUMMARY.md, but a
+      // Hybrid flat-phase milestone: phase dir holds flat task summaries, but a
       // stray slices/S01/ folder also exists on disk. resolveSlicePath then points
       // under slices/, so layout (phases/ vs milestones/) — not slicePath===phaseDir
       // — must decide the flat-phase task summary location.
       const phaseDir = join(root, ".gsd", "phases", "01-foo");
       mkdirSync(join(phaseDir, "slices", "S01"), { recursive: true });
-      const flatSummary = join(phaseDir, "T01-SUMMARY.md");
+      const flatSummary = join(phaseDir, "S01-T01-SUMMARY.md");
+      const legacyFlatSummary = join(phaseDir, "T01-SUMMARY.md");
       writeFileSync(flatSummary, "# task summary\n");
+      writeFileSync(legacyFlatSummary, "# legacy task summary\n");
 
       _clearGsdRootCache();
 
+      assert.deepStrictEqual(resolveTaskFiles(phaseDir, "SUMMARY").sort(), [
+        "S01-T01-SUMMARY.md",
+        "T01-SUMMARY.md",
+      ]);
+      assert.equal(taskIdFromTaskFileName("S01-T01-SUMMARY.md", "SUMMARY"), "T01");
+      assert.equal(taskIdFromTaskFileName("T01-SUMMARY.md", "SUMMARY"), "T01");
+
       assert.deepStrictEqual(
         resolveTaskFile(root, "M001", "S01", "T01", "SUMMARY"),
         flatSummary,
-        "flat-phase TID-SUMMARY.md at phase root is found even when slices/S01/ exists",
+        "flat-phase S01-T01-SUMMARY.md at phase root is preferred even when slices/S01/ exists",
+      );
+
+      unlinkSync(flatSummary);
+      assert.deepStrictEqual(
+        resolveTaskFile(root, "M001", "S01", "T01", "SUMMARY"),
+        legacyFlatSummary,
+        "legacy flat T01-SUMMARY.md is still found as a fallback",
       );
     } finally { cleanup(root); }
   });

package/src/resources/extensions/gsd/tests/integration-branch-meta-location.test.ts

@@ -0,0 +1,62 @@
+// gsd-pi — Integration-branch META lives OUTSIDE milestones/<MID>/ (ADR-045).
+// Verifies the relocation from milestones/<MID>/<MID>-META.json to the flat
+// .gsd/<MID>-META.json so it can never poison isLegacyMilestonesLayout.
+
+import assert from "node:assert/strict";
+import { afterEach, beforeEach, test } from "node:test";
+import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { readIntegrationBranch, writeIntegrationBranch } from "../git-service.js";
+import { gsdRoot, isLegacyMilestonesLayout } from "../paths.js";
+
+let repo: string;
+
+beforeEach(() => {
+  repo = mkdtempSync(join(tmpdir(), "gsd-meta-loc-"));
+});
+
+afterEach(() => {
+  rmSync(repo, { recursive: true, force: true });
+});
+
+test("write goes to the new flat .gsd/<MID>-META.json, not milestones/<MID>/", () => {
+  writeIntegrationBranch(repo, "M001", "main");
+
+  assert.ok(
+    existsSync(join(gsdRoot(repo), "M001-META.json")),
+    "META written to flat .gsd/<MID>-META.json",
+  );
+  assert.ok(
+    !existsSync(join(gsdRoot(repo), "milestones", "M001", "M001-META.json")),
+    "no META in legacy milestones/<MID>/ location",
+  );
+});
+
+test("round-trip: read returns what write recorded", () => {
+  writeIntegrationBranch(repo, "M001", "main");
+  assert.equal(readIntegrationBranch(repo, "M001"), "main");
+});
+
+test("read falls back to the legacy milestones/<MID>/ location", () => {
+  const legacyDir = join(gsdRoot(repo), "milestones", "M001");
+  mkdirSync(legacyDir, { recursive: true });
+  writeFileSync(
+    join(legacyDir, "M001-META.json"),
+    JSON.stringify({ integrationBranch: "develop" }) + "\n",
+    "utf-8",
+  );
+
+  assert.equal(readIntegrationBranch(repo, "M001"), "develop");
+});
+
+test("writing META does not create milestones/<MID>/ or flip layout detection", () => {
+  assert.equal(isLegacyMilestonesLayout(repo), false, "clean tree is not legacy layout");
+  writeIntegrationBranch(repo, "M001", "main");
+  assert.equal(
+    isLegacyMilestonesLayout(repo),
+    false,
+    "writing integration-branch META must not poison layout detection",
+  );
+});