gsd-pi 2.18.0 → 2.20.0

package/dist/resources/extensions/gsd/auto-prompts.ts

@@ -55,7 +55,7 @@ export async function inlineFileOptional(
  * Load and inline dependency slice summaries (full content, not just paths).
  */
 export async function inlineDependencySummaries(
-  mid: string, sid: string, base: string,
+  mid: string, sid: string, base: string, budgetChars?: number,
 ): Promise<string> {
   const roadmapFile = resolveMilestoneFile(base, mid, "ROADMAP");
   const roadmapContent = roadmapFile ? await loadFile(roadmapFile) : null;
@@ -79,7 +79,14 @@ export async function inlineDependencySummaries(
       sections.push(`- \`${relPath}\` _(not found)_`);
     }
   }
-  return sections.join("\n\n");
+
+  const result = sections.join("\n\n");
+  // When a budget is provided, truncate at section boundaries to fit
+  if (budgetChars !== undefined && result.length > budgetChars) {
+    const { truncateAtSectionBoundary } = await import("./context-budget.js");
+    return truncateAtSectionBoundary(result, budgetChars).content;
+  }
+  return result;
 }
 
 /**
@@ -95,6 +102,76 @@ export async function inlineGsdRootFile(
   return inlineFileOptional(absPath, relGsdRootFile(key), label);
 }
 
+// ─── DB-Aware Inline Helpers ──────────────────────────────────────────────
+
+/**
+ * Inline decisions with optional milestone scoping from the DB.
+ * Falls back to filesystem via inlineGsdRootFile when DB unavailable or empty.
+ */
+export async function inlineDecisionsFromDb(
+  base: string, milestoneId?: string, scope?: string,
+): Promise<string | null> {
+  try {
+    const { isDbAvailable } = await import("./gsd-db.js");
+    if (isDbAvailable()) {
+      const { queryDecisions, formatDecisionsForPrompt } = await import("./context-store.js");
+      const decisions = queryDecisions({ milestoneId, scope });
+      if (decisions.length > 0) {
+        const formatted = formatDecisionsForPrompt(decisions);
+        return `### Decisions\nSource: \`.gsd/DECISIONS.md\`\n\n${formatted}`;
+      }
+    }
+  } catch {
+    // DB not available — fall through to filesystem
+  }
+  return inlineGsdRootFile(base, "decisions.md", "Decisions");
+}
+
+/**
+ * Inline requirements with optional slice scoping from the DB.
+ * Falls back to filesystem via inlineGsdRootFile when DB unavailable or empty.
+ */
+export async function inlineRequirementsFromDb(
+  base: string, sliceId?: string,
+): Promise<string | null> {
+  try {
+    const { isDbAvailable } = await import("./gsd-db.js");
+    if (isDbAvailable()) {
+      const { queryRequirements, formatRequirementsForPrompt } = await import("./context-store.js");
+      const requirements = queryRequirements({ sliceId });
+      if (requirements.length > 0) {
+        const formatted = formatRequirementsForPrompt(requirements);
+        return `### Requirements\nSource: \`.gsd/REQUIREMENTS.md\`\n\n${formatted}`;
+      }
+    }
+  } catch {
+    // DB not available — fall through to filesystem
+  }
+  return inlineGsdRootFile(base, "requirements.md", "Requirements");
+}
+
+/**
+ * Inline project context from the DB.
+ * Falls back to filesystem via inlineGsdRootFile when DB unavailable or empty.
+ */
+export async function inlineProjectFromDb(
+  base: string,
+): Promise<string | null> {
+  try {
+    const { isDbAvailable } = await import("./gsd-db.js");
+    if (isDbAvailable()) {
+      const { queryProject } = await import("./context-store.js");
+      const content = queryProject();
+      if (content) {
+        return `### Project\nSource: \`.gsd/PROJECT.md\`\n\n${content}`;
+      }
+    }
+  } catch {
+    // DB not available — fall through to filesystem
+  }
+  return inlineGsdRootFile(base, "project.md", "Project");
+}
+
 // ─── Skill Discovery ──────────────────────────────────────────────────────
 
 /**
@@ -371,11 +448,11 @@ export async function buildResearchMilestonePrompt(mid: string, midTitle: string
 
   const inlined: string[] = [];
   inlined.push(await inlineFile(contextPath, contextRel, "Milestone Context"));
-  const projectInline = await inlineGsdRootFile(base, "project.md", "Project");
+  const projectInline = await inlineProjectFromDb(base);
   if (projectInline) inlined.push(projectInline);
-  const requirementsInline = await inlineGsdRootFile(base, "requirements.md", "Requirements");
+  const requirementsInline = await inlineRequirementsFromDb(base);
   if (requirementsInline) inlined.push(requirementsInline);
-  const decisionsInline = await inlineGsdRootFile(base, "decisions.md", "Decisions");
+  const decisionsInline = await inlineDecisionsFromDb(base, mid);
   if (decisionsInline) inlined.push(decisionsInline);
   const knowledgeInlineRM = await inlineGsdRootFile(base, "knowledge.md", "Project Knowledge");
   if (knowledgeInlineRM) inlined.push(knowledgeInlineRM);
@@ -389,7 +466,7 @@ export async function buildResearchMilestonePrompt(mid: string, midTitle: string
     milestoneId: mid, milestoneTitle: midTitle,
     milestonePath: relMilestonePath(base, mid),
     contextPath: contextRel,
-    outputPath: outputRelPath,
+    outputPath: join(base, outputRelPath),
     inlinedContext,
     ...buildSkillDiscoveryVars(),
   });
@@ -409,12 +486,14 @@ export async function buildPlanMilestonePrompt(mid: string, midTitle: string, ba
   const { inlinePriorMilestoneSummary } = await import("./files.js");
   const priorSummaryInline = await inlinePriorMilestoneSummary(mid, base);
   if (priorSummaryInline) inlined.push(priorSummaryInline);
-  const projectInline = inlineLevel !== "minimal" ? await inlineGsdRootFile(base, "project.md", "Project") : null;
-  if (projectInline) inlined.push(projectInline);
-  const requirementsInline = inlineLevel !== "minimal" ? await inlineGsdRootFile(base, "requirements.md", "Requirements") : null;
-  if (requirementsInline) inlined.push(requirementsInline);
-  const decisionsInline = inlineLevel !== "minimal" ? await inlineGsdRootFile(base, "decisions.md", "Decisions") : null;
-  if (decisionsInline) inlined.push(decisionsInline);
+  if (inlineLevel !== "minimal") {
+    const projectInline = await inlineProjectFromDb(base);
+    if (projectInline) inlined.push(projectInline);
+    const requirementsInline = await inlineRequirementsFromDb(base);
+    if (requirementsInline) inlined.push(requirementsInline);
+    const decisionsInline = await inlineDecisionsFromDb(base, mid);
+    if (decisionsInline) inlined.push(decisionsInline);
+  }
   const knowledgeInlinePM = await inlineGsdRootFile(base, "knowledge.md", "Project Knowledge");
   if (knowledgeInlinePM) inlined.push(knowledgeInlinePM);
   inlined.push(inlineTemplate("roadmap", "Roadmap"));
@@ -432,14 +511,14 @@ export async function buildPlanMilestonePrompt(mid: string, midTitle: string, ba
   const inlinedContext = `## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`;
 
   const outputRelPath = relMilestoneFile(base, mid, "ROADMAP");
-  const secretsOutputPath = relMilestoneFile(base, mid, "SECRETS");
+  const secretsOutputPath = join(base, relMilestoneFile(base, mid, "SECRETS"));
   return loadPrompt("plan-milestone", {
     workingDirectory: base,
     milestoneId: mid, milestoneTitle: midTitle,
     milestonePath: relMilestonePath(base, mid),
     contextPath: contextRel,
     researchPath: researchRel,
-    outputPath: outputRelPath,
+    outputPath: join(base, outputRelPath),
     secretsOutputPath,
     inlinedContext,
   });
@@ -461,9 +540,9 @@ export async function buildResearchSlicePrompt(
   if (contextInline) inlined.push(contextInline);
   const researchInline = await inlineFileOptional(milestoneResearchPath, milestoneResearchRel, "Milestone Research");
   if (researchInline) inlined.push(researchInline);
-  const decisionsInline = await inlineGsdRootFile(base, "decisions.md", "Decisions");
+  const decisionsInline = await inlineDecisionsFromDb(base, mid);
   if (decisionsInline) inlined.push(decisionsInline);
-  const requirementsInline = await inlineGsdRootFile(base, "requirements.md", "Requirements");
+  const requirementsInline = await inlineRequirementsFromDb(base, sid);
   if (requirementsInline) inlined.push(requirementsInline);
   const knowledgeInlineRS = await inlineGsdRootFile(base, "knowledge.md", "Project Knowledge");
   if (knowledgeInlineRS) inlined.push(knowledgeInlineRS);
@@ -484,7 +563,7 @@ export async function buildResearchSlicePrompt(
     roadmapPath: roadmapRel,
     contextPath: contextRel,
     milestoneResearchPath: milestoneResearchRel,
-    outputPath: outputRelPath,
+    outputPath: join(base, outputRelPath),
     inlinedContext,
     dependencySummaries: depContent,
     ...buildSkillDiscoveryVars(),
@@ -505,9 +584,9 @@ export async function buildPlanSlicePrompt(
   const researchInline = await inlineFileOptional(researchPath, researchRel, "Slice Research");
   if (researchInline) inlined.push(researchInline);
   if (inlineLevel !== "minimal") {
-    const decisionsInline = await inlineGsdRootFile(base, "decisions.md", "Decisions");
+    const decisionsInline = await inlineDecisionsFromDb(base, mid);
     if (decisionsInline) inlined.push(decisionsInline);
-    const requirementsInline = await inlineGsdRootFile(base, "requirements.md", "Requirements");
+    const requirementsInline = await inlineRequirementsFromDb(base, sid);
     if (requirementsInline) inlined.push(requirementsInline);
   }
   const knowledgeInlinePS = await inlineGsdRootFile(base, "knowledge.md", "Project Knowledge");
@@ -531,7 +610,7 @@ export async function buildPlanSlicePrompt(
     slicePath: relSlicePath(base, mid, sid),
     roadmapPath: roadmapRel,
     researchPath: researchRel,
-    outputPath: outputRelPath,
+    outputPath: join(base, outputRelPath),
     inlinedContext,
     dependencySummaries: depContent,
   });
@@ -598,7 +677,7 @@ export async function buildExecuteTaskPrompt(
         ...(knowledgeInlineET ? [knowledgeInlineET] : []),
       ].join("\n\n---\n\n");
 
-  const taskSummaryPath = `${relSlicePath(base, mid, sid)}/tasks/${tid}-SUMMARY.md`;
+  const taskSummaryPath = join(base, `${relSlicePath(base, mid, sid)}/tasks/${tid}-SUMMARY.md`);
 
   const activeOverrides = await loadActiveOverrides(base);
   const overridesSection = formatOverridesSection(activeOverrides);
@@ -607,7 +686,7 @@ export async function buildExecuteTaskPrompt(
     overridesSection,
     workingDirectory: base,
     milestoneId: mid, sliceId: sid, sliceTitle: sTitle, taskId: tid, taskTitle: tTitle,
-    planPath: relSliceFile(base, mid, sid, "PLAN"),
+    planPath: join(base, relSliceFile(base, mid, sid, "PLAN")),
     slicePath: relSlicePath(base, mid, sid),
     taskPlanPath: taskPlanRelPath,
     taskPlanInline,
@@ -634,7 +713,7 @@ export async function buildCompleteSlicePrompt(
   inlined.push(await inlineFile(roadmapPath, roadmapRel, "Milestone Roadmap"));
   inlined.push(await inlineFile(slicePlanPath, slicePlanRel, "Slice Plan"));
   if (inlineLevel !== "minimal") {
-    const requirementsInline = await inlineGsdRootFile(base, "requirements.md", "Requirements");
+    const requirementsInline = await inlineRequirementsFromDb(base, sid);
     if (requirementsInline) inlined.push(requirementsInline);
   }
   const knowledgeInlineCS = await inlineGsdRootFile(base, "knowledge.md", "Project Knowledge");
@@ -665,14 +744,14 @@ export async function buildCompleteSlicePrompt(
   const inlinedContext = `## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`;
 
   const sliceRel = relSlicePath(base, mid, sid);
-  const sliceSummaryPath = `${sliceRel}/${sid}-SUMMARY.md`;
-  const sliceUatPath = `${sliceRel}/${sid}-UAT.md`;
+  const sliceSummaryPath = join(base, `${sliceRel}/${sid}-SUMMARY.md`);
+  const sliceUatPath = join(base, `${sliceRel}/${sid}-UAT.md`);
 
   return loadPrompt("complete-slice", {
     workingDirectory: base,
     milestoneId: mid, sliceId: sid, sliceTitle: sTitle,
     slicePath: sliceRel,
-    roadmapPath: roadmapRel,
+    roadmapPath: join(base, roadmapRel),
     inlinedContext,
     sliceSummaryPath,
     sliceUatPath,
@@ -705,11 +784,11 @@ export async function buildCompleteMilestonePrompt(
 
   // Inline root GSD files (skip for minimal — completion can read these if needed)
   if (inlineLevel !== "minimal") {
-    const requirementsInline = await inlineGsdRootFile(base, "requirements.md", "Requirements");
+    const requirementsInline = await inlineRequirementsFromDb(base);
     if (requirementsInline) inlined.push(requirementsInline);
-    const decisionsInline = await inlineGsdRootFile(base, "decisions.md", "Decisions");
+    const decisionsInline = await inlineDecisionsFromDb(base, mid);
     if (decisionsInline) inlined.push(decisionsInline);
-    const projectInline = await inlineGsdRootFile(base, "project.md", "Project");
+    const projectInline = await inlineProjectFromDb(base);
     if (projectInline) inlined.push(projectInline);
   }
   const knowledgeInlineCM = await inlineGsdRootFile(base, "knowledge.md", "Project Knowledge");
@@ -723,7 +802,7 @@ export async function buildCompleteMilestonePrompt(
 
   const inlinedContext = `## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`;
 
-  const milestoneSummaryPath = `${relMilestonePath(base, mid)}/${mid}-SUMMARY.md`;
+  const milestoneSummaryPath = join(base, `${relMilestonePath(base, mid)}/${mid}-SUMMARY.md`);
 
   return loadPrompt("complete-milestone", {
     workingDirectory: base,
@@ -767,7 +846,7 @@ export async function buildReplanSlicePrompt(
   }
 
   // Inline decisions
-  const decisionsInline = await inlineGsdRootFile(base, "decisions.md", "Decisions");
+  const decisionsInline = await inlineDecisionsFromDb(base, mid);
   if (decisionsInline) inlined.push(decisionsInline);
   const replanActiveOverrides = await loadActiveOverrides(base);
   const replanOverridesInline = formatOverridesSection(replanActiveOverrides);
@@ -775,7 +854,21 @@ export async function buildReplanSlicePrompt(
 
   const inlinedContext = `## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`;
 
-  const replanPath = `${relSlicePath(base, mid, sid)}/${sid}-REPLAN.md`;
+  const replanPath = join(base, `${relSlicePath(base, mid, sid)}/${sid}-REPLAN.md`);
+
+  // Build capture context for replan prompt (captures that triggered this replan)
+  let captureContext = "(none)";
+  try {
+    const { loadReplanCaptures } = await import("./triage-resolution.js");
+    const replanCaptures = loadReplanCaptures(base);
+    if (replanCaptures.length > 0) {
+      captureContext = replanCaptures.map(c =>
+        `- **${c.id}**: "${c.text}" — ${c.rationale ?? "no rationale"}`
+      ).join("\n");
+    }
+  } catch {
+    // Non-fatal — captures module may not be available
+  }
 
   return loadPrompt("replan-slice", {
     workingDirectory: base,
@@ -783,10 +876,11 @@ export async function buildReplanSlicePrompt(
     sliceId: sid,
     sliceTitle: sTitle,
     slicePath: relSlicePath(base, mid, sid),
-    planPath: slicePlanRel,
+    planPath: join(base, slicePlanRel),
     blockerTaskId,
     inlinedContext,
     replanPath,
+    captureContext,
   });
 }
 
@@ -803,12 +897,12 @@ export async function buildRunUatPrompt(
     if (summaryInline) inlined.push(summaryInline);
   }
 
-  const projectInline = await inlineGsdRootFile(base, "project.md", "Project");
+  const projectInline = await inlineProjectFromDb(base);
   if (projectInline) inlined.push(projectInline);
 
   const inlinedContext = `## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`;
 
-  const uatResultPath = relSliceFile(base, mid, sliceId, "UAT-RESULT");
+  const uatResultPath = join(base, relSliceFile(base, mid, sliceId, "UAT-RESULT"));
   const uatType = extractUatType(uatContent) ?? "human-experience";
 
   return loadPrompt("run-uat", {
@@ -835,11 +929,11 @@ export async function buildReassessRoadmapPrompt(
   inlined.push(await inlineFile(roadmapPath, roadmapRel, "Current Roadmap"));
   inlined.push(await inlineFile(summaryPath, summaryRel, `${completedSliceId} Summary`));
   if (inlineLevel !== "minimal") {
-    const projectInline = await inlineGsdRootFile(base, "project.md", "Project");
+    const projectInline = await inlineProjectFromDb(base);
     if (projectInline) inlined.push(projectInline);
-    const requirementsInline = await inlineGsdRootFile(base, "requirements.md", "Requirements");
+    const requirementsInline = await inlineRequirementsFromDb(base);
     if (requirementsInline) inlined.push(requirementsInline);
-    const decisionsInline = await inlineGsdRootFile(base, "decisions.md", "Decisions");
+    const decisionsInline = await inlineDecisionsFromDb(base, mid);
     if (decisionsInline) inlined.push(decisionsInline);
   }
   const knowledgeInlineRA = await inlineGsdRootFile(base, "knowledge.md", "Project Knowledge");
@@ -847,7 +941,21 @@ export async function buildReassessRoadmapPrompt(
 
   const inlinedContext = `## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`;
 
-  const assessmentPath = relSliceFile(base, mid, completedSliceId, "ASSESSMENT");
+  const assessmentPath = join(base, relSliceFile(base, mid, completedSliceId, "ASSESSMENT"));
+
+  // Build deferred captures context for reassess prompt
+  let deferredCaptures = "(none)";
+  try {
+    const { loadDeferredCaptures } = await import("./triage-resolution.js");
+    const deferred = loadDeferredCaptures(base);
+    if (deferred.length > 0) {
+      deferredCaptures = deferred.map(c =>
+        `- **${c.id}**: "${c.text}" — ${c.rationale ?? "deferred during triage"}`
+      ).join("\n");
+    }
+  } catch {
+    // Non-fatal — captures module may not be available
+  }
 
   return loadPrompt("reassess-roadmap", {
     workingDirectory: base,
@@ -858,6 +966,7 @@ export async function buildReassessRoadmapPrompt(
     completedSliceSummaryPath: summaryRel,
     assessmentPath,
     inlinedContext,
+    deferredCaptures,
   });
 }
 

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

@@ -7,8 +7,9 @@
  */
 
 import { existsSync, cpSync, readFileSync, realpathSync, utimesSync } from "node:fs";
