gsd-pi 2.67.0-dev.2142d3e → 2.67.0-dev.2367d7e

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

@@ -18,22 +18,33 @@ const { assertTrue, report } = createTestContext();
 
 const autoSrc = readFileSync(join(import.meta.dirname, "..", "auto.ts"), "utf-8");
 
-console.log("\n=== #2940: resume path opens DB before rebuildState/deriveState ===");
+console.log("\n=== resume path refreshes resources and opens DB before rebuildState/deriveState ===");
 
 // The resume block is the `if (s.paused) { ... }` section that calls rebuildState/deriveState.
 // Locate the resume section by finding `s.paused = false;` followed by `rebuildState`.
 const resumeSectionStart = autoSrc.indexOf("if (s.paused) {", autoSrc.indexOf("// If resuming from paused state"));
 assertTrue(resumeSectionStart > 0, "auto.ts has the paused-session resume block");
 
-const resumeSection = autoSrc.slice(resumeSectionStart, resumeSectionStart + 3000);
+const resumeSectionEnd = autoSrc.indexOf("await autoLoop(", resumeSectionStart);
+assertTrue(resumeSectionEnd > resumeSectionStart, "resume block reaches autoLoop");
 
-// The resume path must open the DB before rebuildState/deriveState
+const resumeSection = autoSrc.slice(resumeSectionStart, resumeSectionEnd);
+
+// The resume path must refresh managed resources and open the DB before
+// rebuildState/deriveState so resumed auto-mode uses current extension code.
 const rebuildIdx = resumeSection.indexOf("rebuildState(");
 assertTrue(rebuildIdx > 0, "resume block calls rebuildState");
 
 const deriveIdx = resumeSection.indexOf("deriveState(");
 assertTrue(deriveIdx > 0, "resume block calls deriveState");
 
