@opengsd/gsd-pi 1.4.0-dev.c18009cd → 1.5.0-dev.4fb2d460

package/src/resources/extensions/gsd/tests/milestone-merge-stash-restore.test.ts

@@ -3,6 +3,10 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 
 import {
   _runMilestoneMergeOnceWithStashRestore,
@@ -10,6 +14,9 @@ import {
 } from "../auto/closeout.js";
 import type { IterationContext } from "../auto/types.js";
 import { MergeConflictError } from "../git-service.js";
+import { closeDatabase, insertDecision, insertMilestone, insertSlice, insertTask, openDatabase } from "../gsd-db.js";
+import { renderAllFromDb } from "../markdown-renderer.js";
+import { resolveMilestoneFile } from "../paths.js";
 import type {
   PostflightResult,
   PreflightResult,
@@ -234,6 +241,70 @@ const PREFLIGHT_UNMERGED_EVAL_FAILED: PreflightResult = {
   summary: "Unable to fully evaluate unresolved Git conflicts before milestone M002 merge.",
 };
 
+function git(basePath: string, args: string[], stdio: "ignore" | "pipe" = "pipe"): void {
+  execFileSync("git", args, { cwd: basePath, stdio });
+}
+
+async function withProjectionBackedProject<T>(
+  fn: (basePath: string, roadmapPath: string) => Promise<T>,
+  options: { gitInit?: boolean } = {},
+): Promise<T> {
+  const basePath = mkdtempSync(join(tmpdir(), "gsd-postflight-projection-"));
+  try {
+    mkdirSync(join(basePath, ".gsd"), { recursive: true });
+    openDatabase(join(basePath, ".gsd", "gsd.db"));
+    insertMilestone({
+      id: "M002",
+      title: "Postflight Guard",
+      status: "active",
+    });
+    insertSlice({
+      id: "S01",
+      milestoneId: "M002",
+      title: "Slice",
+      status: "pending",
+      risk: "medium",
+      depends: [],
+      demo: "demo",
+      sequence: 1,
+    });
+    insertTask({
+      id: "T01",
+      sliceId: "S01",
+      milestoneId: "M002",
+      title: "Task",
+      status: "pending",
+    });
+    await renderAllFromDb(basePath);
+    if (options.gitInit !== false) {
+      git(basePath, ["init"], "ignore");
+      git(basePath, ["config", "user.email", "test@example.invalid"]);
+      git(basePath, ["config", "user.name", "Test"]);
+      git(basePath, ["add", ".gsd"]);
+      git(basePath, ["commit", "-m", "initial projections"], "ignore");
+    }
+    const roadmapPath = resolveMilestoneFile(basePath, "M002", "ROADMAP");
+    assert.ok(roadmapPath, "expected rendered M002 roadmap path");
+    return await fn(basePath, roadmapPath);
+  } finally {
+    closeDatabase();
+    rmSync(basePath, { recursive: true, force: true });
+  }
+}
+
+function insertFreshDbSlice(): void {
+  insertSlice({
+    id: "S02",
+    milestoneId: "M002",
+    title: "Fresh DB Slice",
+    status: "pending",
+    risk: "medium",
+    depends: [],
+    demo: "demo",
+    sequence: 2,
+  });
+}
+
 const POP_OK: PostflightResult = {
   restored: true,
   needsManualRecovery: false,
@@ -469,6 +540,374 @@ test("already-merged milestone skips guarded merge to terminate duplicate closeo
   );
 });
 
+
+test("postflight-restored projection edits survive successful merge rebuild", async () => {
+  await withProjectionBackedProject(async (basePath, roadmapPath) => {
+    const { ic } = buildIc({
+      preflightResult: STASH_PUSHED,
+      mergeBehavior: "succeed",
+      postflightResult: POP_OK,
+    });
+    (ic.s as { basePath: string; originalBasePath: string }).basePath = basePath;
+    (ic.s as { basePath: string; originalBasePath: string }).originalBasePath = basePath;
+    (ic.deps as unknown as { postflightPopStash: () => PostflightResult }).postflightPopStash = () => {
+      writeFileSync(roadmapPath, "# local projection edit restored from stash\n", "utf8");
+      return POP_OK;
+    };
+
+    const result = await _runMilestoneMergeWithStashRestore(ic, "M002");
+
+    assert.equal(result, null);
+    assert.equal(
+      readFileSync(roadmapPath, "utf8"),
+      "# local projection edit restored from stash\n",
+      "projection rebuild must not overwrite user edits restored by postflight stash pop",
+    );
+  });
+});
+
+test("untracked markdown under a new generated .gsd projection directory suppresses successful merge rebuild", async () => {
+  await withProjectionBackedProject(async (basePath, roadmapPath) => {
+    insertFreshDbSlice();
+
+    const { ic } = buildIc({
+      preflightResult: STASH_PUSHED,
+      mergeBehavior: "succeed",
+      postflightResult: POP_OK,
+    });
+    (ic.s as { basePath: string; originalBasePath: string }).basePath = basePath;
+    (ic.s as { basePath: string; originalBasePath: string }).originalBasePath = basePath;
+    (ic.deps as unknown as { postflightPopStash: () => PostflightResult }).postflightPopStash = () => {
+      const restoredDir = join(basePath, ".gsd", "milestones", "M002", "slices", "S99");
+      mkdirSync(restoredDir, { recursive: true });
+      writeFileSync(join(restoredDir, "S99-SUMMARY.md"), "# restored local markdown\n", "utf8");
+      return POP_OK;
+    };
+
+    const result = await _runMilestoneMergeWithStashRestore(ic, "M002");
+
+    assert.equal(result, null);
+    assert.doesNotMatch(
+      readFileSync(roadmapPath, "utf8"),
+      /Fresh DB Slice/,
+      "untracked markdown projections inside generated .gsd directories must suppress rebuild",
+    );
+  });
+});
+
+test("ignored untracked markdown under .gsd suppresses successful merge rebuild", async () => {
+  await withProjectionBackedProject(async (basePath, roadmapPath) => {
+    writeFileSync(join(basePath, ".gitignore"), ".gsd\n", "utf8");
+    git(basePath, ["add", ".gitignore"]);
+    git(basePath, ["commit", "-m", "ignore gsd projections"], "ignore");
+    insertFreshDbSlice();
+
+    const { ic } = buildIc({
+      preflightResult: STASH_PUSHED,
+      mergeBehavior: "succeed",
+      postflightResult: POP_OK,
+    });
+    (ic.s as { basePath: string; originalBasePath: string }).basePath = basePath;
+    (ic.s as { basePath: string; originalBasePath: string }).originalBasePath = basePath;
+    (ic.deps as unknown as { postflightPopStash: () => PostflightResult }).postflightPopStash = () => {
+      const restoredDir = join(basePath, ".gsd", "milestones", "M002", "ignored-restored-projections");
+      mkdirSync(restoredDir, { recursive: true });
+      writeFileSync(join(restoredDir, "S99-SUMMARY.md"), "# ignored restored local markdown\n", "utf8");
+      return POP_OK;
+    };
+
+    const result = await _runMilestoneMergeWithStashRestore(ic, "M002");
+
+    assert.equal(result, null);
+    assert.doesNotMatch(
+      readFileSync(roadmapPath, "utf8"),
+      /Fresh DB Slice/,
+      "ignored .gsd markdown projections restored by postflight must suppress rebuild",
+    );
+  });
+});
+
+test("preexisting ignored markdown under .gsd does not suppress successful merge rebuild", async () => {
+  await withProjectionBackedProject(async (basePath, roadmapPath) => {
+    writeFileSync(join(basePath, ".gitignore"), ".gsd\n", "utf8");
+    git(basePath, ["add", ".gitignore"]);
+    git(basePath, ["commit", "-m", "ignore gsd projections"], "ignore");
+    mkdirSync(join(basePath, ".gsd", "milestones", "M002", "ignored-existing-projections"), { recursive: true });
+    writeFileSync(
+      join(basePath, ".gsd", "milestones", "M002", "ignored-existing-projections", "S99-SUMMARY.md"),
+      "# already ignored local markdown\n",
+      "utf8",
+    );
+    insertFreshDbSlice();
+
+    const { ic } = buildIc({
+      preflightResult: STASH_PUSHED,
+      mergeBehavior: "succeed",
+      postflightResult: POP_OK,
+    });
+    (ic.s as { basePath: string; originalBasePath: string }).basePath = basePath;
+    (ic.s as { basePath: string; originalBasePath: string }).originalBasePath = basePath;
+
+    const result = await _runMilestoneMergeWithStashRestore(ic, "M002");
+
+    assert.equal(result, null);
+    assert.match(
+      readFileSync(roadmapPath, "utf8"),
+      /Fresh DB Slice/,
+      "stable preexisting ignored .gsd markdown must not block the required projection rebuild",
+    );
+  });
+});
+
+test("failed pre-merge ignored snapshot still suppresses rebuild over restored ignored markdown", async () => {
+  await withProjectionBackedProject(async (basePath, roadmapPath) => {
+    insertFreshDbSlice();
+
+    const { ic } = buildIc({
+      preflightResult: STASH_PUSHED,
+      mergeBehavior: "succeed",
+      postflightResult: POP_OK,
+    });
+    (ic.s as { basePath: string; originalBasePath: string }).basePath = basePath;
+    (ic.s as { basePath: string; originalBasePath: string }).originalBasePath = basePath;
+    (ic.deps as unknown as { postflightPopStash: () => PostflightResult }).postflightPopStash = () => {
+      // Git only becomes available AFTER the pre-merge ignored-markdown
+      // snapshot was attempted, so `before` is null. Postflight then restores
+      // ignored `.gsd` markdown that plain `git status` cannot see. With no
+      // baseline to diff against, the guard must fail closed and refuse to
+      // rebuild over the restored edit.
+      git(basePath, ["init"], "ignore");
+      git(basePath, ["config", "user.email", "test@example.invalid"]);
+      git(basePath, ["config", "user.name", "Test"]);
+      writeFileSync(join(basePath, ".gitignore"), ".gsd\n", "utf8");
+      git(basePath, ["add", ".gitignore"]);
+      git(basePath, ["commit", "-m", "ignore gsd projections"], "ignore");
+      writeFileSync(roadmapPath, "# ignored projection edit restored from stash\n", "utf8");
+      return POP_OK;
+    };
+
+    const result = await _runMilestoneMergeWithStashRestore(ic, "M002");
+
+    assert.equal(result, null);
+    assert.equal(
+      readFileSync(roadmapPath, "utf8"),
+      "# ignored projection edit restored from stash\n",
+      "a null pre-merge ignored snapshot must fail closed and preserve restored ignored .gsd markdown",
+    );
+  }, { gitInit: false });
+});
+
+test("non-projection .gsd markdown does not suppress successful merge rebuild", async () => {
+  await withProjectionBackedProject(async (basePath, roadmapPath) => {
+    insertFreshDbSlice();
+
+    const { ic } = buildIc({
+      preflightResult: STASH_PUSHED,
+      mergeBehavior: "succeed",
+      postflightResult: POP_OK,
+    });
+    (ic.s as { basePath: string; originalBasePath: string }).basePath = basePath;
+    (ic.s as { basePath: string; originalBasePath: string }).originalBasePath = basePath;
+    (ic.deps as unknown as { postflightPopStash: () => PostflightResult }).postflightPopStash = () => {
+      writeFileSync(join(basePath, ".gsd", "PREFERENCES.md"), "# local preferences note\n", "utf8");
+      mkdirSync(join(basePath, ".gsd", "milestones", "M002"), { recursive: true });
+      writeFileSync(join(basePath, ".gsd", "milestones", "M002", "NOTES.md"), "# local milestone note\n", "utf8");
+      return POP_OK;
+    };
+
+    const result = await _runMilestoneMergeWithStashRestore(ic, "M002");
+
+    assert.equal(result, null);
+    assert.match(
+      readFileSync(roadmapPath, "utf8"),
+      /Fresh DB Slice/,
+      "non-generated .gsd markdown must not block the required projection rebuild",
+    );
+  });
+});
+
+test("three-digit flat-phase projection restored by postflight suppresses successful merge rebuild", async () => {
+  await withProjectionBackedProject(async (basePath, roadmapPath) => {
+    insertFreshDbSlice();
+
+    const { ic } = buildIc({
+      preflightResult: STASH_PUSHED,
+      mergeBehavior: "succeed",
+      postflightResult: POP_OK,
+    });
+    (ic.s as { basePath: string; originalBasePath: string }).basePath = basePath;
+    (ic.s as { basePath: string; originalBasePath: string }).originalBasePath = basePath;
+    (ic.deps as unknown as { postflightPopStash: () => PostflightResult }).postflightPopStash = () => {
+      const restoredDir = join(basePath, ".gsd", "phases", "999-db-backed-planning");
+      mkdirSync(restoredDir, { recursive: true });
+      writeFileSync(join(restoredDir, "999-ROADMAP.md"), "# restored 3-digit projection\n", "utf8");
+      return POP_OK;
+    };
+
+    const result = await _runMilestoneMergeWithStashRestore(ic, "M002");
+
+    assert.equal(result, null);
+    assert.doesNotMatch(
+      readFileSync(roadmapPath, "utf8"),
+      /Fresh DB Slice/,
+      "three-digit flat-phase projections restored by postflight must suppress rebuild",
+    );
+  });
+});
+
+test("root DECISIONS projection restored by postflight suppresses successful merge rebuild", async () => {
+  await withProjectionBackedProject(async (basePath, roadmapPath) => {
+    insertFreshDbSlice();
+    insertDecision({
+      id: "D001",
+      when_context: "closeout",
+      scope: "global",
+      decision: "Regenerate decisions from DB",
+      choice: "Use database projection",
+      rationale: "Exercise root decision projection rebuild",
+      revisable: "Yes",
+      made_by: "agent",
+      superseded_by: null,
+    });
+
+    const { ic } = buildIc({
+      preflightResult: STASH_PUSHED,
+      mergeBehavior: "succeed",
+      postflightResult: POP_OK,
+    });
+    (ic.s as { basePath: string; originalBasePath: string }).basePath = basePath;
+    (ic.s as { basePath: string; originalBasePath: string }).originalBasePath = basePath;
+    (ic.deps as unknown as { postflightPopStash: () => PostflightResult }).postflightPopStash = () => {
+      writeFileSync(
+        join(basePath, ".gsd", "DECISIONS.md"),
+        "# local decisions edit restored from stash\n",
+        "utf8",
+      );
+      return POP_OK;
+    };
+
+    const result = await _runMilestoneMergeWithStashRestore(ic, "M002");
+
+    assert.equal(result, null);
+    assert.doesNotMatch(
+      readFileSync(roadmapPath, "utf8"),
+      /Fresh DB Slice/,
+      "root generated DECISIONS.md restored by postflight must suppress rebuild",
+    );
+    assert.equal(
+      readFileSync(join(basePath, ".gsd", "DECISIONS.md"), "utf8"),
+      "# local decisions edit restored from stash\n",
+      "rebuild must not overwrite restored root DECISIONS.md edits",
+    );
+  });
+});
+
+test("non-projection .gsd dirt does not suppress successful merge rebuild", async () => {
+  await withProjectionBackedProject(async (basePath, roadmapPath) => {
+    insertFreshDbSlice();
+    mkdirSync(join(basePath, ".gsd", "runtime"), { recursive: true });
+
+    const { ic } = buildIc({
+      preflightResult: STASH_PUSHED,
+      mergeBehavior: "succeed",
+      postflightResult: POP_OK,
+    });
+    (ic.s as { basePath: string; originalBasePath: string }).basePath = basePath;
+    (ic.s as { basePath: string; originalBasePath: string }).originalBasePath = basePath;
+    (ic.deps as unknown as { postflightPopStash: () => PostflightResult }).postflightPopStash = () => {
+      writeFileSync(join(basePath, ".gsd", "runtime", "restored.json"), "{}\n", "utf8");
+      return POP_OK;
+    };
+
+    const result = await _runMilestoneMergeWithStashRestore(ic, "M002");
+
+    assert.equal(result, null);
+    assert.match(
+      readFileSync(roadmapPath, "utf8"),
+      /Fresh DB Slice/,
+      "non-projection .gsd dirt must not block the required projection rebuild",
+    );
+  });
+});
+
+test("guarded merge stash restore and rebuild target the same canonical project root", async () => {
+  await withProjectionBackedProject(async (realRoot, roadmapPath) => {
+    insertFreshDbSlice();
+    let postflightProjectRoot: string | undefined;
+
+    const { ic } = buildIc({
+      preflightResult: STASH_PUSHED,
+      mergeBehavior: "succeed",
+      postflightResult: POP_OK,
+    });
+    // originalBasePath empty + basePath diverging from canonicalProjectRoot is
+    // the exact condition where the guard (snapshot / dirty check / rebuild)
+    // could run against a different tree than the postflight stash restore.
+    // The postflight restore must land on the same canonical root the guard
+    // inspects and the rebuild writes, otherwise restored edits are missed.
+    (ic.s as unknown as {
+      basePath: string;
+      originalBasePath: string;
+      canonicalProjectRoot: string;
+    }).basePath = "/tmp/gsd-decoy-basepath-not-the-project-root";
+    (ic.s as unknown as { originalBasePath: string }).originalBasePath = "";
+    (ic.s as unknown as { canonicalProjectRoot: string }).canonicalProjectRoot = realRoot;
+    (ic.deps as unknown as { postflightPopStash: (projectRoot: string) => PostflightResult }).postflightPopStash =
+      (projectRoot: string) => {
+        postflightProjectRoot = projectRoot;
+        writeFileSync(roadmapPath, "# projection edit restored from stash\n", "utf8");
+        return POP_OK;
+      };
+
+    const result = await _runMilestoneMergeWithStashRestore(ic, "M002");
+
+    assert.equal(result, null);
+    assert.equal(
+      postflightProjectRoot,
+      realRoot,
+      "postflight stash restore must run at the canonical project root the guard and rebuild use",
+    );
+    assert.equal(
+      readFileSync(roadmapPath, "utf8"),
+      "# projection edit restored from stash\n",
+      "restored projection edits on the canonical root must suppress the rebuild",
+    );
+  });
+});
+
+test("git-quoted special-character .gsd markdown paths still suppress rebuild", async () => {
+  await withProjectionBackedProject(async (basePath, roadmapPath) => {
+    insertFreshDbSlice();
+
+    const { ic } = buildIc({
+      preflightResult: STASH_PUSHED,
+      mergeBehavior: "succeed",
+      postflightResult: POP_OK,
+    });
+    (ic.s as { basePath: string; originalBasePath: string }).basePath = basePath;
+    (ic.s as { basePath: string; originalBasePath: string }).originalBasePath = basePath;
+    (ic.deps as unknown as { postflightPopStash: () => PostflightResult }).postflightPopStash = () => {
+      const restoredDir = join(basePath, ".gsd", "milestones", "M002", "restoréd");
+      mkdirSync(restoredDir, { recursive: true });
+      // A non-ASCII generated projection path that `git status --porcelain`
+      // C-quotes without -z; a naive line.endsWith(".md") check would miss the
+      // quoted path. NUL-delimited (-z) parsing sees the raw path and still
+      // detects it as generated projection dirt.
+      writeFileSync(join(restoredDir, "S99-SUMMARY.md"), "# restored local markdown\n", "utf8");
+      return POP_OK;
+    };
+
+    const result = await _runMilestoneMergeWithStashRestore(ic, "M002");
+
+    assert.equal(result, null);
+    assert.doesNotMatch(
+      readFileSync(roadmapPath, "utf8"),
+      /Fresh DB Slice/,
+      "special-character generated .gsd markdown restored by postflight must suppress the rebuild",
+    );
+  });
+});
+
 test("merge succeeds but stash pop needs manual recovery -> postflight-stash-restore-failed break", async () => {
   const { ic, log } = buildIc({
     preflightResult: STASH_PUSHED,

package/src/resources/extensions/gsd/tests/milestone-merge-transaction.test.ts

@@ -5,6 +5,7 @@ import test from "node:test";
 import assert from "node:assert/strict";
 
 import {
+  createDefaultMilestoneMergeTransaction,
   createMilestoneMergeTransaction,
   runMilestoneMergeTransaction,
 } from "../milestone-merge-transaction.js";
@@ -44,3 +45,26 @@ test("createMilestoneMergeTransaction returns a lifecycle-compatible runner", ()
     codeFilesChanged: false,
   });
 });
+
+test("createDefaultMilestoneMergeTransaction hides the legacy merge adapter behind the transaction seam", () => {
+  const calls: unknown[][] = [];
+  const runner = createDefaultMilestoneMergeTransaction(
+    (basePath, milestoneId, roadmapContent) => {
+      calls.push([basePath, milestoneId, roadmapContent]);
+      return {
+        pushed: false,
+        codeFilesChanged: true,
+        commitMessage: "merge M003",
+        prCreated: false,
+      };
+    },
+  );
+
+  assert.deepEqual(runner("/repo", "M003", "# M003"), {
+    pushed: false,
+    codeFilesChanged: true,
+    commitMessage: "merge M003",
+    prCreated: false,
+  });
+  assert.deepEqual(calls, [["/repo", "M003", "# M003"]]);
+});

package/src/resources/extensions/gsd/tests/none-mode-gates.test.ts

@@ -18,7 +18,7 @@ import { execFileSync } from "node:child_process";
 
 import { shouldUseWorktreeIsolation } from "../auto.ts";
 import { getIsolationMode } from "../preferences.ts";
-import { getActiveAutoWorktreeContext } from "../auto-worktree.ts";
+import { getActiveAutoWorktreeContext } from "../auto-worktree-session-registry.ts";
 import { invalidateAllCaches } from "../cache.ts";
 import { describe, test, beforeEach, afterEach } from 'node:test';
 import assert from 'node:assert/strict';

package/src/resources/extensions/gsd/tests/originalbase-path-comparison.test.ts

@@ -26,12 +26,12 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execFileSync } from "node:child_process";
 
+import { createAutoWorktree } from "../auto-worktree-creation.ts";
 import {
   getAutoWorktreeOriginalBase,
   _resetAutoWorktreeOriginalBaseForTests,
-  createAutoWorktree,
-  teardownAutoWorktree,
-} from "../auto-worktree.ts";
+} from "../auto-worktree-session-registry.ts";
+import { teardownAutoWorktree } from "../auto-worktree-teardown.ts";
 import { normalizeWorktreePathForCompare } from "../worktree-root.ts";
 
 // ─── Helpers ──────────────────────────────────────────────────────────────────