-import { join, resolve } from "node:path";
-import { execSync } from "node:child_process";
+import { isAbsolute, join, resolve } from "node:path";
+import { copyWorktreeDb, reconcileWorktreeDb, isDbAvailable } from "./gsd-db.js";
+import { execSync, execFileSync } from "node:child_process";
 import {
   createWorktree,
   removeWorktree,
@@ -33,6 +34,7 @@ import {
   nativeAddPaths,
   nativeRmForce,
   nativeBranchDelete,
+  nativeBranchExists,
 } from "./native-git-bridge.js";
 
 // ─── Module State ──────────────────────────────────────────────────────────
@@ -75,6 +77,48 @@ function nudgeGitBranchCache(previousCwd: string): void {
   }
 }
 
+// ─── Worktree Post-Create Hook (#597) ────────────────────────────────────────
+
+/**
+ * Run the user-configured post-create hook script after worktree creation.
+ * The script receives SOURCE_DIR and WORKTREE_DIR as environment variables.
+ * Failure is non-fatal — returns the error message or null on success.
+ *
+ * Reads the hook path from git.worktree_post_create in preferences.
+ * Pass hookPath directly to bypass preference loading (useful for testing).
+ */
+export function runWorktreePostCreateHook(sourceDir: string, worktreeDir: string, hookPath?: string): string | null {
+  if (hookPath === undefined) {
+    const prefs = loadEffectiveGSDPreferences()?.preferences?.git;
+    hookPath = prefs?.worktree_post_create;
+  }
+  if (!hookPath) return null;
+
+  // Resolve relative paths against the source project root
+  const resolved = isAbsolute(hookPath) ? hookPath : join(sourceDir, hookPath);
+  if (!existsSync(resolved)) {
+    return `Worktree post-create hook not found: ${resolved}`;
+  }
+
+  try {
+    execSync(resolved, {
+      cwd: worktreeDir,
+      env: {
+        ...process.env,
+        SOURCE_DIR: sourceDir,
+        WORKTREE_DIR: worktreeDir,
+      },
+      stdio: ["ignore", "pipe", "pipe"],
+      encoding: "utf-8",
+      timeout: 30_000, // 30 second timeout
+    });
+    return null;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return `Worktree post-create hook failed: ${msg}`;
+  }
+}
+
 // ─── Auto-Worktree Branch Naming ───────────────────────────────────────────
 
 export function autoWorktreeBranch(milestoneId: string): string {
@@ -93,11 +137,21 @@ export function autoWorktreeBranch(milestoneId: string): string {
 export function createAutoWorktree(basePath: string, milestoneId: string): string {
   const branch = autoWorktreeBranch(milestoneId);
 
-  // Use the integration branch recorded in META.json as the start point.
-  // This ensures the worktree branch is created from the branch the user
-  // was on when they started the milestone (e.g. f-setup-gsd-2), not main.
-  const integrationBranch = readIntegrationBranch(basePath, milestoneId) ?? undefined;
-  const info = createWorktree(basePath, milestoneId, { branch, startPoint: integrationBranch });
+  // Check if the milestone branch already exists — it survives auto-mode
+  // stop/pause and contains committed work from prior sessions. If it exists,
+  // re-attach the worktree to it WITHOUT resetting. Only create a fresh branch
+  // from the integration branch when no prior work exists.
+  const branchExists = nativeBranchExists(basePath, branch);
+
+  let info: { name: string; path: string; branch: string; exists: boolean };
+  if (branchExists) {
+    // Re-attach worktree to the existing milestone branch (preserving commits)
+    info = createWorktree(basePath, milestoneId, { branch, reuseExistingBranch: true });
+  } else {
+    // Fresh start — create branch from integration branch
+    const integrationBranch = readIntegrationBranch(basePath, milestoneId) ?? undefined;
+    info = createWorktree(basePath, milestoneId, { branch, startPoint: integrationBranch });
+  }
 
   // Copy .gsd/ planning artifacts from the source repo into the new worktree.
   // Worktrees are fresh git checkouts — untracked files don't carry over.
@@ -106,6 +160,13 @@ export function createAutoWorktree(basePath: string, milestoneId: string): strin
   // on plan-slice because the plan file doesn't exist in the worktree.
   copyPlanningArtifacts(basePath, info.path);
 
+  // Run user-configured post-create hook (#597) — e.g. copy .env, symlink assets
+  const hookError = runWorktreePostCreateHook(basePath, info.path);
+  if (hookError) {
+    // Non-fatal — log but don't prevent worktree usage
+    console.error(`[GSD] ${hookError}`);
+  }
+
   const previousCwd = process.cwd();
 
   try {
@@ -151,14 +212,28 @@ function copyPlanningArtifacts(srcBase: string, wtPath: string): void {
       } catch { /* non-fatal */ }
     }
   }
+
+  // Copy gsd.db if present in source
+  const srcDb = join(srcGsd, "gsd.db");
+  const destDb = join(dstGsd, "gsd.db");
+  if (existsSync(srcDb)) {
+    try {
+      copyWorktreeDb(srcDb, destDb);
+    } catch { /* non-fatal */ }
+  }
 }
 
 /**
  * Teardown an auto-worktree: chdir back to original base, then remove
  * the worktree and its branch.
  */
-export function teardownAutoWorktree(originalBasePath: string, milestoneId: string): void {
+export function teardownAutoWorktree(
+  originalBasePath: string,
+  milestoneId: string,
+  opts: { preserveBranch?: boolean } = {},
+): void {
   const branch = autoWorktreeBranch(milestoneId);
+  const { preserveBranch = false } = opts;
   const previousCwd = process.cwd();
 
   try {
@@ -171,7 +246,7 @@ export function teardownAutoWorktree(originalBasePath: string, milestoneId: stri
   }
 
   nudgeGitBranchCache(previousCwd);
-  removeWorktree(originalBasePath, milestoneId, { branch });
+  removeWorktree(originalBasePath, milestoneId, { branch, deleteBranch: !preserveBranch });
 }
 
 /**
@@ -299,6 +374,15 @@ export function mergeMilestoneToMain(
   // 1. Auto-commit dirty state in worktree before leaving
   autoCommitDirtyState(worktreeCwd);
 
+  // Reconcile worktree DB into main DB before leaving worktree context
+  if (isDbAvailable()) {
+    try {
+      const worktreeDbPath = join(worktreeCwd, ".gsd", "gsd.db");
+      const mainDbPath = join(originalBasePath_, ".gsd", "gsd.db");
+      reconcileWorktreeDb(mainDbPath, worktreeDbPath);
+    } catch { /* non-fatal */ }
+  }
+
   // 2. Parse roadmap for slice listing
   const roadmap = parseRoadmap(roadmapContent);
   const completedSlices = roadmap.slices.filter(s => s.done);