gsd-pi 2.58.0-dev.d63175c → 2.58.0-dev.e002a57

package/dist/resources/extensions/gsd/health-widget.js

@@ -10,6 +10,7 @@
 import { runProviderChecks, summariseProviderIssues } from "./doctor-providers.js";
 import { runEnvironmentChecks } from "./doctor-environment.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
+import { nativeIsRepo, nativeLastCommitEpoch, nativeGetCurrentBranch, nativeCommitSubject } from "./native-git-bridge.js";
 import { loadLedgerFromDisk, getProjectTotals } from "./metrics.js";
 import { projectRoot } from "./commands/context.js";
 import { buildHealthLines, detectHealthWidgetProjectState, } from "./health-widget-core.js";
@@ -20,6 +21,8 @@ function loadHealthWidgetData(basePath) {
     let providerIssue = null;
     let environmentErrorCount = 0;
     let environmentWarningCount = 0;
+    let lastCommitEpoch = null;
+    let lastCommitMessage = null;
     const projectState = detectHealthWidgetProjectState(basePath);
     try {
         const prefs = loadEffectiveGSDPreferences();
@@ -46,6 +49,18 @@ function loadHealthWidgetData(basePath) {
         }
     }
     catch { /* non-fatal */ }
+    // ── Last commit info ──
+    try {
+        if (nativeIsRepo(basePath)) {
+            const branch = nativeGetCurrentBranch(basePath);
+            const epoch = nativeLastCommitEpoch(basePath, branch || "HEAD");
+            if (epoch > 0) {
+                lastCommitEpoch = epoch;
+                lastCommitMessage = nativeCommitSubject(basePath, branch || "HEAD") || null;
+            }
+        }
+    }
+    catch { /* non-fatal */ }
     return {
         projectState,
         budgetCeiling,
@@ -53,6 +68,8 @@ function loadHealthWidgetData(basePath) {
         providerIssue,
         environmentErrorCount,
         environmentWarningCount,
+        lastCommitEpoch,
+        lastCommitMessage,
         lastRefreshed: Date.now(),
     };
 }

package/dist/resources/extensions/gsd/index.js

@@ -1,4 +1,4 @@
-export { isDepthVerified, isQueuePhaseActive, setQueuePhaseActive, shouldBlockContextWrite, } from "./bootstrap/write-gate.js";
+export { isDepthVerified, isQueuePhaseActive, setQueuePhaseActive, shouldBlockContextWrite, shouldBlockQueueExecution, } from "./bootstrap/write-gate.js";
 export default async function registerExtension(pi) {
     const { registerGsdExtension } = await import("./bootstrap/register-extension.js");
     registerGsdExtension(pi);

package/dist/resources/extensions/gsd/memory-extractor.js

@@ -57,14 +57,21 @@ export function buildMemoryLLMCall(ctx) {
         if (!model)
             return null;
         const selectedModel = model;
+        // Resolve API key via modelRegistry so OAuth tokens (auth.json) are used.
+        // Without this, streamSimpleAnthropic only checks env vars via getEnvApiKey,
+        // which returns undefined for OAuth users (Claude Max / Claude Pro).
+        // See: https://github.com/gsd-build/gsd-2/issues/2959
+        const resolvedKeyPromise = ctx.modelRegistry.getApiKey(selectedModel).catch(() => undefined);
         return async (system, user) => {
             const { completeSimple } = await import('@gsd/pi-ai');
+            const resolvedApiKey = await resolvedKeyPromise;
             const result = await completeSimple(selectedModel, {
                 systemPrompt: system,
                 messages: [{ role: 'user', content: [{ type: 'text', text: user }], timestamp: Date.now() }],
             }, {
                 maxTokens: 2048,
                 temperature: 0,
+                ...(resolvedApiKey ? { apiKey: resolvedApiKey } : {}),
             });
             // Extract text from response
             const textParts = result.content

package/dist/resources/extensions/gsd/migrate-external.js

@@ -8,7 +8,7 @@
 import { execFileSync } from "node:child_process";
 import { existsSync, lstatSync, mkdirSync, readdirSync, realpathSync, renameSync, cpSync, rmSync, symlinkSync } from "node:fs";
 import { join } from "node:path";
-import { externalGsdRoot } from "./repo-identity.js";
+import { externalGsdRoot, isInsideWorktree } from "./repo-identity.js";
 import { getErrorMessage } from "./error-utils.js";
 import { hasGitTrackedGsdFiles } from "./gitignore.js";
 import { GIT_NO_PROMPT_ENV } from "./git-constants.js";
@@ -27,6 +27,13 @@ import { GIT_NO_PROMPT_ENV } from "./git-constants.js";
  * 3. On failure: rename `.gsd.migrating` back to `.gsd` (rollback)
  */
 export function migrateToExternalState(basePath) {
+    // Worktrees get their .gsd via syncGsdStateToWorktree(), not migration.
+    // Migration inside a worktree would compute the same external hash as the
+    // main repo (externalGsdRoot hashes remoteUrl + gitRoot), creating a broken
+    // junction and orphaning .gsd.migrating (#2970).
+    if (isInsideWorktree(basePath)) {
+        return { migrated: false };
+    }
     const localGsd = join(basePath, ".gsd");
     // Skip if doesn't exist
     if (!existsSync(localGsd)) {

package/dist/resources/extensions/gsd/milestone-validation-gates.js

@@ -0,0 +1,45 @@
+/**
+ * Milestone validation quality gate persistence.
+ *
+ * #2945 Bug 4: validate-milestone was writing VALIDATION.md to disk and
+ * inserting an assessment row, but never persisted structured quality_gates
+ * records in the DB. This module inserts milestone-level validation gates
+ * that correspond to the validation checks performed.
+ *
+ * Gate IDs for milestone validation:
+ *   MV01 — Success criteria checklist
+ *   MV02 — Slice delivery audit
+ *   MV03 — Cross-slice integration
+ *   MV04 — Requirement coverage
+ *
+ * These use the existing quality_gates table with scope "milestone".
+ */
+import { _getAdapter } from "./gsd-db.js";
+/** Milestone validation gate IDs. */
+const MILESTONE_GATE_IDS = ["MV01", "MV02", "MV03", "MV04"];
+/**
+ * Insert milestone-level quality_gates records for a validation run.
+ *
+ * Each gate is inserted with status "complete" and a verdict derived
+ * from the overall milestone validation verdict. Individual gate-level
+ * verdicts are not available (the handler receives a single verdict),
+ * so all gates share the overall verdict.
+ */
+export function insertMilestoneValidationGates(milestoneId, sliceId, verdict, evaluatedAt) {
+    const db = _getAdapter();
+    if (!db)
+        return;
+    const gateVerdict = verdict === "pass" ? "pass" : "flag";
+    for (const gateId of MILESTONE_GATE_IDS) {
+        db.prepare(`INSERT OR REPLACE INTO quality_gates
+       (milestone_id, slice_id, gate_id, scope, task_id, status, verdict, rationale, findings, evaluated_at)
+       VALUES (:mid, :sid, :gid, 'milestone', '', 'complete', :verdict, :rationale, '', :evaluated_at)`).run({
+            ":mid": milestoneId,
+            ":sid": sliceId,
+            ":gid": gateId,
+            ":verdict": gateVerdict,
+            ":rationale": `Milestone validation verdict: ${verdict}`,
+            ":evaluated_at": evaluatedAt,
+        });
+    }
+}

package/dist/resources/extensions/gsd/model-cost-table.js

@@ -20,9 +20,27 @@ export const BUNDLED_COST_TABLE = [
     // OpenAI
     { id: "gpt-4o", inputPer1k: 0.0025, outputPer1k: 0.01, updatedAt: "2025-03-15" },
     { id: "gpt-4o-mini", inputPer1k: 0.00015, outputPer1k: 0.0006, updatedAt: "2025-03-15" },
+    { id: "gpt-4.1", inputPer1k: 0.002, outputPer1k: 0.008, updatedAt: "2026-03-29" },
+    { id: "gpt-4.1-mini", inputPer1k: 0.0004, outputPer1k: 0.0016, updatedAt: "2026-03-29" },
+    { id: "gpt-4.1-nano", inputPer1k: 0.0001, outputPer1k: 0.0004, updatedAt: "2026-03-29" },
+    { id: "gpt-5", inputPer1k: 0.01, outputPer1k: 0.04, updatedAt: "2026-03-29" },
+    { id: "gpt-5-mini", inputPer1k: 0.0003, outputPer1k: 0.0012, updatedAt: "2026-03-29" },
+    { id: "gpt-5-nano", inputPer1k: 0.0001, outputPer1k: 0.0004, updatedAt: "2026-03-29" },
+    { id: "gpt-5-pro", inputPer1k: 0.015, outputPer1k: 0.06, updatedAt: "2026-03-29" },
     { id: "o1", inputPer1k: 0.015, outputPer1k: 0.06, updatedAt: "2025-03-15" },
     { id: "o3", inputPer1k: 0.015, outputPer1k: 0.06, updatedAt: "2025-03-15" },
+    { id: "o4-mini", inputPer1k: 0.005, outputPer1k: 0.02, updatedAt: "2026-03-29" },
+    { id: "o4-mini-deep-research", inputPer1k: 0.005, outputPer1k: 0.02, updatedAt: "2026-03-29" },
     { id: "gpt-4-turbo", inputPer1k: 0.01, outputPer1k: 0.03, updatedAt: "2025-03-15" },
+    // OpenAI Codex
+    { id: "gpt-5.1", inputPer1k: 0.005, outputPer1k: 0.02, updatedAt: "2026-03-29" },
+    { id: "gpt-5.1-codex-max", inputPer1k: 0.003, outputPer1k: 0.012, updatedAt: "2026-03-29" },
+    { id: "gpt-5.1-codex-mini", inputPer1k: 0.0003, outputPer1k: 0.0012, updatedAt: "2026-03-29" },
+    { id: "gpt-5.2", inputPer1k: 0.005, outputPer1k: 0.02, updatedAt: "2026-03-29" },
+    { id: "gpt-5.2-codex", inputPer1k: 0.005, outputPer1k: 0.02, updatedAt: "2026-03-29" },
+    { id: "gpt-5.3-codex", inputPer1k: 0.005, outputPer1k: 0.02, updatedAt: "2026-03-29" },
+    { id: "gpt-5.3-codex-spark", inputPer1k: 0.0003, outputPer1k: 0.0012, updatedAt: "2026-03-29" },
+    { id: "gpt-5.4", inputPer1k: 0.005, outputPer1k: 0.02, updatedAt: "2026-03-29" },
     // Google
     { id: "gemini-2.0-flash", inputPer1k: 0.0001, outputPer1k: 0.0004, updatedAt: "2025-03-15" },
     { id: "gemini-flash-2.0", inputPer1k: 0.0001, outputPer1k: 0.0004, updatedAt: "2025-03-15" },

package/dist/resources/extensions/gsd/model-router.js

@@ -11,6 +11,12 @@ const MODEL_CAPABILITY_TIER = {
     "claude-3-5-haiku-latest": "light",
     "claude-3-haiku-20240307": "light",
     "gpt-4o-mini": "light",
+    "gpt-4.1-mini": "light",
+    "gpt-4.1-nano": "light",
+    "gpt-5-mini": "light",
+    "gpt-5-nano": "light",
+    "gpt-5.1-codex-mini": "light",
+    "gpt-5.3-codex-spark": "light",
     "gemini-2.0-flash": "light",
     "gemini-flash-2.0": "light",
     // Standard-tier models
@@ -18,14 +24,25 @@ const MODEL_CAPABILITY_TIER = {
     "claude-sonnet-4-5-20250514": "standard",
     "claude-3-5-sonnet-latest": "standard",
     "gpt-4o": "standard",
+    "gpt-4.1": "standard",
+    "gpt-5.1-codex-max": "standard",
     "gemini-2.5-pro": "standard",
     "deepseek-chat": "standard",
     // Heavy-tier models (most capable)
     "claude-opus-4-6": "heavy",
     "claude-3-opus-latest": "heavy",
     "gpt-4-turbo": "heavy",
+    "gpt-5": "heavy",
+    "gpt-5-pro": "heavy",
+    "gpt-5.1": "heavy",
+    "gpt-5.2": "heavy",
+    "gpt-5.2-codex": "heavy",
+    "gpt-5.3-codex": "heavy",
+    "gpt-5.4": "heavy",
     "o1": "heavy",
     "o3": "heavy",
+    "o4-mini": "heavy",
+    "o4-mini-deep-research": "heavy",
 };
 // ─── Cost Table (per 1K input tokens, approximate USD) ───────────────────────
 // Used for cross-provider cost comparison when multiple providers offer
@@ -38,6 +55,23 @@ const MODEL_COST_PER_1K_INPUT = {
     "claude-opus-4-6": 0.015,
     "gpt-4o-mini": 0.00015,
     "gpt-4o": 0.0025,
+    "gpt-4.1": 0.002,
+    "gpt-4.1-mini": 0.0004,
+    "gpt-4.1-nano": 0.0001,
+    "gpt-5": 0.01,
+    "gpt-5-mini": 0.0003,
+    "gpt-5-nano": 0.0001,
+    "gpt-5-pro": 0.015,
+    "gpt-5.1": 0.005,
+    "gpt-5.1-codex-max": 0.003,
+    "gpt-5.1-codex-mini": 0.0003,
+    "gpt-5.2": 0.005,
+    "gpt-5.2-codex": 0.005,
+    "gpt-5.3-codex": 0.005,
+    "gpt-5.3-codex-spark": 0.0003,
+    "gpt-5.4": 0.005,
+    "o4-mini": 0.005,
+    "o4-mini-deep-research": 0.005,
     "gemini-2.0-flash": 0.0001,
     "gemini-2.5-pro": 0.00125,
     "deepseek-chat": 0.00014,
@@ -133,7 +167,7 @@ export function escalateTier(currentTier) {
  */
 export function defaultRoutingConfig() {
     return {
-        enabled: false,
+        enabled: true,
         escalate_on_failure: true,
         budget_pressure: true,
         cross_provider: true,

package/dist/resources/extensions/gsd/native-git-bridge.js

@@ -525,6 +525,15 @@ export function nativeAddAll(basePath) {
     }
     gitFileExec(basePath, ["add", "-A"]);
 }
+/**
+ * Stage only already-tracked files (git add -u).
+ * Does NOT add new untracked files — only updates modifications and deletions
+ * for files git already knows about. Safe for automated snapshots where
+ * pulling in unknown untracked files (secrets, binaries) would be dangerous.
+ */
+export function nativeAddTracked(basePath) {
+    gitFileExec(basePath, ["add", "-u"]);
+}
 /**
  * Stage all files with pathspec exclusions (git add -A -- ':!pattern' ...).
  * Excluded paths are never hashed by git, preventing hangs on large
@@ -758,6 +767,36 @@ export function nativeResetHard(basePath) {
     }
     execSync("git reset --hard HEAD", { cwd: basePath, stdio: "pipe" });
 }
+/**
+ * Soft reset to a target ref (git reset --soft <ref>).
+ * Moves HEAD to `target` while keeping all changes staged in the index.
+ * Used to squash snapshot commits back into a single real commit.
+ */
+export function nativeResetSoft(basePath, target) {
+    execFileSync("git", ["reset", "--soft", target], {
+        cwd: basePath,
+        stdio: ["ignore", "pipe", "pipe"],
+        encoding: "utf-8",
+        env: GIT_NO_PROMPT_ENV,
+    });
+}
+/**
+ * Get the subject line of a commit (git log -1 --format=%s <ref>).
+ * Returns empty string if the ref doesn't exist.
+ */
+export function nativeCommitSubject(basePath, ref) {
+    try {
+        return execFileSync("git", ["log", "-1", "--format=%s", ref], {
+            cwd: basePath,
+            stdio: ["ignore", "pipe", "pipe"],
+            encoding: "utf-8",
+            env: GIT_NO_PROMPT_ENV,
+        }).trim();
+    }
+    catch {
+        return "";
+    }
+}
 /**
  * Delete a branch.
  * Native: libgit2 branch delete.

package/dist/resources/extensions/gsd/notifications.js

@@ -7,7 +7,12 @@ import { CmuxClient, emitOsc777Notification, resolveCmuxConfig } from "../cmux/i
  * Send a native desktop notification. Non-blocking, non-fatal.
  * macOS: osascript, Linux: notify-send, Windows: skipped.
  */
-export function sendDesktopNotification(title, message, level = "info", kind = "complete") {
+export function sendDesktopNotification(title, message, level = "info", kind = "complete", projectName) {
+    // When a projectName is provided and the title is the default "GSD",
+    // replace it with a project-qualified title for multi-project clarity.
+    if (projectName && title === "GSD") {
+        title = formatNotificationTitle(projectName);
+    }
     const loaded = loadEffectiveGSDPreferences()?.preferences;
     if (!shouldSendDesktopNotification(kind, loaded?.notifications))
         return;
@@ -45,6 +50,16 @@ export function shouldSendDesktopNotification(kind, preferences = loadEffectiveG
             return preferences?.on_complete ?? true;
     }
 }
+/**
+ * Format a notification title that includes the project name for context.
+ * Returns "GSD — projectName" when a project name is available, otherwise "GSD".
+ */
+export function formatNotificationTitle(projectName) {
+    const trimmed = projectName?.trim();
+    if (trimmed)
+        return `GSD — ${trimmed}`;
+    return "GSD";
+}
 export function buildDesktopNotificationCommand(platform, title, message, level = "info") {
     const normalizedTitle = normalizeNotificationText(title);
     const normalizedMessage = normalizeNotificationText(message);

package/dist/resources/extensions/gsd/parallel-eligibility.js

@@ -74,7 +74,18 @@ export async function analyzeParallelEligibility(basePath) {
     for (const mid of milestoneIds) {
         const entry = registryMap.get(mid);
         const title = entry?.title ?? mid;
-        const status = entry?.status ?? "pending";
+        // Rule 0: milestones with no registry entry (ghost directories, unknown
+        // state) are ineligible — we cannot determine their status or deps (#2501)
+        if (!entry) {
+            ineligible.push({
+                milestoneId: mid,
+                title,
+                eligible: false,
+                reason: "Milestone has no planning data — cannot determine eligibility.",
+            });
+            continue;
+        }
+        const status = entry.status;
         // Rule 1: skip complete and parked milestones
         if (status === "complete" || status === "parked") {
             ineligible.push({
@@ -86,7 +97,7 @@ export async function analyzeParallelEligibility(basePath) {
             continue;
         }
         // Rule 2: check dependency satisfaction
-        const deps = entry?.dependsOn ?? [];
+        const deps = entry.dependsOn ?? [];
         const unsatisfied = deps.filter(dep => {
             const depEntry = registryMap.get(dep);
             return !depEntry || depEntry.status !== "complete";

package/dist/resources/extensions/gsd/parallel-merge.js

@@ -4,6 +4,9 @@
  * Handles merging completed milestone worktrees back to main branch
  * with safety checks for parallel execution context.
  */
+import { existsSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { spawnSync } from "node:child_process";
 import { loadFile } from "./files.js";
 import { resolveMilestoneFile } from "./paths.js";
 import { mergeMilestoneToMain } from "./auto-worktree.js";
@@ -11,19 +14,89 @@ import { MergeConflictError } from "./git-service.js";
 import { removeSessionStatus } from "./session-status-io.js";
 import { getErrorMessage } from "./error-utils.js";
 // ─── Merge Queue ───────────────────────────────────────────────────────────
+/**
+ * Check whether a milestone is complete by querying its worktree SQLite DB.
+ * Uses a subprocess to avoid disrupting the global DB singleton.
+ * Returns true when milestones.status = 'complete' in the worktree's gsd.db.
+ */
+export function isMilestoneCompleteInWorktreeDb(basePath, mid) {
+    const dbPath = join(basePath, ".gsd", "worktrees", mid, ".gsd", "gsd.db");
+    if (!existsSync(dbPath))
+        return false;
+    try {
+        const result = spawnSync("sqlite3", [dbPath, `SELECT status FROM milestones WHERE id='${mid}' LIMIT 1`], { timeout: 3000, encoding: "utf-8" });
+        return (result.stdout || "").trim() === "complete";
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Discover milestone IDs with status='complete' in their worktree DB,
+ * scanning .gsd/worktrees/<MID>/.gsd/gsd.db for each worktree directory.
+ */
+function discoverDbCompletedMilestones(basePath) {
+    const completed = new Set();
+    const worktreeDir = join(basePath, ".gsd", "worktrees");
+    try {
+        for (const entry of readdirSync(worktreeDir)) {
+            if (entry.startsWith("M") && isMilestoneCompleteInWorktreeDb(basePath, entry)) {
+                completed.add(entry);
+            }
+        }
+    }
+    catch {
+        // worktrees dir may not exist
+    }
+    return completed;
+}
 /**
  * Determine safe merge order for completed milestones.
  * Sequential: merge in milestone ID order (M001 before M002).
  * By-completion: merge in the order milestones finished.
+ *
+ * When basePath is provided, also checks worktree SQLite DBs as the
+ * source of truth — workers with stale orchestrator state (e.g. "error")
+ * are included if their worktree DB shows status='complete'.
+ * See: https://github.com/gsd-build/gsd-2/issues/2812
  */
-export function determineMergeOrder(workers, order = "sequential") {
-    const completed = workers.filter(w => w.state === "stopped");
+export function determineMergeOrder(workers, order = "sequential", basePath) {
+    // Start with workers the orchestrator already knows are stopped
+    const stoppedIds = new Set(workers.filter(w => w.state === "stopped").map(w => w.milestoneId));
+    // When basePath is available, also check worktree DBs for milestones
+    // whose orchestrator state is stale but are actually complete (#2812)
+    const dbCompleted = basePath ? discoverDbCompletedMilestones(basePath) : new Set();
+    // Union: milestone is mergeable if stopped OR DB-complete
+    const mergeableIds = new Set([...stoppedIds, ...dbCompleted]);
+    // Build the list from tracked workers + any DB-discovered milestones
+    // not tracked by the orchestrator at all
+    const workerMap = new Map(workers.map(w => [w.milestoneId, w]));
+    const allMergeable = [];
+    for (const mid of mergeableIds) {
+        const w = workerMap.get(mid);
+        if (w) {
+            allMergeable.push(w);
+        }
+        else {
+            // Milestone discovered from worktree DB but not in workers list
+            allMergeable.push({
+                milestoneId: mid,
+                title: mid,
+                pid: 0,
+                process: null,
+                worktreePath: basePath ? join(basePath, ".gsd", "worktrees", mid) : "",
+                startedAt: 0,
+                state: "stopped",
+                cost: 0,
+            });
+        }
+    }
     if (order === "by-completion") {
-        return completed
+        return allMergeable
             .sort((a, b) => a.startedAt - b.startedAt) // earliest first
             .map(w => w.milestoneId);
     }
-    return completed
+    return allMergeable
         .sort((a, b) => a.milestoneId.localeCompare(b.milestoneId))
         .map(w => w.milestoneId);
 }
@@ -82,7 +155,7 @@ export async function mergeCompletedMilestone(basePath, milestoneId) {
  * Stops on first conflict and returns results so far.
  */
 export async function mergeAllCompleted(basePath, workers, order = "sequential") {
-    const mergeOrder = determineMergeOrder(workers, order);
+    const mergeOrder = determineMergeOrder(workers, order, basePath);
     const results = [];
     for (const mid of mergeOrder) {
         const result = await mergeCompletedMilestone(basePath, mid);

package/dist/resources/extensions/gsd/parsers-legacy.js

@@ -165,16 +165,26 @@ function _parsePlanImpl(content) {
     const demo = extractBoldField(body, 'Demo') || '';
     const mhSection = extractSection(body, 'Must-Haves');
     const mustHaves = mhSection ? parseBullets(mhSection) : [];
+    // Parse tasks from ## Tasks section first, then scan the full body for any
+    // task checkboxes that were missed. Multi-task plans can interleave T01 detail
+    // headings (## Steps, ## Must-Haves) before T02's checkbox, which causes
+    // extractSection("Tasks") to stop at the first ## heading and miss T02+ (#3105).
     const tasksSection = extractSection(body, 'Tasks');
     const tasks = [];
-    if (tasksSection) {
-        const taskLines = tasksSection.split('\n');
+    // Parse task entries from a set of lines, appending to `tasks`.
+    const parseTaskLines = (lines, knownIds) => {
         let currentTask = null;
-        for (const line of taskLines) {
+        for (const line of lines) {
             const cbMatch = line.match(/^-\s+\[([ xX])\]\s+\*\*([\w.]+):\s+(.+?)\*\*\s*(.*)/);
             // Heading-style: ### T01 -- Title, ### T01: Title, ### T01 — Title
             const hdMatch = !cbMatch ? line.match(/^#{2,4}\s+([\w.]+)\s*(?:--|—|:)\s*(.+)/) : null;
             if (cbMatch || hdMatch) {
+                const taskId = cbMatch ? cbMatch[2] : hdMatch[1];
+                // Skip tasks already found in the Tasks section
+                if (knownIds.has(taskId)) {
+                    currentTask = null;
+                    continue;
+                }
                 if (currentTask)
                     tasks.push(currentTask);
                 if (cbMatch) {
@@ -229,7 +239,14 @@ function _parsePlanImpl(content) {
         }
         if (currentTask)
             tasks.push(currentTask);
+    };
+    if (tasksSection) {
+        parseTaskLines(tasksSection.split('\n'), new Set());
     }
+    // Second pass: scan the full body for task checkboxes outside ## Tasks.
+    // This handles interleaved plans where T02+ appear after T01's detail headings.
+    const foundIds = new Set(tasks.map(t => t.id));
+    parseTaskLines(body.split('\n'), foundIds);
     const filesSection = extractSection(body, 'Files Likely Touched');
     const filesLikelyTouched = filesSection ? parseBullets(filesSection) : [];
     const result = { id, title, goal, demo, mustHaves, tasks, filesLikelyTouched };

package/dist/resources/extensions/gsd/paths.js

@@ -254,6 +254,7 @@ export const GSD_ROOT_FILES = {
     REQUIREMENTS: "REQUIREMENTS.md",
     OVERRIDES: "OVERRIDES.md",
     KNOWLEDGE: "KNOWLEDGE.md",
+    CODEBASE: "CODEBASE.md",
 };
 const LEGACY_GSD_ROOT_FILES = {
     PROJECT: "project.md",
@@ -263,6 +264,7 @@ const LEGACY_GSD_ROOT_FILES = {
     REQUIREMENTS: "requirements.md",
     OVERRIDES: "overrides.md",
     KNOWLEDGE: "knowledge.md",
+    CODEBASE: "codebase.md",
 };
 // ─── GSD Root Discovery ───────────────────────────────────────────────────────
 const gsdRootCache = new Map();
@@ -289,11 +291,51 @@ export function gsdRoot(basePath) {
     gsdRootCache.set(basePath, result);
     return result;
 }
+/**
+ * Detect if a path is inside a .gsd/worktrees/<name>/ structure.
+ *
+ * GSD auto-worktrees live at <project>/.gsd/worktrees/<milestoneId>/.
+ * When gsdRoot() is called with such a path, we must NOT walk up to the
+ * project root's .gsd — each worktree manages its own .gsd state (#2594).
+ *
+ * Matches both forward-slash and platform-native separators to handle
+ * Windows paths (path.sep = '\\') and normalized Unix paths.
+ */
+function isInsideGsdWorktree(p) {
+    // Match /.gsd/worktrees/<name> where <name> is the final segment or
+    // followed by a separator. The <name> segment must be non-empty.
+    const sepFwd = "/";
+    const sepNative = "\\";
+    const markers = [
+        `${sepFwd}.gsd${sepFwd}worktrees${sepFwd}`,
+        `${sepNative}.gsd${sepNative}worktrees${sepNative}`,
+    ];
+    for (const marker of markers) {
+        const idx = p.indexOf(marker);
+        if (idx === -1)
+            continue;
+        // Verify there's a non-empty worktree name after the marker
+        const afterMarker = p.slice(idx + marker.length);
+        // The name is everything up to the next separator (or end of string)
+        const nameEnd = afterMarker.search(/[/\\]/);
+        const name = nameEnd === -1 ? afterMarker : afterMarker.slice(0, nameEnd);
+        if (name.length > 0)
+            return true;
+    }
+    return false;
+}
 function probeGsdRoot(rawBasePath) {
     // 1. Fast path — check the input path directly
     const local = join(rawBasePath, ".gsd");
     if (existsSync(local))
         return local;
+    // 1b. Worktree guard (#2594) — if basePath is inside a .gsd/worktrees/<name>/
+    //     structure, return the worktree-local .gsd path immediately. Without this,
+    //     the git-root probe (step 2) or walk-up (step 3) escapes to the project
+    //     root's .gsd, causing ensurePreconditions() and deriveState() to read/write
+    //     state in the wrong location.
+    if (isInsideGsdWorktree(rawBasePath))
+        return local;
     // Resolve symlinks so path comparisons work correctly across platforms
     // (e.g. macOS /var → /private/var). Use rawBasePath as fallback if not resolvable.
     let basePath;
@@ -303,6 +345,9 @@ function probeGsdRoot(rawBasePath) {
     catch {
         basePath = rawBasePath;
     }
+    // Also check the resolved path for the worktree pattern (macOS /tmp → /private/tmp)
+    if (basePath !== rawBasePath && isInsideGsdWorktree(basePath))
+        return local;
     // 2. Git root anchor — used as both probe target and walk-up boundary
     //    Only walk if we're inside a git project — prevents escaping into
     //    unrelated filesystem territory when running outside any repo.

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

@@ -53,6 +53,7 @@ export function resolveModelWithFallbacksForUnit(unitType) {
             break;
         case "complete-slice":
         case "complete-milestone":
+        case "worktree-merge":
         case "run-uat":
             phaseConfig = m.completion;
             break;
@@ -110,6 +111,18 @@ export function getNextFallbackModel(currentModelId, modelConfig) {
         return modelsToTry[0];
     }
 }
+/**
+ * Detect whether an error message indicates a transient network error
+ * (worth retrying the same model) vs a permanent provider error
+ * (auth failure, quota exceeded, etc. -- should fall back immediately).
+ */
+export function isTransientNetworkError(errorMsg) {
+    if (!errorMsg)
+        return false;
+    const hasNetworkSignal = /network|ECONNRESET|ETIMEDOUT|ECONNREFUSED|socket hang up|fetch failed|connection.*reset|dns/i.test(errorMsg);
+    const hasPermanentSignal = /auth|unauthorized|forbidden|invalid.*key|quota|billing/i.test(errorMsg);
+    return hasNetworkSignal && !hasPermanentSignal;
+}
 /**
  * Validate a model ID string.
  * Returns true if the ID looks like a valid model identifier.
@@ -273,7 +286,7 @@ export function resolveContextSelection() {
     return profile === "budget" ? "smart" : "full";
 }
 /**
- * Resolve the search provider preference from PREFERENCES.md.
+ * Resolve the search provider preference from preferences.md.
  * Returns undefined if not configured (caller falls back to existing behavior).
  */
 export function resolveSearchProviderFromPreferences() {

package/dist/resources/extensions/gsd/preferences-types.js

@@ -70,12 +70,14 @@ export const KNOWN_PREFERENCE_KEYS = new Set([
     "service_tier",
     "forensics_dedup",
     "show_token_cost",
+    "stale_commit_threshold_minutes",
     "experimental",
 ]);
 /** Canonical list of all dispatch unit types. */
 export const KNOWN_UNIT_TYPES = [
     "research-milestone", "plan-milestone", "research-slice", "plan-slice",
     "execute-task", "reactive-execute", "gate-evaluate", "complete-slice", "replan-slice", "reassess-roadmap",
-    "run-uat", "complete-milestone",
+    "run-uat", "complete-milestone", "validate-milestone", "rewrite-docs",
+    "discuss-milestone", "discuss-slice", "worktree-merge",
 ];
 export const SKILL_ACTIONS = new Set(["use", "prefer", "avoid"]);