gsd-pi 2.19.0 → 2.20.0

package/src/resources/extensions/google-search/index.ts

@@ -68,6 +68,101 @@ async function getClient(): Promise<GoogleGenAIClient> {
 	return client;
 }
 
+/**
+ * Perform a search using OAuth credentials via the Cloud Code Assist API.
+ * This is used as a fallback when GEMINI_API_KEY is not set.
+ */
+async function searchWithOAuth(
+	query: string,
+	accessToken: string,
+	projectId: string,
+	signal?: AbortSignal,
+): Promise<SearchResult> {
+	const model = process.env.GEMINI_SEARCH_MODEL || "gemini-2.5-flash";
+	const url = `https://cloudcode-pa.googleapis.com/v1internal:streamGenerateContent`;
+
+	const GEMINI_CLI_HEADERS = {
+	        ideType: "IDE_UNSPECIFIED",
+	        platform: "PLATFORM_UNSPECIFIED",
+	        pluginType: "GEMINI",
+	};
+
+	const executeFetch = async (retries = 3): Promise<Response> => {
+	        const response = await fetch(url, {
+	                method: "POST",
+	                headers: {
+	                        Authorization: `Bearer ${accessToken}`,
+	                        "Content-Type": "application/json",
+	                        "User-Agent": "google-cloud-sdk vscode_cloudshelleditor/0.1",
+	                        "X-Goog-Api-Client": "gl-node/22.17.0",
+	                        "Client-Metadata": JSON.stringify(GEMINI_CLI_HEADERS),
+	                },
+	                body: JSON.stringify({
+	                        project: projectId,
+	                        model,
+	                        request: {
+	                                contents: [{ parts: [{ text: query }] }],
+	                                tools: [{ googleSearch: {} }],
+	                        },
+	                }),
+	                signal,
+	        });
+
+	        if (!response.ok && retries > 0 && (response.status === 429 || response.status >= 500)) {
+	                await new Promise((resolve) => setTimeout(resolve, 1000 * (4 - retries)));
+	                return executeFetch(retries - 1);
+	        }
+
+	        return response;
+	};
+
+	const response = await executeFetch();
+
+	if (!response.ok) {
+	        const errorText = await response.text();
+	        throw new Error(`Cloud Code Assist API error (${response.status}): ${errorText}`);
+	}
+
+	// Note: streamGenerateContent returns SSE; for now, we consume all chunks.
+	// For simplicity and to match the previous structure, we'll read to end.
+	const text = await response.text();
+	const jsonLines = text.split("\n")
+	        .filter(l => l.startsWith("data:"))
+	        .map(l => l.slice(5).trim())
+	        .filter(l => l.length > 0);
+
+	let data;
+	if (jsonLines.length > 0) {
+	    // Aggregate chunks if needed, but for now we take the last chunk or assume it's one
+	    data = JSON.parse(jsonLines[jsonLines.length - 1]);
+	} else {
+	    data = JSON.parse(text);
+	}	const candidate = data.response?.candidates?.[0];
+	const answer = candidate?.content?.parts?.find((p: any) => p.text)?.text ?? "";
+	const grounding = candidate?.groundingMetadata;
+
+	const sources: SearchSource[] = [];
+	const seenTitles = new Set<string>();
+	if (grounding?.groundingChunks) {
+		for (const chunk of grounding.groundingChunks) {
+			if (chunk.web) {
+				const title = chunk.web.title ?? "Untitled";
+				if (seenTitles.has(title)) continue;
+				seenTitles.add(title);
+				const domain = chunk.web.domain ?? title;
+				sources.push({
+					title,
+					uri: chunk.web.uri ?? "",
+					domain,
+				});
+			}
+		}
+	}
+
+	const searchQueries = grounding?.webSearchQueries ?? [];
+	return { answer, sources, searchQueries, cached: false };
+}
+
 // ── In-session cache ─────────────────────────────────────────────────────────
 
 const resultCache = new Map<string, SearchResult>();
@@ -87,7 +182,7 @@ export default function (pi: ExtensionAPI) {
 			"Returns an AI-synthesized answer grounded in Google Search results, plus source URLs. " +
 			"Use this when you need current information from the web: recent events, documentation, " +
 			"product details, technical references, news, etc. " +
-			"Requires GEMINI_API_KEY. Alternative to Brave-based search tools for users with Google Cloud credits.",
+			"Requires GEMINI_API_KEY or Google login. Alternative to Brave-based search tools.",
 		promptSnippet: "Search the web via Google Search to get current information with sources",
 		promptGuidelines: [
 			"Use google_search when you need up-to-date web information that isn't in your training data.",
@@ -109,17 +204,33 @@ export default function (pi: ExtensionAPI) {
 			),
 		}),
 
