gsd-pi 2.29.0-dev.49d972f → 2.29.0-dev.4c155ee

package/dist/resources/extensions/gsd/preferences-models.ts

@@ -254,13 +254,19 @@ export function resolveProfileDefaults(profile: TokenProfile): Partial<GSDPrefer
           subagent: "claude-sonnet-4-5-20250514",
         },
         phases: {
+          skip_research: true,
+          skip_reassess: true,
           skip_slice_research: true,
         },
       };
     case "quality":
       return {
         models: {},
-        phases: {},
+        phases: {
+          skip_research: true,
+          skip_slice_research: true,
+          skip_reassess: true,
+        },
       };
   }
 }

package/dist/resources/extensions/gsd/preferences-validation.ts

@@ -172,9 +172,10 @@ export function validatePreferences(preferences: GSDPreferences): {
       if (p.skip_reassess !== undefined) validatedPhases.skip_reassess = !!p.skip_reassess;
       if (p.skip_slice_research !== undefined) validatedPhases.skip_slice_research = !!p.skip_slice_research;
       if (p.skip_milestone_validation !== undefined) validatedPhases.skip_milestone_validation = !!p.skip_milestone_validation;
+      if (p.reassess_after_slice !== undefined) validatedPhases.reassess_after_slice = !!p.reassess_after_slice;
       if ((p as any).require_slice_discussion !== undefined) (validatedPhases as any).require_slice_discussion = !!(p as any).require_slice_discussion;
       // Warn on unknown phase keys
-      const knownPhaseKeys = new Set(["skip_research", "skip_reassess", "skip_slice_research", "skip_milestone_validation", "require_slice_discussion"]);
+      const knownPhaseKeys = new Set(["skip_research", "skip_reassess", "skip_slice_research", "skip_milestone_validation", "reassess_after_slice", "require_slice_discussion"]);
       for (const key of Object.keys(p)) {
         if (!knownPhaseKeys.has(key)) {
           warnings.push(`unknown phases key "${key}" — ignored`);

package/dist/resources/extensions/gsd/preferences.ts

@@ -13,6 +13,7 @@
 import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
+import { gsdRoot } from "./paths.js";
 import { parse as parseYaml } from "yaml";
 import type { PostUnitHookConfig, PreDispatchHookConfig } from "./types.js";
 import type { DynamicRoutingConfig } from "./model-router.js";
@@ -81,11 +82,15 @@ export {
 
 const GLOBAL_PREFERENCES_PATH = join(homedir(), ".gsd", "preferences.md");
 const LEGACY_GLOBAL_PREFERENCES_PATH = join(homedir(), ".pi", "agent", "gsd-preferences.md");
-const PROJECT_PREFERENCES_PATH = join(process.cwd(), ".gsd", "preferences.md");
+function projectPreferencesPath(): string {
+  return join(gsdRoot(process.cwd()), "preferences.md");
+}
 // Bootstrap in gitignore.ts historically created PREFERENCES.md (uppercase) by mistake.
 // Check uppercase as a fallback so those files aren't silently ignored.
 const GLOBAL_PREFERENCES_PATH_UPPERCASE = join(homedir(), ".gsd", "PREFERENCES.md");
-const PROJECT_PREFERENCES_PATH_UPPERCASE = join(process.cwd(), ".gsd", "PREFERENCES.md");
+function projectPreferencesPathUppercase(): string {
+  return join(gsdRoot(process.cwd()), "PREFERENCES.md");
+}
 
 export function getGlobalGSDPreferencesPath(): string {
   return GLOBAL_PREFERENCES_PATH;
@@ -96,7 +101,7 @@ export function getLegacyGlobalGSDPreferencesPath(): string {
 }
 
 export function getProjectGSDPreferencesPath(): string {
-  return PROJECT_PREFERENCES_PATH;
+  return projectPreferencesPath();
 }
 
 // ─── Loading ────────────────────────────────────────────────────────────────
@@ -108,8 +113,8 @@ export function loadGlobalGSDPreferences(): LoadedGSDPreferences | null {
 }
 
 export function loadProjectGSDPreferences(): LoadedGSDPreferences | null {
-  return loadPreferencesFile(PROJECT_PREFERENCES_PATH, "project")
-    ?? loadPreferencesFile(PROJECT_PREFERENCES_PATH_UPPERCASE, "project");
+  return loadPreferencesFile(projectPreferencesPath(), "project")
+    ?? loadPreferencesFile(projectPreferencesPathUppercase(), "project");
 }
 
 export function loadEffectiveGSDPreferences(): LoadedGSDPreferences | null {

package/dist/resources/extensions/gsd/prompts/discuss-headless.md

@@ -16,13 +16,15 @@ Summarize your understanding of the specification concretely:
 - Scope estimate (how many milestones × slices)
 - Any ambiguities or gaps you notice
 
-### Step 2: Investigate
+### Step 2: Investigate (brief)
 
-Scout the codebase to understand what already exists:
+Quickly scout the codebase to understand what already exists — spend no more than 5-6 tool calls here:
 - `ls` the project root and key directories
 - Search for relevant existing code, patterns, dependencies
 - Check library docs if needed (`resolve_library` / `get_library_docs`)
 
+Then move on to writing artifacts. Do not explore exhaustively — the research phase will do deeper investigation later.
+
 ### Step 3: Make Decisions
 
 For any ambiguities or gaps in the specification:

package/dist/resources/extensions/gsd/prompts/guided-discuss-milestone.md

@@ -91,7 +91,7 @@ Before moving to the wrap-up gate, verify you have covered:
 - options: "Yes, you got it (Recommended)", "Not quite — let me clarify"
 - **The question ID must contain `depth_verification`** (e.g. `depth_verification_confirm`) — this enables the write-gate downstream.
 
-**If `{{structuredQuestionsAvailable}}` is `false`:** ask in plain text: "Did I capture that correctly? Anything I missed?" Wait for confirmation before proceeding.
+**If `{{structuredQuestionsAvailable}}` is `false`:** ask in plain text: "Did I capture that correctly? If not, tell me what I missed." Wait for confirmation before proceeding.
 
 If they clarify, absorb the correction and re-verify.
 

package/dist/resources/extensions/gsd/prompts/plan-milestone.md

@@ -12,9 +12,33 @@ All relevant context has been preloaded below — start working immediately with
 
 ## Your Role in the Pipeline
 
-A **researcher agent** already explored the codebase and documented findings in the milestone research doc (inlined above, if present). It identified key files, technology choices, constraints, and risks. **Trust the research.** Your job is strategic decomposition — turning findings into an ordered set of demoable slices — not re-exploration. Don't read code files the research already summarized unless something is ambiguous or missing.
+You are the first deep look at this milestone. You have full tool access — explore the codebase, look up docs, investigate technology choices. Your job is to understand the landscape and then strategically decompose the work into demoable slices.
 
-After you finish, each slice goes through its own research → plan → execute cycle. Slice researchers dive deeper into the specific area. Slice planners decompose into tasks. Executors build each task. Your roadmap sets the strategic frame for all of them.
+After you finish, each slice goes through its own plan → execute cycle. Slice planners decompose into tasks. Executors build each task. Your roadmap sets the strategic frame for all of them.
+
+### Explore First, Then Decompose
+
+Before decomposing, build your understanding:
+
+1. **Codebase exploration.** For small/familiar codebases, use `rg`, `find`, and targeted reads. For large or unfamiliar codebases, use `scout` to build a broad map efficiently before diving in.
+2. **Library docs.** Use `resolve_library` / `get_library_docs` for unfamiliar libraries — skip this for libraries already used in the codebase.
+3. **Skill Discovery ({{skillDiscoveryMode}}):**{{skillDiscoveryInstructions}}
+4. **Requirements analysis.** If `.gsd/REQUIREMENTS.md` exists, research against it. Identify which Active requirements are table stakes, likely omissions, overbuilt risks, or domain-standard behaviors.
+
+### Strategic Questions to Answer
+
+- What should be proven first?
+- What existing patterns should be reused?
+- What boundary contracts matter?
+- What constraints does the existing codebase impose?
+- Are there known failure modes that should shape slice ordering?
+- If requirements exist: what table stakes, expected behaviors, continuity expectations, launchability expectations, or failure-visibility expectations are missing, optional, or clearly out of scope?
+
+### Source Files
+
+{{sourceFilePaths}}
+
+If milestone research exists (inlined above), trust those findings and skip redundant exploration. If findings are significant and no research file exists yet, write `{{researchOutputPath}}`.
 
 Narrate your decomposition reasoning — why you're grouping work this way, what risks are driving the order, what verification strategy you're choosing and why. Use complete sentences rather than planner shorthand or fragmentary notes.
 

package/dist/resources/extensions/gsd/prompts/plan-slice.md

@@ -18,7 +18,21 @@ Pay particular attention to **Forward Intelligence** sections — they contain h
 
 ## Your Role in the Pipeline
 
-A **researcher agent** already explored the codebase and documented findings in the slice research doc (inlined above, if present). It identified key files, build order, constraints, and verification approach. **Trust the research.** Your job is decomposition — turning findings into executable tasks — not re-exploration. Don't read code files the research already summarized unless something is ambiguous or missing from its findings.
+You have full tool access. Before decomposing, explore the relevant code to ground your plan in reality.
+
+### Verify Roadmap Assumptions
+
+Check prior slice summaries (inlined above as dependency summaries, if present). If prior slices discovered constraints, changed approaches, or flagged fragility, adjust your plan accordingly. The roadmap description may be stale — verify it against the current codebase state.
+
+### Explore Slice Scope
+
+Read the code files relevant to this slice. Confirm the roadmap's description of what exists, what needs to change, and what boundaries apply. Use `rg`, `find`, and targeted reads.
+
+### Source Files
+
+{{sourceFilePaths}}
+
+If slice research exists (inlined above), trust those findings and skip redundant exploration.
 
 After you finish, **executor agents** implement each task in isolated fresh context windows. They see only their task plan, the slice plan excerpt (goal/demo/verification), and compressed summaries of prior tasks. They do not see the research doc, the roadmap, or REQUIREMENTS.md. Everything an executor needs must be in the task plan itself — file paths, specific steps, expected inputs and outputs.
 

package/dist/resources/extensions/gsd/prompts/workflow-start.md

@@ -0,0 +1,28 @@
+# Workflow Template: {{templateName}}
+
+You are executing a **{{templateName}}** workflow (template: `{{templateId}}`).
+
+## Context
+
+- **Description:** {{description}}
+- **Issue reference:** {{issueRef}}
+- **Date:** {{date}}
+- **Branch:** {{branch}}
+- **Artifact directory:** {{artifactDir}}
+- **Phases:** {{phases}}
+- **Complexity:** {{complexity}}
+
+## Workflow Definition
+
+Follow the workflow defined below. Execute each phase in order, completing one before moving to the next. At each phase gate, confirm with the user before proceeding.
+
+{{workflowContent}}
+
+## Execution Rules
+
+1. **Follow the phases in order.** Do not skip phases unless the workflow explicitly allows it.
+2. **Artifact discipline.** If an artifact directory is specified, write all planning/summary documents there.
+3. **Atomic commits.** Commit working code after each meaningful change. Use conventional commit format: `<type>(<scope>): <description>`.
+4. **Verify before shipping.** Run the project's test suite and build before marking the workflow complete.
+5. **Gate between phases.** After each phase, summarize what was done and ask the user to confirm before moving to the next phase.
+6. **Stay focused.** This is a {{complexity}}-complexity workflow. Match your ceremony level to the task — don't over-engineer or under-deliver.

package/dist/resources/extensions/gsd/repo-identity.ts

@@ -0,0 +1,148 @@
+/**
+ * GSD Repo Identity — external state directory primitives.
+ *
+ * Computes a stable per-repo identity hash, resolves the external
+ * `~/.gsd/projects/<hash>/` state directory, and manages the
+ * `<project>/.gsd → external` symlink.
+ */
+
+import { createHash } from "node:crypto";
+import { execFileSync } from "node:child_process";
+import { existsSync, lstatSync, mkdirSync, readFileSync, realpathSync, symlinkSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+
+// ─── Repo Identity ──────────────────────────────────────────────────────────
+
+/**
+ * Get the git remote URL for "origin", or "" if no remote is configured.
+ * Uses `git config` rather than `git remote get-url` for broader compat.
+ */
+function getRemoteUrl(basePath: string): string {
+  try {
+    return execFileSync("git", ["config", "--get", "remote.origin.url"], {
+      cwd: basePath,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 5_000,
+    }).trim();
+  } catch {
+    return "";
+  }
+}
+
+/**
+ * Resolve the git toplevel (real root) for the given path.
+ * For worktrees this returns the main repo root, not the worktree path.
+ */
+function resolveGitRoot(basePath: string): string {
+  try {
+    return execFileSync("git", ["rev-parse", "--show-toplevel"], {
+      cwd: basePath,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 5_000,
+    }).trim();
+  } catch {
+    return resolve(basePath);
+  }
+}
+
+/**
+ * Compute a stable identity for a repository.
+ *
+ * SHA-256 of `${remoteUrl}\n${resolvedRoot}`, truncated to 12 hex chars.
+ * Deterministic: same repo always produces the same hash regardless of
+ * which worktree the caller is inside.
+ */
+export function repoIdentity(basePath: string): string {
+  const remoteUrl = getRemoteUrl(basePath);
+  const root = resolveGitRoot(basePath);
+  const input = `${remoteUrl}\n${root}`;
+  return createHash("sha256").update(input).digest("hex").slice(0, 12);
+}
+
+// ─── External State Directory ───────────────────────────────────────────────
+
+/**
+ * Compute the external GSD state directory for a repository.
+ *
+ * Returns `$GSD_STATE_DIR/projects/<hash>` if `GSD_STATE_DIR` is set,
+ * otherwise `~/.gsd/projects/<hash>`.
+ */
+export function externalGsdRoot(basePath: string): string {
+  const base = process.env.GSD_STATE_DIR || join(homedir(), ".gsd");
+  return join(base, "projects", repoIdentity(basePath));
+}
+
+// ─── Symlink Management ─────────────────────────────────────────────────────
+
+/**
+ * Ensure the `<project>/.gsd` symlink points to the external state directory.
+ *
+ * 1. mkdir -p the external dir
+ * 2. If `<project>/.gsd` doesn't exist → create symlink
+ * 3. If `<project>/.gsd` is already the correct symlink → no-op
+ * 4. If `<project>/.gsd` is a real directory → return as-is (migration handles later)
+ *
+ * Returns the resolved external path.
+ */
+export function ensureGsdSymlink(projectPath: string): string {
+  const externalPath = externalGsdRoot(projectPath);
+  const localGsd = join(projectPath, ".gsd");
+
+  // Ensure external directory exists
+  mkdirSync(externalPath, { recursive: true });
+
+  if (!existsSync(localGsd)) {
+    // Nothing exists yet — create symlink
+    symlinkSync(externalPath, localGsd, "junction");
+    return externalPath;
+  }
+
+  try {
+    const stat = lstatSync(localGsd);
+
+    if (stat.isSymbolicLink()) {
+      // Already a symlink — verify it points to the right place
+      const target = realpathSync(localGsd);
+      if (target === externalPath) {
+        return externalPath; // correct symlink, no-op
+      }
+      // Symlink exists but points elsewhere — leave it for now
+      // (could be a custom override or stale symlink)
+      return target;
+    }
+
+    if (stat.isDirectory()) {
+      // Real directory — migration will handle this later.
+      // Return the local path so existing code still works.
+      return localGsd;
+    }
+  } catch {
+    // lstat failed — path exists but we can't stat it
+  }
+
+  return localGsd;
+}
+
+// ─── Worktree Detection ─────────────────────────────────────────────────────
+
+/**
+ * Check if the given directory is a git worktree (not the main repo).
+ *
+ * Git worktrees have a `.git` *file* (not directory) containing a
+ * `gitdir:` pointer. This is git's native worktree indicator — no
+ * string marker parsing needed.
+ */
+export function isInsideWorktree(cwd: string): boolean {
+  const gitPath = join(cwd, ".git");
+  try {
+    const stat = lstatSync(gitPath);
+    if (!stat.isFile()) return false;
+    const content = readFileSync(gitPath, "utf-8").trim();
+    return content.startsWith("gitdir:");
+  } catch {
+    return false;
+  }
+}

package/dist/resources/extensions/gsd/resource-version.ts

@@ -0,0 +1,99 @@
+/**
+ * Resource version tracking and stale worktree detection.
+ *
+ * Staleness detection for managed GSD resources and utilities
+ * for escaping stale worktree cwd after milestone teardown.
+ */
+
+import { existsSync, readdirSync, unlinkSync } from "node:fs";
+import { loadJsonFileOrNull } from "./json-persistence.js";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { resolveProjectRoot } from "./worktree.js";
+
+// ─── Resource Staleness ───────────────────────────────────────────────────
+
+/**
+ * Read the resource version (semver) from the managed-resources manifest.
+ * Uses gsdVersion instead of syncedAt so that launching a second session
+ * doesn't falsely trigger staleness (#804).
+ */
+function isManifestWithVersion(data: unknown): data is { gsdVersion: string } {
+  return data !== null && typeof data === "object" && "gsdVersion" in data! && typeof (data as Record<string, unknown>).gsdVersion === "string";
+}
+
+export function readResourceVersion(): string | null {
+  const agentDir = process.env.GSD_CODING_AGENT_DIR || join(homedir(), ".gsd", "agent");
+  const manifestPath = join(agentDir, "managed-resources.json");
+  const manifest = loadJsonFileOrNull(manifestPath, isManifestWithVersion);
+  return manifest?.gsdVersion ?? null;
+}
+
+/**
+ * Check if managed resources have been updated since session start.
+ * Returns a warning message if stale, null otherwise.
+ */
+export function checkResourcesStale(versionOnStart: string | null): string | null {
+  if (versionOnStart === null) return null;
+  const current = readResourceVersion();
+  if (current === null) return null;
+  if (current !== versionOnStart) {
+    return "GSD resources were updated since this session started. Restart gsd to load the new code.";
+  }
+  return null;
+}
+
+// ─── Stale Worktree Escape ────────────────────────────────────────────────
+
+/**
+ * Detect and escape a stale worktree cwd (#608).
+ *
+ * After milestone completion + merge, the worktree directory is removed but
+ * the process cwd may still point inside `.gsd/worktrees/<MID>/`.
+ * When a new session starts, `process.cwd()` is passed as `base` to startAuto
+ * and all subsequent writes land in the wrong directory. This function detects
+ * that scenario and chdir back to the project root.
+ *
+ * Returns the corrected base path.
+ */
+export function escapeStaleWorktree(base: string): string {
+  const projectRoot = resolveProjectRoot(base);
+  if (projectRoot === base) return base;
+  try {
+    process.chdir(projectRoot);
+  } catch {
+    return base;
+  }
+  return projectRoot;
+}
+
+/**
+ * Clean stale runtime unit files for completed milestones.
+ *
+ * After restart, stale runtime/units/*.json from prior milestones can
+ * cause deriveState to resume the wrong milestone (#887). Removes files
+ * for milestones that have a SUMMARY (fully complete).
+ */
+export function cleanStaleRuntimeUnits(
+  gsdRootPath: string,
+  hasMilestoneSummary: (mid: string) => boolean,
+): number {
+  const runtimeUnitsDir = join(gsdRootPath, "runtime", "units");
+  if (!existsSync(runtimeUnitsDir)) return 0;
+
+  let cleaned = 0;
+  try {
+    for (const file of readdirSync(runtimeUnitsDir)) {
+      if (!file.endsWith(".json")) continue;
+      const midMatch = file.match(/(M\d+(?:-[a-z0-9]{6})?)/);
+      if (!midMatch) continue;
+      if (hasMilestoneSummary(midMatch[1])) {
+        try {
+          unlinkSync(join(runtimeUnitsDir, file));
+          cleaned++;
+        } catch { /* non-fatal */ }
+      }
+    }
+  } catch { /* non-fatal */ }
+  return cleaned;
+}

package/dist/resources/extensions/gsd/session-forensics.ts

@@ -20,6 +20,7 @@
 
 import { readFileSync, readdirSync, existsSync, statSync } from "node:fs";
 import { basename, join } from "node:path";
+import { gsdRoot } from "./paths.js";
 import { truncateWithEllipsis } from "../shared/format-utils.js";
 import { nativeParseJsonlTail } from "./native-parser-bridge.js";
 import { MAX_JSONL_BYTES, parseJSONL } from "./jsonl-utils.js";
@@ -292,7 +293,7 @@ export function getDeepDiagnostic(basePath: string): string | null {
     if (mid) {
       const wtPath = getAutoWorktreePath(basePath, mid);
       if (wtPath) {
-        const wtActivityDir = join(wtPath, ".gsd", "activity");
+        const wtActivityDir = join(gsdRoot(wtPath), "activity");
         trace = readLastActivityLog(wtActivityDir);
       }
     }
@@ -300,7 +301,7 @@ export function getDeepDiagnostic(basePath: string): string | null {
 
   // Fall back to root activity logs
   if (!trace || trace.toolCallCount === 0) {
-    const activityDir = join(basePath, ".gsd", "activity");
+    const activityDir = join(gsdRoot(basePath), "activity");
     trace = readLastActivityLog(activityDir);
   }
 
@@ -314,7 +315,7 @@ export function getDeepDiagnostic(basePath: string): string | null {
  */
 function readActiveMilestoneId(basePath: string): string | null {
   try {
-    const statePath = join(basePath, ".gsd", "STATE.md");
+    const statePath = join(gsdRoot(basePath), "STATE.md");
     if (!existsSync(statePath)) return null;
     const content = readFileSync(statePath, "utf-8");
     const match = /\*\*Active Milestone:\*\*\s*(\S+)/i.exec(content);

package/dist/resources/extensions/gsd/tests/activity-log.test.ts

@@ -6,7 +6,7 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { existsSync, mkdtempSync, mkdirSync, readdirSync, rmSync, utimesSync, writeFileSync, readFileSync } from "node:fs";
+import { existsSync, mkdtempSync, mkdirSync, readdirSync, realpathSync, rmSync, utimesSync, writeFileSync, readFileSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { tmpdir } from "node:os";
 import { fileURLToPath } from "node:url";
@@ -18,7 +18,7 @@ const __dirname = dirname(fileURLToPath(import.meta.url));
 // ── Helpers ──────────────────────────────────────────────────────────────────
 
 function createTmpDir(): string {
-  return mkdtempSync(join(tmpdir(), "gsd-activity-test-"));
+  return realpathSync(mkdtempSync(join(tmpdir(), "gsd-activity-test-")));
 }
 
 function writeActivityFile(dir: string, seq: string, name: string): string {

package/dist/resources/extensions/gsd/tests/auto-recovery.test.ts

@@ -308,8 +308,8 @@ test("loadPersistedKeys unions keys from project root and worktree", () => {
 });
 
 test("completed-units.json set-union merge produces correct result", () => {
-  // Verify that a manual set-union merge (as done in syncStateToProjectRoot)
-  // correctly merges two JSON arrays of keys.
+  // Verify that a manual set-union merge correctly merges two JSON arrays
+  // of completed-unit keys.
   const projectRoot = makeTmpBase();
   const worktree = makeTmpBase();
   try {
@@ -320,7 +320,7 @@ test("completed-units.json set-union merge produces correct result", () => {
     writeFileSync(prKeysFile, JSON.stringify(["a", "b"]));
     writeFileSync(wtKeysFile, JSON.stringify(["b", "c", "d"]));
 
-    // Perform the same merge logic used in syncStateToProjectRoot
+    // Perform a set-union merge of two JSON key arrays
     const srcKeys: string[] = JSON.parse(readFileSync(wtKeysFile, "utf8"));
     let dstKeys: string[] = [];
     if (existsSync(prKeysFile)) {

package/dist/resources/extensions/gsd/tests/auto-worktree.test.ts

@@ -153,64 +153,6 @@ async function main(): Promise<void> {
     // After teardown, originalBase should be null
     assertEq(getAutoWorktreeOriginalBase(), null, "no split-brain: originalBase cleared");
 
-    // ─── #778: reconcile plan checkboxes on re-attach ─────────────────
-    console.log("\n=== #778: reconcile plan checkboxes on re-attach ===");
-    {
-      // Simulate: T01 [x] was committed to milestone branch, T02 [x] was
-      // written to project root by syncStateToProjectRoot() but the
-      // auto-commit crashed before it fired. On restart the worktree is
-      // re-created from the milestone branch HEAD (T02 still [ ]).
-      // reconcilePlanCheckboxes should forward-apply T02 [x] from the root.
-
-      const planRelPath = join(".gsd", "milestones", "M004", "slices", "S01", "S01-PLAN.md");
-      const planDir = join(tempDir, ".gsd", "milestones", "M004", "slices", "S01");
-      const { mkdirSync: mkdir, writeFileSync: write, readFileSync: read } = await import("node:fs");
-
-      // Plan on integration branch (project root): T01 [x], T02 [x]
-      mkdir(planDir, { recursive: true });
-      write(
-        join(tempDir, planRelPath),
-        "# S01 Plan\n- [x] **T01:** task one\n- [x] **T02:** task two\n- [ ] **T03:** task three\n",
-      );
-
-      // Write integration-branch plan to git so milestone branch starts from it
-      run(`git add .`, tempDir);
-      run(`git commit -m "add plan with T01 and T02 checked" --allow-empty`, tempDir);
-
-      // Create milestone branch with only T01 [x] (simulating crash before T02 commit)
-      const milestoneBranch = "milestone/M004";
-      run(`git checkout -b ${milestoneBranch}`, tempDir);
-      mkdir(planDir, { recursive: true });
-      write(
-        join(tempDir, planRelPath),
-        "# S01 Plan\n- [x] **T01:** task one\n- [ ] **T02:** task two\n- [ ] **T03:** task three\n",
-      );
-      run(`git add .`, tempDir);
-      run(`git commit -m "milestone: only T01 checked"`, tempDir);
-      run(`git checkout main`, tempDir);
-
-      // Restore project root plan (T01+T02 [x]) — simulates syncStateToProjectRoot
-      write(
-        join(tempDir, planRelPath),
-        "# S01 Plan\n- [x] **T01:** task one\n- [x] **T02:** task two\n- [ ] **T03:** task three\n",
-      );
-
-      // Create worktree re-attached to existing milestone branch (T02 still [ ] in branch)
-      const wtPath = createAutoWorktree(tempDir, "M004");
-
-      try {
-        const wtPlanPath = join(wtPath, planRelPath);
-        assertTrue(existsSync(wtPlanPath), "plan file exists in worktree after re-attach");
-
-        const wtPlan = read(wtPlanPath, "utf-8");
-        assertTrue(wtPlan.includes("- [x] **T02:"), "T02 should be [x] after reconciliation (was [ ] on branch)");
-        assertTrue(wtPlan.includes("- [x] **T01:"), "T01 stays [x]");
-        assertTrue(wtPlan.includes("- [ ] **T03:"), "T03 stays [ ] (not in root either)");
-      } finally {
-        teardownAutoWorktree(tempDir, "M004");
-      }
-    }
-
   } finally {
     // Always restore cwd and clean up
     process.chdir(savedCwd);

package/dist/resources/extensions/gsd/tests/doctor-runtime.test.ts

@@ -231,15 +231,14 @@ None
       const detect = await runGSDDoctor(dir);
       const gitignoreIssues = detect.issues.filter(i => i.code === "gitignore_missing_patterns");
       assertTrue(gitignoreIssues.length > 0, "detects missing gitignore patterns");
-      assertTrue(gitignoreIssues[0]?.message.includes(".gsd/activity/"), "message lists missing patterns");
+      assertTrue(gitignoreIssues[0]?.message.includes(".gsd"), "message lists missing .gsd pattern");
 
       const fixed = await runGSDDoctor(dir, { fix: true });
       assertTrue(fixed.fixesApplied.some(f => f.includes("added missing GSD runtime patterns")), "fix adds patterns");
 
-      // Verify patterns were added
+      // Verify .gsd entry was added (external state symlink)
       const content = readFileSync(join(dir, ".gitignore"), "utf-8");
-      assertTrue(content.includes(".gsd/activity/"), "gitignore now has activity pattern");
-      assertTrue(content.includes(".gsd/auto.lock"), "gitignore now has auto.lock pattern");
+      assertTrue(content.includes(".gsd"), "gitignore now has .gsd entry");
     }
     } else {
       console.log("\n=== gitignore_missing_patterns (skipped on Windows) ===");