gsd-pi 2.64.0 → 2.65.0-dev.16e10d7

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

@@ -187,8 +187,17 @@ export async function handleCompleteSlice(params, basePath) {
     if (ownershipErr) {
         return { error: ownershipErr };
     }
+    // ── Verification content gate (#3580) ──────────────────────────────────
+    // Reject completion when the provided verification/UAT clearly indicates
+    // the slice is blocked or failed. Prevents prompt regressions from
+    // silently advancing blocked slices.
+    const BLOCKED_SIGNALS = /\b(status:\s*blocked|verification_result:\s*failed|slice is blocked|cannot complete|verification failed)\b/i;
+    if (BLOCKED_SIGNALS.test(params.verification || "") || BLOCKED_SIGNALS.test(params.uatContent || "")) {
+        return { error: `slice verification indicates blocked/failed state — do not complete a slice that has not passed verification. Address the blockers and re-verify first.` };
+    }
     // ── Guards + DB writes inside a single transaction (prevents TOCTOU) ───
     const completedAt = new Date().toISOString();
+    const originalSliceStatus = getSlice(params.milestoneId, params.sliceId)?.status ?? "pending";
     let guardError = null;
     transaction(() => {
         // State machine preconditions (inside txn for atomicity).
@@ -217,8 +226,8 @@ export async function handleCompleteSlice(params, basePath) {
             return;
         }
         // All guards passed — perform writes
-        insertMilestone({ id: params.milestoneId });
-        insertSlice({ id: params.sliceId, milestoneId: params.milestoneId });
+        insertMilestone({ id: params.milestoneId, title: params.milestoneId });
+        insertSlice({ id: params.sliceId, milestoneId: params.milestoneId, title: params.sliceId });
         updateSliceStatus(params.milestoneId, params.sliceId, "complete", completedAt);
     });
     if (guardError) {
@@ -256,7 +265,7 @@ export async function handleCompleteSlice(params, basePath) {
     catch (renderErr) {
         // Disk render failed — roll back DB status so state stays consistent
         logWarning("tool", `complete_slice — disk render failed for ${params.milestoneId}/${params.sliceId}, rolling back DB status`, { error: renderErr.message });
-        updateSliceStatus(params.milestoneId, params.sliceId, 'pending');
+        updateSliceStatus(params.milestoneId, params.sliceId, originalSliceStatus);
         invalidateStateCache();
         return { error: `disk render failed: ${renderErr.message}` };
     }

package/dist/resources/extensions/gsd/tools/complete-task.js

@@ -19,6 +19,18 @@ import { renderAllProjections, renderSummaryContent } from "../workflow-projecti
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
 import { logWarning } from "../workflow-logger.js";
+/**
+ * Normalize a list parameter that may arrive as a string (newline-delimited
+ * bullet list from the LLM) into a string array (#3361).
+ */
+function normalizeListParam(value) {
+    if (Array.isArray(value))
+        return value.map(String);
+    if (typeof value === "string" && value.trim()) {
+        return value.split(/\n/).map(s => s.replace(/^[\s\-*•]+/, "").trim()).filter(Boolean);
+    }
+    return [];
+}
 /**
  * Build a TaskRow-shaped object from CompleteTaskParams so the unified
  * renderSummaryContent() can be used at completion time (#2720).
@@ -38,8 +50,8 @@ function paramsToTaskRow(params, completedAt) {
         blocker_discovered: params.blockerDiscovered ?? false,
         deviations: params.deviations ?? "",
         known_issues: params.knownIssues ?? "",
-        key_files: params.keyFiles ?? [],
-        key_decisions: params.keyDecisions ?? [],
+        key_files: normalizeListParam(params.keyFiles),
+        key_decisions: normalizeListParam(params.keyDecisions),
         full_summary_md: "",
         description: "",
         estimate: "",
@@ -101,8 +113,8 @@ export async function handleCompleteTask(params, basePath) {
             return;
         }
         // All guards passed — perform writes
-        insertMilestone({ id: params.milestoneId });
-        insertSlice({ id: params.sliceId, milestoneId: params.milestoneId });
+        insertMilestone({ id: params.milestoneId, title: params.milestoneId });
+        insertSlice({ id: params.sliceId, milestoneId: params.milestoneId, title: params.sliceId });
         insertTask({
             id: params.taskId,
             sliceId: params.sliceId,

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

@@ -113,10 +113,10 @@ function validateParams(params) {
         successCriteria: params.successCriteria ? validateStringArray(params.successCriteria, "successCriteria") : [],
         keyRisks: params.keyRisks ? validateRiskEntries(params.keyRisks) : [],
         proofStrategy: params.proofStrategy ? validateProofStrategy(params.proofStrategy) : [],
-        verificationContract: params.verificationContract ?? "Not provided.",
-        verificationIntegration: params.verificationIntegration ?? "Not provided.",
-        verificationOperational: params.verificationOperational ?? "Not provided.",
-        verificationUat: params.verificationUat ?? "Not provided.",
+        verificationContract: params.verificationContract ?? "",
+        verificationIntegration: params.verificationIntegration ?? "",
+        verificationOperational: params.verificationOperational ?? "",
+        verificationUat: params.verificationUat ?? "",
         definitionOfDone: params.definitionOfDone ? validateStringArray(params.definitionOfDone, "definitionOfDone") : [],
         requirementCoverage: params.requirementCoverage ?? "Not provided.",
         boundaryMapMarkdown: params.boundaryMapMarkdown ?? "Not provided.",
@@ -191,7 +191,8 @@ export async function handlePlanMilestone(rawParams, basePath) {
                 requirementCoverage: params.requirementCoverage,
                 boundaryMapMarkdown: params.boundaryMapMarkdown,
             });
-            for (const slice of params.slices) {
+            for (let i = 0; i < params.slices.length; i++) {
+                const slice = params.slices[i];
                 // Preserve completed/done status on re-plan (#2558).
                 // Without this, a re-plan after milestone transition would reset
                 // already-completed slices back to "pending".
@@ -207,6 +208,7 @@ export async function handlePlanMilestone(rawParams, basePath) {
                     risk: slice.risk,
                     depends: slice.depends,
                     demo: slice.demo,
+                    sequence: i + 1, // Preserve agent-ordered sequence (#3356)
                 });
                 upsertSlicePlanning(params.milestoneId, slice.sliceId, {
                     goal: slice.goal,

package/dist/resources/extensions/gsd/tools/reassess-roadmap.js

@@ -129,8 +129,10 @@ export async function handleReassessRoadmap(rawParams, basePath) {
                     demo: mod.demo,
                 });
             }
-            // Insert new slices
-            for (const added of params.sliceChanges.added) {
+            // Insert new slices — assign sequence after existing slices (#3356)
+            const existingCount = getMilestoneSlices(params.milestoneId).length;
+            for (let i = 0; i < params.sliceChanges.added.length; i++) {
+                const added = params.sliceChanges.added[i];
                 insertSlice({
                     id: added.sliceId,
                     milestoneId: params.milestoneId,
@@ -139,6 +141,7 @@ export async function handleReassessRoadmap(rawParams, basePath) {
                     risk: added.risk,
                     depends: added.depends,
                     demo: added.demo ?? "",
+                    sequence: existingCount + i + 1,
                 });
             }
             // Delete removed slices

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

@@ -0,0 +1,119 @@
+// GSD — reopen-milestone tool handler
+/**
+ * reopen-milestone handler — the core operation behind gsd_milestone_reopen.
+ *
+ * Resets a closed milestone back to "active", all of its slices to
+ * "in_progress", and all tasks to "pending". Cleans up stale filesystem
+ * artifacts so the DB-filesystem reconciler does not auto-correct
+ * entities back to "complete".
+ */
+import { getMilestone, getMilestoneSlices, getSliceTasks, updateMilestoneStatus, updateSliceStatus, updateTaskStatus, transaction, } from "../gsd-db.js";
+import { invalidateStateCache } from "../state.js";
+import { isClosedStatus } from "../status-guards.js";
+import { renderAllProjections } from "../workflow-projections.js";
+import { writeManifest } from "../workflow-manifest.js";
+import { appendEvent } from "../workflow-events.js";
+import { logWarning } from "../workflow-logger.js";
+import { debugLog } from "../debug-logger.js";
+import { existsSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
+import { resolveMilestonePath, resolveSlicePath, resolveTasksDir, clearPathCache } from "../paths.js";
+export async function handleReopenMilestone(params, basePath) {
+    // ── Validate required fields ────────────────────────────────────────────
+    if (!params.milestoneId || typeof params.milestoneId !== "string" || params.milestoneId.trim() === "") {
+        return { error: "milestoneId is required and must be a non-empty string" };
+    }
+    // ── Guards + DB writes inside a single transaction (prevents TOCTOU) ───
+    let guardError = null;
+    let slicesResetCount = 0;
+    let tasksResetCount = 0;
+    transaction(() => {
+        const milestone = getMilestone(params.milestoneId);
+        if (!milestone) {
+            guardError = `milestone not found: ${params.milestoneId}`;
+            return;
+        }
+        if (!isClosedStatus(milestone.status)) {
+            guardError = `milestone ${params.milestoneId} is not closed (status: ${milestone.status}) — nothing to reopen`;
+            return;
+        }
+        updateMilestoneStatus(params.milestoneId, "active", null);
+        const slices = getMilestoneSlices(params.milestoneId);
+        slicesResetCount = slices.length;
+        for (const slice of slices) {
+            updateSliceStatus(params.milestoneId, slice.id, "in_progress");
+            const tasks = getSliceTasks(params.milestoneId, slice.id);
+            tasksResetCount += tasks.length;
+            for (const task of tasks) {
+                updateTaskStatus(params.milestoneId, slice.id, task.id, "pending");
+            }
+        }
+    });
+    if (guardError) {
+        return { error: guardError };
+    }
+    // ── Invalidate caches ────────────────────────────────────────────────────
+    invalidateStateCache();
+    // ── Clean up stale filesystem artifacts (M12 fix) ────────────────────────
+    // Without this, the DB-filesystem reconciler sees SUMMARY.md files and
+    // auto-corrects entities back to "complete", making reopen a no-op (#3161).
+    try {
+        const milestoneDir = resolveMilestonePath(basePath, params.milestoneId);
+        if (milestoneDir) {
+            const milestoneSummary = join(milestoneDir, `${params.milestoneId}-SUMMARY.md`);
+            if (existsSync(milestoneSummary))
+                unlinkSync(milestoneSummary);
+        }
+        const slices = getMilestoneSlices(params.milestoneId);
+        for (const slice of slices) {
+            const sliceDir = resolveSlicePath(basePath, params.milestoneId, slice.id);
+            if (sliceDir) {
+                const sliceSummary = join(sliceDir, `${slice.id}-SUMMARY.md`);
+                if (existsSync(sliceSummary))
+                    unlinkSync(sliceSummary);
+                const sliceUat = join(sliceDir, `${slice.id}-UAT.md`);
+                if (existsSync(sliceUat))
+                    unlinkSync(sliceUat);
+            }
+            const tasksDir = resolveTasksDir(basePath, params.milestoneId, slice.id);
+            if (tasksDir) {
+                const tasks = getSliceTasks(params.milestoneId, slice.id);
+                for (const task of tasks) {
+                    const taskSummary = join(tasksDir, `${task.id}-SUMMARY.md`);
+                    if (existsSync(taskSummary))
+                        unlinkSync(taskSummary);
+                }
+            }
+        }
+    }
+    catch (err) {
+        debugLog("reopen-milestone-cleanup-failed", { milestoneId: params.milestoneId, error: String(err) });
+    }
+    clearPathCache();
+    // ── Post-mutation hook ───────────────────────────────────────────────────
+    try {
+        await renderAllProjections(basePath, params.milestoneId);
+        writeManifest(basePath);
+        appendEvent(basePath, {
+            cmd: "reopen-milestone",
+            params: {
+                milestoneId: params.milestoneId,
+                reason: params.reason ?? null,
+                slicesReset: slicesResetCount,
+                tasksReset: tasksResetCount,
+            },
+            ts: new Date().toISOString(),
+            actor: "agent",
+            actor_name: params.actorName,
+            trigger_reason: params.triggerReason,
+        });
+    }
+    catch (hookErr) {
+        logWarning("tool", `reopen-milestone post-mutation hook warning: ${hookErr.message}`);
+    }
+    return {
+        milestoneId: params.milestoneId,
+        slicesReset: slicesResetCount,
+        tasksReset: tasksResetCount,
+    };
+}

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

@@ -16,6 +16,9 @@ import { renderAllProjections } from "../workflow-projections.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
 import { logWarning } from "../workflow-logger.js";
+import { existsSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
+import { resolveTasksDir, resolveSlicePath, clearPathCache } from "../paths.js";
 export async function handleReopenSlice(params, basePath) {
     // ── Validate required fields ────────────────────────────────────────────
     if (!params.sliceId || typeof params.sliceId !== "string" || params.sliceId.trim() === "") {
@@ -59,6 +62,33 @@ export async function handleReopenSlice(params, basePath) {
     }
     // ── Invalidate caches ────────────────────────────────────────────────────
     invalidateStateCache();
+    // ── Clean up stale filesystem artifacts (M12 fix) ────────────────────────
+    // Without this, the DB-filesystem reconciler sees SUMMARY.md files and
+    // auto-corrects tasks back to "complete", making reopen a no-op (#3161).
+    try {
+        const tasksDir = resolveTasksDir(basePath, params.milestoneId, params.sliceId);
+        if (tasksDir) {
+            const tasks = getSliceTasks(params.milestoneId, params.sliceId);
+            for (const task of tasks) {
+                const summaryPath = join(tasksDir, `${task.id}-SUMMARY.md`);
+                if (existsSync(summaryPath))
+                    unlinkSync(summaryPath);
+            }
+        }
+        const sliceDir = resolveSlicePath(basePath, params.milestoneId, params.sliceId);
+        if (sliceDir) {
+            const sliceSummary = join(sliceDir, `${params.sliceId}-SUMMARY.md`);
+            if (existsSync(sliceSummary))
+                unlinkSync(sliceSummary);
+            const sliceUat = join(sliceDir, `${params.sliceId}-UAT.md`);
+            if (existsSync(sliceUat))
+                unlinkSync(sliceUat);
+        }
+    }
+    catch (cleanupErr) {
+        logWarning("tool", `reopen-slice artifact cleanup warning: ${cleanupErr.message}`);
+    }
+    clearPathCache();
     // ── Post-mutation hook ───────────────────────────────────────────────────
     try {
         await renderAllProjections(basePath, params.milestoneId);

package/dist/resources/extensions/gsd/tools/reopen-task.js

@@ -15,6 +15,9 @@ import { renderAllProjections } from "../workflow-projections.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
 import { logWarning } from "../workflow-logger.js";
+import { existsSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
+import { resolveTasksDir, clearPathCache } from "../paths.js";
 export async function handleReopenTask(params, basePath) {
     // ── Validate required fields ────────────────────────────────────────────
     if (!params.taskId || typeof params.taskId !== "string" || params.taskId.trim() === "") {
@@ -63,6 +66,21 @@ export async function handleReopenTask(params, basePath) {
     }
     // ── Invalidate caches ────────────────────────────────────────────────────
     invalidateStateCache();
+    // ── Clean up stale filesystem artifacts (M12 fix) ────────────────────────
+    // Without this, the DB-filesystem reconciler sees the SUMMARY.md and
+    // auto-corrects the task back to "complete", making reopen a no-op (#3161).
+    try {
+        const tasksDir = resolveTasksDir(basePath, params.milestoneId, params.sliceId);
+        if (tasksDir) {
+            const summaryPath = join(tasksDir, `${params.taskId}-SUMMARY.md`);
+            if (existsSync(summaryPath))
+                unlinkSync(summaryPath);
+        }
+    }
+    catch (cleanupErr) {
+        logWarning("tool", `reopen-task artifact cleanup warning: ${cleanupErr.message}`);
+    }
+    clearPathCache();
     // ── Post-mutation hook ───────────────────────────────────────────────────
     try {
         await renderAllProjections(basePath, params.milestoneId);

package/dist/resources/extensions/gsd/triage-resolution.js

@@ -373,13 +373,16 @@ export function executeTriageResolutions(basePath, mid, sid) {
             }
         }
     }
-    // Also process deferred captures that target milestone IDs — create
-    // milestone directories so deriveState() discovers them.
-    const deferred = loadAllCaptures(basePath).filter(c => c.status === "resolved" && !c.executed && c.classification === "defer");
-    if (deferred.length > 0) {
-        // Group deferred captures by target milestone
+    // Also process deferred and milestone-class captures (#3542).
+    // A defer/milestone capture's "action" is the triage decision itself —
+    // once classified and resolved, the capture is done. The target milestone
+    // picks up the work naturally from its planning context.
+    const deferrable = loadAllCaptures(basePath).filter(c => c.status === "resolved" && !c.executed &&
+        (c.classification === "defer" || c.classification === "milestone"));
+    if (deferrable.length > 0) {
+        // Group captures that reference a specific milestone — create dirs as needed.
         const byMilestone = new Map();
-        for (const cap of deferred) {
+        for (const cap of deferrable) {
             const target = cap.resolution?.match(/\b(M\d{3}(?:-[a-z0-9]{6})?)\b/)?.[1];
             if (target) {
                 const list = byMilestone.get(target) ?? [];
@@ -394,12 +397,25 @@ export function executeTriageResolutions(basePath, mid, sid) {
                 if (created) {
                     result.deferredMilestones++;
                     result.actions.push(`Created milestone ${milestoneId} for ${captures.length} deferred capture(s)`);
-                    for (const cap of captures) {
-                        markCaptureExecuted(basePath, cap.id);
-                    }
                 }
             }
         }
+        // Stamp ALL defer/milestone captures as executed (#3542 gaps 1-3).
+        // Previously only captures that triggered dir creation were stamped.
+        // Captures without a milestone ID in resolution text, or targeting an
+        // existing directory, were silently dropped — never stamped.
+        for (const cap of deferrable) {
+            if (!cap.executed) {
+                markCaptureExecuted(basePath, cap.id);
+            }
+        }
+    }
+    // Mark note captures as executed — they're informational only, no action
+    // needed. Without this they stay in "resolved but not executed" limbo (#3578).
+    const notes = loadAllCaptures(basePath).filter(c => c.status === "resolved" && !c.executed && c.classification === "note");
+    for (const cap of notes) {
+        markCaptureExecuted(basePath, cap.id);
+        result.actions.push(`Note acknowledged: ${cap.id} — "${cap.text}"`);
     }
     if (actionable.length === 0)
         return result;

package/dist/resources/extensions/gsd/verification-evidence.js

@@ -55,6 +55,24 @@ export function writeVerificationJSON(result, tasksDir, taskId, unitId, retryAtt
     const filePath = join(tasksDir, `${taskId}-VERIFY.json`);
     writeFileSync(filePath, JSON.stringify(evidence, null, 2) + "\n", "utf-8");
 }
+/**
+ * Write pre-execution check results to a PRE-EXEC-VERIFY.json artifact
+ * in the slice directory.
+ */
+export function writePreExecutionEvidence(result, sliceDir, milestoneId, sliceId) {
+    mkdirSync(sliceDir, { recursive: true });
+    const evidence = {
+        schemaVersion: 1,
+        milestoneId,
+        sliceId,
+        timestamp: Date.now(),
+        status: result.status,
+        durationMs: result.durationMs,
+        checks: result.checks,
+    };
+    const filePath = join(sliceDir, `${sliceId}-PRE-EXEC-VERIFY.json`);
+    writeFileSync(filePath, JSON.stringify(evidence, null, 2) + "\n", "utf-8");
+}
 // ─── Markdown Evidence Table ─────────────────────────────────────────────────
 /**
  * Format duration in milliseconds as seconds with 1 decimal place.

package/dist/resources/extensions/gsd/workflow-logger.js

@@ -17,6 +17,7 @@
 // Node process.
 import { appendFileSync, readFileSync, existsSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
+import { appendNotification } from "./notification-store.js";
 // ─── Buffer & Persistent Audit ──────────────────────────────────────────
 const MAX_BUFFER = 100;
 let _buffer = [];
@@ -179,6 +180,13 @@ function _push(severity, component, message, context) {
     const prefix = severity === "error" ? "ERROR" : "WARN";
     const ctxStr = context ? ` ${JSON.stringify(context)}` : "";
     process.stderr.write(`[gsd:${component}] ${prefix}: ${message}${ctxStr}\n`);
+    // Persist to notification store (both warnings and errors)
+    try {
+        appendNotification(`[${component}] ${message}`, severity === "error" ? "error" : "warning", "workflow-logger");
+    }
+    catch (notifErr) {
+        process.stderr.write(`[gsd:workflow-logger] notification-store append failed: ${notifErr.message}\n`);
+    }
     // Buffer for auto-loop to drain
     _buffer.push(entry);
     if (_buffer.length > MAX_BUFFER) {

package/dist/resources/extensions/gsd/workflow-projections.js

@@ -324,13 +324,10 @@ export async function renderAllProjections(basePath, milestoneId) {
     // Query all slices for this milestone
     const sliceRows = getMilestoneSlices(milestoneId);
     for (const slice of sliceRows) {
-        // Render PLAN.md for each slice
-        try {
-            renderPlanProjection(basePath, milestoneId, slice.id);
-        }
-        catch (err) {
-            logWarning("projection", `renderPlanProjection failed for ${milestoneId}/${slice.id}: ${err.message}`);
-        }
+        // PLAN.md is rendered by the authoritative markdown-renderer.js in
+        // plan-slice/replan-slice tools. Do NOT overwrite it here — the simplified
+        // projection is missing key sections (Must-Haves, Verification, Files
+        // Likely Touched) and corrupts multi-line task descriptions (#3651).
         // Render SUMMARY.md for each completed task
         const taskRows = getSliceTasks(milestoneId, slice.id);
         const doneTasks = taskRows.filter(t => t.status === "done" || t.status === "complete");

package/dist/resources/extensions/gsd/workflow-reconcile.js

@@ -2,7 +2,7 @@ import { join } from "node:path";
 import { mkdirSync, existsSync, readFileSync, unlinkSync } from "node:fs";
 import { logWarning, logError } from "./workflow-logger.js";
 import { readEvents, findForkPoint, appendEvent, getSessionId } from "./workflow-events.js";
-import { transaction, updateTaskStatus, updateSliceStatus, getSliceTasks, insertVerificationEvidence, upsertDecision, openDatabase, } from "./gsd-db.js";
+import { transaction, updateTaskStatus, updateSliceStatus, getSliceTasks, insertVerificationEvidence, upsertDecision, openDatabase, setTaskBlockerDiscovered, } from "./gsd-db.js";
 import { isClosedStatus } from "./status-guards.js";
 import { writeManifest } from "./workflow-manifest.js";
 import { atomicWriteSync } from "./atomic-write.js";
@@ -60,13 +60,11 @@ function replayEvents(events) {
                     break;
                 }
                 case "report_blocker": {
-                    // report_blocker marks the task with blocker_discovered = 1
-                    // The DB helper updateTaskStatus doesn't handle blockers,
-                    // so we just update status to "blocked" as a best-effort replay.
                     const milestoneId = p["milestoneId"];
                     const sliceId = p["sliceId"];
                     const taskId = p["taskId"];
                     updateTaskStatus(milestoneId, sliceId, taskId, "blocked");
+                    setTaskBlockerDiscovered(milestoneId, sliceId, taskId, true);
                     break;
                 }
                 case "record_verification": {

package/dist/resources/extensions/gsd/workflow-templates.js

@@ -29,8 +29,17 @@ let cachedRegistry = null;
 export function loadRegistry() {
     if (cachedRegistry)
         return cachedRegistry;
-    const content = readFileSync(registryPath, "utf-8");
-    cachedRegistry = JSON.parse(content);
+    if (!existsSync(registryPath)) {
+        cachedRegistry = { version: 1, templates: {} };
+        return cachedRegistry;
+    }
+    try {
+        const content = readFileSync(registryPath, "utf-8");
+        cachedRegistry = JSON.parse(content);
+    }
+    catch {
+        cachedRegistry = { version: 1, templates: {} };
+    }
     return cachedRegistry;
 }
 /**

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

@@ -44,7 +44,10 @@ function normalizePathForComparison(path) {
 export function resolveGitDir(basePath) {
     const gitPath = join(basePath, ".git");
     if (!existsSync(gitPath))
-        return join(basePath, ".git");
+        return gitPath;
+    // In a normal repo .git is a directory — skip the file read (#3597)
+    if (lstatSync(gitPath).isDirectory())
+        return gitPath;
     try {
         const content = readFileSync(gitPath, "utf-8").trim();
         if (content.startsWith("gitdir: ")) {
@@ -54,7 +57,7 @@ export function resolveGitDir(basePath) {
     catch (e) {
         logWarning("worktree", `.git file read failed: ${e.message}`);
     }
-    return join(basePath, ".git");
+    return gitPath;
 }
 export function worktreesDir(basePath) {
     return join(basePath, ".gsd", "worktrees");

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

@@ -34,6 +34,15 @@ function getService(basePath) {
     }
     return cachedService;
 }
+/**
+ * Clear the cached GitServiceImpl. For testing only — forces the next
+ * getService() call to re-read preferences and create a fresh instance.
+ * @internal
+ */
+export function _resetServiceCache() {
+    cachedService = null;
+    cachedBasePath = null;
+}
 /**
  * Set the active milestone ID on the cached GitServiceImpl.
  * This enables integration branch resolution in getMainBranch().

package/dist/resources/extensions/shared/interview-ui.js

@@ -204,7 +204,7 @@ export async function showInterviewRound(questions, opts, ctx) {
             // instead of being trapped in a re-asking loop (bug #2715).
             // Only auto-open if the user hasn't already provided notes —
             // otherwise Enter from notes mode loops back here endlessly.
-            if (!isMultiSelect(currentIdx) && states[currentIdx].cursorIndex === noneOrDoneIdx(currentIdx) && !states[currentIdx].notes) {
+            if (!isMultiSelect(currentIdx) && states[currentIdx].cursorIndex === noneOrDoneIdx(currentIdx) && !states[currentIdx].notes && !states[currentIdx].notesVisible) {
                 states[currentIdx].notesVisible = true;
                 focusNotes = true;
                 loadStateToEditor();

package/dist/web/standalone/.next/BUILD_ID

@@ -1 +1 @@
-eebXKteM9EaWyseHKTjqp
+Z3TgDP0c7kG9j8CVQVGcl

package/dist/web/standalone/.next/app-path-routes-manifest.json

@@ -1,46 +1,47 @@
 {
-  "/_not-found/page": "/_not-found",
   "/_global-error/page": "/_global-error",
+  "/_not-found/page": "/_not-found",
   "/api/bridge-terminal/input/route": "/api/bridge-terminal/input",
   "/api/boot/route": "/api/boot",
   "/api/bridge-terminal/resize/route": "/api/bridge-terminal/resize",
   "/api/bridge-terminal/stream/route": "/api/bridge-terminal/stream",
+  "/api/cleanup/route": "/api/cleanup",
   "/api/dev-mode/route": "/api/dev-mode",
-  "/api/doctor/route": "/api/doctor",
-  "/api/captures/route": "/api/captures",
   "/api/browse-directories/route": "/api/browse-directories",
   "/api/export-data/route": "/api/export-data",
-  "/api/cleanup/route": "/api/cleanup",
+  "/api/captures/route": "/api/captures",
+  "/api/doctor/route": "/api/doctor",
   "/api/forensics/route": "/api/forensics",
   "/api/history/route": "/api/history",
-  "/api/hooks/route": "/api/hooks",
   "/api/git/route": "/api/git",
   "/api/inspect/route": "/api/inspect",
-  "/api/knowledge/route": "/api/knowledge",
+  "/api/hooks/route": "/api/hooks",
   "/api/experimental/route": "/api/experimental",
+  "/api/notifications/route": "/api/notifications",
   "/api/live-state/route": "/api/live-state",
-  "/api/preferences/route": "/api/preferences",
+  "/api/knowledge/route": "/api/knowledge",
   "/api/recovery/route": "/api/recovery",
-  "/api/onboarding/route": "/api/onboarding",
-  "/api/projects/route": "/api/projects",
+  "/api/preferences/route": "/api/preferences",
   "/api/session/browser/route": "/api/session/browser",
+  "/api/onboarding/route": "/api/onboarding",
   "/api/session/command/route": "/api/session/command",
+  "/api/projects/route": "/api/projects",
   "/api/session/events/route": "/api/session/events",
-  "/api/settings-data/route": "/api/settings-data",
-  "/api/session/manage/route": "/api/session/manage",
   "/api/shutdown/route": "/api/shutdown",
+  "/api/settings-data/route": "/api/settings-data",
   "/api/skill-health/route": "/api/skill-health",
   "/api/steer/route": "/api/steer",
+  "/api/session/manage/route": "/api/session/manage",
   "/api/terminal/input/route": "/api/terminal/input",
-  "/api/files/route": "/api/files",
   "/api/terminal/resize/route": "/api/terminal/resize",
   "/api/switch-root/route": "/api/switch-root",
   "/api/terminal/sessions/route": "/api/terminal/sessions",
   "/api/terminal/stream/route": "/api/terminal/stream",
-  "/api/terminal/upload/route": "/api/terminal/upload",
   "/api/undo/route": "/api/undo",
-  "/api/visualizer/route": "/api/visualizer",
   "/api/update/route": "/api/update",
+  "/api/files/route": "/api/files",
+  "/api/terminal/upload/route": "/api/terminal/upload",
+  "/api/visualizer/route": "/api/visualizer",
   "/api/remote-questions/route": "/api/remote-questions",
   "/page": "/"
 }

package/dist/web/standalone/.next/build-manifest.json

@@ -4,14 +4,14 @@
   ],
   "devFiles": [],
   "lowPriorityFiles": [
-    "static/eebXKteM9EaWyseHKTjqp/_buildManifest.js",
-    "static/eebXKteM9EaWyseHKTjqp/_ssgManifest.js"
+    "static/Z3TgDP0c7kG9j8CVQVGcl/_buildManifest.js",
+    "static/Z3TgDP0c7kG9j8CVQVGcl/_ssgManifest.js"
   ],
   "rootMainFiles": [
-    "static/chunks/webpack-a1c1e452c6b32d04.js",
+    "static/chunks/webpack-9fed74684e1c5bb1.js",
     "static/chunks/4bd1b696-e5d7c65570c947b7.js",
     "static/chunks/3794-337d1ca25ad99a89.js",
-    "static/chunks/main-app-d3d4c336195465f9.js"
+    "static/chunks/main-app-fdab67f7802d7832.js"
   ],
   "rootMainFilesTree": {},
   "pages": {