-		async execute(_toolCallId, params, signal, _onUpdate, _ctx) {
+		async execute(_toolCallId, params, signal, _onUpdate, ctx) {
 			const startTime = Date.now();
 			const maxSources = Math.min(Math.max(params.maxSources ?? 5, 1), 10);
 
-			// Check for API key
+			// Check for credentials
+			let oauthToken: string | undefined;
+			let projectId: string | undefined;
+
 			if (!process.env.GEMINI_API_KEY) {
+				const oauthRaw = await ctx.modelRegistry.getApiKeyForProvider("google-gemini-cli");
+				if (oauthRaw) {
+					try {
+						const parsed = JSON.parse(oauthRaw);
+						oauthToken = parsed.token;
+						projectId = parsed.projectId;
+					} catch {
+						// Fall through to error
+					}
+				}
+			}
+
+			if (!process.env.GEMINI_API_KEY && (!oauthToken || !projectId)) {
 				return {
 					content: [
 						{
 							type: "text",
-							text: "Error: GEMINI_API_KEY is not set. Please set this environment variable to use Google Search.\n\nExample: export GEMINI_API_KEY=your_key",
+							text: "Error: No authentication found for Google Search. Please set GEMINI_API_KEY or log in via Google.\n\nExample: export GEMINI_API_KEY=your_key or use /login google",
 						},
 					],
 					isError: true,
@@ -128,7 +239,7 @@ export default function (pi: ExtensionAPI) {
 						sourceCount: 0,
 						cached: false,
 						durationMs: Date.now() - startTime,
-						error: "auth_error: GEMINI_API_KEY not set",
+						error: "auth_error: No credentials set",
 					} as SearchDetails,
 				};
 			}
@@ -152,49 +263,52 @@ export default function (pi: ExtensionAPI) {
 			// Call Gemini with Google Search grounding
 			let result: SearchResult;
 			try {
-				const ai = await getClient();
-				const response = await ai.models.generateContent({
-					model: process.env.GEMINI_SEARCH_MODEL || "gemini-2.5-flash",
-					contents: params.query,
-					config: {
-						tools: [{ googleSearch: {} }],
-						abortSignal: signal,
-					},
-				});
-
-				// Extract answer text
-				const answer = response.text ?? "";
-
-				// Extract grounding metadata
-				const candidate = response.candidates?.[0];
-				const grounding = candidate?.groundingMetadata;
-
-				// Parse sources from grounding chunks
-				const sources: SearchSource[] = [];
-				const seenTitles = new Set<string>();
-				if (grounding?.groundingChunks) {
-					for (const chunk of grounding.groundingChunks) {
-						if (chunk.web) {
-							const title = chunk.web.title ?? "Untitled";
-							// Dedupe by title since URIs are redirect URLs that differ per call
-							if (seenTitles.has(title)) continue;
-							seenTitles.add(title);
-							// domain field is not available via Gemini API, use title as fallback
-							// (title is typically the domain name, e.g. "wikipedia.org")
-							const domain = chunk.web.domain ?? title;
-							sources.push({
-								title,
-								uri: chunk.web.uri ?? "",
-								domain,
-							});
+				if (process.env.GEMINI_API_KEY) {
+					const ai = await getClient();
+					const response = await ai.models.generateContent({
+						model: process.env.GEMINI_SEARCH_MODEL || "gemini-2.5-flash",
+						contents: params.query,
+						config: {
+							tools: [{ googleSearch: {} }],
+							abortSignal: signal,
+						},
+					});
+
+					// Extract answer text
+					const answer = response.text ?? "";
+
+					// Extract grounding metadata
+					const candidate = response.candidates?.[0];
+					const grounding = candidate?.groundingMetadata;
+
+					// Parse sources from grounding chunks
+					const sources: SearchSource[] = [];
+					const seenTitles = new Set<string>();
+					if (grounding?.groundingChunks) {
+						for (const chunk of grounding.groundingChunks) {
+							if (chunk.web) {
+								const title = chunk.web.title ?? "Untitled";
+								// Dedupe by title since URIs are redirect URLs that differ per call
+								if (seenTitles.has(title)) continue;
+								seenTitles.add(title);
+								// domain field is not available via Gemini API, use title as fallback
+								// (title is typically the domain name, e.g. "wikipedia.org")
+								const domain = chunk.web.domain ?? title;
+								sources.push({
+									title,
+									uri: chunk.web.uri ?? "",
+									domain,
+								});
+							}
 						}
 					}
-				}
 
-				// Extract search queries Gemini actually performed
-				const searchQueries = grounding?.webSearchQueries ?? [];
-
-				result = { answer, sources, searchQueries, cached: false };
+					// Extract search queries Gemini actually performed
+					const searchQueries = grounding?.webSearchQueries ?? [];
+					result = { answer, sources, searchQueries, cached: false };
+				} else {
+					result = await searchWithOAuth(params.query, oauthToken!, projectId!, signal);
+				}
 			} catch (err: unknown) {
 				const msg = err instanceof Error ? err.message : String(err);
 
@@ -287,9 +401,12 @@ export default function (pi: ExtensionAPI) {
 	// ── Startup notification ─────────────────────────────────────────────────
 
 	pi.on("session_start", async (_event, ctx) => {
-		if (!process.env.GEMINI_API_KEY) {
+		if (process.env.GEMINI_API_KEY) return;
+
+		const hasOAuth = await ctx.modelRegistry.authStorage.hasAuth("google-gemini-cli");
+		if (!hasOAuth) {
 			ctx.ui.notify(
-				"Google Search: No GEMINI_API_KEY set. The google_search tool will not work until this is configured.",
+				"Google Search: No authentication set. Log in via Google or set GEMINI_API_KEY to use google_search.",
 				"warning",
 			);
 		}

package/src/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);
@@ -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"));
@@ -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);
@@ -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");
@@ -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");
@@ -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");
@@ -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);
@@ -818,7 +897,7 @@ 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")}`;
@@ -850,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");

package/src/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);