gsd-pi 2.48.0 → 2.49.0-dev.9e177e9

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

@@ -349,6 +349,35 @@ export function ensureGsdSymlink(projectPath) {
     if (localGsdNormalized === gsdHomePath) {
         return localGsd;
     }
+    // Guard: If projectPath is a plain subdirectory (not a worktree) of a git
+    // repo that already has a .gsd at the git root, do not create a duplicate
+    // symlink in the subdirectory — that causes `.gsd 2` collision variants on
+    // macOS (#2380). Worktrees are excluded because they legitimately need their
+    // own .gsd symlink pointing at the shared external state dir.
+    if (!inWorktree) {
+        try {
+            const gitRoot = resolveGitRoot(projectPath);
+            const normalizedProject = canonicalizeExistingPath(projectPath);
+            const normalizedRoot = canonicalizeExistingPath(gitRoot);
+            if (normalizedProject !== normalizedRoot) {
+                const rootGsd = join(gitRoot, ".gsd");
+                if (existsSync(rootGsd)) {
+                    try {
+                        const rootStat = lstatSync(rootGsd);
+                        if (rootStat.isSymbolicLink() || rootStat.isDirectory()) {
+                            return rootStat.isSymbolicLink() ? realpathSync(rootGsd) : rootGsd;
+                        }
+                    }
+                    catch {
+                        // Fall through to normal logic if we can't stat root .gsd
+                    }
+                }
+            }
+        }
+        catch {
+            // If git root detection fails, fall through to normal logic
+        }
+    }
     // Clean up macOS numbered collision variants (.gsd 2, .gsd 3, etc.) before
     // any existence checks — otherwise they accumulate and confuse state (#2205).
     cleanNumberedGsdVariants(projectPath);

package/dist/resources/extensions/gsd/roadmap-slices.js

@@ -36,8 +36,8 @@ export function expandDependencies(deps) {
     return result;
 }
 function extractSlicesSection(content) {
-    // Match "## Slices", "## Slice Overview", "## Slice Table", etc.
-    const headingMatch = /^## Slice(?:s| Overview| Table| Summary| Status)\b.*$/m.exec(content);
+    // Match "## Slices", "## Slice Overview", "## Slice Table", "## Slice Roadmap", etc.
+    const headingMatch = /^## Slice(?:s| Overview| Table| Summary| Status| Roadmap)\b.*$/m.exec(content);
     if (!headingMatch || headingMatch.index == null)
         return "";
     const start = headingMatch.index + headingMatch[0].length;

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

@@ -24,7 +24,6 @@ import { truncateWithEllipsis } from "../shared/format-utils.js";
 import { nativeParseJsonlTail } from "./native-parser-bridge.js";
 import { MAX_JSONL_BYTES, parseJSONL } from "./jsonl-utils.js";
 import { nativeWorkingTreeStatus, nativeDiffStat } from "./native-git-bridge.js";
-import { getAutoWorktreePath } from "./auto-worktree.js";
 // ─── JSONL Parsing ────────────────────────────────────────────────────────────
 // MAX_JSONL_BYTES and parseJSONL are imported from ./jsonl-utils.js
 /**
@@ -235,17 +234,13 @@ export function synthesizeCrashRecovery(basePath, unitType, unitId, sessionFile,
  * Deep diagnostic from any JSONL source (activity log or session file).
  * Replaces the old shallow getLastActivityDiagnostic().
  */
-export function getDeepDiagnostic(basePath) {
-    // Try worktree activity logs first if an auto-worktree is active
+export function getDeepDiagnostic(basePath, worktreePath) {
+    // Try worktree activity logs first if a worktree path is provided
     let trace = null;
     try {
-        const mid = readActiveMilestoneId(basePath);
-        if (mid) {
-            const wtPath = getAutoWorktreePath(basePath, mid);
-            if (wtPath) {
-                const wtActivityDir = join(gsdRoot(wtPath), "activity");
-                trace = readLastActivityLog(wtActivityDir);
-            }
+        if (worktreePath) {
+            const wtActivityDir = join(gsdRoot(worktreePath), "activity");
+            trace = readLastActivityLog(wtActivityDir);
         }
     }
     catch { /* non-fatal — fall through to root */ }
@@ -262,7 +257,7 @@ export function getDeepDiagnostic(basePath) {
  * Read the active milestone ID directly from STATE.md without async deriveState().
  * Looks for `**Active Milestone:** M001` pattern.
  */
-function readActiveMilestoneId(basePath) {
+export function readActiveMilestoneId(basePath) {
     try {
         const statePath = join(gsdRoot(basePath), "STATE.md");
         if (!existsSync(statePath))

package/dist/resources/extensions/gsd/session-lock.js

@@ -134,6 +134,49 @@ function ensureExitHandler(_gsdDir) {
         }
     });
 }
+// ─── Lock Acquisition Helpers ───────────────────────────────────────────────
+/**
+ * Create the onCompromised callback for proper-lockfile.
+ *
+ * proper-lockfile fires onCompromised when it detects mtime drift (system sleep,
+ * event loop stall, etc.). The default handler throws inside setTimeout — an
+ * uncaught exception that crashes or corrupts process state.
+ *
+ * False-positive suppression (#1362): If we're still within the stale window
+ * (30 min since acquisition), the mtime mismatch is from an event loop stall
+ * during a long LLM call — not a real takeover. Log and continue.
+ *
+ * PID ownership check (#1578): Past the stale window, check if the lock file
+ * still contains our PID before declaring compromise. Retry reads tolerate
+ * transient filesystem hiccups (NFS/CIFS latency, APFS snapshots, etc.) (#2324).
+ */
+function createLockCompromisedHandler(lockFilePath) {
+    return () => {
+        const elapsed = Date.now() - _lockAcquiredAt;
+        if (elapsed < 1_800_000) {
+            process.stderr.write(`[gsd] Lock heartbeat caught up after ${Math.round(elapsed / 1000)}s — long LLM call, no action needed.\n`);
+            return;
+        }
+        const existing = readExistingLockDataWithRetry(lockFilePath);
+        if (existing && existing.pid === process.pid) {
+            process.stderr.write(`[gsd] Lock heartbeat mismatch after ${Math.round(elapsed / 1000)}s — lock file still owned by PID ${process.pid}, treating as false positive.\n`);
+            return;
+        }
+        _lockCompromised = true;
+        _releaseFunction = null;
+    };
+}
+/**
+ * Assign module-level lock state after a successful lock acquisition.
+ */
+function assignLockState(basePath, release, lockFilePath) {
+    _releaseFunction = release;
+    _lockedPath = basePath;
+    _lockPid = process.pid;
+    _lockCompromised = false;
+    _lockAcquiredAt = Date.now();
+    _snapshotLockPath = lockFilePath;
+}
 // ─── Public API ─────────────────────────────────────────────────────────────
 /**
  * Attempt to acquire an exclusive session lock for the given project.
@@ -188,38 +231,9 @@ export function acquireSessionLock(basePath) {
             realpath: false,
             stale: 1_800_000, // 30 minutes — safe for laptop sleep / long event loop stalls
             update: 10_000, // Update lock mtime every 10s to prove liveness
-            onCompromised: () => {
-                // proper-lockfile detected mtime drift (system sleep, event loop stall, etc.).
-                // Default handler throws inside setTimeout — an uncaught exception that crashes
-                // or corrupts process state.
-                //
-                // False-positive suppression (#1362): If we're still within the stale window
-                // (30 min since acquisition), the mtime mismatch is from an event loop stall
-                // during a long LLM call — not a real takeover. Log and continue.
-                const elapsed = Date.now() - _lockAcquiredAt;
-                if (elapsed < 1_800_000) {
-                    process.stderr.write(`[gsd] Lock heartbeat caught up after ${Math.round(elapsed / 1000)}s — long LLM call, no action needed.\n`);
-                    return; // Suppress false positive
-                }
-                // Past the stale window — check if the lock file still belongs to us before
-                // declaring compromise (#1578). If our PID still owns the metadata, this is
-                // a false positive from a very long event loop stall (e.g. subagent execution).
-                const existing = readExistingLockData(lp);
-                if (existing && existing.pid === process.pid) {
-                    process.stderr.write(`[gsd] Lock heartbeat mismatch after ${Math.round(elapsed / 1000)}s — lock file still owned by PID ${process.pid}, treating as false positive.\n`);
-                    return; // Our PID still owns the lock file — no real takeover
-                }
-                // Lock file is gone or owned by another PID — real compromise
-                _lockCompromised = true;
-                _releaseFunction = null;
-            },
+            onCompromised: createLockCompromisedHandler(lp),
         });
-        _releaseFunction = release;
-        _lockedPath = basePath;
-        _lockPid = process.pid;
-        _lockCompromised = false;
-        _lockAcquiredAt = Date.now();
-        _snapshotLockPath = lp; // Snapshot the resolved path for consistent access (#1363)
+        assignLockState(basePath, release, lp);
         // Safety net: clean up lock dir on process exit if _releaseFunction
         // wasn't called (e.g., normal exit after clean completion) (#1245).
         ensureExitHandler(gsdDir);
@@ -245,31 +259,9 @@ export function acquireSessionLock(basePath) {
                     realpath: false,
                     stale: 1_800_000, // 30 minutes — match primary lock settings
                     update: 10_000,
-                    onCompromised: () => {
-                        // Same false-positive suppression as the primary lock (#1512).
-                        // Without this, the retry path fires _lockCompromised unconditionally
-                        // on benign mtime drift (laptop sleep, heavy LLM event loop stalls).
-                        const elapsed = Date.now() - _lockAcquiredAt;
-                        if (elapsed < 1_800_000) {
-                            process.stderr.write(`[gsd] Lock heartbeat caught up after ${Math.round(elapsed / 1000)}s — long LLM call, no action needed.\n`);
-                            return;
-                        }
-                        // Check PID ownership before declaring compromise (#1578)
-                        const existing = readExistingLockData(lp);
-                        if (existing && existing.pid === process.pid) {
-                            process.stderr.write(`[gsd] Lock heartbeat mismatch after ${Math.round(elapsed / 1000)}s — lock file still owned by PID ${process.pid}, treating as false positive.\n`);
-                            return;
-                        }
-                        _lockCompromised = true;
-                        _releaseFunction = null;
-                    },
+                    onCompromised: createLockCompromisedHandler(lp),
                 });
-                _releaseFunction = release;
-                _lockedPath = basePath;
-                _lockPid = process.pid;
-                _lockCompromised = false;
-                _lockAcquiredAt = Date.now();
-                _snapshotLockPath = lp; // Snapshot for retry path too (#1363)
+                assignLockState(basePath, release, lp);
                 // Safety net — uses centralized handler to avoid double-registration
                 ensureExitHandler(gsdDir);
                 atomicWriteSync(lp, JSON.stringify(lockData, null, 2));
@@ -348,7 +340,8 @@ export function getSessionLockStatus(basePath) {
         // onCompromised fired from benign mtime drift (laptop sleep, event loop stall
         // beyond the stale window). Attempt re-acquisition instead of giving up.
         const lp = lockPath(basePath);
-        const existing = readExistingLockData(lp);
+        // Retry reads to tolerate transient filesystem hiccups (#2324).
+        const existing = readExistingLockDataWithRetry(lp);
         if (existing && existing.pid === process.pid) {
             // Lock file still ours — try to re-acquire the OS lock
             try {
@@ -492,6 +485,24 @@ function readExistingLockData(lp) {
         return null;
     }
 }
+export function readExistingLockDataWithRetry(lp, options) {
+    const maxAttempts = options?.maxAttempts ?? 3;
+    const delayMs = options?.delayMs ?? 200;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        const data = readExistingLockData(lp);
+        if (data !== null)
+            return data;
+        if (attempt < maxAttempts) {
+            // Synchronous busy-wait — onCompromised runs in a sync callback context
+            // and the delays are short (200ms default).
+            const start = Date.now();
+            while (Date.now() - start < delayMs) {
+                // busy-wait
+            }
+        }
+    }
+    return null;
+}
 function isPidAlive(pid) {
     if (!Number.isInteger(pid) || pid <= 0)
         return false;

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

@@ -9,7 +9,8 @@ import { nativeBatchParseGsdFiles } from './native-parser-bridge.js';
 import { join, resolve } from 'path';
 import { existsSync, readdirSync } from 'node:fs';
 import { debugCount, debugTime } from './debug-logger.js';
-import { isDbAvailable, getAllMilestones, getMilestoneSlices, getSliceTasks, getReplanHistory, getSlice, insertMilestone, updateTaskStatus, } from './gsd-db.js';
+import { extractVerdict } from './verdict-parser.js';
+import { isDbAvailable, getAllMilestones, getMilestoneSlices, getSliceTasks, getReplanHistory, getSlice, insertMilestone, updateTaskStatus, getPendingSliceGateCount, } from './gsd-db.js';
 /**
  * A "ghost" milestone directory contains only META.json (and no substantive
  * files like CONTEXT, CONTEXT-DRAFT, ROADMAP, or SUMMARY).  These appear when
@@ -42,13 +43,9 @@ export function isMilestoneComplete(roadmap) {
  * after remediation slices are executed.
  */
 export function isValidationTerminal(validationContent) {
-    const match = validationContent.match(/^---\n([\s\S]*?)\n---/);
-    if (!match)
+    const v = extractVerdict(validationContent);
+    if (!v)
         return false;
-    const verdict = match[1].match(/verdict:\s*(\S+)/);
-    if (!verdict)
-        return false;
-    const v = verdict[1] === 'passed' ? 'pass' : verdict[1];
     // 'pass' and 'needs-attention' are always terminal.
     // 'needs-remediation' is treated as terminal to prevent infinite loops
     // when no remediation slices exist in the roadmap (#832). The validation
@@ -595,6 +592,21 @@ export async function deriveStateFromDb(basePath) {
             };
         }
     }
+    // ── Quality gate evaluation check ──────────────────────────────────
+    // If slice-scoped gates (Q3/Q4) are still pending, pause before execution
+    // so the gate-evaluate dispatch rule can run parallel sub-agents.
+    // Slices with zero gate rows (pre-feature or simple) skip straight through.
+    const pendingGateCount = getPendingSliceGateCount(activeMilestone.id, activeSlice.id);
+    if (pendingGateCount > 0) {
+        return {
+            activeMilestone, activeSlice, activeTask: null,
+            phase: 'evaluating-gates',
+            recentDecisions: [], blockers: [],
+            nextAction: `Evaluate ${pendingGateCount} quality gate(s) for ${activeSlice.id} before execution.`,
+            registry, requirements,
+            progress: { milestones: milestoneProgress, slices: sliceProgress, tasks: taskProgress },
+        };
+    }
     // ── Blocker detection: check completed tasks for blocker_discovered ──
     const completedTasks = tasks.filter(t => isStatusDone(t.status));
     let blockerTaskId = null;
@@ -1143,6 +1155,21 @@ export async function _deriveStateImpl(basePath) {
         };
     }
     const slicePlan = parsePlan(slicePlanContent);
+    // ── Reconcile stale task status for filesystem-based projects (#2514) ──
+    // Heading-style tasks (### T01:) are always parsed as done=false by
+    // parsePlan because the heading syntax has no checkbox. When the agent
+    // writes a SUMMARY file but the plan's heading isn't converted to a
+    // checkbox, the task appears incomplete forever — causing infinite
+    // re-dispatch. Reconcile by checking SUMMARY files on disk.
+    for (const t of slicePlan.tasks) {
+        if (t.done)
+            continue;
+        const summaryPath = resolveTaskFile(basePath, activeMilestone.id, activeSlice.id, t.id, "SUMMARY");
+        if (summaryPath && existsSync(summaryPath)) {
+            t.done = true;
+            process.stderr.write(`gsd-reconcile: task ${activeMilestone.id}/${activeSlice.id}/${t.id} has SUMMARY on disk but plan shows incomplete — marking done (#2514)\n`);
+        }
+    }
     const taskProgress = {
         done: slicePlan.tasks.filter(t => t.done).length,
         total: slicePlan.tasks.length,

package/dist/resources/extensions/gsd/templates/milestone-summary.md

@@ -49,6 +49,14 @@ completed_at: {{date}}
 
 - {{requirementId}}: {{fromStatus}} → {{toStatus}} — {{evidence}}
 
+## Decision Re-evaluation
+
+<!-- Review decisions from this milestone. OMIT if no decisions need re-evaluation. -->
+
+| Decision | Original Rationale | Still Valid? | Action |
+|----------|-------------------|-------------|--------|
+| {{decisionId}} | {{originalRationale}} | {{yes/no/partially}} | {{keep/revise/supersede}} |
+
 ## Forward Intelligence
 
 <!-- Write what you wish you'd known at the start of this milestone.

package/dist/resources/extensions/gsd/templates/plan.md

@@ -8,6 +8,22 @@
 - {{mustHave}}
 - {{mustHave}}
 
+## Threat Surface
+
+<!-- Q3: How can this be exploited? OMIT ENTIRELY for simple slices with no auth, user input, or data exposure. -->
+
+- **Abuse**: {{abuseScenarios — parameter tampering, replay, privilege escalation, or N/A}}
+- **Data exposure**: {{sensitiveDataAccessible — PII, tokens, secrets, or none}}
+- **Input trust**: {{untrustedInput — user input reaching DB/API/filesystem, or none}}
+
+## Requirement Impact
+
+<!-- Q4: What existing promises does this break? OMIT ENTIRELY if no existing requirements are affected. -->
+
+- **Requirements touched**: {{requirementIds — e.g. R001, R003, or none}}
+- **Re-verify**: {{whatMustBeRetested — e.g. login flow, API contract, or N/A}}
+- **Decisions revisited**: {{decisionIds — e.g. D002, or none}}
+
 ## Proof Level
 
 <!-- Omit this section entirely for simple slices where the answer is trivially obvious. -->

package/dist/resources/extensions/gsd/templates/roadmap.md

@@ -92,6 +92,19 @@ This milestone is complete only when all are true:
   - Each "After this" line must be truthful about proof level: if only fixtures or tests prove it, say so; do not imply the user can already perform the live end-to-end behavior unless that has actually been exercised
 -->
 
+## Horizontal Checklist
+
+<!-- Cross-cutting concerns across all slices. Check each that was considered.
+     OMIT ENTIRELY for trivial milestones. -->
+
+- [ ] Every active R### re-read against new code — still fully satisfied?
+- [ ] Every D### from prior milestones re-evaluated — still valid at new scope?
+- [ ] Graceful shutdown / cleanup on termination verified
+- [ ] Revenue / billing path impact assessed (or N/A)
+- [ ] Auth boundary documented — what's protected vs public
+- [ ] Shared resource budget confirmed — connection pools, caches, rate limits hold under peak
+- [ ] Reconnection / retry strategy verified for every external dependency
+
 ## Boundary Map
 
 <!-- Be specific. Name concrete outputs: API endpoints, event payloads, shared types/interfaces,

package/dist/resources/extensions/gsd/templates/slice-summary.md

@@ -57,6 +57,15 @@ completed_at: {{date}}
 
 - {{requirementIdOr_none}} — {{what changed}}
 
+## Operational Readiness
+
+<!-- Q8: How will ops know it's healthy/broken? OMIT ENTIRELY for simple slices with no runtime concerns. -->
+
+- **Health signal**: {{howToConfirmHealthy — health endpoint, heartbeat log, metric, or N/A}}
+- **Failure signal**: {{howToDetectBroken — error rate spike, alert, log pattern, or N/A}}
+- **Recovery**: {{selfRecoverOrRestart — auto-reconnect, circuit breaker, manual restart, or N/A}}
+- **Monitoring gaps**: {{silentFailureModes — background jobs, cache eviction, memory pressure, or none}}
+
 ## Deviations
 
 <!-- Deviations are unplanned changes to the written plan, not ordinary debugging inside the plan's intended scope. -->

package/dist/resources/extensions/gsd/templates/task-plan.md

@@ -17,6 +17,30 @@ skills_used:
 
 {{description}}
 
+## Failure Modes
+
+<!-- Q5: What breaks when dependencies fail? OMIT ENTIRELY for tasks with no external dependencies. -->
+
+| Dependency | On error | On timeout | On malformed response |
+|------------|----------|-----------|----------------------|
+| {{dependency}} | {{errorStrategy}} | {{timeoutStrategy}} | {{malformedStrategy}} |
+
+## Load Profile
+
+<!-- Q6: What breaks at 10x load? OMIT ENTIRELY for tasks with no shared resources or scaling concerns. -->
+
+- **Shared resources**: {{sharedResources — DB connections, caches, rate limiters, or none}}
+- **Per-operation cost**: {{perOpCost — N API calls, M DB queries, K bytes, or trivial}}
+- **10x breakpoint**: {{whatBreaksFirst — pool exhaustion, rate limit, memory, or N/A}}
+
+## Negative Tests
+
+<!-- Q7: What negative tests prove robustness? OMIT ENTIRELY for trivial tasks. -->
+
+- **Malformed inputs**: {{malformedInputTests — empty string, null, oversized, wrong type}}
+- **Error paths**: {{errorPathTests — network timeout, auth failure, 5xx, invalid JSON}}
+- **Boundary conditions**: {{boundaryTests — empty list, max length, zero, off-by-one}}
+
 ## Steps
 
 1. {{step}}

package/dist/resources/extensions/gsd/tools/plan-slice.js

@@ -1,5 +1,5 @@
 import { clearParseCache } from "../files.js";
-import { transaction, getMilestone, getSlice, insertTask, upsertSlicePlanning, upsertTaskPlanning, } from "../gsd-db.js";
+import { transaction, getMilestone, getSlice, insertTask, upsertSlicePlanning, upsertTaskPlanning, insertGateRow, } from "../gsd-db.js";
 import { invalidateStateCache } from "../state.js";
 import { renderPlanFromDb } from "../markdown-renderer.js";
 import { renderAllProjections } from "../workflow-projections.js";
@@ -145,6 +145,19 @@ export async function handlePlanSlice(rawParams, basePath) {
                     fullPlanMd: task.fullPlanMd,
                 });
             }
+            // Seed quality gate rows inside the transaction — all-or-nothing with
+            // the plan data so a crash can't leave orphaned gates without tasks.
+            const sliceGates = ["Q3", "Q4"];
+            for (const gid of sliceGates) {
+                insertGateRow({ milestoneId: params.milestoneId, sliceId: params.sliceId, gateId: gid, scope: "slice" });
+            }
+            const taskGates = ["Q5", "Q6", "Q7"];
+            for (const task of params.tasks) {
+                for (const gid of taskGates) {
+                    insertGateRow({ milestoneId: params.milestoneId, sliceId: params.sliceId, gateId: gid, scope: "task", taskId: task.taskId });
+                }
+            }
+            insertGateRow({ milestoneId: params.milestoneId, sliceId: params.sliceId, gateId: "Q8", scope: "slice" });
         });
     }
     catch (err) {

package/dist/resources/extensions/gsd/tools/validate-milestone.js

@@ -9,6 +9,7 @@ import { transaction, _getAdapter, } from "../gsd-db.js";
 import { resolveMilestonePath, clearPathCache } from "../paths.js";
 import { saveFile, clearParseCache } from "../files.js";
 import { invalidateStateCache } from "../state.js";
+import { VALIDATION_VERDICTS, isValidMilestoneVerdict } from "../verdict-parser.js";
 function renderValidationMarkdown(params) {
     let md = `---
 verdict: ${params.verdict}
@@ -41,9 +42,8 @@ export async function handleValidateMilestone(params, basePath) {
     if (!params.milestoneId || typeof params.milestoneId !== "string" || params.milestoneId.trim() === "") {
         return { error: "milestoneId is required and must be a non-empty string" };
     }
-    const validVerdicts = ["pass", "needs-attention", "needs-remediation"];
-    if (!validVerdicts.includes(params.verdict)) {
-        return { error: `verdict must be one of: ${validVerdicts.join(", ")}` };
+    if (!isValidMilestoneVerdict(params.verdict)) {
+        return { error: `verdict must be one of: ${VALIDATION_VERDICTS.join(", ")}` };
     }
     // ── Filesystem render ──────────────────────────────────────────────────
     const validationMd = renderValidationMarkdown(params);

package/dist/resources/extensions/gsd/verdict-parser.js

@@ -0,0 +1,84 @@
+/**
+ * Centralized verdict extraction, normalization, and schema validation.
+ *
+ * All verdict-related logic lives here so that normalization rules
+ * (e.g. `passed` → `pass`) are applied consistently across the codebase.
+ */
+import { extractUatType } from "./files.js";
+// ── Verdict extraction ──────────────────────────────────────────────────
+/**
+ * Extract and normalize the `verdict` value from YAML frontmatter.
+ *
+ * Normalization:
+ * - lowercased
+ * - `passed` → `pass`
+ *
+ * Returns `undefined` when frontmatter is absent or has no `verdict` field.
+ */
+export function extractVerdict(content) {
+    const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!fmMatch)
+        return undefined;
+    const verdictMatch = fmMatch[1].match(/verdict:\s*([\w-]+)/i);
+    if (!verdictMatch)
+        return undefined;
+    let v = verdictMatch[1].toLowerCase();
+    if (v === "passed")
+        v = "pass";
+    return v;
+}
+/**
+ * Returns `true` when the content's frontmatter contains a `verdict` field.
+ */
+export function hasVerdict(content) {
+    return /verdict:\s*[\w-]+/i.test(content);
+}
+// ── UAT verdict schema ──────────────────────────────────────────────────
+/**
+ * Base verdicts that are always acceptable for UAT results.
+ */
+export const UAT_ACCEPTABLE_VERDICTS = ["pass", "passed"];
+/**
+ * UAT types whose results may legitimately produce a `partial` verdict
+ * when all automatable checks pass but human-only checks remain.
+ */
+const PARTIAL_ELIGIBLE_UAT_TYPES = [
+    "mixed",
+    "human-experience",
+    "live-runtime",
+];
+/**
+ * Check whether a verdict is acceptable for a given UAT type.
+ *
+ * `pass` / `passed` are always acceptable. `partial` is acceptable only for
+ * UAT types that include non-automatable human checks.
+ */
+export function isAcceptableUatVerdict(verdict, uatType) {
+    if (UAT_ACCEPTABLE_VERDICTS.includes(verdict))
+        return true;
+    if (verdict === "partial" && uatType && PARTIAL_ELIGIBLE_UAT_TYPES.includes(uatType)) {
+        return true;
+    }
+    return false;
+}
+// ── Milestone validation verdict schema ─────────────────────────────────
+/**
+ * Valid verdicts for the `validate-milestone` tool.
+ */
+export const VALIDATION_VERDICTS = ["pass", "needs-attention", "needs-remediation"];
+/**
+ * Check whether a string is a valid milestone validation verdict.
+ */
+export function isValidMilestoneVerdict(verdict) {
+    return VALIDATION_VERDICTS.includes(verdict);
+}
+// ── UAT type helper ─────────────────────────────────────────────────────
+/**
+ * Extract the UAT type from content, defaulting to `"artifact-driven"`.
+ *
+ * The `"artifact-driven"` fallback is the original default used throughout
+ * the codebase when a UAT file lacks an explicit `## UAT Type` section.
+ */
+export function getUatType(content) {
+    return extractUatType(content) ?? "artifact-driven";
+}

package/dist/resources/extensions/gsd/worktree-command.js

@@ -548,7 +548,7 @@ async function handleMerge(basePath, name, ctx, pi, targetBranch) {
         // --- Deterministic merge path (preferred) ---
         // Try a direct squash-merge first. Only fall back to LLM on conflict.
         const commitType = inferCommitType(name);
-        const commitMessage = `${commitType}(${name}): merge worktree ${name}`;
+        const commitMessage = `${commitType}: merge worktree ${name}\n\nGSD-Worktree: ${name}`;
         // Reconcile worktree DB into main DB before squash merge
         const wtDbPath = join(worktreePath(basePath, name), ".gsd", "gsd.db");
         const mainDbPath = join(basePath, ".gsd", "gsd.db");

package/dist/resources/extensions/gsd/worktree-resolver.js

@@ -72,6 +72,16 @@ export class WorktreeResolver {
      */
     enterMilestone(milestoneId, ctx) {
         this.validateMilestoneId(milestoneId);
+        // If worktree creation failed earlier this session, skip all future attempts
+        if (this.s.isolationDegraded) {
+            debugLog("WorktreeResolver", {
+                action: "enterMilestone",
+                milestoneId,
+                skipped: true,
+                reason: "isolation-degraded",
+            });
+            return;
+        }
         if (!this.deps.shouldUseWorktreeIsolation()) {
             debugLog("WorktreeResolver", {
                 action: "enterMilestone",
@@ -136,6 +146,9 @@ export class WorktreeResolver {
                 data: { milestoneId, error: msg, fallback: "project-root" },
             });
             ctx.notify(`Auto-worktree creation for ${milestoneId} failed: ${msg}. Continuing in project root.`, "warning");
+            // Degrade isolation for the rest of this session so mergeAndExit
+            // doesn't try to merge a nonexistent worktree branch (#2483)
+            this.s.isolationDegraded = true;
             // Do NOT update s.basePath — stay in project root
         }
     }
@@ -210,6 +223,17 @@ export class WorktreeResolver {
      */
     mergeAndExit(milestoneId, ctx) {
         this.validateMilestoneId(milestoneId);
+        // If worktree creation failed earlier, skip merge — work is on current branch (#2483)
+        if (this.s.isolationDegraded) {
+            debugLog("WorktreeResolver", {
+                action: "mergeAndExit",
+                milestoneId,
+                skipped: true,
+                reason: "isolation-degraded",
+            });
+            ctx.notify(`Skipping worktree merge for ${milestoneId} — isolation was degraded (worktree creation failed earlier). Work is on the current branch.`, "info");
+            return;
+        }
         const mode = this.deps.getIsolationMode();
         debugLog("WorktreeResolver", {
             action: "mergeAndExit",

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

@@ -220,8 +220,9 @@ export function getSliceBranchName(milestoneId, sliceId, worktreeName) {
     }
     return `gsd/${milestoneId}/${sliceId}`;
 }
-/** Regex that matches both plain and worktree-namespaced slice branches. */
-export const SLICE_BRANCH_RE = /^gsd\/(?:([a-zA-Z0-9_-]+)\/)?(M\d+(?:-[a-z0-9]{6})?)\/(S\d+)$/;
+/** Re-export for backward compatibility — canonical definition in branch-patterns.ts */
+export { SLICE_BRANCH_RE } from "./branch-patterns.js";
+import { SLICE_BRANCH_RE } from "./branch-patterns.js";
 /**
  * Parse a slice branch name into its components.
  * Handles both `gsd/M001/S01` and `gsd/myworktree/M001/S01`.