gsd-pi 2.66.1-dev.ed243f2 → 2.67.0-dev.43b0159

package/dist/resources/extensions/gsd/commands/handlers/core.js

@@ -44,6 +44,7 @@ export function showHelp(ctx) {
         "SETUP & CONFIGURATION",
         "  /gsd init           Project init wizard — detect, configure, bootstrap .gsd/",
         "  /gsd setup          Global setup status  [llm|search|remote|keys|prefs]",
+        "  /gsd model          Switch active session model  [provider/model|model-id]",
         "  /gsd mode           Set workflow mode (solo/team)  [global|project]",
         "  /gsd prefs          Manage preferences  [global|project|status|wizard|setup|import-claude]",
         "  /gsd cmux           Manage cmux integration  [status|on|off|notifications|sidebar|splits|browser]",
@@ -77,7 +78,7 @@ export async function handleStatus(ctx) {
         return;
     }
     const { GSDDashboardOverlay } = await import("../../dashboard-overlay.js");
-    const result = await ctx.ui.custom((tui, theme, _kb, done) => new GSDDashboardOverlay(tui, theme, () => done()), {
+    const result = await ctx.ui.custom((tui, theme, _kb, done) => new GSDDashboardOverlay(tui, theme, () => done(true)), {
         overlay: true,
         overlayOptions: {
             width: "70%",
@@ -99,7 +100,7 @@ export async function handleVisualize(ctx) {
         return;
     }
     const { GSDVisualizerOverlay } = await import("../../visualizer-overlay.js");
-    const result = await ctx.ui.custom((tui, theme, _kb, done) => new GSDVisualizerOverlay(tui, theme, () => done()), {
+    const result = await ctx.ui.custom((tui, theme, _kb, done) => new GSDVisualizerOverlay(tui, theme, () => done(true)), {
         overlay: true,
         overlayOptions: {
             width: "80%",
@@ -152,7 +153,92 @@ export async function handleSetup(args, ctx) {
         "  /gsd setup keys    — Tool API keys\n" +
         "  /gsd setup prefs   — Global preferences wizard", "info");
 }
-export async function handleCoreCommand(trimmed, ctx) {
+function sortModelsForSelection(models, currentModel) {
+    return [...models].sort((a, b) => {
+        const aCurrent = currentModel && a.provider === currentModel.provider && a.id === currentModel.id;
+        const bCurrent = currentModel && b.provider === currentModel.provider && b.id === currentModel.id;
+        if (aCurrent && !bCurrent)
+            return -1;
+        if (!aCurrent && bCurrent)
+            return 1;
+        const providerCmp = a.provider.localeCompare(b.provider);
+        if (providerCmp !== 0)
+            return providerCmp;
+        return a.id.localeCompare(b.id);
+    });
+}
+async function resolveRequestedModel(query, ctx) {
+    const { resolveModelId } = await import("../../auto-model-selection.js");
+    const models = ctx.modelRegistry.getAvailable();
+    const exact = resolveModelId(query, models, ctx.model?.provider);
+    if (exact)
+        return exact;
+    const lowerQuery = query.toLowerCase();
+    const partialMatches = models.filter((model) => model.id.toLowerCase().includes(lowerQuery)
+        || `${model.provider}/${model.id}`.toLowerCase().includes(lowerQuery));
+    if (partialMatches.length === 1)
+        return partialMatches[0];
+    if (partialMatches.length === 0 || !ctx.hasUI)
+        return undefined;
+    const sorted = sortModelsForSelection(partialMatches, ctx.model);
+    const optionToModel = new Map();
+    const options = sorted.map((model) => {
+        const label = `${model.provider}/${model.id}`;
+        optionToModel.set(label, model);
+        return label;
+    });
+    options.push("(cancel)");
+    const choice = await ctx.ui.select(`Multiple models match "${query}" — choose one:`, options);
+    if (!choice || typeof choice !== "string" || choice === "(cancel)")
+        return undefined;
+    return optionToModel.get(choice);
+}
+async function handleModel(trimmedArgs, ctx, pi) {
+    const availableModels = ctx.modelRegistry.getAvailable();
+    if (availableModels.length === 0) {
+        ctx.ui.notify("No available models found. Check provider auth and model discovery.", "warning");
+        return;
+    }
+    if (!pi) {
+        ctx.ui.notify("Model switching is unavailable in this context.", "warning");
+        return;
+    }
+    const trimmed = trimmedArgs.trim();
+    let targetModel;
+    if (!trimmed) {
+        if (!ctx.hasUI) {
+            const current = ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : "(none)";
+            ctx.ui.notify(`Current model: ${current}\nUsage: /gsd model <provider/model|model-id>`, "info");
+            return;
+        }
+        const optionToModel = new Map();
+        const options = sortModelsForSelection(availableModels, ctx.model).map((model) => {
+            const isCurrent = ctx.model && model.provider === ctx.model.provider && model.id === ctx.model.id;
+            const label = `${isCurrent ? "* " : ""}${model.provider}/${model.id}`;
+            optionToModel.set(label, model);
+            return label;
+        });
+        options.push("(cancel)");
+        const choice = await ctx.ui.select("Select session model:", options);
+        if (!choice || typeof choice !== "string" || choice === "(cancel)")
+            return;
+        targetModel = optionToModel.get(choice);
+    }
+    else {
+        targetModel = await resolveRequestedModel(trimmed, ctx);
+    }
+    if (!targetModel) {
+        ctx.ui.notify(`Model "${trimmed}" not found. Use /gsd model with an exact provider/model or a unique model ID.`, "warning");
+        return;
+    }
+    const ok = await pi.setModel(targetModel);
+    if (!ok) {
+        ctx.ui.notify(`No API key for ${targetModel.provider}/${targetModel.id}`, "warning");
+        return;
+    }
+    ctx.ui.notify(`Model: ${targetModel.provider}/${targetModel.id}`, "info");
+}
+export async function handleCoreCommand(trimmed, ctx, pi) {
     if (trimmed === "help" || trimmed === "h" || trimmed === "?") {
         showHelp(ctx);
         return true;
@@ -177,6 +263,10 @@ export async function handleCoreCommand(trimmed, ctx) {
         ctx.ui.notify(`Widget: ${getWidgetMode()}`, "info");
         return true;
     }
+    if (trimmed === "model" || trimmed.startsWith("model ")) {
+        await handleModel(trimmed.replace(/^model\s*/, "").trim(), ctx, pi);
+        return true;
+    }
     if (trimmed === "mode" || trimmed.startsWith("mode ")) {
         const modeArgs = trimmed.replace(/^mode\s*/, "").trim();
         const scope = modeArgs === "project" ? "project" : "global";
@@ -195,7 +285,7 @@ export async function handleCoreCommand(trimmed, ctx) {
     }
     if (trimmed === "show-config") {
         const { GSDConfigOverlay, formatConfigText } = await import("../../config-overlay.js");
-        const result = await ctx.ui.custom((tui, theme, _kb, done) => new GSDConfigOverlay(tui, theme, () => done()), {
+        const result = await ctx.ui.custom((tui, theme, _kb, done) => new GSDConfigOverlay(tui, theme, () => done(true)), {
             overlay: true,
             overlayOptions: {
                 width: "65%",

package/dist/resources/extensions/gsd/commands-prefs-wizard.js

@@ -137,7 +137,7 @@ export function buildCategorySummaries(prefs) {
     const models = prefs.models;
     let modelsSummary = "(not configured)";
     if (models && Object.keys(models).length > 0) {
-        const parts = Object.entries(models).map(([phase, model]) => `${phase}: ${model}`);
+        const parts = Object.entries(models).map(([phase, model]) => `${phase}: ${formatConfiguredModel(model)}`);
         modelsSummary = parts.join(", ");
     }
     // Timeouts
@@ -220,8 +220,39 @@ export function buildCategorySummaries(prefs) {
     };
 }
 // ─── Category configuration functions ────────────────────────────────────────
+export function formatConfiguredModel(config) {
+    if (typeof config === "string")
+        return config;
+    if (!config || typeof config !== "object")
+        return "(invalid)";
+    const maybeConfig = config;
+    if (typeof maybeConfig.model !== "string" || maybeConfig.model.trim() === "")
+        return "(invalid)";
+    if (typeof maybeConfig.provider === "string" && maybeConfig.provider && !maybeConfig.model.includes("/")) {
+        return `${maybeConfig.provider}/${maybeConfig.model}`;
+    }
+    return maybeConfig.model;
+}
+export function toPersistedModelId(provider, modelId) {
+    if (!provider.trim())
+        return modelId;
+    const normalizedProvider = provider.trim();
+    const normalizedModelId = modelId.trim();
+    return normalizedModelId.startsWith(`${normalizedProvider}/`)
+        ? normalizedModelId
+        : `${normalizedProvider}/${normalizedModelId}`;
+}
 async function configureModels(ctx, prefs) {
-    const modelPhases = ["research", "planning", "execution", "completion"];
+    const modelPhases = [
+        "research",
+        "planning",
+        "discuss",
+        "execution",
+        "execution_simple",
+        "completion",
+        "validation",
+        "subagent",
+    ];
     const models = prefs.models ?? {};
     const availableModels = ctx.modelRegistry.getAvailable();
     if (availableModels.length > 0) {
@@ -240,14 +271,20 @@ async function configureModels(ctx, prefs) {
         for (const group of byProvider.values()) {
             group.sort((a, b) => a.id.localeCompare(b.id));
         }
-        // Build provider menu with model counts
+        // Display names for providers in the preferences wizard UI.
+        const PROVIDER_DISPLAY_NAMES = { anthropic: "anthropic-api" };
+        const displayName = (p) => PROVIDER_DISPLAY_NAMES[p] ?? p;
+        // Build provider menu with model counts (display name → real name lookup)
+        const displayToReal = new Map();
         const providerOptions = providers.map(p => {
             const count = byProvider.get(p).length;
-            return `${p} (${count} models)`;
+            const label = `${displayName(p)} (${count} models)`;
+            displayToReal.set(label, p);
+            return label;
         });
         providerOptions.push("(keep current)", "(clear)", "(type manually)");
         for (const phase of modelPhases) {
-            const current = models[phase] ?? "";
+            const current = formatConfiguredModel(models[phase]);
             const phaseLabel = `Model for ${phase} phase${current ? ` (current: ${current})` : ""}`;
             // Step 1: pick provider
             const providerChoice = await ctx.ui.select(`${phaseLabel} — choose provider:`, providerOptions);
@@ -267,26 +304,26 @@ async function configureModels(ctx, prefs) {
                 continue;
             }
             // Step 2: pick model within provider
-            const providerName = providerChoice.replace(/ \(\d+ models?\)$/, "");
+            const providerName = displayToReal.get(providerChoice) ?? providerChoice.replace(/ \(\d+ models?\)$/, "");
             const group = byProvider.get(providerName);
             if (!group)
                 continue;
             const modelOptions = group.map(m => m.id);
             modelOptions.push("(keep current)", "(clear)");
-            const modelChoice = await ctx.ui.select(`${phaseLabel} — ${providerName}:`, modelOptions);
+            const modelChoice = await ctx.ui.select(`${phaseLabel} — ${displayName(providerName)}:`, modelOptions);
             if (modelChoice && typeof modelChoice === "string" && modelChoice !== "(keep current)") {
                 if (modelChoice === "(clear)") {
                     delete models[phase];
                 }
                 else {
-                    models[phase] = modelChoice;
+                    models[phase] = toPersistedModelId(providerName, modelChoice);
                 }
             }
         }
     }
     else {
         for (const phase of modelPhases) {
-            const current = models[phase] ?? "";
+            const current = formatConfiguredModel(models[phase]);
             const input = await ctx.ui.input(`Model for ${phase} phase${current ? ` (current: ${current})` : ""}:`, current || "e.g. claude-sonnet-4-20250514");
             if (input !== null && input !== undefined) {
                 const val = input.trim();
@@ -302,6 +339,9 @@ async function configureModels(ctx, prefs) {
     if (Object.keys(models).length > 0) {
         prefs.models = models;
     }
+    else {
+        delete prefs.models;
+    }
 }
 async function configureTimeouts(ctx, prefs) {
     const autoSup = prefs.auto_supervisor ?? {};

package/dist/resources/extensions/gsd/context-store.js

@@ -49,7 +49,8 @@ export function queryDecisions(opts) {
 }
 /**
  * Query active (non-superseded) requirements with optional filters.
- * - sliceId: filters where primary_owner LIKE '%sliceId%' OR supporting_slices LIKE '%sliceId%'
+ * - milestoneId: combined with sliceId for precise filtering (e.g. %M005/S01%)
+ * - sliceId: filters where primary_owner LIKE '%pattern%' OR supporting_slices LIKE '%pattern%'
  * - status: filters where status = :status (exact match)
  *
  * Returns [] if DB is not available. Never throws.
@@ -63,10 +64,22 @@ export function queryRequirements(opts) {
     try {
         const clauses = ['superseded_by IS NULL'];
         const params = {};
-        if (opts?.sliceId) {
+        // Combined milestone+slice filtering for precise scoping
+        if (opts?.milestoneId && opts?.sliceId) {
+            // Use combined pattern like %M005/S01% to avoid cross-milestone contamination
+            clauses.push('(primary_owner LIKE :combined_pattern OR supporting_slices LIKE :combined_pattern)');
+            params[':combined_pattern'] = `%${opts.milestoneId}/${opts.sliceId}%`;
+        }
+        else if (opts?.sliceId) {
+            // Slice-only filtering (legacy behavior)
             clauses.push('(primary_owner LIKE :slice_pattern OR supporting_slices LIKE :slice_pattern)');
             params[':slice_pattern'] = `%${opts.sliceId}%`;
         }
+        else if (opts?.milestoneId) {
+            // Milestone-only filtering
+            clauses.push('(primary_owner LIKE :milestone_pattern OR supporting_slices LIKE :milestone_pattern)');
+            params[':milestone_pattern'] = `%${opts.milestoneId}%`;
+        }
         if (opts?.status) {
             clauses.push('status = :status');
             params[':status'] = opts.status;
@@ -164,3 +177,122 @@ export function queryArtifact(path) {
 export function queryProject() {
     return queryArtifact('PROJECT.md');
 }
+// ─── Knowledge Query ───────────────────────────────────────────────────────
+/**
+ * Filter KNOWLEDGE.md sections by keyword matching.
+ * Uses H2 sections, matches keywords case-insensitively against:
+ * 1. Section header text
+ * 2. First paragraph of section content (up to first blank line or next heading)
+ *
+ * Per D020, returns empty string (not null) when no matches found.
+ * This signals "no relevant knowledge" vs "file not found".
+ *
+ * @param content - Full KNOWLEDGE.md content
+ * @param keywords - Keywords to match (case-insensitive)
+ * @returns Concatenated matching sections with H2 headers, or empty string
+ */
+export async function queryKnowledge(content, keywords) {
+    if (!content || keywords.length === 0)
+        return '';
+    // Lazy import to avoid circular dependency
+    const { extractAllSections } = await import('./files.js');
+    const sections = extractAllSections(content, 2);
+    if (sections.size === 0)
+        return '';
+    // Normalize keywords for case-insensitive matching
+    const normalizedKeywords = keywords.map(k => k.toLowerCase());
+    const matchingSections = [];
+    for (const [header, body] of sections) {
+        // Extract first paragraph: everything up to first blank line or next heading
+        const firstParagraph = body.split(/\n\s*\n|\n#/)[0] || '';
+        // Check if any keyword matches header or first paragraph
+        const headerLower = header.toLowerCase();
+        const paragraphLower = firstParagraph.toLowerCase();
+        const matches = normalizedKeywords.some(kw => headerLower.includes(kw) || paragraphLower.includes(kw));
+        if (matches) {
+            matchingSections.push(`## ${header}\n\n${body}`);
+        }
+    }
+    return matchingSections.join('\n\n');
+}
+// ─── Roadmap Excerpt Formatter ─────────────────────────────────────────────
+/**
+ * Format a minimal roadmap excerpt for prompt injection.
+ * Parses the slice table from roadmap content, extracts:
+ * 1. Header row + separator
+ * 2. Predecessor row (if sliceId depends on one via the Depends column)
+ * 3. Target slice row
+ * 4. Reference directive pointing to full roadmap path
+ *
+ * Per D021, this minimizes injected content while preserving dependency awareness.
+ * Returns empty string if sliceId is not found in the table.
+ * Never throws.
+ *
+ * @param roadmapContent - Full content of the M###-ROADMAP.md file
+ * @param sliceId - Target slice ID (e.g. 'S02')
+ * @param roadmapPath - Optional path for reference directive (defaults to generic)
+ */
+export function formatRoadmapExcerpt(roadmapContent, sliceId, roadmapPath = 'ROADMAP.md') {
+    if (!roadmapContent || !sliceId)
+        return '';
+    const lines = roadmapContent.split('\n');
+    // Find the slice table header: | ID | Slice | ... (case insensitive)
+    let headerIndex = -1;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (line && /^\s*\|\s*ID\s*\|\s*Slice\s*\|/i.test(line)) {
+            headerIndex = i;
+            break;
+        }
+    }
+    if (headerIndex === -1)
+        return '';
+    // The separator should be the next line (|---|---|...)
+    const separatorIndex = headerIndex + 1;
+    if (separatorIndex >= lines.length)
+        return '';
+    const headerLine = lines[headerIndex];
+    const separatorLine = lines[separatorIndex];
+    // Validate separator line looks like |---|---|... (may include : for alignment)
+    if (!separatorLine || !/^\s*\|[\s:\-|]+\|/.test(separatorLine))
+        return '';
+    const sliceRows = [];
+    for (let i = separatorIndex + 1; i < lines.length; i++) {
+        const line = lines[i];
+        if (!line || !line.trim().startsWith('|'))
+            break; // End of table
+        // Parse row: | ID | Slice | Risk | Depends | Done | After this |
+        const cells = line.split('|').map(c => c.trim());
+        // cells[0] is empty (before first |), cells[1] is ID, etc.
+        if (cells.length < 5)
+            continue;
+        const id = cells[1] || '';
+        const depends = cells[4] || ''; // Depends column (0-indexed: empty, ID, Slice, Risk, Depends, ...)
+        sliceRows.push({ line, id, depends });
+    }
+    // Find target slice row
+    const targetRow = sliceRows.find(r => r.id === sliceId);
+    if (!targetRow)
+        return '';
+    // Find predecessor if target depends on one
+    // Depends column may contain: '—', 'S01', 'S01, S02', etc.
+    let predecessorRow;
+    const dependsRaw = targetRow.depends;
+    if (dependsRaw && dependsRaw !== '—' && dependsRaw !== '-') {
+        // Extract first dependency (e.g. 'S01' from 'S01, S02')
+        const depMatch = dependsRaw.match(/S\d+/);
+        if (depMatch) {
+            predecessorRow = sliceRows.find(r => r.id === depMatch[0]);
+        }
+    }
+    // Build excerpt
+    const excerptLines = [headerLine, separatorLine];
+    if (predecessorRow) {
+        excerptLines.push(predecessorRow.line);
+    }
+    excerptLines.push(targetRow.line);
+    // Add reference directive
+    excerptLines.push('');
+    excerptLines.push(`> See full roadmap: ${roadmapPath}`);
+    return excerptLines.join('\n');
+}

package/dist/resources/extensions/gsd/custom-workflow-engine.js

@@ -135,7 +135,9 @@ export class CustomWorkflowEngine {
      * Returns "milestone-complete" when all steps are now done, "continue" otherwise.
      */
     async reconcile(state, completedStep) {
-        const graph = state.raw;
+        // Re-read the graph from disk so we do not overwrite concurrent
+        // workflow edits with a stale in-memory snapshot from deriveState().
+        const graph = readGraph(this.runDir);
         // Extract stepId from "<workflowName>/<stepId>"
         const { milestone, slice, task } = parseUnitId(completedStep.unitId);
         const stepId = task ?? slice ?? milestone;

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

@@ -170,6 +170,12 @@ const TEST_MARKERS = [
 /** Directories skipped during bounded recursive project scans. */
 const RECURSIVE_SCAN_IGNORED_DIRS = new Set([
     ".git",
+    ".gsd",
+    ".planning",
+    ".plans",
+    ".claude",
+    ".cursor",
+    ".vscode",
     "node_modules",
     ".venv",
     "venv",

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

@@ -104,6 +104,23 @@ export function extractAllSections(body, level = 2) {
 function escapeRegex(s) {
     return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
+/**
+ * Normalize a task-plan file reference that may include inline description text
+ * after the path, for example:
+ *   "docs/file.md — explanation"
+ *   "docs/file.md - explanation"
+ */
+export function normalizePlannedFileReference(value) {
+    const trimmed = value.trim().replace(/`/g, "");
+    const match = /^(.*?)(?:\s+(?:—|-)\s+)(.+)$/.exec(trimmed);
+    if (!match)
+        return trimmed;
+    const pathCandidate = match[1].trim();
+    if (pathCandidate.includes("/") || pathCandidate.includes("\\") || pathCandidate.includes(".")) {
+        return pathCandidate;
+    }
+    return trimmed;
+}
 /** Parse bullet list items from a text block. */
 export function parseBullets(text) {
     return text.split('\n')
@@ -540,11 +557,11 @@ export function parseTaskPlanIO(content) {
             let match;
             backtickPathRegex.lastIndex = 0;
             while ((match = backtickPathRegex.exec(trimmed)) !== null) {
-                const candidate = match[1];
+                const candidate = normalizePlannedFileReference(match[1]);
                 // Filter out things that look like code tokens rather than file paths
                 // (e.g. `true`, `false`, `npm run test`). A file path has at least one
                 // dot or slash.
-                if (candidate.includes("/") || candidate.includes(".")) {
+                if (candidate.includes("/") || candidate.includes("\\") || candidate.includes(".")) {
                     paths.push(candidate);
                 }
             }

package/dist/resources/extensions/gsd/guided-flow.js

@@ -142,12 +142,13 @@ export function checkAutoStartAfterDiscuss() {
     // Parse PROJECT.md for milestone sequence, warn if any are missing context.
     // Don't block — milestones can be intentionally queued without context.
     const projectFile = resolveGsdRootFile(basePath, "PROJECT");
+    let projectIds = [];
     if (projectFile) {
         try {
             const projectContent = readFileSync(projectFile, "utf-8");
-            const milestoneIds = parseMilestoneSequenceFromProject(projectContent);
-            if (milestoneIds.length > 1) {
-                const missing = milestoneIds.filter(id => {
+            projectIds = parseMilestoneSequenceFromProject(projectContent);
+            if (projectIds.length > 1) {
+                const missing = projectIds.filter(id => {
                     const hasContext = !!resolveMilestoneFile(basePath, id, "CONTEXT");
                     const hasDraft = !!resolveMilestoneFile(basePath, id, "CONTEXT-DRAFT");
                     const hasDir = existsSync(join(gsdRoot(basePath), "milestones", id));
@@ -165,9 +166,14 @@ export function checkAutoStartAfterDiscuss() {
     }
     // Gate 4: Discussion manifest process verification (multi-milestone only)
     // The LLM writes DISCUSSION-MANIFEST.json after each Phase 3 gate decision.
-    // If the manifest exists but gates_completed < total, the LLM hasn't finished
-    // presenting all readiness gates to the user — block auto-start.
+    // If the project is multi-milestone, the manifest is required. When it is
+    // missing, fail closed instead of assuming the discussion finished.
     const manifestPath = join(gsdRoot(basePath), "DISCUSSION-MANIFEST.json");
+    const requiresManifest = projectIds.length > 1 || findMilestoneIds(basePath).length > 1;
+    if (requiresManifest && !existsSync(manifestPath)) {
+        ctx.ui.notify("Multi-milestone discussion manifest is missing. Auto-start will remain paused until the manifest is written.", "warning");
+        return false;
+    }
     if (existsSync(manifestPath)) {
         try {
             const manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
@@ -178,9 +184,7 @@ export function checkAutoStartAfterDiscuss() {
                 return false;
             }
             // Cross-check manifest milestones against PROJECT.md if available
-            if (projectFile) {
-                const projectContent = readFileSync(projectFile, "utf-8");
-                const projectIds = parseMilestoneSequenceFromProject(projectContent);
+            if (projectIds.length > 0) {
                 const manifestIds = Object.keys(manifest.milestones ?? {});
                 const untracked = projectIds.filter(id => !manifestIds.includes(id));
                 if (untracked.length > 0) {

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

@@ -1,4 +1,4 @@
-export { isDepthConfirmationAnswer, isDepthVerified, isQueuePhaseActive, setQueuePhaseActive, shouldBlockContextWrite, shouldBlockQueueExecution, } from "./bootstrap/write-gate.js";
+export { isDepthConfirmationAnswer, isDepthVerified, isGateQuestionId, isQueuePhaseActive, setQueuePhaseActive, shouldBlockContextWrite, shouldBlockPendingGate, shouldBlockPendingGateBash, shouldBlockQueueExecution, setPendingGate, clearPendingGate, getPendingGate, } 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/parallel-monitor-overlay.js

@@ -406,6 +406,8 @@ export class ParallelMonitorOverlay {
         lines.push(t.fg("muted", "  ESC/q to close  │  ↑↓ scroll"));
         // Apply scroll — use terminal rows as height estimate
         const termHeight = process.stdout.rows || 40;
+        const maxScroll = Math.max(0, lines.length - termHeight);
+        this.scrollOffset = Math.min(Math.max(this.scrollOffset, 0), maxScroll);
         const visible = lines.slice(this.scrollOffset, this.scrollOffset + termHeight);
         this.cachedLines = visible;
         return visible;

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

@@ -177,7 +177,9 @@ function _parsePlanImpl(content) {
         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;
+            const hdMatch = !cbMatch
+                ? line.match(/^#{2,4}\s+([A-Z]+\d+(?:\.[A-Z]+\d+)*)\s*(?:--|—|:)\s*(.+)/)
+                : null;
             if (cbMatch || hdMatch) {
                 const taskId = cbMatch ? cbMatch[2] : hdMatch[1];
                 // Skip tasks already found in the Tasks section

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

@@ -127,10 +127,12 @@ function loadPreferencesFile(path, scope) {
     };
 }
 let _warnedUnrecognizedFormat = false;
+let _warnedSectionParse = false;
 /** @internal Reset the warn-once flags — exported for testing only. */
 export function _resetParseWarningFlag() {
     _warnedUnrecognizedFormat = false;
     _warnedFrontmatterParse = false;
+    _warnedSectionParse = false;
 }
 /** @internal Exported for testing only */
 export function parsePreferencesMarkdown(content) {
@@ -227,7 +229,10 @@ function parseHeadingListFormat(content) {
             typed[targetSection] = value;
         }
         catch (e) {
-            logWarning("guided", `preferences section parse failed: ${e.message}`);
+            if (!_warnedSectionParse) {
+                _warnedSectionParse = true;
+                logWarning("guided", `preferences section parse failed: ${e.message}`);
+            }
         }
     }
     return typed;

package/dist/resources/extensions/gsd/prompts/complete-milestone.md

@@ -63,6 +63,6 @@ Then:
 13. Do not commit manually — the system auto-commits your changes after this unit completes.
 - Say: "Milestone {{milestoneId}} complete."
 
-**Important:** Do NOT skip the code change verification, success criteria, or definition of done verification (steps 3-5). The milestone summary must reflect actual verified outcomes, not assumed success. Verification failures BLOCK completion — there is no override. The milestone stays in its current state until issues are resolved and verification is re-run.
+**Important:** Do NOT skip the code change verification, success criteria, or definition of done verification (steps 3-5). The milestone summary must reflect actual verified outcomes, not assumed success. Verification failures BLOCK completion — there is no override. The milestone stays in its current state until issues are resolved and verification is re-run. **If a verification tool itself fails, errors, or returns unexpected output, treat it as a verification failure** — never rationalize past a tool error ("tool didn't respond, assuming success" is forbidden). A tool that cannot verify is a tool that did not verify.
 
 **File system safety:** When scanning milestone directories for evidence, use `ls` or `find` to list directory contents first — never pass a directory path (e.g. `tasks/`, `slices/`) directly to the `read` tool. The `read` tool only accepts file paths, not directories.

package/dist/resources/extensions/gsd/prompts/complete-slice.md

@@ -25,11 +25,11 @@ Then:
 4. If the slice plan includes observability/diagnostic surfaces, confirm they work. Skip this for simple slices that don't have observability sections.
 5. If the slice involved runtime behavior, fill the **Operational Readiness** section (Q8) in the slice summary: health signal, failure signal, recovery procedure, and monitoring gaps. Omit entirely for simple slices with no runtime concerns.
 6. If this slice produced evidence that a requirement changed status (Active → Validated, Active → Deferred, etc.), call `gsd_requirement_update` with the requirement ID, updated `status`, and `validation` evidence. Do NOT write `.gsd/REQUIREMENTS.md` directly — the engine renders it from the database.
-7. Write `{{sliceSummaryPath}}` (compress all task summaries).
-8. Write `{{sliceUatPath}}` — a concrete UAT script with real test cases derived from the slice plan and task summaries. Include preconditions, numbered steps with expected outcomes, and edge cases. This must NOT be a placeholder or generic template — tailor every test case to what this slice actually built.
+7. Prepare the slice completion content you will pass to `gsd_complete_slice` using the camelCase fields `milestoneId`, `sliceId`, `sliceTitle`, `oneLiner`, `narrative`, `verification`, and `uatContent`. Do **not** manually write `{{sliceSummaryPath}}`. Do **not** manually write `{{sliceUatPath}}` — the DB-backed tool is the canonical write path for both artifacts.
+8. Draft the UAT content you will pass as `uatContent` — a concrete UAT script with real test cases derived from the slice plan and task summaries. Include preconditions, numbered steps with expected outcomes, and edge cases. This must NOT be a placeholder or generic template — tailor every test case to what this slice actually built.
 9. Review task summaries for `key_decisions`. Append any significant decisions to `.gsd/DECISIONS.md` if missing.
 10. Review task summaries for patterns, gotchas, or non-obvious lessons learned. If any would save future agents from repeating investigation or hitting the same issues, append them to `.gsd/KNOWLEDGE.md`. Only add entries that are genuinely useful — don't pad with obvious observations.
-11. Call `gsd_complete_slice` with milestoneId, sliceId, the slice summary, and the UAT result. Do NOT manually mark the roadmap checkbox — the tool writes to the DB and renders the ROADMAP.md projection automatically.
+11. Call `gsd_complete_slice` with the camelCase fields `milestoneId`, `sliceId`, `sliceTitle`, `oneLiner`, `narrative`, `verification`, and `uatContent`, plus any optional enrichment fields you have. Do NOT manually mark the roadmap checkbox — the tool writes to the DB, renders `{{sliceSummaryPath}}` and `{{sliceUatPath}}`, and updates the ROADMAP.md projection automatically.
 12. Do not run git commands — the system commits your changes and handles any merge after this unit succeeds.
 13. Update `.gsd/PROJECT.md` if it exists — refresh current state if needed: use the `write` tool with `path: ".gsd/PROJECT.md"` and `content` containing the full updated document reflecting current project state. Do NOT use the `edit` tool for this — PROJECT.md is a full-document refresh.