package/src/resources/extensions/gsd/tests/parallel-worker-lock-contention.test.ts

@@ -32,7 +32,7 @@ import { gsdRoot } from "../paths.ts";
 import {
   syncProjectRootToWorktree,
   syncStateToProjectRoot,
-} from "../auto-worktree.ts";
+} from "../auto-worktree-sync.ts";
 import { writeLock, readCrashLock, clearLock } from "../crash-recovery.ts";
 import { describe, test, beforeEach, afterEach } from "node:test";
 import assert from "node:assert/strict";

package/src/resources/extensions/gsd/tests/preferences-worktree-sync.test.ts

@@ -12,7 +12,7 @@ import assert from "node:assert/strict";
 import { readFileSync, mkdtempSync, mkdirSync, writeFileSync, existsSync, readdirSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
-import { syncWorktreeStateBack } from "../auto-worktree.ts";
+import { syncGsdStateToWorktree, syncWorktreeStateBack } from "../auto-worktree-sync.ts";
 
 test("#2684: syncWorktreeStateBack does not overwrite project PREFERENCES.md", () => {
   const mainBase = mkdtempSync(join(tmpdir(), "gsd-wt-prefs-main-"));
@@ -58,8 +58,6 @@ test("syncGsdStateToWorktree copies canonical PREFERENCES.md", async () => {
       "---\nversion: 1\n---\n\npost_unit_hooks:\n  - name: notify\n    command: echo done\n",
     );
 
-    // Import and call syncGsdStateToWorktree
-    const { syncGsdStateToWorktree } = await import("../auto-worktree.ts");
     syncGsdStateToWorktree(srcBase, dstBase);
 
     // Verify PREFERENCES.md was copied
@@ -93,7 +91,6 @@ test("syncGsdStateToWorktree falls back to legacy lowercase preferences.md", asy
       "---\nversion: 1\n---\n\ngit:\n  auto_push: true\n",
     );
 
-    const { syncGsdStateToWorktree } = await import("../auto-worktree.ts");
     const result = syncGsdStateToWorktree(srcBase, dstBase);
 
     const copiedEntries = readdirSync(dstGsd)

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

@@ -24,6 +24,7 @@ import {
   loadProjectGSDPreferences,
   parsePreferencesMarkdown,
   renderPreferencesForSystemPrompt,
+  renderLanguageDirectiveForPrompt,
   clearGSDPreferencesCache,
   _resetParseWarningFlag,
 } from "../preferences.ts";
@@ -1674,6 +1675,24 @@ test("language: renderPreferencesForSystemPrompt omits language line when not se
   assert.ok(!output.includes("Always respond in"), `expected no language line in output, got:\n${output}`);
 });
 
+test("language: renderLanguageDirectiveForPrompt emits directive when language set", () => {
+  const output = renderLanguageDirectiveForPrompt({ language: "Chinese" });
+  assert.ok(output.includes("## Response Language"), `expected language heading, got:\n${output}`);
+  assert.ok(output.includes("Always respond in Chinese"), `expected language instruction, got:\n${output}`);
+});
+
+test("language: renderLanguageDirectiveForPrompt returns empty when language unset", () => {
+  assert.equal(renderLanguageDirectiveForPrompt({}), "");
+  assert.equal(renderLanguageDirectiveForPrompt(undefined), "");
+});
+
+test("language: renderLanguageDirectiveForPrompt sanitizes newlines and caps length", () => {
+  const output = renderLanguageDirectiveForPrompt({ language: `Chinese\ninjected${"x".repeat(80)}` });
+  assert.ok(!output.includes("\ninjected"), `expected newlines stripped, got:\n${output}`);
+  // "Chinese injected" + padding, capped to 50 chars after newline replacement.
+  assert.ok(output.includes("Always respond in Chinese injected"), `got:\n${output}`);
+});
+
 test("language: parses from markdown frontmatter", () => {
   const content = [
     "---",

package/src/resources/extensions/gsd/tests/prefs-wizard-coverage.test.ts

@@ -79,6 +79,11 @@ const PREF_SAMPLE_VALUES: Record<string, unknown> = {
   min_request_interval_ms: 250,
   stale_commit_threshold_minutes: 15,
   context_management: { enabled: true },
+  tool_call_loop_guard: {
+    enabled: true,
+    identical_args: { enabled: true, max_consecutive_calls: 4 },
+    repeated_tool: { enabled: true, default_cap: 6, repeatable_cap: 15, exempt_tools: ["ctx_execute"] },
+  },
   experimental: { rtk: true },
   codebase: { indexing: "auto" },
   slice_parallel: { enabled: true, max_workers: 2 },

package/src/resources/extensions/gsd/tests/reopen-slice.test.ts

@@ -125,6 +125,58 @@ test('handleReopenSlice: rejects slice in a closed milestone', async () => {
   }
 });
 
+test('handleReopenSlice: recovers a desynced slice (open status, completed tasks) — #1205', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+  try {
+    // Desync signature: slice left "pending" by a UAT→planning fallback while
+    // its tasks stayed "complete" from the first execution pass.
+    insertMilestone({ id: 'M001', title: 'Active', status: 'active' });
+    insertSlice({ id: 'S01', milestoneId: 'M001', status: 'pending' });
+    insertTask({ id: 'T01', sliceId: 'S01', milestoneId: 'M001', status: 'complete' });
+    insertTask({ id: 'T02', sliceId: 'S01', milestoneId: 'M001', status: 'complete' });
+
+    const result = await handleReopenSlice({ milestoneId: 'M001', sliceId: 'S01' }, base);
+
+    assert.ok(!('error' in result), `unexpected error: ${'error' in result ? result.error : ''}`);
+    assert.equal(result.tasksReset, 2, 'both completed tasks should be reset');
+
+    const slice = getSlice('M001', 'S01');
+    assert.equal(slice!.status, 'in_progress', 'slice should be reopened to in_progress');
+    const tasks = getSliceTasks('M001', 'S01');
+    assert.ok(tasks.every(t => t.status === 'pending'), 'all tasks should be reset to pending');
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('handleReopenSlice: rejects an in-flight slice with mixed task progress and preserves it — #1205', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+  try {
+    // Normal in-flight slice, NOT the #1205 desync: one task finished while
+    // another is still in progress. The desync guard must not treat a single
+    // completed task as reopenable, or a full reset would wipe live progress.
+    insertMilestone({ id: 'M001', title: 'Active', status: 'active' });
+    insertSlice({ id: 'S01', milestoneId: 'M001', status: 'in_progress' });
+    insertTask({ id: 'T01', sliceId: 'S01', milestoneId: 'M001', status: 'complete' });
+    insertTask({ id: 'T02', sliceId: 'S01', milestoneId: 'M001', status: 'in_progress' });
+
+    const result = await handleReopenSlice({ milestoneId: 'M001', sliceId: 'S01' }, base);
+
+    assert.ok('error' in result, 'in-flight slice with unfinished tasks must be rejected');
+    assert.match(result.error, /not complete/);
+
+    // Progress must be untouched — nothing reset to pending.
+    const byId = Object.fromEntries(getSliceTasks('M001', 'S01').map(t => [t.id, t.status]));
+    assert.equal(byId['T01'], 'complete', 'completed task must stay complete');
+    assert.equal(byId['T02'], 'in_progress', 'in-progress task must stay in_progress');
+    assert.equal(getSlice('M001', 'S01')!.status, 'in_progress', 'slice status must be untouched');
+  } finally {
+    cleanup(base);
+  }
+});
+
 test('handleReopenSlice: rejects reopening a slice that is not complete', async () => {
   const base = makeTmpBase();
   openDatabase(join(base, '.gsd', 'gsd.db'));