+const preDeriveSection = resumeSection.slice(0, rebuildIdx);
+
+assertTrue(
+  preDeriveSection.includes("initResources("),
+  "resume path must refresh managed resources before rebuildState/deriveState (#3761)",
+);
+
 // There must be a DB open call before the first rebuildState call
 const dbOpenPatterns = [
   "openProjectDbIfPresent(",
@@ -41,7 +52,6 @@ const dbOpenPatterns = [
   "ensureDbOpen(",
 ];
 
-const preDeriveSection = resumeSection.slice(0, rebuildIdx);
 const hasDbOpen = dbOpenPatterns.some(pat => preDeriveSection.includes(pat));
 assertTrue(
   hasDbOpen,

package/src/resources/extensions/gsd/tests/copy-planning-artifacts-samepath.test.ts

@@ -0,0 +1,21 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+test("copyPlanningArtifacts skips when source and destination .gsd resolve to the same path", () => {
+  const srcPath = join(import.meta.dirname, "..", "auto-worktree.ts");
+  const src = readFileSync(srcPath, "utf-8");
+
+  const fnIdx = src.indexOf("function copyPlanningArtifacts");
+  assert.ok(fnIdx !== -1, "copyPlanningArtifacts function exists");
+
+  const fnBody = src.slice(fnIdx, fnIdx + 2400);
+
+  const guardIdx = fnBody.indexOf("if (isSamePath(srcGsd, dstGsd)) return;");
+  const copyIdx = fnBody.indexOf("safeCopyRecursive(join(srcGsd, \"milestones\")");
+
+  assert.ok(guardIdx !== -1, "copyPlanningArtifacts should guard same-path .gsd copies");
+  assert.ok(copyIdx !== -1, "copyPlanningArtifacts should still copy milestones when paths differ");
+  assert.ok(guardIdx < copyIdx, "same-path guard should run before any copy attempt");
+});

package/src/resources/extensions/gsd/tests/crash-recovery.test.ts

@@ -1,6 +1,6 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdirSync, existsSync, readFileSync, rmSync } from "node:fs";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
@@ -13,6 +13,14 @@ import {
   formatCrashInfo,
   type LockData,
 } from "../crash-recovery.ts";
+import {
+  assessInterruptedSession,
+  hasResumableDerivedState,
+  isBootstrapCrashLock,
+  readPausedSessionMetadata,
+} from "../interrupted-session.ts";
+import { gsdRoot } from "../paths.ts";
+import type { GSDState } from "../types.ts";
 
 function makeTmpBase(): string {
   const base = join(tmpdir(), `gsd-test-${randomUUID()}`);
@@ -24,6 +32,376 @@ function cleanup(base: string): void {
   try { rmSync(base, { recursive: true, force: true }); } catch { /* */ }
 }
 
+function writeTestLock(
+  base: string,
+  unitType: string,
+  unitId: string,
+  sessionFile?: string,
+): void {
+  writeFileSync(
+    join(gsdRoot(base), "auto.lock"),
+    JSON.stringify({
+      pid: 999999999,
+      startedAt: new Date().toISOString(),
+      unitType,
+      unitId,
+      unitStartedAt: new Date().toISOString(),
+      sessionFile,
+    }, null, 2),
+    "utf-8",
+  );
+}
+
+function writeRoadmap(base: string, checked = false): void {
+  const milestoneDir = join(base, ".gsd", "milestones", "M001");
+  mkdirSync(join(milestoneDir, "slices", "S01", "tasks"), { recursive: true });
+  writeFileSync(
+    join(milestoneDir, "M001-ROADMAP.md"),
+    [
+      "# M001: Test Milestone",
+      "",
+      "## Vision",
+      "",
+      "Test milestone.",
+      "",
+      "## Success Criteria",
+      "",
+      "- It works.",
+      "",
+      "## Slices",
+      "",
+      `- [${checked ? "x" : " "}] **S01: Test slice** \`risk:low\``,
+      "  After this: Demo",
+      "",
+      "## Boundary Map",
+      "",
+      "- S01 → terminal",
+      "  - Produces: done",
+      "  - Consumes: nothing",
+    ].join("\n"),
+    "utf-8",
+  );
+}
+
+function writeCompleteSliceArtifacts(base: string): void {
+  const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+  mkdirSync(sliceDir, { recursive: true });
+  writeFileSync(join(sliceDir, "S01-SUMMARY.md"), "# Summary\nDone.\n", "utf-8");
+  writeFileSync(join(sliceDir, "S01-UAT.md"), "# UAT\nPassed.\n", "utf-8");
+}
+
+function writeCompleteMilestoneSummary(base: string): void {
+  const milestoneDir = join(base, ".gsd", "milestones", "M001");
+  mkdirSync(milestoneDir, { recursive: true });
+  writeFileSync(join(milestoneDir, "M001-SUMMARY.md"), "# Milestone Summary\nDone.\n", "utf-8");
+}
+
+function writePausedSession(
+  base: string,
+  milestoneId = "M001",
+  stepMode = false,
+  worktreePath?: string,
+  unitType?: string,
+  unitId?: string,
+): void {
+  const runtimeDir = join(base, ".gsd", "runtime");
+  mkdirSync(runtimeDir, { recursive: true });
+  writeFileSync(
+    join(runtimeDir, "paused-session.json"),
+    JSON.stringify({ milestoneId, originalBasePath: base, stepMode, worktreePath, unitType, unitId }, null, 2),
+    "utf-8",
+  );
+}
+
+function writeActivityLog(base: string, entries: Record<string, unknown>[]): void {
+  const activityDir = join(base, ".gsd", "activity");
+  mkdirSync(activityDir, { recursive: true });
+  writeFileSync(
+    join(activityDir, "001-execute-task-M001-S01-T01.jsonl"),
+    entries.map((entry) => JSON.stringify(entry)).join("\n") + "\n",
+    "utf-8",
+  );
+}
+
+function makeState(phase: GSDState["phase"], activeMilestone = true): GSDState {
+  return {
+    activeMilestone: activeMilestone ? { id: "M001", title: "Test" } : null,
+    activeSlice: null,
+    activeTask: null,
+    phase,
+    recentDecisions: [],
+    blockers: [],
+    nextAction: "",
+    registry: [],
+  };
+}
+
+// ─── interrupted-session helpers ───────────────────────────────────────────
+
+test("hasResumableDerivedState treats only unfinished active work as resumable", () => {
+  assert.equal(hasResumableDerivedState(makeState("executing")), true);
+  assert.equal(hasResumableDerivedState(makeState("complete")), false);
+  assert.equal(hasResumableDerivedState(makeState("pre-planning", false)), false);
+});
+
+test("isBootstrapCrashLock detects starting/bootstrap special case", () => {
+  const bootstrap: LockData = {
+    pid: 999999999,
+    startedAt: new Date().toISOString(),
+    unitType: "starting",
+    unitId: "bootstrap",
+    unitStartedAt: new Date().toISOString(),
+  };
+  assert.equal(isBootstrapCrashLock(bootstrap), true);
+  assert.equal(isBootstrapCrashLock({ ...bootstrap, unitType: "execute-task" }), false);
+});
+
+test("readPausedSessionMetadata reads paused-session metadata when present", () => {
+  const base = makeTmpBase();
+  try {
+    writePausedSession(base, "M009");
+    const meta = readPausedSessionMetadata(base);
+    assert.equal(meta?.milestoneId, "M009");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("readPausedSessionMetadata preserves unitType and unitId through round-trip", () => {
+  const base = makeTmpBase();
+  try {
+    writePausedSession(base, "M001", false, undefined, "execute-task", "M001/S01/T02");
+    const meta = readPausedSessionMetadata(base);
+    assert.equal(meta?.unitType, "execute-task");
+    assert.equal(meta?.unitId, "M001/S01/T02");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("readPausedSessionMetadata handles legacy metadata without unitType/unitId", () => {
+  const base = makeTmpBase();
+  try {
+    // Write metadata without unitType/unitId (simulates older version)
+    const runtimeDir = join(base, ".gsd", "runtime");
+    mkdirSync(runtimeDir, { recursive: true });
+    writeFileSync(
+      join(runtimeDir, "paused-session.json"),
+      JSON.stringify({ milestoneId: "M001", originalBasePath: base }),
+      "utf-8",
+    );
+    const meta = readPausedSessionMetadata(base);
+    assert.equal(meta?.milestoneId, "M001");
+    assert.equal(meta?.unitType, undefined);
+    assert.equal(meta?.unitId, undefined);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("assessInterruptedSession returns none when no lock and no paused session exist", async () => {
+  const base = makeTmpBase();
+  try {
+    const assessment = await assessInterruptedSession(base);
+    assert.equal(assessment.classification, "none");
+    assert.equal(assessment.lock, null);
+    assert.equal(assessment.pausedSession, null);
+    assert.equal(assessment.state, null);
+    assert.equal(assessment.recovery, null);
+    assert.equal(assessment.recoveryPrompt, null);
+    assert.equal(assessment.recoveryToolCallCount, 0);
+    assert.equal(assessment.artifactSatisfied, false);
+    assert.equal(assessment.hasResumableDiskState, false);
+    assert.equal(assessment.isBootstrapCrash, false);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("assessInterruptedSession classifies stale complete repo as stale and suppresses recovery", async () => {
+  const base = makeTmpBase();
+  try {
+    writeRoadmap(base, true);
+    writeCompleteSliceArtifacts(base);
+    writeCompleteMilestoneSummary(base);
+    writeTestLock(base, "execute-task", "M001/S01/T01");
+
+    const assessment = await assessInterruptedSession(base);
+    assert.equal(assessment.classification, "stale");
+    assert.equal(assessment.hasResumableDiskState, false);
+    assert.equal(assessment.recoveryPrompt, null);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("assessInterruptedSession suppresses prompt when expected artifact already exists and no resumable state remains", async () => {
+  const base = makeTmpBase();
+  try {
+    writeRoadmap(base, true);
+    writeCompleteSliceArtifacts(base);
+    writeCompleteMilestoneSummary(base);
+    writeTestLock(base, "complete-slice", "M001/S01");
+
+    const assessment = await assessInterruptedSession(base);
+    assert.equal(assessment.classification, "stale");
+    assert.equal(assessment.artifactSatisfied, true);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("assessInterruptedSession keeps paused-session resume recoverable when disk state is unfinished", async () => {
+  const base = makeTmpBase();
+  try {
+    writeRoadmap(base, false);
+    writePausedSession(base);
+    writeTestLock(base, "execute-task", "M001/S01/T01");
+
+    const assessment = await assessInterruptedSession(base);
+    assert.equal(assessment.classification, "recoverable");
+    assert.equal(assessment.pausedSession?.milestoneId, "M001");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("assessInterruptedSession marks stale paused-session metadata as stale when no work remains", async () => {
+  const base = makeTmpBase();
+  try {
+    writeRoadmap(base, true);
+    writeCompleteSliceArtifacts(base);
+    writeCompleteMilestoneSummary(base);
+    writePausedSession(base, "M999");
+
+    const assessment = await assessInterruptedSession(base);
+    assert.equal(assessment.classification, "stale");
+    assert.equal(assessment.hasResumableDiskState, false);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("assessInterruptedSession classifies paused session without lock as recoverable when disk state is resumable", async () => {
+  const base = makeTmpBase();
+  try {
+    writeRoadmap(base, false);
+    writePausedSession(base, "M001", true);
+
+    const assessment = await assessInterruptedSession(base);
+    assert.equal(assessment.classification, "recoverable");
+    assert.equal(assessment.lock, null);
+    assert.equal(assessment.pausedSession?.milestoneId, "M001");
+    assert.equal(assessment.hasResumableDiskState, true);
+    assert.equal(assessment.isBootstrapCrash, false);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("assessInterruptedSession falls back to basePath when worktreePath no longer exists", async () => {
+  const base = makeTmpBase();
+  try {
+    writeRoadmap(base, false);
+    // Reference a worktree that doesn't exist on disk
+    writePausedSession(base, "M001", false, "/nonexistent/worktree");
+
+    const assessment = await assessInterruptedSession(base);
+    // Should use basePath (which has an unfinished roadmap) instead of the missing worktree
+    assert.equal(assessment.classification, "recoverable");
+    assert.equal(assessment.hasResumableDiskState, true);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("assessInterruptedSession prefers paused worktree state when worktreePath is recorded", async () => {
+  const base = makeTmpBase();
+  const worktree = join(base, "worktree-copy");
+  try {
+    writeRoadmap(base, false);
+    writeRoadmap(worktree, true);
+    writeCompleteSliceArtifacts(worktree);
+    writeCompleteMilestoneSummary(worktree);
+    writePausedSession(base, "M001", false, worktree);
+
+    const assessment = await assessInterruptedSession(base);
+    assert.equal(assessment.classification, "stale");
+    assert.equal(assessment.hasResumableDiskState, false);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("assessInterruptedSession keeps unfinished derived state recoverable without trace", async () => {
+  const base = makeTmpBase();
+  try {
+    writeRoadmap(base, false);
+    writeTestLock(base, "plan-slice", "M001/S01");
+
+    const assessment = await assessInterruptedSession(base);
+    assert.equal(assessment.classification, "recoverable");
+    assert.equal(assessment.hasResumableDiskState, true);
+    assert.equal(assessment.recoveryPrompt, null);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("assessInterruptedSession preserves crash trace when activity log has tool calls", async () => {
+  const base = makeTmpBase();
+  try {
+    writeRoadmap(base, false);
+    writeTestLock(base, "execute-task", "M001/S01/T01");
+    writeActivityLog(base, [
+      {
+        type: "message",
+        message: {
+          role: "assistant",
+          content: [
+            {
+              type: "toolCall",
+              id: "1",
+              name: "bash",
+              arguments: { command: "npm test" },
+            },
+          ],
+        },
+      },
+      {
+        type: "message",
+        message: {
+          role: "toolResult",
+          toolCallId: "1",
+          toolName: "bash",
+          isError: false,
+          content: [{ type: "text", text: "ok" }],
+        },
+      },
+    ]);
+
+    const assessment = await assessInterruptedSession(base);
+    assert.equal(assessment.classification, "recoverable");
+    assert.ok(assessment.recoveryToolCallCount > 0);
+    assert.ok(assessment.recoveryPrompt?.includes("Recovery Briefing"));
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("assessInterruptedSession treats bootstrap crash as stale without paused metadata", async () => {
+  const base = makeTmpBase();
+  try {
+    writeTestLock(base, "starting", "bootstrap");
+
+    const assessment = await assessInterruptedSession(base);
+    assert.equal(assessment.classification, "stale");
+    assert.equal(assessment.isBootstrapCrash, true);
+  } finally {
+    cleanup(base);
+  }
+});
+
 // ─── writeLock / readCrashLock ────────────────────────────────────────────
 
 test("writeLock creates lock file and readCrashLock reads it", (t) => {
@@ -84,7 +462,7 @@ test("#2470: isLockProcessAlive returns true for own PID (we hold the lock)", ()
 
 test("isLockProcessAlive returns false for dead PID", () => {
   const lock: LockData = {
-    pid: 999999999, // almost certainly not running
+    pid: 999999999,
     startedAt: new Date().toISOString(),
     unitType: "execute-task",
     unitId: "M001/S01/T01",

package/src/resources/extensions/gsd/tests/forensics-context-persist.test.ts

@@ -126,4 +126,34 @@ describe("forensics context persistence (#2941)", () => {
     // Should not throw
     clearForensicsMarker(join(tmpBase, "nonexistent"));
   });
+
+  it("buildForensicsContextInjection keeps marker for low-entropy resume prompts", async () => {
+    const { buildForensicsContextInjection } = await import("../bootstrap/system-context.ts");
+
+    const markerPath = join(tmpBase, ".gsd", "runtime", "active-forensics.json");
+    writeFileSync(markerPath, JSON.stringify({
+      reportPath: "/some/report.md",
+      promptContent: "forensics prompt",
+      createdAt: new Date().toISOString(),
+    }), "utf-8");
+
+    const result = buildForensicsContextInjection(tmpBase, "continue");
+    assert.equal(result, "forensics prompt");
+    assert.ok(existsSync(markerPath), "resume-like follow-up should keep marker intact");
+  });
+
+  it("buildForensicsContextInjection clears marker on unrelated user prompts", async () => {
+    const { buildForensicsContextInjection } = await import("../bootstrap/system-context.ts");
+
+    const markerPath = join(tmpBase, ".gsd", "runtime", "active-forensics.json");
+    writeFileSync(markerPath, JSON.stringify({
+      reportPath: "/some/report.md",
+      promptContent: "forensics prompt",
+      createdAt: new Date().toISOString(),
+    }), "utf-8");
+
+    const result = buildForensicsContextInjection(tmpBase, "please summarize the README");
+    assert.equal(result, null);
+    assert.ok(!existsSync(markerPath), "unrelated follow-up should clear the stale marker");
+  });
 });

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

@@ -7,6 +7,7 @@ import {
   openDatabase,
   closeDatabase,
   isDbAvailable,
+  wasDbOpenAttempted,
   getDbProvider,
   insertDecision,
   getDecisionById,
@@ -346,6 +347,17 @@ describe('gsd-db', () => {
     assert.deepStrictEqual(ar, [], 'getActiveRequirements returns [] when DB closed');
   });
 
+  test('gsd-db: wasDbOpenAttempted tracks openDatabase calls', () => {
+    // wasDbOpenAttempted should return true once openDatabase has been called
+    // (previous tests in this suite already called openDatabase, so the flag is set)
+    assert.ok(wasDbOpenAttempted(), 'wasDbOpenAttempted should be true after openDatabase was called');
+
+    // Verify the flag persists even after closeDatabase
+    closeDatabase();
+    assert.ok(!isDbAvailable(), 'DB should not be available after close');
+    assert.ok(wasDbOpenAttempted(), 'wasDbOpenAttempted should remain true after closeDatabase');
+  });
+
   // ─── Final Report ──────────────────────────────────────────────────────────
 
 });

package/src/resources/extensions/gsd/tests/guided-flow-session-isolation.test.ts

@@ -100,7 +100,7 @@ describe("#2985 Bug 4 — getDiscussionMilestoneId must be keyed by basePath", (
   });
 });
 
-test("checkAutoStartAfterDiscuss fails closed when a multi-milestone manifest is missing", () => {
+test("checkAutoStartAfterDiscuss ignores missing manifest for single-milestone discuss on established project", () => {
   const base = mkdtempSync(join(tmpdir(), "gsd-auto-start-manifest-"));
   try {
     const gsdDir = join(base, ".gsd");
@@ -123,7 +123,7 @@ test("checkAutoStartAfterDiscuss fails closed when a multi-milestone manifest is
     });
 
     const started = checkAutoStartAfterDiscuss();
-    assert.equal(started, false, "auto-start should fail closed without the manifest");
+    assert.equal(started, true, "project history alone should not require a manifest");
   } finally {
     clearPendingAutoStart();
     rmSync(base, { recursive: true, force: true });

package/src/resources/extensions/gsd/tests/integration/doctor-fixlevel.test.ts

@@ -15,7 +15,7 @@ import { tmpdir } from "node:os";
 import test from "node:test";
 import assert from "node:assert/strict";
 import { runGSDDoctor } from "../../doctor.ts";
-import { closeDatabase } from "../../gsd-db.ts";
+import { closeDatabase, insertMilestone, insertSlice, openDatabase } from "../../gsd-db.ts";
 
 function makeTmp(name: string): string {
   const dir = join(tmpdir(), `doctor-fixlevel-${name}-${Date.now()}-${Math.random().toString(36).slice(2)}`);
@@ -177,6 +177,57 @@ test("legacy roadmap fallback: future slices are treated as pending, active slic
   );
 });
 
+test("db skipped slices do not report missing directories", async (t) => {
+  const tmp = makeTmp("skipped-slice-dir");
+  t.after(() => {
+    try { closeDatabase(); } catch { /* noop */ }
+    rmSync(tmp, { recursive: true, force: true });
+  });
+
+  const gsd = join(tmp, ".gsd");
+  const m = join(gsd, "milestones", "M001");
+  mkdirSync(m, { recursive: true });
+
+  writeFileSync(join(m, "M001-ROADMAP.md"), `# M001: Test
+
+## Slices
+
+- [ ] **S05: Skipped Slice** \`risk:low\` \`depends:[]\`
+  > Intentionally skipped
+`);
+
+  openDatabase(join(gsd, "gsd.db"));
+  insertMilestone({ id: "M001", title: "Test", status: "active" });
+  insertSlice({ id: "S05", milestoneId: "M001", title: "Skipped Slice", status: "skipped", sequence: 5 });
+
+  const report = await runGSDDoctor(tmp, { scope: "M001" });
+  const missingDirIssues = report.issues.filter(
+    i =>
+      (i.code === "missing_slice_dir" || i.code === "missing_tasks_dir") &&
+      i.unitId === "M001/S05",
+  );
+
+  assert.deepStrictEqual(
+    missingDirIssues,
+    [],
+    "skipped slices should not require slice or tasks directories",
+  );
+});
+
+test("doctor source treats skipped DB slices as closed and directory-optional", () => {
+  const doctorSource = readFileSync(join(process.cwd(), "src/resources/extensions/gsd/doctor.ts"), "utf8");
+  assert.match(
+    doctorSource,
+    /done:\s*isClosedStatus\(s\.status\)/,
+    "doctor should normalize skipped DB slices through isClosedStatus()",
+  );
+  assert.match(
+    doctorSource,
+    /if \(slice\.pending \|\| slice\.skipped\) continue;/,
+    "doctor should skip missing-directory checks for skipped slices",
+  );
+});
+
 test("fixLevel:all — delimiter_in_title still fixable", async (t) => {
   const tmp = makeTmp("delimiter-fix");
   t.after(() => rmSync(tmp, { recursive: true, force: true }));

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

@@ -661,10 +661,9 @@ describe('doctor-git', async () => {
         env: { ...process.env, GIT_COMMITTER_DATE: pastDate },
       });
 
-      // Modify a tracked file and create a new untracked file. The snapshot
-      // must preserve both, not just tracked changes.
+      // Modify an already-tracked file (nativeAddTracked uses git add -u,
+      // which only stages tracked files — new untracked files are not staged)
       writeFileSync(join(dir, "README.md"), "# test\nmodified content\n");
-      writeFileSync(join(dir, "new-untracked.ts"), "export const preserved = true;\n");
 
       const detect = await runGSDDoctor(dir);
       const staleIssues = detect.issues.filter(i => i.code === "stale_uncommitted_changes");
@@ -682,12 +681,6 @@ describe('doctor-git', async () => {
       // Verify the snapshot commit was created with the gsd snapshot tag
       const log = run("git log -1 --oneline", dir);
       assert.ok(log.includes("gsd snapshot"), "commit is tagged with gsd snapshot");
-
-      const files = run("git show --name-only --format= HEAD", dir);
-      assert.ok(files.includes("README.md"), "snapshot keeps tracked modifications");
-      assert.ok(files.includes("new-untracked.ts"), "snapshot also includes new untracked files");
-      const status = run("git status --short", dir);
-      assert.ok(!status.includes("new-untracked.ts"), "snapshot does not leave the new source file untracked");
     });
 
     // ─── Test: stale_uncommitted_changes NOT flagged when recent commit ──